import fs from "node:fs";
import path from "node:path";
import vm from "node:vm";
import assert from "node:assert/strict";

const root = path.resolve(import.meta.dirname, "..");

function loadWindowScript(relativePath) {
  const sourcePath = path.join(root, relativePath);
  const context = { window: {} };
  vm.runInNewContext(fs.readFileSync(sourcePath, "utf8"), context, {
    filename: sourcePath,
  });
  return context.window;
}

const bounds = loadWindowScript("assets/bounds-engine.js").LocalFrontierBounds;
const modelData = loadWindowScript(
  "assets/local-frontier-model-data.js",
).LOCAL_FRONTIER_MODEL_DATA;
const hardwareData = loadWindowScript(
  "assets/local-frontier-data.js",
).LOCAL_FRONTIER_DATA;
const profileData = loadWindowScript(
  "assets/local-frontier-profile-data.js",
).LOCAL_FRONTIER_PROFILE_DATA;

function model(id) {
  const item = modelData.models.find((row) => row.id === id);
  assert.ok(item, `missing model ${id}`);
  return item;
}

function hardware(id) {
  const item = hardwareData.items.find((row) => row.id === id);
  assert.ok(item, `missing hardware ${id}`);
  return item;
}

function profile(repo) {
  const item = profileData.profiles.find((row) => row.repo === repo);
  assert.ok(item, `missing profile ${repo}`);
  return item;
}

function assertNear(actual, expected, tolerance, label) {
  assert.ok(
    Math.abs(actual - expected) <= tolerance,
    `${label}: expected ${actual} to be within ${tolerance} of ${expected}`,
  );
}

function calculate(modelId, hardwareId, overrides = {}) {
  const assumptions = modelData.assumptions;
  return bounds.calculateBounds({
    model: model(modelId),
    hardware: hardware(hardwareId),
    lAlloc: assumptions.default_l_alloc_tokens,
    lRead: assumptions.default_l_read_tokens,
    overhead: assumptions.default_overhead_gb,
    rho: assumptions.default_rho,
    rStar: assumptions.default_r_star_toks,
    fixedBatch: 32,
    ...overrides,
  });
}

{
  const result = calculate("Qwen/Qwen3-32B", "nvidia-dgx-spark");
  assert.equal(result.status.residentFit.code, "fits");
  assert.equal(result.status.sessionFit.code, "fits");
  assert.equal(result.status.sessionFit.sessionCount, 2);
  assert.equal(result.status.floorFit.code, "below_floor");
  assert.equal(result.status.inspectBatchFit.code, "exceeds_memory_fit");
  assert.equal(result.status.inspectBatchFit.batch, 32);
  assert.equal(result.status.inspectBatchFit.fitCap, 2);
  assert.equal(result.status.inspectFloorFit.code, "not_evaluated");
}

{
  const result = calculate("Qwen/Qwen3-32B", "nvidia-dgx-spark", {
    fixedBatch: 1,
  });
  assert.equal(result.status.residentFit.code, "fits");
  assert.equal(result.status.sessionFit.code, "fits");
  assert.equal(result.status.inspectBatchFit.code, "fits");
  assert.equal(result.status.inspectFloorFit.code, "below_floor");
}

{
  const result = calculate("nvidia/Gemma-4-26B-A4B-NVFP4", "nvidia-dgx-spark", {
    fixedBatch: 1,
  });
  assert.equal(result.status.residentFit.code, "fits");
  assert.equal(result.status.sessionFit.code, "fits");
  assert.equal(result.status.floorFit.code, "meets_floor");
  assert.equal(result.status.inspectBatchFit.code, "fits");
  assert.equal(result.status.inspectFloorFit.code, "meets_floor");
}

{
  const result = calculate(
    "nvidia/NVIDIA-Nemotron-3-Nano-4B-BF16",
    "nvidia-dgx-spark",
  );
  assertNear(
    result.single.batchWeight,
    7.125,
    0.000000001,
    "Legacy hybrid row should use active weight traffic",
  );
  assertNear(
    result.alloc,
    1.681322,
    0.000000001,
    "Legacy hybrid row should include fixed Mamba state allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.56721,
    0.000000001,
    "Legacy hybrid row should include fixed Mamba state read traffic",
  );
  assert.equal(result.best.batch, 11);
}

{
  const result = calculate(
    "nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-BF16",
    "nvidia-dgx-spark",
  );
  assertNear(
    result.single.batchWeight,
    6.455521408,
    0.000000001,
    "Legacy Nemotron 3 Nano 30B BF16 row should use exact active hybrid MoE traffic",
  );
  assertNear(
    result.alloc,
    0.663764992,
    0.000000001,
    "Legacy Nemotron 3 Nano 30B BF16 row should include fixed Mamba state allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.245972992,
    0.000000001,
    "Legacy Nemotron 3 Nano 30B BF16 row should include fixed Mamba state read traffic",
  );
  assert.equal(result.bMem, 85);
  assert.equal(result.best.batch, 3);
}

{
  const result = calculate(
    "Qwen/Qwen3-Omni-30B-A3B-Instruct",
    "nvidia-dgx-spark",
  );
  assertNear(
    result.single.batchWeight,
    6.08425984,
    0.000000001,
    "Legacy Qwen3 Omni row should use exact Thinker text active traffic",
  );
  assertNear(
    result.alloc,
    9.8304,
    0.000000001,
    "Legacy Qwen3 Omni row should use full-context Thinker text KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    3.145728,
    0.000000001,
    "Legacy Qwen3 Omni row should use full-context Thinker text KV read traffic",
  );
  assert.equal(result.best.batch, 1);
}

{
  const result = calculate(
    "lmstudio-community/Qwen3.6-27B-MLX-6bit",
    "nvidia-dgx-spark",
  );
  assertNear(
    result.single.batchWeight,
    20.823129088,
    0.000000001,
    "Legacy LM Studio Qwen3.6 27B MLX 6bit row should use exact swept text-decode traffic",
  );
  assertNear(
    result.alloc,
    6.708527104,
    0.000000001,
    "Legacy LM Studio Qwen3.6 27B MLX 6bit row should include hybrid full-attention KV plus fixed DeltaNet allocation",
  );
  assertNear(
    result.single.readTraffic,
    2.252079104,
    0.000000001,
    "Legacy LM Studio Qwen3.6 27B MLX 6bit row should include hybrid full-attention KV plus fixed DeltaNet read traffic",
  );
  assertNear(
    result.single.aggregate,
    11.830879173,
    0.000000001,
    "Legacy LM Studio Qwen3.6 27B MLX 6bit row should match audited single-session bound",
  );
}

{
  const result = calculate(
    "lmstudio-community/Qwen3.6-27B-MLX-5bit",
    "nvidia-dgx-spark",
  );
  assertNear(
    result.single.batchWeight,
    17.620384768,
    0.000000001,
    "Legacy LM Studio Qwen3.6 27B MLX 5bit row should use exact swept text-decode traffic",
  );
  assertNear(
    result.alloc,
    6.708527104,
    0.000000001,
    "Legacy LM Studio Qwen3.6 27B MLX 5bit row should include hybrid full-attention KV plus fixed DeltaNet allocation",
  );
  assertNear(
    result.single.readTraffic,
    2.252079104,
    0.000000001,
    "Legacy LM Studio Qwen3.6 27B MLX 5bit row should include hybrid full-attention KV plus fixed DeltaNet read traffic",
  );
  assertNear(
    result.single.aggregate,
    13.737602029,
    0.000000001,
    "Legacy LM Studio Qwen3.6 27B MLX 5bit row should match audited single-session bound",
  );
}

{
  const result = calculate(
    "empero-ai/Qwythos-9B-Claude-Mythos-5-1M-GGUF",
    "nvidia-dgx-spark",
  );
  assertNear(
    result.single.batchWeight,
    5.046011904,
    0.000000001,
    "Legacy Qwythos 9B GGUF row should use exact Q4_K_M swept text-decode traffic",
  );
  assertNear(
    result.alloc,
    3.328704512,
    0.000000001,
    "Legacy Qwythos 9B GGUF row should include 1M Qwen3.5 hybrid KV plus fixed DeltaNet allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.100480512,
    0.000000001,
    "Legacy Qwythos 9B GGUF row should include Qwen3.5 hybrid KV plus fixed DeltaNet read traffic",
  );
  assertNear(
    result.single.aggregate,
    44.415575831,
    0.000000001,
    "Legacy Qwythos 9B GGUF row should match audited Q4_K_M single-session bound",
  );
}

{
  const result = calculate("deepseek-ai/DeepSeek-V4-Flash", "nvidia-dgx-spark");
  assert.equal(result.status.residentFit.code, "resident_not_fit");
  assertNear(
    result.resident,
    159.609485896,
    0.000000001,
    "Legacy DeepSeek V4 Flash row should use exact mixed FP4/FP8 resident bytes",
  );
  assertNear(
    result.single.batchWeight,
    11.23618838,
    0.000000001,
    "Legacy DeepSeek V4 Flash row should use exact mixed FP4/FP8 active traffic",
  );
  assertNear(
    result.alloc,
    0.705842176,
    0.000000001,
    "Legacy DeepSeek V4 Flash row should use CSA/HCA allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.064774144,
    0.000000001,
    "Legacy DeepSeek V4 Flash row should use CSA/HCA read traffic",
  );
}

{
  const result = calculate("deepseek-ai/DeepSeek-V4-Pro", "nvidia-dgx-spark");
  assert.equal(result.status.residentFit.code, "resident_not_fit");
  assertNear(
    result.resident,
    864.704792696,
    0.000000001,
    "Legacy DeepSeek V4 Pro row should use exact mixed FP4/FP8 resident bytes",
  );
  assertNear(
    result.single.batchWeight,
    39.6852203,
    0.000000001,
    "Legacy DeepSeek V4 Pro row should use exact mixed FP4/FP8 active traffic",
  );
  assertNear(
    result.alloc,
    1.01150592,
    0.000000001,
    "Legacy DeepSeek V4 Pro row should use CSA/HCA allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.108828672,
    0.000000001,
    "Legacy DeepSeek V4 Pro row should use CSA/HCA read traffic",
  );
}

{
  const result = calculate("deepseek-ai/DeepSeek-V3-0324", "nvidia-dgx-spark");
  assert.equal(result.status.residentFit.code, "resident_not_fit");
  assertNear(
    result.resident,
    688.57483936,
    0.000000001,
    "Legacy DeepSeek V3 0324 row should use exact FP8/BF16/F32 resident bytes",
  );
  assertNear(
    result.single.batchWeight,
    39.521833312,
    0.000000001,
    "Legacy DeepSeek V3 0324 row should use exact active MLA MoE traffic",
  );
  assertNear(
    result.alloc,
    7.0272,
    0.000000001,
    "Legacy DeepSeek V3 0324 row should use MLA allocation",
  );
  assertNear(
    result.single.readTraffic,
    2.248704,
    0.000000001,
    "Legacy DeepSeek V3 0324 row should use MLA read traffic",
  );
}

{
  const result = calculate("deepseek-ai/DeepSeek-V3.1", "nvidia-dgx-spark");
  assert.equal(result.status.residentFit.code, "resident_not_fit");
  assertNear(
    result.resident,
    688.57483936,
    0.000000001,
    "Legacy DeepSeek V3.1 row should use exact FP8/BF16/F32 resident bytes",
  );
  assertNear(
    result.single.batchWeight,
    39.521833312,
    0.000000001,
    "Legacy DeepSeek V3.1 row should use exact active MLA MoE traffic",
  );
  assertNear(
    result.alloc,
    7.0272,
    0.000000001,
    "Legacy DeepSeek V3.1 row should use MLA allocation",
  );
  assertNear(
    result.single.readTraffic,
    2.248704,
    0.000000001,
    "Legacy DeepSeek V3.1 row should use MLA read traffic",
  );
}

{
  const result = calculate(
    "nvidia/DeepSeek-R1-0528-NVFP4-v2",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status.residentFit.code, "resident_not_fit");
  assertNear(
    result.resident,
    413.306995616,
    0.000000001,
    "Legacy NVIDIA DeepSeek R1 0528 NVFP4 v2 row should use exact stored resident bytes",
  );
  assertNear(
    result.single.batchWeight,
    28.197245728,
    0.000000001,
    "Legacy NVIDIA DeepSeek R1 0528 NVFP4 v2 row should use exact audited active traffic",
  );
  assertNear(
    result.alloc,
    249.856,
    0.000000001,
    "Legacy NVIDIA DeepSeek R1 0528 NVFP4 v2 row should use expanded FP8 K/V allocation",
  );
  assertNear(
    result.single.readTraffic,
    79.95392,
    0.000000001,
    "Legacy NVIDIA DeepSeek R1 0528 NVFP4 v2 row should use expanded FP8 K/V read traffic",
  );
}

{
  const result = calculate("deepseek-ai/deepseek-vl2-tiny", "nvidia-dgx-spark");
  assert.equal(result.status.residentFit.code, "fits");
  assertNear(
    result.resident,
    6.74100288,
    0.000000001,
    "Legacy DeepSeek VL2 Tiny row should use exact BF16 resident bytes",
  );
  assertNear(
    result.single.batchWeight,
    1.14825472,
    0.000000001,
    "Legacy DeepSeek VL2 Tiny row should use exact audited active traffic",
  );
  assertNear(
    result.alloc,
    6.144,
    0.000000001,
    "Legacy DeepSeek VL2 Tiny row should use standard BF16 MHA KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.96608,
    0.000000001,
    "Legacy DeepSeek VL2 Tiny row should use standard BF16 MHA KV read traffic",
  );
}

{
  const result = calculate(
    "rippertnt/HyperCLOVAX-SEED-Text-Instruct-1.5B-Q4_K_M-GGUF",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status.residentFit.code, "fits");
  assertNear(
    result.resident,
    1.133974368,
    0.000000001,
    "Legacy HyperCLOVAX SEED GGUF row should use exact Q4_K_M resident bytes",
  );
  assertNear(
    result.single.batchWeight,
    1.002512384,
    0.000000001,
    "Legacy HyperCLOVAX SEED GGUF row should use exact swept text-decode traffic",
  );
  assertNear(
    result.alloc,
    9.8304,
    0.000000001,
    "Legacy HyperCLOVAX SEED GGUF row should use full-context FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    3.145728,
    0.000000001,
    "Legacy HyperCLOVAX SEED GGUF row should use full-context FP16 KV read traffic",
  );
  assert.equal(result.bMem, 12);
  assert.equal(result.best.batch, 4);
}

{
  const result = calculate(
    "Qwen/Qwen3.5-35B-A3B-GPTQ-Int4",
    "nvidia-dgx-spark",
    { fixedBatch: 1 },
  );
  assertNear(
    result.single.batchWeight,
    4.408478336,
    0.000000001,
    "Legacy Qwen3.5 GPTQ row should use exact active MoE traffic",
  );
  assertNear(
    result.alloc,
    2.11288064,
    0.000000001,
    "Legacy Qwen3.5 GPTQ row should use hybrid KV plus DeltaNet allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.72024064,
    0.000000001,
    "Legacy Qwen3.5 GPTQ row should use hybrid KV plus DeltaNet read traffic",
  );
}

{
  const tinyHardware = {
    ...hardware("nvidia-dgx-spark"),
    memory: { ...hardware("nvidia-dgx-spark").memory, capacity_gb: 8 },
  };
  const result = bounds.calculateBounds({
    model: model("Qwen/Qwen3-32B"),
    hardware: tinyHardware,
    lAlloc: 100000,
    lRead: 32000,
    overhead: 8,
    rho: 1,
    rStar: 20,
    fixedBatch: 1,
  });
  assert.equal(result.status.residentFit.code, "resident_not_fit");
  assert.equal(result.status.sessionFit.code, "not_evaluated");
  assert.equal(result.status.floorFit.code, "not_evaluated");
  assert.equal(result.status.inspectBatchFit.code, "resident_not_fit");
}

{
  const tightHardware = {
    ...hardware("nvidia-dgx-spark"),
    memory: { ...hardware("nvidia-dgx-spark").memory, capacity_gb: 80 },
  };
  const result = bounds.calculateBounds({
    model: model("Qwen/Qwen3-32B"),
    hardware: tightHardware,
    lAlloc: 100000,
    lRead: 32000,
    overhead: 8,
    rho: 1,
    rStar: 20,
    fixedBatch: 1,
  });
  assert.equal(result.status.residentFit.code, "fits");
  assert.equal(result.status.sessionFit.code, "no_session_capacity");
  assert.equal(result.status.floorFit.code, "not_evaluated");
  assert.equal(result.status.inspectBatchFit.code, "no_session_capacity");
}

console.log("bounds engine status tests passed");

function profiled(repo, hardwareId) {
  const assumptions = modelData.assumptions;
  return bounds.calculateProfiledBounds({
    profile: profile(repo),
    model: model(repo),
    hardware: hardware(hardwareId),
    workloadSettings: {
      l_alloc_tokens: assumptions.default_l_alloc_tokens,
      l_read_tokens: assumptions.default_l_read_tokens,
      min_toks_per_session: assumptions.default_r_star_toks,
      overhead_gb: assumptions.default_overhead_gb,
      decode_policy: {
        kind: "ordinary",
        rho: 1,
      },
    },
  });
}

function assertProfiledReference({
  repo,
  hardwareId,
  status,
  single,
  batch,
  aggregate,
  dennard,
}) {
  const result = profiled(repo, hardwareId);
  assert.equal(result.status_code, status, `${repo} on ${hardwareId} status`);
  assertNear(
    result.single.aggregate,
    single,
    0.01,
    `${repo} on ${hardwareId} single`,
  );
  assert.equal(
    result.best?.batch ?? null,
    batch,
    `${repo} on ${hardwareId} b*`,
  );
  assertNear(
    result.best?.aggregate ?? 0,
    aggregate,
    0.01,
    `${repo} on ${hardwareId} aggregate`,
  );
  assertNear(result.dennard, dennard, 0.01, `${repo} on ${hardwareId} Dennard`);
}

{
  const item = profile("nvidia/Nemotron-Mini-4B-Instruct");
  const weightAdapter = item.architecture.weight_adapter;
  assertNear(
    weightAdapter.resident_weight_gb,
    8.381018112,
    0.000000001,
    "Nemotron Mini 4B PyTorch BF16 resident tensor payload",
  );
  assertNear(
    weightAdapter.swept_weight_gb,
    6.808154112,
    0.000000001,
    "Nemotron Mini 4B swept text-decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.572864,
    0.000000001,
    "Nemotron Mini 4B resident-only input embedding",
  );
  assert.equal(item.architecture.kv_adapter.kind, "full_context");
  assert.equal(item.architecture.kv_adapter.layers, 32);
  assert.equal(item.architecture.kv_adapter.kv_heads, 8);
  assert.equal(item.architecture.kv_adapter.head_dim, 128);

  const dgx = profiled("nvidia/Nemotron-Mini-4B-Instruct", "nvidia-dgx-spark");
  assert.equal(dgx.status_code, "ok");
  assertNear(
    dgx.alloc,
    13.1072,
    0.000000001,
    "Nemotron Mini 4B full-context BF16 KV allocation",
  );
  assertNear(
    dgx.single.readTraffic,
    4.194304,
    0.000000001,
    "Nemotron Mini 4B full-context BF16 KV read traffic",
  );
  assert.equal(dgx.bMem, 8);
  assert.equal(dgx.best.batch, 1);
  assertNear(
    dgx.single.aggregate,
    24.812637069,
    0.000000001,
    "Nemotron Mini 4B DGX Spark single-session throughput",
  );
  assertNear(
    dgx.dennard,
    341.476954583,
    0.000000001,
    "Nemotron Mini 4B DGX Spark Dennard bound",
  );

  const m5 = profiled(
    "nvidia/Nemotron-Mini-4B-Instruct",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(m5.status_code, "ok");
  assert.equal(m5.best.batch, 5);
  assertNear(
    m5.best.aggregate,
    110.512455532,
    0.000000001,
    "Nemotron Mini 4B M5 Max aggregate throughput",
  );
  assertNear(
    m5.best.perSession,
    22.102491106,
    0.000000001,
    "Nemotron Mini 4B M5 Max per-session throughput",
  );
}

{
  const item = profile("nvidia/Nemotron-Labs-Diffusion-3B-Base");
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(
    "nvidia/Nemotron-Labs-Diffusion-3B-Base",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "nvidia/Nemotron-Labs-Diffusion-3B-Base",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(
    item.serving.runtime_format,
    "custom-nemotron-labs-diffusion-ar-bf16-text-decode-memory-bound",
  );
  assertNear(
    result.resident,
    7.66331904,
    0.000000001,
    "Nemotron Labs Diffusion 3B Base BF16 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    6.858012672,
    0.000000001,
    "Nemotron Labs Diffusion 3B Base AR swept decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.805306368,
    0.000000001,
    "Nemotron Labs Diffusion 3B Base resident input embedding",
  );
  assert.equal(item.architecture.kv_adapter.kind, "full_context");
  assert.equal(item.architecture.kv_adapter.layers, 26);
  assert.equal(item.architecture.kv_adapter.kv_heads, 8);
  assert.equal(item.architecture.kv_adapter.head_dim, 128);
  assertNear(
    result.alloc,
    10.6496,
    0.000000001,
    "Nemotron Labs Diffusion 3B Base full-context BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    3.407872,
    0.000000001,
    "Nemotron Labs Diffusion 3B Base full-context BF16 KV read traffic",
  );
  assert.equal(result.bMem, 10);
  assert.equal(result.best.batch, 1);
  assertNear(
    result.single.aggregate,
    26.592934629842684,
    0.000000001,
    "Nemotron Labs Diffusion 3B Base DGX Spark AR single-session throughput",
  );
  assertNear(
    result.dennard,
    419.9065567868347,
    0.000000001,
    "Nemotron Labs Diffusion 3B Base DGX Spark AR Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 6);
  assertNear(
    m5Result.single.aggregate,
    59.809750412906254,
    0.000000001,
    "Nemotron Labs Diffusion 3B Base M5 Max AR single-session throughput",
  );
  assertNear(
    m5Result.best.aggregate,
    134.91913528897018,
    0.000000001,
    "Nemotron Labs Diffusion 3B Base M5 Max AR aggregate throughput",
  );
  assertNear(
    m5Result.best.perSession,
    22.486522548161698,
    0.000000001,
    "Nemotron Labs Diffusion 3B Base M5 Max AR per-session throughput",
  );
  assertNear(
    m5Result.dennard,
    944.4052229564708,
    0.000000001,
    "Nemotron Labs Diffusion 3B Base M5 Max AR Dennard bound",
  );
}

for (const reference of [
  {
    repo: "Andycurrent/Gemma-3-1B-it-GLM-4.7-Flash-Heretic-Uncensored-Thinking_GGUF",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 127.412508,
    batch: 81,
    aggregate: 1631.816785,
    dennard: 38243.798843,
  },
  {
    repo: "Andycurrent/Gemma-3-1B-it-GLM-4.7-Flash-Heretic-Uncensored-Thinking_GGUF",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 286.561464,
    batch: 201,
    aggregate: 4024.730831,
    dennard: 86013.525603,
  },
  {
    repo: "empero-ai/Qwythos-9B-Claude-Mythos-5-1M-GGUF",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 44.415576,
    batch: 7,
    aggregate: 149.889695,
    dennard: 1858.894042,
  },
  {
    repo: "empero-ai/Qwythos-9B-Claude-Mythos-5-1M-GGUF",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 99.894372,
    batch: 23,
    aggregate: 465.196507,
    dennard: 4180.809311,
  },
  {
    repo: "rippertnt/HyperCLOVAX-SEED-Text-Instruct-1.5B-Q4_K_M-GGUF",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 65.811037,
    batch: 4,
    aggregate: 80.380264,
    dennard: 3292.755268,
  },
  {
    repo: "rippertnt/HyperCLOVAX-SEED-Text-Instruct-1.5B-Q4_K_M-GGUF",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 148.014566,
    batch: 9,
    aggregate: 188.510195,
    dennard: 7405.684009,
  },
  {
    repo: "lmg-anon/vntl-llama3-8b-v2-gguf",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 28.561605,
    batch: 1,
    aggregate: 28.561605,
    dennard: 443.696744,
  },
  {
    repo: "lmg-anon/vntl-llama3-8b-v2-gguf",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 64.237456,
    batch: 6,
    aggregate: 120.668961,
    dennard: 997.911357,
  },
  {
    repo: "Qwen/Qwen3-0.6B",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 56.148395,
    batch: 3,
    aggregate: 67.119331,
    dennard: 2366.129025,
  },
  {
    repo: "Qwen/Qwen3-0.6B",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 126.28247,
    batch: 8,
    aggregate: 160.773873,
    dennard: 5321.623522,
  },
  {
    repo: "Qwen/Qwen3-0.6B-FP8",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 61.740014,
    batch: 3,
    aggregate: 69.632201,
    dennard: 3766.062688,
  },
  {
    repo: "Qwen/Qwen3-0.6B-FP8",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 138.858494,
    batch: 8,
    aggregate: 163.124988,
    dennard: 8470.192273,
  },
  {
    repo: "Qwen/Qwen3-1.7B",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 38.390329,
    batch: 2,
    aggregate: 50.643798,
    dennard: 801.975924,
  },
  {
    repo: "Qwen/Qwen3-1.7B",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 86.343084,
    batch: 7,
    aggregate: 147.539094,
    dennard: 1803.71142,
  },
  {
    repo: "Qwen/Qwen3-1.7B-Base",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 38.390329,
    batch: 2,
    aggregate: 50.643798,
    dennard: 806.280811,
  },
  {
    repo: "Qwen/Qwen3-1.7B-Base",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 86.343084,
    batch: 7,
    aggregate: 147.539094,
    dennard: 1813.393472,
  },
  {
    repo: "Qwen/Qwen3-4B",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 21.38907,
    batch: 1,
    aggregate: 21.38907,
    dennard: 257.644773,
  },
  {
    repo: "Qwen/Qwen3-4B",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 48.105821,
    batch: 4,
    aggregate: 91.235642,
    dennard: 579.464801,
  },
  {
    repo: "Qwen/Qwen3-4B-Base",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 21.38907,
    batch: 1,
    aggregate: 21.38907,
    dennard: 257.644773,
  },
  {
    repo: "Qwen/Qwen3-4B-Base",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 48.105821,
    batch: 4,
    aggregate: 91.235642,
    dennard: 579.464801,
  },
  {
    repo: "Qwen/Qwen3-4B-Instruct-2507",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 21.38907,
    batch: 1,
    aggregate: 21.38907,
    dennard: 257.644773,
  },
  {
    repo: "Qwen/Qwen3-4B-Instruct-2507",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 48.105821,
    batch: 4,
    aggregate: 91.235642,
    dennard: 579.464801,
  },
  {
    repo: "Qwen/Qwen3-8B",
    hardwareId: "nvidia-dgx-spark",
    status: "no_floor",
    single: 13.749406,
    batch: null,
    aggregate: 0,
    dennard: 126.736945,
  },
  {
    repo: "Qwen/Qwen3-8B",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 30.923573,
    batch: 3,
    aggregate: 62.882804,
    dennard: 285.042066,
  },
  {
    repo: "deepseek-ai/DeepSeek-R1-0528-Qwen3-8B",
    hardwareId: "nvidia-dgx-spark",
    status: "no_floor",
    single: 13.749406,
    batch: null,
    aggregate: 0,
    dennard: 126.736945,
  },
  {
    repo: "deepseek-ai/DeepSeek-R1-0528-Qwen3-8B",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 30.923573,
    batch: 3,
    aggregate: 62.882804,
    dennard: 285.042066,
  },
  {
    repo: "lmstudio-community/DeepSeek-R1-0528-Qwen3-8B-MLX-4bit",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 30.413547,
    batch: 1,
    aggregate: 30.413547,
    dennard: 501.770116,
  },
  {
    repo: "lmstudio-community/DeepSeek-R1-0528-Qwen3-8B-MLX-4bit",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 68.402629,
    batch: 5,
    aggregate: 110.230895,
    dennard: 1128.523264,
  },
  {
    repo: "Qwen/Qwen3-14B",
    hardwareId: "nvidia-dgx-spark",
    status: "no_floor",
    single: 8.217033,
    batch: null,
    aggregate: 0,
    dennard: 53.871067,
  },
  {
    repo: "Qwen/Qwen3-14B",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "no_floor",
    single: 18.4808,
    batch: null,
    aggregate: 0,
    dennard: 121.160568,
  },
  {
    repo: "cyankiwi/Hermes-4-14B-AWQ-4bit",
    hardwareId: "nvidia-dgx-spark",
    status: "no_floor",
    single: 19.183012,
    batch: null,
    aggregate: 0,
    dennard: 202.906419,
  },
  {
    repo: "cyankiwi/Hermes-4-14B-AWQ-4bit",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 43.144211,
    batch: 4,
    aggregate: 81.976019,
    dennard: 456.353631,
  },
  {
    repo: "Qwen/Qwen3-32B",
    hardwareId: "nvidia-dgx-spark",
    status: "no_floor",
    single: 3.772958,
    batch: null,
    aggregate: 0,
    dennard: 8.868708,
  },
  {
    repo: "Qwen/Qwen3-32B",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "no_floor",
    single: 8.485699,
    batch: null,
    aggregate: 0,
    dennard: 19.94647,
  },
  {
    repo: "Qwen/Qwen3-30B-A3B",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 29.579184,
    batch: 1,
    aggregate: 29.579184,
    dennard: 269.029546,
  },
  {
    repo: "Qwen/Qwen3-30B-A3B",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 66.526077,
    batch: 4,
    aggregate: 86.984032,
    dennard: 605.070115,
  },
  {
    repo: "Qwen/Qwen3-30B-A3B-Instruct-2507",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 29.579184,
    batch: 1,
    aggregate: 29.579184,
    dennard: 269.029546,
  },
  {
    repo: "Qwen/Qwen3-30B-A3B-Instruct-2507",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 66.526077,
    batch: 4,
    aggregate: 86.984032,
    dennard: 605.070115,
  },
  {
    repo: "Qwen/Qwen3-30B-A3B-Thinking-2507",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 29.579184,
    batch: 1,
    aggregate: 29.579184,
    dennard: 269.029546,
  },
  {
    repo: "Qwen/Qwen3-30B-A3B-Thinking-2507",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 66.526077,
    batch: 4,
    aggregate: 86.984032,
    dennard: 605.070115,
  },
  {
    repo: "Qwen/Qwen3-Omni-30B-A3B-Instruct",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 29.577504,
    batch: 1,
    aggregate: 29.577504,
    dennard: 225.848172,
  },
  {
    repo: "Qwen/Qwen3-Omni-30B-A3B-Instruct",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 66.522298,
    batch: 4,
    aggregate: 86.982417,
    dennard: 507.951567,
  },
  {
    repo: "Qwen/Qwen3-Omni-30B-A3B-Thinking",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 29.577504,
    batch: 1,
    aggregate: 29.577504,
    dennard: 258.169721,
  },
  {
    repo: "Qwen/Qwen3-Omni-30B-A3B-Thinking",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 66.522298,
    batch: 4,
    aggregate: 86.982417,
    dennard: 580.645454,
  },
  {
    repo: "deepseek-ai/DeepSeek-V4-Flash",
    hardwareId: "nvidia-dgx-spark",
    status: "resident_not_fit",
    single: 24.157234,
    batch: null,
    aggregate: 0,
    dennard: 0,
  },
  {
    repo: "deepseek-ai/DeepSeek-V4-Flash",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "resident_not_fit",
    single: 54.331655,
    batch: null,
    aggregate: 0,
    dennard: 0,
  },
  {
    repo: "deepseek-ai/DeepSeek-V4-Pro",
    hardwareId: "nvidia-dgx-spark",
    status: "resident_not_fit",
    single: 6.860322,
    batch: null,
    aggregate: 0,
    dennard: 0,
  },
  {
    repo: "deepseek-ai/DeepSeek-V4-Pro",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "resident_not_fit",
    single: 15.429443,
    batch: null,
    aggregate: 0,
    dennard: 0,
  },
  {
    repo: "deepseek-ai/DeepSeek-V3-0324",
    hardwareId: "nvidia-dgx-spark",
    status: "resident_not_fit",
    single: 6.535707,
    batch: null,
    aggregate: 0,
    dennard: 0,
  },
  {
    repo: "deepseek-ai/DeepSeek-V3-0324",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "resident_not_fit",
    single: 14.699356,
    batch: null,
    aggregate: 0,
    dennard: 0,
  },
  {
    repo: "deepseek-ai/DeepSeek-V3",
    hardwareId: "nvidia-dgx-spark",
    status: "resident_not_fit",
    single: 6.535707,
    batch: null,
    aggregate: 0,
    dennard: 0,
  },
  {
    repo: "deepseek-ai/DeepSeek-V3",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "resident_not_fit",
    single: 14.699356,
    batch: null,
    aggregate: 0,
    dennard: 0,
  },
  {
    repo: "Qwen/Qwen3-VL-2B-Instruct",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 38.390329,
    batch: 2,
    aggregate: 50.643798,
    dennard: 800.650665,
  },
  {
    repo: "Qwen/Qwen3-VL-2B-Instruct",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 86.343084,
    batch: 7,
    aggregate: 147.539094,
    dennard: 1800.7308,
  },
  {
    repo: "cyankiwi/Qwen3-VL-2B-Instruct-AWQ-4bit",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 53.683935,
    batch: 3,
    aggregate: 65.913624,
    dennard: 1980.762533,
  },
  {
    repo: "cyankiwi/Qwen3-VL-2B-Instruct-AWQ-4bit",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 120.739692,
    batch: 7,
    aggregate: 158.566095,
    dennard: 4454.901814,
  },
  {
    repo: "Qwen/Qwen3-VL-4B-Instruct",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 21.38907,
    batch: 1,
    aggregate: 21.38907,
    dennard: 255.733075,
  },
  {
    repo: "Qwen/Qwen3-VL-4B-Instruct",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 48.105821,
    batch: 4,
    aggregate: 91.235642,
    dennard: 575.16523,
  },
  {
    repo: "Qwen/Qwen3-VL-8B-Instruct",
    hardwareId: "nvidia-dgx-spark",
    status: "no_floor",
    single: 13.749406,
    batch: null,
    aggregate: 0,
    dennard: 125.326971,
  },
  {
    repo: "Qwen/Qwen3-VL-8B-Instruct",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 30.923573,
    batch: 3,
    aggregate: 62.882804,
    dennard: 281.870917,
  },
  {
    repo: "Qwen/Qwen3-VL-8B-Instruct-FP8",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 21.144218,
    batch: 1,
    aggregate: 21.144218,
    dennard: 247.244923,
  },
  {
    repo: "Qwen/Qwen3-VL-8B-Instruct-FP8",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 47.555127,
    batch: 4,
    aggregate: 90.737439,
    dennard: 556.074661,
  },
  {
    repo: "Qwen/Qwen3-VL-32B-Instruct",
    hardwareId: "nvidia-dgx-spark",
    status: "no_floor",
    single: 3.772958,
    batch: null,
    aggregate: 0,
    dennard: 8.674887,
  },
  {
    repo: "Qwen/Qwen3-VL-32B-Instruct",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "no_floor",
    single: 8.485699,
    batch: null,
    aggregate: 0,
    dennard: 19.510553,
  },
  {
    repo: "Qwen/Qwen2-1.5B-Instruct",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 68.165941,
    batch: 11,
    aggregate: 227.845694,
    dennard: 3605.528623,
  },
  {
    repo: "Qwen/Qwen2-1.5B-Instruct",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 153.310944,
    batch: 30,
    aggregate: 601.71403,
    dennard: 8109.137636,
  },
  {
    repo: "Qwen/Qwen2-VL-2B-Instruct",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 68.165941,
    batch: 11,
    aggregate: 227.845694,
    dennard: 3564.495316,
  },
  {
    repo: "Qwen/Qwen2-VL-2B-Instruct",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 153.310944,
    batch: 30,
    aggregate: 601.71403,
    dennard: 8016.850272,
  },
  {
    repo: "Qwen/Qwen2-0.5B",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 197.642546,
    batch: 32,
    aggregate: 643.726657,
    dennard: 26760.006066,
  },
  {
    repo: "Qwen/Qwen2-0.5B",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 444.514738,
    batch: 75,
    aggregate: 1510.863178,
    dennard: 60185.508148,
  },
  {
    repo: "Qwen/Qwen2.5-0.5B",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 197.642546,
    batch: 32,
    aggregate: 643.726657,
    dennard: 26760.006066,
  },
  {
    repo: "Qwen/Qwen2.5-0.5B",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 444.514738,
    batch: 75,
    aggregate: 1510.863178,
    dennard: 60185.508148,
  },
  {
    repo: "Qwen/Qwen2.5-0.5B-Instruct",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 197.642546,
    batch: 32,
    aggregate: 643.726657,
    dennard: 26760.006066,
  },
  {
    repo: "Qwen/Qwen2.5-0.5B-Instruct",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 444.514738,
    batch: 75,
    aggregate: 1510.863178,
    dennard: 60185.508148,
  },
  {
    repo: "Qwen/Qwen2.5-VL-3B-Instruct",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 37.13515,
    batch: 6,
    aggregate: 123.624831,
    dennard: 1349.769868,
  },
  {
    repo: "Qwen/Qwen2.5-VL-3B-Instruct",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 83.520082,
    batch: 20,
    aggregate: 412.567347,
    dennard: 3035.74615,
  },
  {
    repo: "Qwen/Qwen2-7B-Instruct",
    hardwareId: "nvidia-dgx-spark",
    status: "no_floor",
    single: 17.087869,
    batch: null,
    aggregate: 0,
    dennard: 352.711042,
  },
  {
    repo: "Qwen/Qwen2-7B-Instruct",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 38.432057,
    batch: 9,
    aggregate: 180.256526,
    dennard: 793.276849,
  },
  {
    repo: "Qwen/Qwen2.5-7B-Instruct",
    hardwareId: "nvidia-dgx-spark",
    status: "no_floor",
    single: 17.087869,
    batch: null,
    aggregate: 0,
    dennard: 352.711042,
  },
  {
    repo: "Qwen/Qwen2.5-7B-Instruct",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 38.432057,
    batch: 9,
    aggregate: 180.256526,
    dennard: 793.276849,
  },
  {
    repo: "Qwen/Qwen2.5-Coder-7B",
    hardwareId: "nvidia-dgx-spark",
    status: "no_floor",
    single: 17.087869,
    batch: null,
    aggregate: 0,
    dennard: 352.711042,
  },
  {
    repo: "Qwen/Qwen2.5-Coder-7B",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 38.432057,
    batch: 9,
    aggregate: 180.256526,
    dennard: 793.276849,
  },
  {
    repo: "Qwen/Qwen2.5-Coder-7B-Instruct",
    hardwareId: "nvidia-dgx-spark",
    status: "no_floor",
    single: 17.087869,
    batch: null,
    aggregate: 0,
    dennard: 352.711042,
  },
  {
    repo: "Qwen/Qwen2.5-Coder-7B-Instruct",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 38.432057,
    batch: 9,
    aggregate: 180.256526,
    dennard: 793.276849,
  },
  {
    repo: "Qwen/Qwen2.5-Omni-7B",
    hardwareId: "nvidia-dgx-spark",
    status: "no_floor",
    single: 17.087869,
    batch: null,
    aggregate: 0,
    dennard: 328.702976,
  },
  {
    repo: "Qwen/Qwen2.5-Omni-7B",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 38.432057,
    batch: 9,
    aggregate: 180.256526,
    dennard: 739.280686,
  },
  {
    repo: "nvidia/NVIDIA-Nemotron-3-Nano-4B-BF16",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 35.490312,
    batch: 11,
    aggregate: 224.702456,
    dennard: 2553.571962,
  },
  {
    repo: "nvidia/NVIDIA-Nemotron-3-Nano-4B-BF16",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 79.820702,
    batch: 41,
    aggregate: 828.619821,
    dennard: 5743.198478,
  },
  {
    repo: "nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-BF16",
    hardwareId: "nvidia-dgx-spark",
    status: "resident_not_fit",
    single: 11.021889,
    batch: null,
    aggregate: 0,
    dennard: 0,
  },
  {
    repo: "nvidia/Llama-3.1-Nemotron-Nano-VL-8B-V1",
    hardwareId: "nvidia-dgx-spark",
    status: "no_floor",
    single: 14.214123,
    batch: null,
    aggregate: 0,
    dennard: 142.291431,
  },
  {
    repo: "Qwen/Qwen2.5-7B-Instruct-AWQ",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 43.225197,
    batch: 4,
    aggregate: 92.379654,
    dennard: 1215.796127,
  },
  {
    repo: "Qwen/Qwen2.5-7B-Instruct-AWQ",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 97.21711,
    batch: 14,
    aggregate: 284.910628,
    dennard: 2734.427918,
  },
  {
    repo: "Qwen/Qwen2.5-14B-Instruct",
    hardwareId: "nvidia-dgx-spark",
    status: "no_floor",
    single: 7.965131,
    batch: null,
    aggregate: 0,
    dennard: 44.887406,
  },
  {
    repo: "Qwen/Qwen2.5-14B-Instruct",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "no_floor",
    single: 17.914251,
    batch: null,
    aggregate: 0,
    dennard: 100.955557,
  },
  {
    repo: "Qwen/Qwen2.5-32B-Instruct",
    hardwareId: "nvidia-dgx-spark",
    status: "no_floor",
    single: 3.772843,
    batch: null,
    aggregate: 0,
    dennard: 8.867832,
  },
  {
    repo: "Qwen/Qwen2.5-32B-Instruct",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "no_floor",
    single: 8.485442,
    batch: null,
    aggregate: 0,
    dennard: 19.944502,
  },
  {
    repo: "Qwen/Qwen2.5-VL-32B-Instruct",
    hardwareId: "nvidia-dgx-spark",
    status: "no_floor",
    single: 3.772843,
    batch: null,
    aggregate: 0,
    dennard: 8.419271,
  },
  {
    repo: "Qwen/Qwen2.5-VL-32B-Instruct",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "no_floor",
    single: 8.485442,
    batch: null,
    aggregate: 0,
    dennard: 18.93565,
  },
  {
    repo: "Qwen/Qwen2.5-Coder-14B-Instruct",
    hardwareId: "nvidia-dgx-spark",
    status: "no_floor",
    single: 7.965131,
    batch: null,
    aggregate: 0,
    dennard: 44.887406,
  },
  {
    repo: "Qwen/Qwen2.5-Coder-14B-Instruct",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "no_floor",
    single: 17.914251,
    batch: null,
    aggregate: 0,
    dennard: 100.955557,
  },
  {
    repo: "Qwen/Qwen2.5-Coder-14B-Instruct-AWQ",
    hardwareId: "nvidia-dgx-spark",
    status: "no_floor",
    single: 18.553318,
    batch: null,
    aggregate: 0,
    dennard: 181.372599,
  },
  {
    repo: "Qwen/Qwen2.5-Coder-14B-Instruct-AWQ",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 41.727974,
    batch: 3,
    aggregate: 67.479296,
    dennard: 407.922255,
  },
  {
    repo: "Qwen/Qwen2.5-1.5B-Instruct",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 68.165941,
    batch: 11,
    aggregate: 227.845694,
    dennard: 3605.528623,
  },
  {
    repo: "Qwen/Qwen2.5-1.5B-Instruct",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 153.310944,
    batch: 30,
    aggregate: 601.71403,
    dennard: 8109.137636,
  },
  {
    repo: "Qwen/Qwen2.5-3B-Instruct",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 37.13515,
    batch: 6,
    aggregate: 123.624831,
    dennard: 1365.816874,
  },
  {
    repo: "Qwen/Qwen2.5-3B-Instruct",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 83.520082,
    batch: 20,
    aggregate: 412.567347,
    dennard: 3071.837218,
  },
  {
    repo: "google/gemma-4-E2B-it",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 53.8386,
    batch: 19,
    aggregate: 381.607826,
    dennard: 10500.37794,
  },
  {
    repo: "google/gemma-4-E2B-it",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 121.087547,
    batch: 55,
    aggregate: 1102.296409,
    dennard: 23616.234635,
  },
  {
    repo: "unsloth/gemma-4-E2B-it-GGUF",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 53.832376,
    batch: 19,
    aggregate: 381.591368,
    dennard: 4537.922746,
  },
  {
    repo: "unsloth/gemma-4-E2B-it-GGUF",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 121.073549,
    batch: 55,
    aggregate: 1102.275316,
    dennard: 10206.170572,
  },
  {
    repo: "google/gemma-4-E4B-it",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 26.368665,
    batch: 4,
    aggregate: 82.628306,
    dennard: 1040.31545,
  },
  {
    repo: "google/gemma-4-E4B-it",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 59.305349,
    batch: 22,
    aggregate: 444.4666,
    dennard: 2339.757092,
  },
  {
    repo: "google/gemma-4-12B-it",
    hardwareId: "nvidia-dgx-spark",
    status: "no_floor",
    single: 11.182847,
    batch: null,
    aggregate: 0,
    dennard: 953.821525,
  },
  {
    repo: "google/gemma-4-12B-it",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 25.151164,
    batch: 11,
    aggregate: 222.249482,
    dennard: 2145.224968,
  },
  {
    repo: "google/gemma-4-12B-it-qat-w4a16-ct",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 31.22241,
    batch: 9,
    aggregate: 181.660548,
    dennard: 3184.781459,
  },
  {
    repo: "google/gemma-4-12B-it-qat-w4a16-ct",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 70.221831,
    batch: 37,
    aggregate: 750.747695,
    dennard: 7162.841816,
  },
  {
    repo: "cyankiwi/gemma-4-12B-it-AWQ-INT4",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 22.362803,
    batch: 2,
    aggregate: 40.736697,
    dennard: 1167.633193,
  },
  {
    repo: "cyankiwi/gemma-4-12B-it-AWQ-INT4",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 50.295828,
    batch: 16,
    aggregate: 325.962658,
    dennard: 2626.105423,
  },
  {
    repo: "yuxinlu1/gemma-4-12B-coder-fable5-composer2.5-v1-GGUF",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 34.282493,
    batch: 10,
    aggregate: 204.610205,
    dennard: 3614.774808,
  },
  {
    repo: "microsoft/Phi-4-mini-instruct",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 23.006237,
    batch: 1,
    aggregate: 23.006237,
    dennard: 304.95062,
  },
  {
    repo: "google/gemma-4-26B-A4B-it",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 34.045774,
    batch: 2,
    aggregate: 49.329186,
    dennard: 3383.736554,
  },
  {
    repo: "google/gemma-4-26B-A4B",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 34.045774,
    batch: 2,
    aggregate: 49.329186,
    dennard: 3383.736554,
  },
  {
    repo: "google/gemma-4-26B-A4B-it",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 76.571814,
    batch: 10,
    aggregate: 202.998061,
    dennard: 7610.308587,
  },
  {
    repo: "cyankiwi/gemma-4-26B-A4B-it-AWQ-4bit",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 62.45859,
    batch: 10,
    aggregate: 209.371465,
    dennard: 9729.162647,
  },
  {
    repo: "cyankiwi/gemma-4-26B-A4B-it-AWQ-4bit",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 140.474631,
    batch: 41,
    aggregate: 826.85303,
    dennard: 21881.706467,
  },
  {
    repo: "lmstudio-community/gemma-4-26B-A4B-it-QAT-MLX-4bit",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 97.577543,
    batch: 12,
    aggregate: 251.443001,
    dennard: 16288.814631,
  },
  {
    repo: "lmstudio-community/gemma-4-26B-A4B-it-QAT-MLX-4bit",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 219.460114,
    batch: 45,
    aggregate: 903.714646,
    dennard: 36634.916422,
  },
  {
    repo: "RedHatAI/gemma-4-26B-A4B-it-NVFP4",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 75.802882,
    batch: 11,
    aggregate: 229.865091,
    dennard: 12138.535002,
  },
  {
    repo: "RedHatAI/gemma-4-26B-A4B-it-NVFP4",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 170.487068,
    batch: 43,
    aggregate: 864.690309,
    dennard: 27300.587879,
  },
  {
    repo: "google/gemma-4-31B-it",
    hardwareId: "nvidia-dgx-spark",
    status: "no_floor",
    single: 4.340988,
    batch: null,
    aggregate: 0,
    dennard: 88.496259,
  },
  {
    repo: "google/gemma-4-31B-it",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "no_floor",
    single: 9.763247,
    batch: null,
    aggregate: 0,
    dennard: 199.035543,
  },
  {
    repo: "google/gemma-4-31B-it-qat-w4a16-ct",
    hardwareId: "nvidia-dgx-spark",
    status: "no_floor",
    single: 13.131789,
    batch: null,
    aggregate: 0,
    dennard: 474.105161,
  },
  {
    repo: "google/gemma-4-31B-it-qat-w4a16-ct",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 29.534499,
    batch: 7,
    aggregate: 144.44839,
    dennard: 1066.30245,
  },
  {
    repo: "RedHatAI/gemma-4-31B-it-NVFP4",
    hardwareId: "nvidia-dgx-spark",
    status: "no_floor",
    single: 13.131791,
    batch: null,
    aggregate: 0,
    dennard: 474.105258,
  },
  {
    repo: "RedHatAI/gemma-4-31B-it-NVFP4",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 29.534504,
    batch: 7,
    aggregate: 144.448406,
    dennard: 1066.302667,
  },
  {
    repo: "RedHatAI/gemma-4-31B-it-FP8-block",
    hardwareId: "nvidia-dgx-spark",
    status: "no_floor",
    single: 8.123608,
    batch: null,
    aggregate: 0,
    dennard: 255.434743,
  },
  {
    repo: "RedHatAI/gemma-4-31B-it-FP8-block",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "no_floor",
    single: 18.270678,
    batch: null,
    aggregate: 0,
    dennard: 574.494257,
  },
  {
    repo: "nvidia/Gemma-4-31B-IT-NVFP4",
    hardwareId: "nvidia-dgx-spark",
    status: "no_floor",
    single: 8.470664,
    batch: null,
    aggregate: 0,
    dennard: 524.872527,
  },
  {
    repo: "nvidia/Gemma-4-31B-IT-NVFP4",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "no_floor",
    single: 19.051237,
    batch: null,
    aggregate: 0,
    dennard: 1180.482533,
  },
  {
    repo: "zai-org/GLM-4.7-Flash",
    hardwareId: "nvidia-dgx-spark",
    status: "no_session_capacity",
    single: 7.191578,
    batch: null,
    aggregate: 0,
    dennard: 22.801934,
  },
  {
    repo: "zai-org/GLM-4.7-Flash",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "no_session_capacity",
    single: 16.174465,
    batch: null,
    aggregate: 0,
    dennard: 51.28347,
  },
  {
    repo: "zai-org/GLM-5-FP8",
    hardwareId: "nvidia-dgx-spark",
    status: "resident_not_fit",
    single: 1.324305,
    batch: null,
    aggregate: 0,
    dennard: 0,
  },
  {
    repo: "zai-org/GLM-5-FP8",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "resident_not_fit",
    single: 2.978474,
    batch: null,
    aggregate: 0,
    dennard: 0,
  },
  {
    repo: "zai-org/GLM-5.1-FP8",
    hardwareId: "nvidia-dgx-spark",
    status: "resident_not_fit",
    single: 1.324305,
    batch: null,
    aggregate: 0,
    dennard: 0,
  },
  {
    repo: "zai-org/GLM-5.1-FP8",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "resident_not_fit",
    single: 2.978474,
    batch: null,
    aggregate: 0,
    dennard: 0,
  },
  {
    repo: "zai-org/GLM-5.2-FP8",
    hardwareId: "nvidia-dgx-spark",
    status: "resident_not_fit",
    single: 1.330842,
    batch: null,
    aggregate: 0,
    dennard: 0,
  },
  {
    repo: "zai-org/GLM-5.2-FP8",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "resident_not_fit",
    single: 2.993175,
    batch: null,
    aggregate: 0,
    dennard: 0,
  },
  {
    repo: "moonshotai/Kimi-K2.5",
    hardwareId: "nvidia-dgx-spark",
    status: "resident_not_fit",
    single: 2.417203,
    batch: null,
    aggregate: 0,
    dennard: 0,
  },
  {
    repo: "moonshotai/Kimi-K2.5",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "resident_not_fit",
    single: 5.436494,
    batch: null,
    aggregate: 0,
    dennard: 0,
  },
  {
    repo: "moonshotai/Kimi-K2.6",
    hardwareId: "nvidia-dgx-spark",
    status: "resident_not_fit",
    single: 2.417203,
    batch: null,
    aggregate: 0,
    dennard: 0,
  },
  {
    repo: "moonshotai/Kimi-K2.6",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "resident_not_fit",
    single: 5.436494,
    batch: null,
    aggregate: 0,
    dennard: 0,
  },
  {
    repo: "nvidia/Kimi-K2.6-NVFP4",
    hardwareId: "nvidia-dgx-spark",
    status: "resident_not_fit",
    single: 3.7416,
    batch: null,
    aggregate: 0,
    dennard: 0,
  },
  {
    repo: "nvidia/Kimi-K2.6-NVFP4",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "resident_not_fit",
    single: 8.415174,
    batch: null,
    aggregate: 0,
    dennard: 0,
  },
  {
    repo: "moonshotai/Kimi-K2.7-Code",
    hardwareId: "nvidia-dgx-spark",
    status: "resident_not_fit",
    single: 2.417203,
    batch: null,
    aggregate: 0,
    dennard: 0,
  },
  {
    repo: "moonshotai/Kimi-K2.7-Code",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "resident_not_fit",
    single: 5.436494,
    batch: null,
    aggregate: 0,
    dennard: 0,
  },
  {
    repo: "Qwen/Qwen2.5-VL-7B-Instruct",
    hardwareId: "nvidia-dgx-spark",
    status: "no_floor",
    single: 17.087869,
    batch: null,
    aggregate: 0,
    dennard: 348.15574,
  },
  {
    repo: "Qwen/Qwen2.5-VL-7B-Instruct",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 38.432057,
    batch: 9,
    aggregate: 180.256526,
    dennard: 783.031591,
  },
  {
    repo: "Qwen/Qwen2.5-VL-7B-Instruct-AWQ",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 43.225197,
    batch: 4,
    aggregate: 92.379654,
    dennard: 1201.41961,
  },
  {
    repo: "Qwen/Qwen2.5-VL-7B-Instruct-AWQ",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 97.21711,
    batch: 14,
    aggregate: 284.910628,
    dennard: 2702.093921,
  },
  {
    repo: "Qwen/Qwen3.5-9B",
    hardwareId: "nvidia-dgx-spark",
    status: "no_floor",
    single: 16.083557,
    batch: null,
    aggregate: 0,
    dennard: 520.26036,
  },
  {
    repo: "Qwen/Qwen3.5-9B",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 36.173275,
    batch: 13,
    aggregate: 264.483088,
    dennard: 1170.109382,
  },
  {
    repo: "AxionML/Qwen3.5-9B-NVFP4",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 38.84185,
    batch: 7,
    aggregate: 140.191189,
    dennard: 1530.687245,
  },
  {
    repo: "AxionML/Qwen3.5-9B-NVFP4",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 87.358593,
    batch: 22,
    aggregate: 448.196117,
    dennard: 3442.644573,
  },
  {
    repo: "lmstudio-community/Qwen3.5-9B-MLX-4bit",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 49.044329,
    batch: 8,
    aggregate: 164.584784,
    dennard: 2094.460921,
  },
  {
    repo: "lmstudio-community/Qwen3.5-9B-MLX-4bit",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 110.304827,
    batch: 23,
    aggregate: 474.259228,
    dennard: 4710.619067,
  },
  {
    repo: "Qwen/Qwen3.5-0.8B",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 142.353109,
    batch: 29,
    aggregate: 587.267957,
    dennard: 17182.639845,
  },
  {
    repo: "Qwen/Qwen3.5-0.8B",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 320.164135,
    batch: 70,
    aggregate: 1413.209201,
    dennard: 38645.204634,
  },
  {
    repo: "Qwen/Qwen3.5-0.8B-Base",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 142.353109,
    batch: 29,
    aggregate: 587.267957,
    dennard: 17182.639845,
  },
  {
    repo: "Qwen/Qwen3.5-0.8B-Base",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 320.164135,
    batch: 70,
    aggregate: 1413.209201,
    dennard: 38645.204634,
  },
  {
    repo: "Qwen/Qwen3.5-27B",
    hardwareId: "nvidia-dgx-spark",
    status: "no_floor",
    single: 5.10268,
    batch: null,
    aggregate: 0,
    dennard: 51.166346,
  },
  {
    repo: "Qwen/Qwen3.5-27B",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "no_floor",
    single: 11.476357,
    batch: null,
    aggregate: 0,
    dennard: 115.077423,
  },
  {
    repo: "Qwen/Qwen3.5-27B-FP8",
    hardwareId: "nvidia-dgx-spark",
    status: "no_floor",
    single: 9.356588,
    batch: null,
    aggregate: 0,
    dennard: 134.715087,
  },
  {
    repo: "Qwen/Qwen3.5-27B-FP8",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 21.043755,
    batch: 1,
    aggregate: 21.043755,
    dennard: 302.98558,
  },
  {
    repo: "Qwen/Qwen3.6-27B",
    hardwareId: "nvidia-dgx-spark",
    status: "no_floor",
    single: 5.102682,
    batch: null,
    aggregate: 0,
    dennard: 51.166376,
  },
  {
    repo: "Qwen/Qwen3.6-27B",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "no_floor",
    single: 11.476361,
    batch: null,
    aggregate: 0,
    dennard: 115.077491,
  },
  {
    repo: "Qwen/Qwen3.6-27B-FP8",
    hardwareId: "nvidia-dgx-spark",
    status: "no_floor",
    single: 9.356593,
    batch: null,
    aggregate: 0,
    dennard: 134.715197,
  },
  {
    repo: "Qwen/Qwen3.6-27B-FP8",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 21.043767,
    batch: 1,
    aggregate: 21.043767,
    dennard: 302.985827,
  },
  {
    repo: "unsloth/Qwen3.6-35B-A3B-MTP-GGUF",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 78.636048,
    batch: 9,
    aggregate: 181.996537,
    dennard: 4561.971324,
  },
  {
    repo: "unsloth/Qwen3.6-35B-A3B-MTP-GGUF",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 176.859097,
    batch: 24,
    aggregate: 492.935463,
    dennard: 10260.257849,
  },
  {
    repo: "unsloth/Qwen3.6-27B-MTP-GGUF",
    hardwareId: "nvidia-dgx-spark",
    status: "no_floor",
    single: 14.242137,
    batch: null,
    aggregate: 0,
    dennard: 245.592315,
  },
  {
    repo: "unsloth/Qwen3.6-27B-MTP-GGUF",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 32.031767,
    batch: 6,
    aggregate: 121.069248,
    dennard: 552.357806,
  },
  {
    repo: "DavidAU/Qwen3.6-27B-Heretic-Uncensored-FINETUNE-NEO-CODE-Di-IMatrix-MAX-GGUF",
    hardwareId: "nvidia-dgx-spark",
    status: "no_floor",
    single: 8.876153,
    batch: null,
    aggregate: 0,
    dennard: 128.679458,
  },
  {
    repo: "DavidAU/Qwen3.6-27B-Heretic-Uncensored-FINETUNE-NEO-CODE-Di-IMatrix-MAX-GGUF",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "no_floor",
    single: 19.963216,
    batch: null,
    aggregate: 0,
    dennard: 289.410942,
  },
  {
    repo: "lmstudio-community/Qwen3.6-27B-MLX-4bit",
    hardwareId: "nvidia-dgx-spark",
    status: "no_floor",
    single: 16.377,
    batch: null,
    aggregate: 0,
    dennard: 293.391795,
  },
  {
    repo: "lmstudio-community/Qwen3.6-27B-MLX-4bit",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 36.833253,
    batch: 7,
    aggregate: 142.40184,
    dennard: 659.862864,
  },
  {
    repo: "lmstudio-community/Qwen3.6-27B-MLX-5bit",
    hardwareId: "nvidia-dgx-spark",
    status: "no_floor",
    single: 13.737602,
    batch: null,
    aggregate: 0,
    dennard: 232.300037,
  },
  {
    repo: "lmstudio-community/Qwen3.6-27B-MLX-5bit",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 30.897024,
    batch: 5,
    aggregate: 106.299067,
    dennard: 522.462355,
  },
  {
    repo: "lmstudio-community/Qwen3.6-27B-MLX-6bit",
    hardwareId: "nvidia-dgx-spark",
    status: "no_floor",
    single: 11.830879,
    batch: null,
    aggregate: 0,
    dennard: 190.000967,
  },
  {
    repo: "lmstudio-community/Qwen3.6-27B-MLX-6bit",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 26.608644,
    batch: 4,
    aggregate: 82.329232,
    dennard: 427.328183,
  },
  {
    repo: "lmstudio-community/Qwen3.6-27B-MLX-8bit",
    hardwareId: "nvidia-dgx-spark",
    status: "no_floor",
    single: 9.260297,
    batch: null,
    aggregate: 0,
    dennard: 135.255193,
  },
  {
    repo: "lmstudio-community/Qwen3.6-27B-MLX-8bit",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 20.827187,
    batch: 1,
    aggregate: 20.827187,
    dennard: 304.200324,
  },
  {
    repo: "TheBloke/TinyLlama-1.1B-Chat-v0.3-GPTQ",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 201.046372,
    batch: 18,
    aggregate: 360.975091,
    dennard: 22682.625291,
  },
  {
    repo: "TheBloke/TinyLlama-1.1B-Chat-v0.3-GPTQ",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 452.170229,
    batch: 41,
    aggregate: 833.749102,
    dennard: 51015.135269,
  },
  {
    repo: "Qwen/Qwen2.5-72B-Instruct-AWQ",
    hardwareId: "nvidia-dgx-spark",
    status: "no_floor",
    single: 5.505157,
    batch: null,
    aggregate: 0,
    dennard: 16.704415,
  },
  {
    repo: "Qwen/Qwen2.5-72B-Instruct-AWQ",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "no_floor",
    single: 12.381563,
    batch: null,
    aggregate: 0,
    dennard: 37.569637,
  },
  {
    repo: "cyankiwi/Qwen3.6-27B-AWQ-INT4",
    hardwareId: "nvidia-dgx-spark",
    status: "no_floor",
    single: 14.435749,
    batch: null,
    aggregate: 0,
    dennard: 243.190956,
  },
  {
    repo: "cyankiwi/Qwen3.6-27B-AWQ-INT4",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 32.467215,
    batch: 6,
    aggregate: 122.100849,
    dennard: 546.956949,
  },
  {
    repo: "QuantTrio/Qwen3.6-27B-AWQ",
    hardwareId: "nvidia-dgx-spark",
    status: "no_floor",
    single: 13.793967,
    batch: null,
    aggregate: 0,
    dennard: 227.721425,
  },
  {
    repo: "QuantTrio/Qwen3.6-27B-AWQ",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 31.023794,
    batch: 5,
    aggregate: 106.598788,
    dennard: 512.164671,
  },
  {
    repo: "unsloth/Qwen3.6-27B-NVFP4",
    hardwareId: "nvidia-dgx-spark",
    status: "no_floor",
    single: 11.225601,
    batch: null,
    aggregate: 0,
    dennard: 172.643281,
  },
  {
    repo: "unsloth/Qwen3.6-27B-NVFP4",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 25.247321,
    batch: 3,
    aggregate: 63.906033,
    dennard: 388.289285,
  },
  {
    repo: "deepseek-ai/DeepSeek-Coder-V2-Lite-Instruct",
    hardwareId: "nvidia-dgx-spark",
    status: "no_floor",
    single: 19.854213,
    batch: null,
    aggregate: 0,
    dennard: 178.409796,
  },
  {
    repo: "deepseek-ai/DeepSeek-Coder-V2-Lite-Instruct",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 44.653798,
    batch: 2,
    aggregate: 49.034503,
    dennard: 401.258661,
  },
  {
    repo: "deepseek-ai/DeepSeek-V2-Lite-Chat",
    hardwareId: "nvidia-dgx-spark",
    status: "no_floor",
    single: 19.854213,
    batch: null,
    aggregate: 0,
    dennard: 178.409796,
  },
  {
    repo: "deepseek-ai/DeepSeek-V2-Lite-Chat",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 44.653798,
    batch: 2,
    aggregate: 49.034503,
    dennard: 401.258661,
  },
  {
    repo: "deepseek-ai/DeepSeek-V2-Lite",
    hardwareId: "nvidia-dgx-spark",
    status: "no_floor",
    single: 19.854213,
    batch: null,
    aggregate: 0,
    dennard: 178.409796,
  },
  {
    repo: "deepseek-ai/DeepSeek-V2-Lite",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 44.653798,
    batch: 2,
    aggregate: 49.034503,
    dennard: 401.258661,
  },
  {
    repo: "deepseek-ai/deepseek-vl2-tiny",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 87.659171,
    batch: 5,
    aggregate: 110.013092,
    dennard: 4382.742068,
  },
  {
    repo: "deepseek-ai/deepseek-vl2-tiny",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 197.152861,
    batch: 13,
    aggregate: 268.300306,
    dennard: 9857.156154,
  },
  {
    repo: "nm-testing/SmolLM-1.7B-Instruct-quantized.w4a16",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 35.91877,
    batch: 1,
    aggregate: 35.91877,
    dennard: 1254.742878,
  },
  {
    repo: "nm-testing/SmolLM-1.7B-Instruct-quantized.w4a16",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 80.78434,
    batch: 4,
    aggregate: 92.767283,
    dennard: 2822.022443,
  },
  {
    repo: "microsoft/Phi-3.5-mini-instruct",
    hardwareId: "nvidia-dgx-spark",
    status: "no_floor",
    single: 13.630869,
    batch: null,
    aggregate: 0,
    dennard: 104.775789,
  },
  {
    repo: "microsoft/Phi-3.5-mini-instruct",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 30.656973,
    batch: 1,
    aggregate: 30.656973,
    dennard: 235.649576,
  },
  {
    repo: "Qwen/Qwen3.6-35B-A3B",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 41.2817,
    batch: 3,
    aggregate: 68.862096,
    dennard: 1054.566046,
  },
  {
    repo: "Qwen/Qwen3.6-35B-A3B",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 92.846021,
    batch: 10,
    aggregate: 214.632765,
    dennard: 2371.807884,
  },
  {
    repo: "RedHatAI/Qwen3.6-35B-A3B-NVFP4",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 59.434533,
    batch: 8,
    aggregate: 166.298989,
    dennard: 3168.39637,
  },
  {
    repo: "RedHatAI/Qwen3.6-35B-A3B-NVFP4",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 133.673272,
    batch: 24,
    aggregate: 487.060889,
    dennard: 7125.99037,
  },
  {
    repo: "Qwen/Qwen3.5-4B",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 28.700617,
    batch: 4,
    aggregate: 85.223067,
    dennard: 1079.15444,
  },
  {
    repo: "Qwen/Qwen3.5-4B",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 64.550105,
    batch: 20,
    aggregate: 403.666919,
    dennard: 2427.109253,
  },
  {
    repo: "deepseek-ai/DeepSeek-R1",
    hardwareId: "nvidia-dgx-spark",
    status: "resident_not_fit",
    single: 6.535707,
    batch: null,
    aggregate: 0,
    dennard: 0,
  },
  {
    repo: "deepseek-ai/DeepSeek-R1",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "resident_not_fit",
    single: 14.699356,
    batch: null,
    aggregate: 0,
    dennard: 0,
  },
  {
    repo: "deepseek-ai/DeepSeek-R1-0528",
    hardwareId: "nvidia-dgx-spark",
    status: "resident_not_fit",
    single: 6.535707,
    batch: null,
    aggregate: 0,
    dennard: 0,
  },
  {
    repo: "deepseek-ai/DeepSeek-R1-0528",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "resident_not_fit",
    single: 14.699356,
    batch: null,
    aggregate: 0,
    dennard: 0,
  },
  {
    repo: "deepseek-ai/DeepSeek-V3.2",
    hardwareId: "nvidia-dgx-spark",
    status: "resident_not_fit",
    single: 6.509023,
    batch: null,
    aggregate: 0,
    dennard: 0,
  },
  {
    repo: "deepseek-ai/DeepSeek-V3.2",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "resident_not_fit",
    single: 14.639341,
    batch: null,
    aggregate: 0,
    dennard: 0,
  },
  {
    repo: "openai/gpt-oss-20b",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 60.698215,
    batch: 6,
    aggregate: 128.187238,
    dennard: 3178.551951,
  },
  {
    repo: "openai/gpt-oss-20b",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 136.5154,
    batch: 23,
    aggregate: 466.196276,
    dennard: 7148.831127,
  },
  {
    repo: "openai/gpt-oss-120b",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 44.122861,
    batch: 3,
    aggregate: 67.17918,
    dennard: 809.424149,
  },
  {
    repo: "openai/gpt-oss-120b",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 99.236032,
    batch: 9,
    aggregate: 191.108127,
    dennard: 1820.463104,
  },
  {
    repo: "Qwen/Qwen3.6-35B-A3B-FP8",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 64.974175,
    batch: 6,
    aggregate: 132.26805,
    dennard: 3063.529404,
  },
  {
    repo: "Qwen/Qwen3.6-35B-A3B-FP8",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 146.132393,
    batch: 18,
    aggregate: 375.114551,
    dennard: 6890.135729,
  },
  {
    repo: "Qwen/Qwen3.5-35B-A3B-FP8",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 64.974026,
    batch: 6,
    aggregate: 132.267948,
    dennard: 3063.5206,
  },
  {
    repo: "Qwen/Qwen3.5-35B-A3B-FP8",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 146.132059,
    batch: 18,
    aggregate: 375.114429,
    dennard: 6890.115929,
  },
  {
    repo: "Qwen/Qwen3.5-35B-A3B-GPTQ-Int4",
    hardwareId: "nvidia-dgx-spark",
    status: "ok",
    single: 53.229666,
    batch: 8,
    aggregate: 162.529181,
    dennard: 2801.834632,
  },
  {
    repo: "Qwen/Qwen3.5-35B-A3B-GPTQ-Int4",
    hardwareId: "apple-macbook-pro-16-m5-max-128gb",
    status: "ok",
    single: 119.718004,
    batch: 24,
    aggregate: 488.105938,
    dennard: 6301.562139,
  },
]) {
  assertProfiledReference(reference);
}

{
  const result = profiled("Qwen/Qwen3-0.6B", "nvidia-dgx-spark");
  assertNear(
    result.resident,
    1.503264768,
    0.000000001,
    "Qwen3 0.6B resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    1.19209984,
    0.000000001,
    "Qwen3 0.6B swept text-decode traffic",
  );
  assertNear(
    result.alloc,
    11.4688,
    0.000000001,
    "Qwen3 0.6B BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    3.670016,
    0.000000001,
    "Qwen3 0.6B BF16 KV read traffic",
  );
}

{
  const repo = "Qwen/Qwen3Guard-Gen-0.6B";
  const item = profile(repo);
  const modelRow = model(repo);
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  const weightAdapter = item.architecture.weight_adapter;
  assert.equal(item.status, "audited");
  assert.equal(modelRow.hf_downloads, 185541);
  assert.equal(item.architecture.max_context_tokens, 32768);
  assert.equal(item.serving.weight_format, "bf16");
  assert.equal(item.architecture.kv_adapter.kind, "full_context");
  assertNear(
    result.resident,
    1.503264768,
    0.000000001,
    "Qwen3Guard Gen 0.6B resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.311164928,
    0.000000001,
    "Qwen3Guard Gen 0.6B resident input embedding footprint",
  );
  assertNear(
    result.single.batchWeight,
    1.19209984,
    0.000000001,
    "Qwen3Guard Gen 0.6B swept text-decode traffic",
  );
  assertNear(
    result.alloc,
    11.4688,
    0.000000001,
    "Qwen3Guard Gen 0.6B BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    3.670016,
    0.000000001,
    "Qwen3Guard Gen 0.6B BF16 KV read traffic",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(result.bMem, 10);
  assert.equal(result.best.batch, 3);
  assertNear(
    result.single.aggregate,
    56.148394852,
    0.000001,
    "Qwen3Guard Gen 0.6B DGX Spark single-session throughput",
  );
  assertNear(
    result.best.aggregate,
    67.119331018,
    0.000001,
    "Qwen3Guard Gen 0.6B DGX Spark aggregate throughput",
  );
  assertNear(
    result.dennard,
    2366.129025317,
    0.000001,
    "Qwen3Guard Gen 0.6B DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 8);
  assertNear(
    m5Result.best.aggregate,
    160.773873045,
    0.000001,
    "Qwen3Guard Gen 0.6B M5 Max aggregate throughput",
  );
}

{
  const result = profiled("Qwen/Qwen3-0.6B-Base", "nvidia-dgx-spark");
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    1.19209984,
    0.000000001,
    "Qwen3 0.6B Base resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    1.19209984,
    0.000000001,
    "Qwen3 0.6B Base swept text-decode traffic",
  );
  assertNear(
    result.alloc,
    11.4688,
    0.000000001,
    "Qwen3 0.6B Base BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    3.670016,
    0.000000001,
    "Qwen3 0.6B Base BF16 KV read traffic",
  );
  assert.equal(result.bMem, 10);
  assert.equal(result.best.batch, 3);
  assertNear(
    result.single.aggregate,
    56.148394851900534,
    0.000000001,
    "Qwen3 0.6B Base DGX Spark single-session throughput",
  );
  assertNear(
    result.best.aggregate,
    67.11933101771041,
    0.000000001,
    "Qwen3 0.6B Base DGX Spark aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    22.373110339236803,
    0.000000001,
    "Qwen3 0.6B Base DGX Spark per-session throughput",
  );
  assertNear(
    result.dennard,
    2372.3423304041376,
    0.000000001,
    "Qwen3 0.6B Base DGX Spark Dennard bound",
  );
}

{
  const result = profiled("Qwen/Qwen3-0.6B-FP8", "nvidia-dgx-spark");
  assertNear(
    result.resident,
    1.062916608,
    0.000000001,
    "Qwen3 0.6B FP8 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    0.75175168,
    0.000000001,
    "Qwen3 0.6B FP8 swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    0.311164928,
    0.000000001,
    "Qwen3 0.6B FP8 resident input embedding footprint",
  );
  assertNear(
    result.alloc,
    11.4688,
    0.000000001,
    "Qwen3 0.6B FP8 BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    3.670016,
    0.000000001,
    "Qwen3 0.6B FP8 BF16 KV read traffic",
  );
}

{
  const result = profiled("MaziyarPanahi/Qwen3-0.6B-GGUF", "nvidia-dgx-spark");
  const m5Result = profiled(
    "MaziyarPanahi/Qwen3-0.6B-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    1.509347456,
    0.000000001,
    "MaziyarPanahi Qwen3 0.6B F16 GGUF resident file footprint",
  );
  assertNear(
    result.single.batchWeight,
    1.192230912,
    0.000000001,
    "MaziyarPanahi Qwen3 0.6B F16 GGUF swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    0.317116544,
    0.000000001,
    "MaziyarPanahi Qwen3 0.6B F16 GGUF resident input/header footprint",
  );
  assertNear(
    result.alloc,
    11.4688,
    0.000000001,
    "MaziyarPanahi Qwen3 0.6B F16 GGUF FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    3.670016,
    0.000000001,
    "MaziyarPanahi Qwen3 0.6B F16 GGUF FP16 KV read traffic",
  );
  assert.equal(result.bMem, 10);
  assert.equal(result.best.batch, 3);
  assertNear(
    result.best.aggregate,
    67.11861004869974,
    0.000000001,
    "MaziyarPanahi Qwen3 0.6B F16 GGUF DGX aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    22.372870016233247,
    0.000000001,
    "MaziyarPanahi Qwen3 0.6B F16 GGUF DGX per-session throughput",
  );
  assertNear(
    result.dennard,
    2365.747451742909,
    0.000000001,
    "MaziyarPanahi Qwen3 0.6B F16 GGUF DGX Dennard bound",
  );
  assert.equal(m5Result.best.batch, 8);
  assertNear(
    m5Result.best.aggregate,
    160.77318331288396,
    0.000000001,
    "MaziyarPanahi Qwen3 0.6B F16 GGUF M5 Max aggregate throughput",
  );
}

{
  const repo = "unsloth/Qwen3-0.6B-GGUF";
  const row = model(repo);
  const item = profile(repo);
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  const m1Result = profiled(repo, "apple-mac-studio-m1-ultra-128gb");

  assert.equal(row.hf_downloads, 100231);
  assert.ok(row.tags.includes("region:us"));
  assert.equal(row.adapter.weight_precision, "BF16 GGUF");
  assertNear(
    row.architecture.total_params_b,
    0.59604992,
    0.000000001,
    "Unsloth Qwen3 0.6B BF16 GGUF catalog total params",
  );
  assertNear(
    row.architecture.active_params_b,
    0.59604992,
    0.000000001,
    "Unsloth Qwen3 0.6B BF16 GGUF catalog swept params",
  );
  assert.equal(item.status, "audited");
  assert.equal(item.base_model_proof.config_compatible, true);
  assert.equal(item.serving.runtime_format, "llama.cpp-gguf-bf16-memory-bound");
  assert.equal(item.architecture.kv_adapter.kind, "full_context");
  assert.equal(item.architecture.kv_adapter.layers, 28);
  assert.equal(item.architecture.kv_adapter.kv_heads, 8);
  assert.equal(item.architecture.kv_adapter.head_dim, 128);
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    1.198182848,
    0.000000001,
    "Unsloth Qwen3 0.6B BF16 GGUF resident file footprint",
  );
  assertNear(
    result.single.batchWeight,
    1.192230912,
    0.000000001,
    "Unsloth Qwen3 0.6B BF16 GGUF swept tied text-decode traffic",
  );
  assertNear(
    item.architecture.weight_adapter.auxiliary_resident_weight_gb,
    0.005951936,
    0.000000001,
    "Unsloth Qwen3 0.6B BF16 GGUF resident header/tokenizer footprint",
  );
  assertNear(
    result.alloc,
    11.4688,
    0.000000001,
    "Unsloth Qwen3 0.6B BF16 GGUF FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    3.670016,
    0.000000001,
    "Unsloth Qwen3 0.6B BF16 GGUF FP16 KV read traffic",
  );
  assert.equal(result.bMem, 10);
  assert.equal(result.best.batch, 3);
  assertNear(
    result.best.aggregate,
    67.11861004869974,
    0.000000001,
    "Unsloth Qwen3 0.6B BF16 GGUF DGX aggregate throughput",
  );
  assertNear(
    result.dennard,
    2371.9600673597843,
    0.000000001,
    "Unsloth Qwen3 0.6B BF16 GGUF DGX Dennard bound",
  );
  assert.equal(m5Result.best.batch, 8);
  assertNear(
    m5Result.best.aggregate,
    160.77318331288396,
    0.000000001,
    "Unsloth Qwen3 0.6B BF16 GGUF M5 Max aggregate throughput",
  );
  assert.equal(m1Result.best.batch, 10);
  assertNear(
    m1Result.best.aggregate,
    211.12418106788058,
    0.000000001,
    "Unsloth Qwen3 0.6B BF16 GGUF M1 Ultra aggregate throughput",
  );
}

{
  const result = profiled("Qwen/Qwen2-VL-7B-Instruct", "nvidia-dgx-spark");
  assertNear(
    result.resident,
    16.582751232,
    0.000000001,
    "Qwen2-VL 7B resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    14.141238272,
    0.000000001,
    "Qwen2-VL 7B swept text-decode traffic",
  );
  assertNear(
    result.alloc,
    5.7344,
    0.000000001,
    "Qwen2-VL 7B full-context KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.835008,
    0.000000001,
    "Qwen2-VL 7B full-context KV read traffic",
  );
}

{
  const result = profiled("Qwen/Qwen2-VL-7B-Instruct-AWQ", "nvidia-dgx-spark");
  assertNear(
    result.resident,
    6.9222656,
    0.000000001,
    "Qwen2-VL 7B AWQ resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    4.48075264,
    0.000000001,
    "Qwen2-VL 7B AWQ swept text-decode traffic",
  );
  assertNear(
    result.alloc,
    5.7344,
    0.000000001,
    "Qwen2-VL 7B AWQ full-context KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.835008,
    0.000000001,
    "Qwen2-VL 7B AWQ full-context KV read traffic",
  );
}

{
  const repo = "OpenGVLab/InternVL2_5-8B-AWQ";
  const catalogRow = model(repo);
  const item = profile(repo);
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  assert.equal(item.status, "audited");
  assert.equal(item.base_model_proof.config_compatible, true);
  assert.equal(catalogRow.hf_downloads, 304286);
  assert.equal(catalogRow.tags.includes("region:us"), true);
  assertNear(
    catalogRow.adapter.resident_weight_gb,
    5.818062848,
    0.000000001,
    "InternVL2.5 8B AWQ catalog resident footprint",
  );
  assertNear(
    catalogRow.adapter.active_weight_gb,
    4.384702464,
    0.000000001,
    "InternVL2.5 8B AWQ catalog swept traffic",
  );
  assertNear(
    weightAdapter.resident_params_b,
    8.075365376,
    0.000000001,
    "InternVL2.5 8B AWQ logical resident parameters",
  );
  assertNear(
    weightAdapter.swept_params_b,
    7.358685184,
    0.000000001,
    "InternVL2.5 8B AWQ logical swept parameters",
  );
  assertNear(
    weightAdapter.auxiliary_resident_params_b,
    0.716680192,
    0.000000001,
    "InternVL2.5 8B AWQ logical auxiliary resident parameters",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    5.818062848,
    0.000000001,
    "InternVL2.5 8B AWQ resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    4.384702464,
    0.000000001,
    "InternVL2.5 8B AWQ swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    1.433360384,
    0.000000001,
    "InternVL2.5 8B AWQ resident-only multimodal/input-embedding footprint",
  );
  assertNear(
    result.alloc,
    13.1072,
    0.000000001,
    "InternVL2.5 8B AWQ full-context KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    4.194304,
    0.000000001,
    "InternVL2.5 8B AWQ full-context KV read traffic",
  );
  assert.equal(result.best?.batch, 2);
  assertNear(
    result.best?.aggregate ?? 0,
    42.74537924517169,
    0.000000001,
    "InternVL2.5 8B AWQ DGX Spark aggregate throughput",
  );
  assertNear(
    result.best?.perSession ?? 0,
    21.372689622585845,
    0.000000001,
    "InternVL2.5 8B AWQ DGX Spark per-session throughput",
  );
  assertNear(
    result.dennard,
    542.3879083004412,
    0.000000001,
    "InternVL2.5 8B AWQ DGX Spark Dennard bound",
  );
}

{
  const result = profiled("Qwen/Qwen2.5-VL-7B-Instruct", "nvidia-dgx-spark");
  assertNear(
    result.resident,
    16.584333312,
    0.000000001,
    "Qwen2.5-VL 7B resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    14.141238272,
    0.000000001,
    "Qwen2.5-VL 7B swept text-decode traffic",
  );
  assertNear(
    result.alloc,
    5.7344,
    0.000000001,
    "Qwen2.5-VL 7B full-context KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.835008,
    0.000000001,
    "Qwen2.5-VL 7B full-context KV read traffic",
  );
}

{
  const result = profiled(
    "Qwen/Qwen2.5-VL-7B-Instruct-AWQ",
    "nvidia-dgx-spark",
  );
  assertNear(
    result.resident,
    6.92384768,
    0.000000001,
    "Qwen2.5-VL 7B AWQ resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    4.48075264,
    0.000000001,
    "Qwen2.5-VL 7B AWQ swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    2.44309504,
    0.000000001,
    "Qwen2.5-VL 7B AWQ resident-only visual/input-embedding footprint",
  );
  assertNear(
    result.alloc,
    5.7344,
    0.000000001,
    "Qwen2.5-VL 7B AWQ full-context KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.835008,
    0.000000001,
    "Qwen2.5-VL 7B AWQ full-context KV read traffic",
  );
}

{
  const result = profiled(
    "unsloth/Qwen2.5-VL-7B-Instruct-GGUF",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    15.237851776,
    0.000000001,
    "Unsloth Qwen2.5-VL 7B GGUF selected BF16 resident file footprint",
  );
  assertNear(
    result.single.batchWeight,
    14.141904896,
    0.000000001,
    "Unsloth Qwen2.5-VL 7B GGUF swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    1.09594688,
    0.000000001,
    "Unsloth Qwen2.5-VL 7B GGUF resident-only token/header footprint",
  );
  assertNear(
    result.alloc,
    5.7344,
    0.000000001,
    "Unsloth Qwen2.5-VL 7B GGUF full-context KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.835008,
    0.000000001,
    "Unsloth Qwen2.5-VL 7B GGUF full-context KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    17.087155808951593,
    0.000000001,
    "Unsloth Qwen2.5-VL 7B GGUF DGX single-session throughput",
  );
  assert.equal(result.bMem, 18);
  assert.equal(result.best, null);
  assertNear(
    result.dennard,
    352.67213460344647,
    0.000000001,
    "Unsloth Qwen2.5-VL 7B GGUF DGX Dennard bound",
  );

  const m5Result = profiled(
    "unsloth/Qwen2.5-VL-7B-Instruct-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.bMem, 18);
  assert.equal(m5Result.best.batch, 9);
  assertNear(
    m5Result.best.aggregate,
    180.25260673112913,
    0.000000001,
    "Unsloth Qwen2.5-VL 7B GGUF M5 Max aggregate throughput",
  );
  assertNear(
    m5Result.best.perSession,
    20.028067414569904,
    0.000000001,
    "Unsloth Qwen2.5-VL 7B GGUF M5 Max per-session throughput",
  );
  assertNear(
    m5Result.dennard,
    793.1893430275315,
    0.000000001,
    "Unsloth Qwen2.5-VL 7B GGUF M5 Max Dennard bound",
  );
}

{
  const result = profiled("google/gemma-4-E2B-it", "nvidia-dgx-spark");
  assertNear(
    result.resident,
    10.246357958,
    0.000000001,
    "Gemma 4 E2B resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    4.597279302,
    0.000000001,
    "Gemma 4 E2B swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    5.649078656,
    0.000000001,
    "Gemma 4 E2B resident multimodal/PLE footprint",
  );
  assertNear(
    result.alloc,
    0.620691456,
    0.000000001,
    "Gemma 4 E2B shared-KV BF16 allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.473432064,
    0.000000001,
    "Gemma 4 E2B layered BF16 KV read traffic",
  );
}

{
  const item = profile("google/gemma-4-E2B");
  const weightAdapter = item.architecture.weight_adapter;
  const kvAdapter = item.architecture.kv_adapter;
  const result = profiled("google/gemma-4-E2B", "nvidia-dgx-spark");
  const m5Result = profiled(
    "google/gemma-4-E2B",
    "apple-macbook-pro-16-m5-max-128gb",
  );

  assert.equal(item.status, "audited");
  assert.equal(
    item.serving.runtime_format,
    "transformers-bf16-text-decode-memory-bound",
  );
  assert.equal(kvAdapter.kind, "layered_kv");
  assert.equal(kvAdapter.components[0].alloc_layers, 3);
  assert.equal(kvAdapter.components[0].read_layers, 7);
  assert.equal(kvAdapter.components[1].alloc_layers, 12);
  assert.equal(kvAdapter.components[1].read_layers, 28);
  assert.equal(kvAdapter.components[1].window_tokens, 512);
  assertNear(
    result.resident,
    10.246357958,
    0.000000001,
    "Base Gemma 4 E2B resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    4.597279302,
    0.000000001,
    "Base Gemma 4 E2B swept text-decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    5.649078656,
    0.000000001,
    "Base Gemma 4 E2B resident multimodal/PLE footprint",
  );
  assertNear(
    result.alloc,
    0.620691456,
    0.000000001,
    "Base Gemma 4 E2B shared-KV BF16 allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.473432064,
    0.000000001,
    "Base Gemma 4 E2B layered BF16 KV read traffic",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(result.bMem, 176);
  assert.equal(result.best.batch, 19);
  assertNear(
    result.single.aggregate,
    53.83859981274273,
    0.000000001,
    "Base Gemma 4 E2B DGX single-session tok/s",
  );
  assertNear(
    result.best.aggregate,
    381.6078264941007,
    0.000000001,
    "Base Gemma 4 E2B DGX aggregate tok/s",
  );
  assertNear(
    result.best.perSession,
    20.08462244705793,
    0.000000001,
    "Base Gemma 4 E2B DGX per-session tok/s",
  );
  assertNear(
    result.dennard,
    10500.377940328286,
    0.000000001,
    "Base Gemma 4 E2B DGX Dennard bound",
  );
  assert.equal(m5Result.best.batch, 55);
  assertNear(
    m5Result.single.aggregate,
    121.08754683158988,
    0.000000001,
    "Base Gemma 4 E2B M5 Max single-session tok/s",
  );
  assertNear(
    m5Result.best.aggregate,
    1102.2964093701253,
    0.000000001,
    "Base Gemma 4 E2B M5 Max aggregate tok/s",
  );
  assertNear(
    m5Result.best.perSession,
    20.04175289763864,
    0.000000001,
    "Base Gemma 4 E2B M5 Max per-session tok/s",
  );
  assertNear(
    m5Result.dennard,
    23616.23463502406,
    0.000000001,
    "Base Gemma 4 E2B M5 Max Dennard bound",
  );
}

{
  const result = profiled("unsloth/gemma-4-E2B-it-GGUF", "nvidia-dgx-spark");
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    9.311303552,
    0.000000001,
    "Unsloth Gemma 4 E2B GGUF selected BF16 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    4.597865568,
    0.000000001,
    "Unsloth Gemma 4 E2B GGUF swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    4.713437984,
    0.000000001,
    "Unsloth Gemma 4 E2B GGUF resident PLE/header footprint",
  );
  assertNear(
    result.alloc,
    1.448280064,
    0.000000001,
    "Unsloth Gemma 4 E2B GGUF layered FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.473432064,
    0.000000001,
    "Unsloth Gemma 4 E2B GGUF layered FP16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    53.832375816,
    0.000000001,
    "Unsloth Gemma 4 E2B GGUF DGX single-session tok/s",
  );
  assert.equal(result.bMem, 76);
  assert.equal(result.best.batch, 19);
  assertNear(
    result.best.aggregate,
    381.591367842,
    0.000000001,
    "Unsloth Gemma 4 E2B GGUF DGX aggregate tok/s",
  );
  assertNear(
    result.dennard,
    4537.922746163,
    0.000000001,
    "Unsloth Gemma 4 E2B GGUF DGX Dennard bound",
  );
}

{
  const item = profile("lmstudio-community/gemma-4-E2B-it-MLX-4bit");
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(
    "lmstudio-community/gemma-4-E2B-it-MLX-4bit",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "lmstudio-community/gemma-4-E2B-it-MLX-4bit",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(
    item.serving.runtime_format,
    "mlx-vlm-4bit-affine-text-decode-memory-bound",
  );
  assertNear(
    result.resident,
    4.339549126,
    0.000000001,
    "LM Studio Gemma 4 E2B MLX 4-bit resident stored footprint",
  );
  assertNear(
    result.single.batchWeight,
    2.071972422,
    0.000000001,
    "LM Studio Gemma 4 E2B MLX 4-bit swept text-decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    2.267576704,
    0.000000001,
    "LM Studio Gemma 4 E2B MLX 4-bit resident multimodal/PLE footprint",
  );
  assertNear(
    result.alloc,
    0.620691456,
    0.000000001,
    "LM Studio Gemma 4 E2B MLX 4-bit shared-KV BF16 allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.473432064,
    0.000000001,
    "LM Studio Gemma 4 E2B MLX 4-bit layered BF16 KV read traffic",
  );
  assert.equal(result.bMem, 186);
  assert.equal(result.best.batch, 24);
  assertNear(
    result.single.aggregate,
    107.25210924296297,
    0.000000001,
    "LM Studio Gemma 4 E2B MLX 4-bit DGX single-session tok/s",
  );
  assertNear(
    result.best.aggregate,
    487.70531675340874,
    0.000000001,
    "LM Studio Gemma 4 E2B MLX 4-bit DGX aggregate tok/s",
  );
  assertNear(
    result.best.perSession,
    20.321054864725365,
    0.000000001,
    "LM Studio Gemma 4 E2B MLX 4-bit DGX per-session tok/s",
  );
  assertNear(
    result.dennard,
    24552.051710905784,
    0.000000001,
    "LM Studio Gemma 4 E2B MLX 4-bit DGX Dennard bound",
  );
  assert.equal(m5Result.best.batch, 60);
  assertNear(
    m5Result.single.aggregate,
    241.21902957941123,
    0.000000001,
    "LM Studio Gemma 4 E2B MLX 4-bit M5 Max single-session tok/s",
  );
  assertNear(
    m5Result.best.aggregate,
    1208.7448452251708,
    0.000000001,
    "LM Studio Gemma 4 E2B MLX 4-bit M5 Max aggregate tok/s",
  );
  assertNear(
    m5Result.best.perSession,
    20.145747420419514,
    0.000000001,
    "LM Studio Gemma 4 E2B MLX 4-bit M5 Max per-session tok/s",
  );
  assertNear(
    m5Result.dennard,
    55219.63278570019,
    0.000000001,
    "LM Studio Gemma 4 E2B MLX 4-bit M5 Max Dennard bound",
  );
}

{
  const item = profile("lmstudio-community/gemma-4-E2B-it-MLX-5bit");
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(
    "lmstudio-community/gemma-4-E2B-it-MLX-5bit",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "lmstudio-community/gemma-4-E2B-it-MLX-5bit",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(
    item.serving.runtime_format,
    "mlx-vlm-5bit-affine-text-decode-memory-bound",
  );
  assertNear(
    result.resident,
    4.726244294,
    0.000000001,
    "LM Studio Gemma 4 E2B MLX 5-bit resident stored footprint",
  );
  assertNear(
    result.single.batchWeight,
    2.311424582,
    0.000000001,
    "LM Studio Gemma 4 E2B MLX 5-bit swept text-decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    2.414819712,
    0.000000001,
    "LM Studio Gemma 4 E2B MLX 5-bit resident multimodal/PLE footprint",
  );
  assertNear(
    result.alloc,
    0.620691456,
    0.000000001,
    "LM Studio Gemma 4 E2B MLX 5-bit shared-KV BF16 allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.473432064,
    0.000000001,
    "LM Studio Gemma 4 E2B MLX 5-bit layered BF16 KV read traffic",
  );
  assert.equal(result.bMem, 185);
  assert.equal(result.best.batch, 23);
  assertNear(
    result.single.aggregate,
    98.03018061706004,
    0.000000001,
    "LM Studio Gemma 4 E2B MLX 5-bit DGX single-session tok/s",
  );
  assertNear(
    result.best.aggregate,
    475.6687713802005,
    0.000000001,
    "LM Studio Gemma 4 E2B MLX 5-bit DGX aggregate tok/s",
  );
  assertNear(
    result.best.perSession,
    20.681250929573935,
    0.000000001,
    "LM Studio Gemma 4 E2B MLX 5-bit DGX per-session tok/s",
  );
  assertNear(
    result.dennard,
    21934.997798362445,
    0.000000001,
    "LM Studio Gemma 4 E2B MLX 5-bit DGX Dennard bound",
  );
  assert.equal(m5Result.best.batch, 59);
  assertNear(
    m5Result.single.aggregate,
    220.47813516071378,
    0.000000001,
    "LM Studio Gemma 4 E2B MLX 5-bit M5 Max single-session tok/s",
  );
  assertNear(
    m5Result.best.aggregate,
    1197.7946100362642,
    0.000000001,
    "LM Studio Gemma 4 E2B MLX 5-bit M5 Max aggregate tok/s",
  );
  assertNear(
    m5Result.best.perSession,
    20.30160355993668,
    0.000000001,
    "LM Studio Gemma 4 E2B MLX 5-bit M5 Max per-session tok/s",
  );
  assertNear(
    m5Result.dennard,
    49333.65805199466,
    0.000000001,
    "LM Studio Gemma 4 E2B MLX 5-bit M5 Max Dennard bound",
  );
}

{
  const item = profile("lmstudio-community/gemma-4-E2B-it-MLX-6bit");
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(
    "lmstudio-community/gemma-4-E2B-it-MLX-6bit",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "lmstudio-community/gemma-4-E2B-it-MLX-6bit",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(
    item.serving.runtime_format,
    "mlx-vlm-6bit-affine-text-decode-memory-bound",
  );
  assertNear(
    result.resident,
    5.112939462,
    0.000000001,
    "LM Studio Gemma 4 E2B MLX 6-bit resident stored footprint",
  );
  assertNear(
    result.single.batchWeight,
    2.404076102,
    0.000000001,
    "LM Studio Gemma 4 E2B MLX 6-bit swept text-decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    2.70886336,
    0.000000001,
    "LM Studio Gemma 4 E2B MLX 6-bit resident multimodal/PLE footprint",
  );
  assertNear(
    result.alloc,
    0.620691456,
    0.000000001,
    "LM Studio Gemma 4 E2B MLX 6-bit shared-KV BF16 allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.473432064,
    0.000000001,
    "LM Studio Gemma 4 E2B MLX 6-bit layered BF16 KV read traffic",
  );
  assert.equal(result.bMem, 185);
  assert.equal(result.best.batch, 23);
  assertNear(
    result.single.aggregate,
    94.87375334871597,
    0.000000001,
    "LM Studio Gemma 4 E2B MLX 6-bit DGX single-session tok/s",
  );
  assertNear(
    result.best.aggregate,
    472.35338811969535,
    0.000000001,
    "LM Studio Gemma 4 E2B MLX 6-bit DGX aggregate tok/s",
  );
  assertNear(
    result.best.perSession,
    20.537103831291102,
    0.000000001,
    "LM Studio Gemma 4 E2B MLX 6-bit DGX per-session tok/s",
  );
  assertNear(
    result.dennard,
    21018.890435269164,
    0.000000001,
    "LM Studio Gemma 4 E2B MLX 6-bit DGX Dennard bound",
  );
  assert.equal(m5Result.best.batch, 59);
  assertNear(
    m5Result.single.aggregate,
    213.3790643081011,
    0.000000001,
    "LM Studio Gemma 4 E2B MLX 6-bit M5 Max single-session tok/s",
  );
  assertNear(
    m5Result.best.aggregate,
    1194.1364015100405,
    0.000000001,
    "LM Studio Gemma 4 E2B MLX 6-bit M5 Max aggregate tok/s",
  );
  assertNear(
    m5Result.best.perSession,
    20.23960002559391,
    0.000000001,
    "LM Studio Gemma 4 E2B MLX 6-bit M5 Max per-session tok/s",
  );
  assertNear(
    m5Result.dennard,
    47273.25541119146,
    0.000000001,
    "LM Studio Gemma 4 E2B MLX 6-bit M5 Max Dennard bound",
  );
}

{
  const item = profile("lmstudio-community/gemma-4-E2B-it-MLX-8bit");
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(
    "lmstudio-community/gemma-4-E2B-it-MLX-8bit",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "lmstudio-community/gemma-4-E2B-it-MLX-8bit",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(
    item.serving.runtime_format,
    "mlx-vlm-8bit-affine-text-decode-memory-bound",
  );
  assertNear(
    result.resident,
    5.886329798,
    0.000000001,
    "LM Studio Gemma 4 E2B MLX 8-bit resident stored footprint",
  );
  assertNear(
    result.single.batchWeight,
    2.589379142,
    0.000000001,
    "LM Studio Gemma 4 E2B MLX 8-bit swept text-decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    3.296950656,
    0.000000001,
    "LM Studio Gemma 4 E2B MLX 8-bit resident multimodal/PLE footprint",
  );
  assertNear(
    result.alloc,
    0.620691456,
    0.000000001,
    "LM Studio Gemma 4 E2B MLX 8-bit shared-KV BF16 allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.473432064,
    0.000000001,
    "LM Studio Gemma 4 E2B MLX 8-bit layered BF16 KV read traffic",
  );
  assert.equal(result.bMem, 183);
  assert.equal(result.best.batch, 23);
  assertNear(
    result.single.aggregate,
    89.13379951895084,
    0.000000001,
    "LM Studio Gemma 4 E2B MLX 8-bit DGX single-session tok/s",
  );
  assertNear(
    result.best.aggregate,
    465.85936358535827,
    0.000000001,
    "LM Studio Gemma 4 E2B MLX 8-bit DGX aggregate tok/s",
  );
  assertNear(
    result.best.perSession,
    20.25475493849384,
    0.000000001,
    "LM Studio Gemma 4 E2B MLX 8-bit DGX per-session tok/s",
  );
  assertNear(
    result.dennard,
    19383.35314027924,
    0.000000001,
    "LM Studio Gemma 4 E2B MLX 8-bit DGX Dennard bound",
  );
  assert.equal(m5Result.best.batch, 59);
  assertNear(
    m5Result.single.aggregate,
    200.46942455910553,
    0.000000001,
    "LM Studio Gemma 4 E2B MLX 8-bit M5 Max single-session tok/s",
  );
  assertNear(
    m5Result.best.aggregate,
    1186.8866131216105,
    0.000000001,
    "LM Studio Gemma 4 E2B MLX 8-bit M5 Max aggregate tok/s",
  );
  assertNear(
    m5Result.best.perSession,
    20.116722256298484,
    0.000000001,
    "LM Studio Gemma 4 E2B MLX 8-bit M5 Max per-session tok/s",
  );
  assertNear(
    m5Result.dennard,
    43594.79424223976,
    0.000000001,
    "LM Studio Gemma 4 E2B MLX 8-bit M5 Max Dennard bound",
  );
}

{
  const result = profiled(
    "unsloth/gemma-4-E2B-it-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.single.aggregate,
    121.073548538,
    0.000000001,
    "Unsloth Gemma 4 E2B GGUF M5 Max single-session tok/s",
  );
  assert.equal(result.bMem, 76);
  assert.equal(result.best.batch, 55);
  assertNear(
    result.best.aggregate,
    1102.275315701,
    0.000000001,
    "Unsloth Gemma 4 E2B GGUF M5 Max aggregate tok/s",
  );
  assertNear(
    result.dennard,
    10206.170571957,
    0.000000001,
    "Unsloth Gemma 4 E2B GGUF M5 Max Dennard bound",
  );
}

{
  const repo = "lmstudio-community/gemma-4-E2B-it-GGUF";
  const row = model(repo);
  const item = profile(repo);
  const weightAdapter = item.architecture.weight_adapter;
  const kvAdapter = item.architecture.kv_adapter;
  const [fullKv, slidingKv] = kvAdapter.components;
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");

  assert.equal(row.hf_downloads, 141691);
  assert.ok(row.tags.includes("region:us"));
  assert.equal(row.adapter.weight_precision, "GGUF Q4_K_M");
  assertNear(
    row.adapter.kv_alloc_gb_per_1k_tokens,
    0.006144,
    0.000000001,
    "LM Studio Gemma 4 E2B GGUF legacy token-proportional alloc coefficient",
  );
  assertNear(
    row.adapter.kv_alloc_fixed_gb,
    0.006291456,
    0.000000001,
    "LM Studio Gemma 4 E2B GGUF legacy sliding alloc fixed term",
  );
  assert.equal(item.status, "audited");
  assert.equal(
    item.serving.runtime_format,
    "llama.cpp-gguf-q4-k-m-ple-memory-bound",
  );
  assert.equal(kvAdapter.kind, "layered_kv");
  assert.equal(fullKv.alloc_layers, 3);
  assert.equal(fullKv.read_layers, 7);
  assert.equal(slidingKv.alloc_layers, 12);
  assert.equal(slidingKv.read_layers, 28);
  assert.equal(slidingKv.window_tokens, 512);
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    3.427877696,
    0.000000001,
    "LM Studio Gemma 4 E2B GGUF Q4_K_M resident file footprint",
  );
  assertNear(
    result.single.batchWeight,
    1.4853019,
    0.000000001,
    "LM Studio Gemma 4 E2B GGUF Q4_K_M swept text-decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.942575796,
    0.000000001,
    "LM Studio Gemma 4 E2B GGUF Q4_K_M resident PLE/header footprint",
  );
  assertNear(
    result.alloc,
    0.620691456,
    0.000000001,
    "LM Studio Gemma 4 E2B GGUF Q4_K_M shared-KV FP16 allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.473432064,
    0.000000001,
    "LM Studio Gemma 4 E2B GGUF Q4_K_M layered FP16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    139.3757421975249,
    0.000000001,
    "LM Studio Gemma 4 E2B GGUF Q4_K_M DGX single-session tok/s",
  );
  assert.equal(result.bMem, 187);
  assert.equal(result.best.batch, 25);
  assertNear(
    result.best.aggregate,
    512.3449419937319,
    0.000000001,
    "LM Studio Gemma 4 E2B GGUF Q4_K_M DGX aggregate tok/s",
  );
  assertNear(
    result.best.perSession,
    20.493797679749278,
    0.000000001,
    "LM Studio Gemma 4 E2B GGUF Q4_K_M DGX per-session tok/s",
  );
  assertNear(
    result.dennard,
    34519.68678495126,
    0.000000001,
    "LM Studio Gemma 4 E2B GGUF Q4_K_M DGX Dennard bound",
  );
  assertNear(
    m5Result.single.aggregate,
    313.46778648088014,
    0.000000001,
    "LM Studio Gemma 4 E2B GGUF Q4_K_M M5 Max single-session tok/s",
  );
  assert.equal(m5Result.best.batch, 61);
  assertNear(
    m5Result.best.aggregate,
    1233.4734757019428,
    0.000000001,
    "LM Studio Gemma 4 E2B GGUF Q4_K_M M5 Max aggregate tok/s",
  );
  assertNear(
    m5Result.dennard,
    77637.68383135556,
    0.000000001,
    "LM Studio Gemma 4 E2B GGUF Q4_K_M M5 Max Dennard bound",
  );
}

{
  const item = profile("google/gemma-4-E2B-it-qat-q4_0-gguf");
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(
    "google/gemma-4-E2B-it-qat-q4_0-gguf",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "google/gemma-4-E2B-it-qat-q4_0-gguf",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(
    item.serving.runtime_format,
    "llama.cpp-gguf-q4-0-qat-ple-memory-bound",
  );
  assertNear(
    result.resident,
    3.349514112,
    0.000000001,
    "Google Gemma 4 E2B QAT Q4_0 GGUF resident file footprint",
  );
  assertNear(
    result.single.batchWeight,
    1.406942304,
    0.000000001,
    "Google Gemma 4 E2B QAT Q4_0 GGUF swept text-decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.942571808,
    0.000000001,
    "Google Gemma 4 E2B QAT Q4_0 GGUF resident PLE/header footprint",
  );
  assertNear(
    result.alloc,
    0.620691456,
    0.000000001,
    "Google Gemma 4 E2B QAT Q4_0 GGUF shared-KV FP16 allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.473432064,
    0.000000001,
    "Google Gemma 4 E2B QAT Q4_0 GGUF layered FP16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    145.18385521834554,
    0.000000001,
    "Google Gemma 4 E2B QAT Q4_0 GGUF DGX single-session tok/s",
  );
  assert.equal(result.bMem, 187);
  assert.equal(result.best.batch, 25);
  assertNear(
    result.best.aggregate,
    515.3765752381947,
    0.000000001,
    "Google Gemma 4 E2B QAT Q4_0 GGUF DGX aggregate tok/s",
  );
  assertNear(
    result.dennard,
    36466.75705150731,
    0.000000001,
    "Google Gemma 4 E2B QAT Q4_0 GGUF DGX Dennard bound",
  );
  assertNear(
    m5Result.single.aggregate,
    326.53072199290904,
    0.000000001,
    "Google Gemma 4 E2B QAT Q4_0 GGUF M5 Max single-session tok/s",
  );
  assert.equal(m5Result.best.batch, 61);
  assertNear(
    m5Result.best.aggregate,
    1236.66483578725,
    0.000000001,
    "Google Gemma 4 E2B QAT Q4_0 GGUF M5 Max aggregate tok/s",
  );
  assertNear(
    m5Result.dennard,
    82016.80889972705,
    0.000000001,
    "Google Gemma 4 E2B QAT Q4_0 GGUF M5 Max Dennard bound",
  );
}

{
  const row = model("unsloth/gemma-4-E2B-it-qat-GGUF");
  const item = profile("unsloth/gemma-4-E2B-it-qat-GGUF");
  const weightAdapter = item.architecture.weight_adapter;
  const kvAdapter = item.architecture.kv_adapter;
  const [fullKv, slidingKv] = kvAdapter.components;
  const result = profiled(
    "unsloth/gemma-4-E2B-it-qat-GGUF",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "unsloth/gemma-4-E2B-it-qat-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );

  assert.equal(row.hf_downloads, 135267);
  assert.ok(row.tags.includes("region:us"));
  assert.equal(row.adapter.weight_precision, "GGUF UD-Q2_K_XL QAT");
  assertNear(
    row.adapter.kv_alloc_gb_per_1k_tokens,
    0.006144,
    0.000000001,
    "Unsloth Gemma 4 E2B QAT GGUF legacy token-proportional alloc coefficient",
  );
  assertNear(
    row.adapter.kv_alloc_fixed_gb,
    0.006291456,
    0.000000001,
    "Unsloth Gemma 4 E2B QAT GGUF legacy sliding alloc fixed term",
  );
  assert.equal(item.status, "audited");
  assert.equal(
    item.serving.runtime_format,
    "llama.cpp-gguf-ud-q2-k-xl-qat-ple-memory-bound",
  );
  assert.equal(kvAdapter.kind, "layered_kv");
  assert.equal(fullKv.alloc_layers, 3);
  assert.equal(fullKv.read_layers, 7);
  assert.equal(slidingKv.alloc_layers, 12);
  assert.equal(slidingKv.read_layers, 28);
  assert.equal(slidingKv.window_tokens, 512);
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    2.186184768,
    0.000000001,
    "Unsloth Gemma 4 E2B QAT GGUF UD-Q2_K_XL resident file footprint",
  );
  assertNear(
    result.single.batchWeight,
    0.849165408,
    0.000000001,
    "Unsloth Gemma 4 E2B QAT GGUF UD-Q2_K_XL swept text-decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.33701936,
    0.000000001,
    "Unsloth Gemma 4 E2B QAT GGUF UD-Q2_K_XL resident PLE/header footprint",
  );
  assertNear(
    result.alloc,
    0.620691456,
    0.000000001,
    "Unsloth Gemma 4 E2B QAT GGUF shared-KV FP16 allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.473432064,
    0.000000001,
    "Unsloth Gemma 4 E2B QAT GGUF layered FP16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    206.41200802174222,
    0.000000001,
    "Unsloth Gemma 4 E2B QAT GGUF DGX single-session tok/s",
  );
  assert.equal(result.bMem, 189);
  assert.equal(result.best.batch, 27);
  assertNear(
    result.best.aggregate,
    540.7197262394258,
    0.000000001,
    "Unsloth Gemma 4 E2B QAT GGUF DGX aggregate tok/s",
  );
  assertNear(
    result.best.perSession,
    20.02665652738614,
    0.000000001,
    "Unsloth Gemma 4 E2B QAT GGUF DGX per-session tok/s",
  );
  assertNear(
    result.dennard,
    61022.61377569922,
    0.000000001,
    "Unsloth Gemma 4 E2B QAT GGUF DGX Dennard bound",
  );
  assertNear(
    m5Result.single.aggregate,
    464.23799606355215,
    0.000000001,
    "Unsloth Gemma 4 E2B QAT GGUF M5 Max single-session tok/s",
  );
  assert.equal(m5Result.best.batch, 63);
  assertNear(
    m5Result.best.aggregate,
    1261.0110499071207,
    0.000000001,
    "Unsloth Gemma 4 E2B QAT GGUF M5 Max aggregate tok/s",
  );
  assertNear(
    m5Result.dennard,
    137244.9994808766,
    0.000000001,
    "Unsloth Gemma 4 E2B QAT GGUF M5 Max Dennard bound",
  );
}

{
  const item = profile("google/gemma-4-E2B-it-qat-w4a16-ct");
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(
    "google/gemma-4-E2B-it-qat-w4a16-ct",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "google/gemma-4-E2B-it-qat-w4a16-ct",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(
    item.serving.runtime_format,
    "vllm-compressed-tensors-w4a16-ple-text-decode-memory-bound",
  );
  assertNear(
    result.resident,
    8.315979014,
    0.000000001,
    "Google Gemma 4 E2B QAT W4A16 CT resident tensor footprint",
  );
  assertNear(
    result.single.batchWeight,
    1.86159399,
    0.000000001,
    "Google Gemma 4 E2B QAT W4A16 CT swept text-decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    6.454385024,
    0.000000001,
    "Google Gemma 4 E2B QAT W4A16 CT resident PLE/multimodal footprint",
  );
  assertNear(
    result.alloc,
    0.620691456,
    0.000000001,
    "Google Gemma 4 E2B QAT W4A16 CT shared-KV BF16 allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.473432064,
    0.000000001,
    "Google Gemma 4 E2B QAT W4A16 CT layered BF16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    116.91518367957362,
    0.000000001,
    "Google Gemma 4 E2B QAT W4A16 CT DGX single-session tok/s",
  );
  assert.equal(result.bMem, 179);
  assert.equal(result.best.batch, 24);
  assertNear(
    result.best.aggregate,
    495.46416149121495,
    0.000000001,
    "Google Gemma 4 E2B QAT W4A16 CT DGX aggregate tok/s",
  );
  assertNear(
    result.dennard,
    26387.17839351705,
    0.000000001,
    "Google Gemma 4 E2B QAT W4A16 CT DGX Dennard bound",
  );
  assertNear(
    m5Result.single.aggregate,
    262.9520980925209,
    0.000000001,
    "Google Gemma 4 E2B QAT W4A16 CT M5 Max single-session tok/s",
  );
  assert.equal(m5Result.best.batch, 60);
  assertNear(
    m5Result.best.aggregate,
    1217.1463879831472,
    0.000000001,
    "Google Gemma 4 E2B QAT W4A16 CT M5 Max aggregate tok/s",
  );
  assertNear(
    m5Result.dennard,
    59346.98730263541,
    0.000000001,
    "Google Gemma 4 E2B QAT W4A16 CT M5 Max Dennard bound",
  );
}

{
  const repo = "google/gemma-4-E4B-it-qat-w4a16-ct";
  const catalogRow = model(repo);
  const item = profile(repo);
  const weightAdapter = item.architecture.weight_adapter;
  const kvAdapter = item.architecture.kv_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");

  assert.equal(catalogRow.hf_downloads, 291658);
  assertNear(
    catalogRow.adapter.resident_weight_gb,
    11.513497412,
    0.000000001,
    "Google Gemma 4 E4B QAT W4A16 CT catalog resident footprint",
  );
  assertNear(
    catalogRow.adapter.active_weight_gb,
    3.577998788,
    0.000000001,
    "Google Gemma 4 E4B QAT W4A16 CT catalog swept traffic",
  );
  assert.equal(
    item.serving.runtime_format,
    "vllm-compressed-tensors-w4a16-ple-text-decode-memory-bound",
  );
  assertNear(
    weightAdapter.resident_params_b,
    8.736340888,
    0.000000001,
    "Google Gemma 4 E4B QAT W4A16 CT resident tensor elements",
  );
  assertNear(
    weightAdapter.swept_params_b,
    4.768591576,
    0.000000001,
    "Google Gemma 4 E4B QAT W4A16 CT swept tensor elements",
  );
  assertNear(
    weightAdapter.auxiliary_resident_params_b,
    3.967749312,
    0.000000001,
    "Google Gemma 4 E4B QAT W4A16 CT auxiliary resident tensor elements",
  );
  assertNear(
    result.resident,
    11.513497412,
    0.000000001,
    "Google Gemma 4 E4B QAT W4A16 CT resident tensor footprint",
  );
  assertNear(
    result.single.batchWeight,
    3.577998788,
    0.000000001,
    "Google Gemma 4 E4B QAT W4A16 CT swept text-decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    7.935498624,
    0.000000001,
    "Google Gemma 4 E4B QAT W4A16 CT resident PLE/multimodal footprint",
  );
  assert.equal(kvAdapter.components[0].alloc_layers, 4);
  assert.equal(kvAdapter.components[0].read_layers, 7);
  assert.equal(kvAdapter.components[1].alloc_layers, 20);
  assert.equal(kvAdapter.components[1].read_layers, 35);
  assertNear(
    result.alloc,
    1.65937152,
    0.000000001,
    "Google Gemma 4 E4B QAT W4A16 CT shared-KV BF16 allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.95420416,
    0.000000001,
    "Google Gemma 4 E4B QAT W4A16 CT layered BF16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    60.23560796642419,
    0.000000001,
    "Google Gemma 4 E4B QAT W4A16 CT DGX single-session tok/s",
  );
  assert.equal(result.bMem, 65);
  assert.equal(result.best.batch, 10);
  assertNear(
    result.best.aggregate,
    208.0786277530779,
    0.000000001,
    "Google Gemma 4 E4B QAT W4A16 CT DGX aggregate tok/s",
  );
  assertNear(
    result.dennard,
    4988.322628766973,
    0.000000001,
    "Google Gemma 4 E4B QAT W4A16 CT DGX Dennard bound",
  );
  assertNear(
    m5Result.single.aggregate,
    135.47495711129835,
    0.000000001,
    "Google Gemma 4 E4B QAT W4A16 CT M5 Max single-session tok/s",
  );
  assert.equal(m5Result.best.batch, 28);
  assertNear(
    m5Result.best.aggregate,
    567.4729857974054,
    0.000000001,
    "Google Gemma 4 E4B QAT W4A16 CT M5 Max aggregate tok/s",
  );
  assertNear(
    m5Result.dennard,
    11219.157853710336,
    0.000000001,
    "Google Gemma 4 E4B QAT W4A16 CT M5 Max Dennard bound",
  );
}

{
  const result = profiled("google/gemma-4-E4B", "nvidia-dgx-spark");
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    15.992314836,
    0.000000001,
    "Gemma 4 E4B base resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    9.398993492,
    0.000000001,
    "Gemma 4 E4B base swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    6.593321344,
    0.000000001,
    "Gemma 4 E4B base resident multimodal and PLE footprint",
  );
  assertNear(
    result.alloc,
    2.90390016,
    0.000000001,
    "Gemma 4 E4B base layered BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.95420416,
    0.000000001,
    "Gemma 4 E4B base layered BF16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    26.368664945,
    0.000000001,
    "Gemma 4 E4B base DGX single-session tok/s",
  );
  assert.equal(result.bMem, 35);
  assert.equal(result.best.batch, 4);
  assertNear(
    result.best.aggregate,
    82.628305726,
    0.000000001,
    "Gemma 4 E4B base DGX aggregate tok/s",
  );
  assertNear(
    result.best.perSession,
    20.657076431,
    0.000000001,
    "Gemma 4 E4B base DGX per-session tok/s",
  );
  assertNear(
    result.dennard,
    1040.315449503,
    0.000000001,
    "Gemma 4 E4B base DGX Dennard bound",
  );
}

{
  const result = profiled("google/gemma-4-E4B-it", "nvidia-dgx-spark");
  assertNear(
    result.resident,
    15.992314836,
    0.000000001,
    "Gemma 4 E4B resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    9.398993492,
    0.000000001,
    "Gemma 4 E4B swept text-decode traffic",
  );
  assertNear(
    result.alloc,
    2.90390016,
    0.000000001,
    "Gemma 4 E4B layered BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.95420416,
    0.000000001,
    "Gemma 4 E4B layered BF16 KV read traffic",
  );
}

{
  const item = profile("leon-se/gemma-4-E4B-it-FP8-Dynamic");
  const result = profiled(
    "leon-se/gemma-4-E4B-it-FP8-Dynamic",
    "nvidia-dgx-spark",
  );
  assert.equal(item.status, "audited");
  assertNear(
    item.architecture.weight_adapter.resident_params_b,
    8.66860081,
    0.000000001,
    "leon-se Gemma 4 E4B FP8 resident tensor elements",
  );
  assertNear(
    item.architecture.weight_adapter.swept_params_b,
    4.700851498,
    0.000000001,
    "leon-se Gemma 4 E4B FP8 swept tensor elements",
  );
  assertNear(
    item.architecture.weight_adapter.auxiliary_resident_params_b,
    3.967749312,
    0.000000001,
    "leon-se Gemma 4 E4B FP8 auxiliary resident tensor elements",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    13.30935906,
    0.000000001,
    "leon-se Gemma 4 E4B FP8 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    5.373860436,
    0.000000001,
    "leon-se Gemma 4 E4B FP8 swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    7.935498624,
    0.000000001,
    "leon-se Gemma 4 E4B FP8 resident-only embedding and multimodal footprint",
  );
  assertNear(
    result.alloc,
    2.90390016,
    0.000000001,
    "leon-se Gemma 4 E4B FP8 layered BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.95420416,
    0.000000001,
    "leon-se Gemma 4 E4B FP8 layered BF16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    43.141152537,
    0.000000001,
    "leon-se Gemma 4 E4B FP8 DGX single-session tok/s",
  );
  assert.equal(result.bMem, 36);
  assert.equal(result.best.batch, 8);
  assertNear(
    result.best.aggregate,
    167.903213923,
    0.000000001,
    "leon-se Gemma 4 E4B FP8 DGX aggregate tok/s",
  );
  assertNear(
    result.best.perSession,
    20.98790174,
    0.000000001,
    "leon-se Gemma 4 E4B FP8 DGX per-session tok/s",
  );
  assertNear(
    result.dennard,
    1866.469542102,
    0.000000001,
    "leon-se Gemma 4 E4B FP8 DGX Dennard bound",
  );
}

{
  const repo = "prithivMLmods/gemma-4-E4B-it-NVFP4";
  const catalogRow = model(repo);
  const item = profile(repo);
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  assert.equal(item.status, "audited");
  assert.equal(item.serving.weight_format, "nvfp4");
  assert.equal(item.serving.kv_store_format, "bf16");
  assert.equal(catalogRow.hf_downloads, 243514);
  assertNear(
    catalogRow.adapter.resident_weight_gb,
    11.544469952,
    0.000000001,
    "prithivMLmods Gemma 4 E4B NVFP4 catalog resident footprint",
  );
  assertNear(
    catalogRow.adapter.active_weight_gb,
    3.608971328,
    0.000000001,
    "prithivMLmods Gemma 4 E4B NVFP4 catalog swept traffic",
  );
  assertNear(
    weightAdapter.resident_params_b,
    6.905065317,
    0.000000001,
    "prithivMLmods Gemma 4 E4B NVFP4 resident tensor elements",
  );
  assertNear(
    weightAdapter.swept_params_b,
    2.937316005,
    0.000000001,
    "prithivMLmods Gemma 4 E4B NVFP4 swept tensor elements",
  );
  assertNear(
    weightAdapter.auxiliary_resident_params_b,
    3.967749312,
    0.000000001,
    "prithivMLmods Gemma 4 E4B NVFP4 auxiliary resident tensor elements",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    11.544469952,
    0.000000001,
    "prithivMLmods Gemma 4 E4B NVFP4 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    3.608971328,
    0.000000001,
    "prithivMLmods Gemma 4 E4B NVFP4 swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    7.935498624,
    0.000000001,
    "prithivMLmods Gemma 4 E4B NVFP4 resident-only embedding and multimodal footprint",
  );
  assertNear(
    result.alloc,
    2.90390016,
    0.000000001,
    "prithivMLmods Gemma 4 E4B NVFP4 layered BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.95420416,
    0.000000001,
    "prithivMLmods Gemma 4 E4B NVFP4 layered BF16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    59.826758957,
    0.000000001,
    "prithivMLmods Gemma 4 E4B NVFP4 DGX single-session tok/s",
  );
  assert.equal(result.bMem, 37);
  assert.equal(result.best.batch, 10);
  assertNear(
    result.best.aggregate,
    207.58857245,
    0.000000001,
    "prithivMLmods Gemma 4 E4B NVFP4 DGX aggregate tok/s",
  );
  assertNear(
    result.best.perSession,
    20.758857245,
    0.000000001,
    "prithivMLmods Gemma 4 E4B NVFP4 DGX per-session tok/s",
  );
  assertNear(
    result.dennard,
    2825.200248769,
    0.000000001,
    "prithivMLmods Gemma 4 E4B NVFP4 DGX Dennard bound",
  );
}

{
  const repo = "nvidia/music-flamingo-2601-hf";
  const catalogRow = model(repo);
  const item = profile(repo);
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  assert.equal(item.status, "audited");
  assert.equal(item.serving.weight_format, "bf16");
  assert.equal(item.serving.kv_store_format, "bf16");
  assert.equal(catalogRow.hf_downloads, 188844);
  assert.equal(catalogRow.tags.includes("region:us"), true);
  assertNear(
    catalogRow.adapter.resident_weight_gb,
    16.53443072,
    0.000000001,
    "Music Flamingo catalog resident footprint",
  );
  assertNear(
    catalogRow.adapter.active_weight_gb,
    14.138428416,
    0.000000001,
    "Music Flamingo catalog swept traffic",
  );
  assertNear(
    weightAdapter.resident_params_b,
    8.26721536,
    0.000000001,
    "Music Flamingo resident BF16 parameters",
  );
  assertNear(
    weightAdapter.swept_params_b,
    7.069214208,
    0.000000001,
    "Music Flamingo swept BF16 parameters",
  );
  assertNear(
    weightAdapter.auxiliary_resident_params_b,
    1.198001152,
    0.000000001,
    "Music Flamingo auxiliary resident BF16 parameters",
  );
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    16.53443072,
    0.000000001,
    "Music Flamingo resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    14.138428416,
    0.000000001,
    "Music Flamingo swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    2.396002304,
    0.000000001,
    "Music Flamingo resident-only audio/projector/input footprint",
  );
  assertNear(
    result.alloc,
    5.7344,
    0.000000001,
    "Music Flamingo full-context BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.835008,
    0.000000001,
    "Music Flamingo full-context BF16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    17.090874680325268,
    0.000000001,
    "Music Flamingo DGX single-session tok/s",
  );
  assert.equal(result.bMem, 18);
  assert.equal(result.best, null);
  assertNear(
    result.dennard,
    348.3929657044281,
    0.000000001,
    "Music Flamingo DGX Dennard bound",
  );
}

{
  const repo = "Chunity/gemma-4-E4B-it-AWQ-4bit";
  const catalogRow = model(repo);
  const item = profile(repo);
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  assert.equal(item.status, "audited");
  assert.equal(item.serving.weight_format, "int4");
  assert.equal(item.serving.kv_store_format, "fp16");
  assert.equal(catalogRow.hf_downloads, 223205);
  assert.equal(catalogRow.tags.includes("region:us"), true);
  assertNear(
    catalogRow.adapter.resident_weight_gb,
    10.522597844,
    0.000000001,
    "Chunity Gemma 4 E4B AWQ catalog resident footprint",
  );
  assertNear(
    catalogRow.adapter.active_weight_gb,
    3.9292765,
    0.000000001,
    "Chunity Gemma 4 E4B AWQ catalog swept traffic",
  );
  assertNear(
    weightAdapter.resident_params_b,
    4.805237482,
    0.000000001,
    "Chunity Gemma 4 E4B AWQ stored resident tensor elements",
  );
  assertNear(
    weightAdapter.swept_params_b,
    1.50857681,
    0.000000001,
    "Chunity Gemma 4 E4B AWQ swept tensor elements",
  );
  assertNear(
    weightAdapter.auxiliary_resident_params_b,
    3.296660672,
    0.000000001,
    "Chunity Gemma 4 E4B AWQ auxiliary resident tensor elements",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    10.522597844,
    0.000000001,
    "Chunity Gemma 4 E4B AWQ resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    3.9292765,
    0.000000001,
    "Chunity Gemma 4 E4B AWQ swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    6.593321344,
    0.000000001,
    "Chunity Gemma 4 E4B AWQ resident-only multimodal and PLE footprint",
  );
  assertNear(
    result.alloc,
    2.90390016,
    0.000000001,
    "Chunity Gemma 4 E4B AWQ layered two-byte KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.95420416,
    0.000000001,
    "Chunity Gemma 4 E4B AWQ layered two-byte KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    55.9027503141581,
    0.000000001,
    "Chunity Gemma 4 E4B AWQ DGX single-session tok/s",
  );
  assert.equal(result.bMem, 37);
  assert.equal(result.best.batch, 10);
  assertNear(
    result.best.aggregate,
    202.6527753063748,
    0.000000001,
    "Chunity Gemma 4 E4B AWQ DGX aggregate tok/s",
  );
  assertNear(
    result.best.perSession,
    20.26527753063748,
    0.000000001,
    "Chunity Gemma 4 E4B AWQ DGX per-session tok/s",
  );
  assertNear(
    result.dennard,
    2619.3459329892357,
    0.000000001,
    "Chunity Gemma 4 E4B AWQ DGX Dennard bound",
  );
}

{
  const repo = "cyankiwi/gemma-4-E4B-it-AWQ-INT4";
  const catalogRow = model(repo);
  const item = profile(repo);
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  assert.equal(item.status, "audited");
  assert.equal(item.serving.weight_format, "int4");
  assert.equal(item.serving.kv_store_format, "fp16");
  assert.equal(catalogRow.hf_downloads, 247056);
  assertNear(
    catalogRow.adapter.resident_weight_gb,
    10.311668228,
    0.000000001,
    "cyankiwi Gemma 4 E4B AWQ catalog resident footprint",
  );
  assertNear(
    catalogRow.adapter.active_weight_gb,
    3.718346884,
    0.000000001,
    "cyankiwi Gemma 4 E4B AWQ catalog swept traffic",
  );
  assertNear(
    weightAdapter.resident_params_b,
    8.185960272,
    0.000000001,
    "cyankiwi Gemma 4 E4B AWQ logical resident parameters",
  );
  assertNear(
    weightAdapter.swept_params_b,
    4.8892996,
    0.000000001,
    "cyankiwi Gemma 4 E4B AWQ logical swept parameters",
  );
  assertNear(
    weightAdapter.auxiliary_resident_params_b,
    3.296660672,
    0.000000001,
    "cyankiwi Gemma 4 E4B AWQ logical auxiliary resident parameters",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    10.311668228,
    0.000000001,
    "cyankiwi Gemma 4 E4B AWQ resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    3.718346884,
    0.000000001,
    "cyankiwi Gemma 4 E4B AWQ swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    6.593321344,
    0.000000001,
    "cyankiwi Gemma 4 E4B AWQ resident-only multimodal and PLE footprint",
  );
  assertNear(
    result.alloc,
    2.90390016,
    0.000000001,
    "cyankiwi Gemma 4 E4B AWQ layered FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.95420416,
    0.000000001,
    "cyankiwi Gemma 4 E4B AWQ layered FP16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    58.426328022795595,
    0.000000001,
    "cyankiwi Gemma 4 E4B AWQ DGX single-session tok/s",
  );
  assert.equal(result.bMem, 37);
  assert.equal(result.best.batch, 10);
  assertNear(
    result.best.aggregate,
    205.87632129285058,
    0.000000001,
    "cyankiwi Gemma 4 E4B AWQ DGX aggregate tok/s",
  );
  assertNear(
    result.best.perSession,
    20.58763212928506,
    0.000000001,
    "cyankiwi Gemma 4 E4B AWQ DGX per-session tok/s",
  );
  assertNear(
    result.dennard,
    2773.2657953763014,
    0.000000001,
    "cyankiwi Gemma 4 E4B AWQ DGX Dennard bound",
  );
}

{
  const result = profiled(
    "leon-se/gemma-4-E4B-it-FP8-Dynamic",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.single.aggregate,
    97.028086658,
    0.000000001,
    "leon-se Gemma 4 E4B FP8 M5 Max single-session tok/s",
  );
  assert.equal(result.bMem, 36);
  assert.equal(result.best.batch, 26);
  assertNear(
    result.best.aggregate,
    528.904046281,
    0.000000001,
    "leon-se Gemma 4 E4B FP8 M5 Max aggregate tok/s",
  );
  assertNear(
    result.best.perSession,
    20.342463318,
    0.000000001,
    "leon-se Gemma 4 E4B FP8 M5 Max per-session tok/s",
  );
  assertNear(
    result.dennard,
    4197.847248537,
    0.000000001,
    "leon-se Gemma 4 E4B FP8 M5 Max Dennard bound",
  );
}

{
  const result = profiled("unsloth/gemma-4-E4B-it-GGUF", "nvidia-dgx-spark");
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    15.05309584,
    0.000000001,
    "Unsloth Gemma 4 E4B GGUF selected BF16 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    9.400126784,
    0.000000001,
    "Unsloth Gemma 4 E4B GGUF swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    5.652969056,
    0.000000001,
    "Unsloth Gemma 4 E4B GGUF resident PLE/header footprint",
  );
  assertNear(
    result.alloc,
    2.90390016,
    0.000000001,
    "Unsloth Gemma 4 E4B GGUF layered FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.95420416,
    0.000000001,
    "Unsloth Gemma 4 E4B GGUF layered FP16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    26.365778868,
    0.000000001,
    "Unsloth Gemma 4 E4B GGUF DGX single-session tok/s",
  );
  assert.equal(result.bMem, 36);
  assert.equal(result.best.batch, 4);
  assertNear(
    result.best.aggregate,
    82.621220729,
    0.000000001,
    "Unsloth Gemma 4 E4B GGUF DGX aggregate tok/s",
  );
  assertNear(
    result.best.perSession,
    20.655305182,
    0.000000001,
    "Unsloth Gemma 4 E4B GGUF DGX per-session tok/s",
  );
  assertNear(
    result.dennard,
    1049.583239637,
    0.000000001,
    "Unsloth Gemma 4 E4B GGUF DGX Dennard bound",
  );
}

{
  const result = profiled(
    "unsloth/gemma-4-E4B-it-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.single.aggregate,
    59.298857968,
    0.000000001,
    "Unsloth Gemma 4 E4B GGUF M5 Max single-session tok/s",
  );
  assert.equal(result.bMem, 36);
  assert.equal(result.best.batch, 22);
  assertNear(
    result.best.aggregate,
    444.450026151,
    0.000000001,
    "Unsloth Gemma 4 E4B GGUF M5 Max aggregate tok/s",
  );
  assertNear(
    result.best.perSession,
    20.202273916,
    0.000000001,
    "Unsloth Gemma 4 E4B GGUF M5 Max per-session tok/s",
  );
  assertNear(
    result.dennard,
    2360.60113237,
    0.000000001,
    "Unsloth Gemma 4 E4B GGUF M5 Max Dennard bound",
  );
}

{
  const result = profiled(
    "lmstudio-community/gemma-4-E4B-it-GGUF",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    5.335289664,
    0.000000001,
    "LM Studio Gemma 4 E4B GGUF selected Q4_K_M resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    3.007356224,
    0.000000001,
    "LM Studio Gemma 4 E4B GGUF swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    2.32793344,
    0.000000001,
    "LM Studio Gemma 4 E4B GGUF resident PLE/header footprint",
  );
  assertNear(
    result.alloc,
    2.90390016,
    0.000000001,
    "LM Studio Gemma 4 E4B GGUF layered FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.95420416,
    0.000000001,
    "LM Studio Gemma 4 E4B GGUF layered FP16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    68.912240011,
    0.000000001,
    "LM Studio Gemma 4 E4B GGUF DGX single-session tok/s",
  );
  assert.equal(result.bMem, 39);
  assert.equal(result.best.batch, 11);
  assertNear(
    result.best.aggregate,
    222.385109066,
    0.000000001,
    "LM Studio Gemma 4 E4B GGUF DGX aggregate tok/s",
  );
  assertNear(
    result.best.perSession,
    20.216828097,
    0.000000001,
    "LM Studio Gemma 4 E4B GGUF DGX per-session tok/s",
  );
  assertNear(
    result.dennard,
    3584.477601666,
    0.000000001,
    "LM Studio Gemma 4 E4B GGUF DGX Dennard bound",
  );
}

{
  const result = profiled(
    "lmstudio-community/gemma-4-E4B-it-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.single.aggregate,
    154.989433578,
    0.000000001,
    "LM Studio Gemma 4 E4B GGUF M5 Max single-session tok/s",
  );
  assert.equal(result.bMem, 39);
  assert.equal(result.best.batch, 29);
  assertNear(
    result.best.aggregate,
    580.391776473,
    0.000000001,
    "LM Studio Gemma 4 E4B GGUF M5 Max aggregate tok/s",
  );
  assertNear(
    result.best.perSession,
    20.013509534,
    0.000000001,
    "LM Studio Gemma 4 E4B GGUF M5 Max per-session tok/s",
  );
  assertNear(
    result.dennard,
    8061.792115103,
    0.000000001,
    "LM Studio Gemma 4 E4B GGUF M5 Max Dennard bound",
  );
}

{
  const result = profiled(
    "google/gemma-4-E4B-it-qat-q4_0-gguf",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    5.154939136,
    0.000000001,
    "Google Gemma 4 E4B QAT Q4_0 GGUF selected resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    2.82700832,
    0.000000001,
    "Google Gemma 4 E4B QAT Q4_0 GGUF swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    2.327930816,
    0.000000001,
    "Google Gemma 4 E4B QAT Q4_0 GGUF resident PLE/header footprint",
  );
  assertNear(
    result.alloc,
    2.90390016,
    0.000000001,
    "Google Gemma 4 E4B QAT Q4_0 GGUF layered FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.95420416,
    0.000000001,
    "Google Gemma 4 E4B QAT Q4_0 GGUF layered FP16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    72.199063513,
    0.000000001,
    "Google Gemma 4 E4B QAT Q4_0 GGUF DGX single-session tok/s",
  );
  assert.equal(result.bMem, 39);
  assert.equal(result.best.batch, 11);
  assertNear(
    result.best.aggregate,
    225.39538629,
    0.000000001,
    "Google Gemma 4 E4B QAT Q4_0 GGUF DGX aggregate tok/s",
  );
  assertNear(
    result.best.perSession,
    20.490489663,
    0.000000001,
    "Google Gemma 4 E4B QAT Q4_0 GGUF DGX per-session tok/s",
  );
  assertNear(
    result.dennard,
    3819.145480339,
    0.000000001,
    "Google Gemma 4 E4B QAT Q4_0 GGUF DGX Dennard bound",
  );
}

{
  const result = profiled(
    "google/gemma-4-E4B-it-qat-q4_0-gguf",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.single.aggregate,
    162.381776546,
    0.000000001,
    "Google Gemma 4 E4B QAT Q4_0 GGUF M5 Max single-session tok/s",
  );
  assert.equal(result.bMem, 39);
  assert.equal(result.best.batch, 29);
  assertNear(
    result.best.aggregate,
    583.823780283,
    0.000000001,
    "Google Gemma 4 E4B QAT Q4_0 GGUF M5 Max aggregate tok/s",
  );
  assertNear(
    result.best.perSession,
    20.131854493,
    0.000000001,
    "Google Gemma 4 E4B QAT Q4_0 GGUF M5 Max per-session tok/s",
  );
  assertNear(
    result.dennard,
    8589.579944791,
    0.000000001,
    "Google Gemma 4 E4B QAT Q4_0 GGUF M5 Max Dennard bound",
  );
}

{
  const repo = "unsloth/gemma-4-E4B-it-qat-GGUF";
  const catalogRow = model(repo);
  const item = profile(repo);
  const result = profiled(repo, "nvidia-dgx-spark");
  assert.equal(item.base_model_proof.config_compatible, true);
  assert.equal(
    item.serving.runtime_format,
    "llama.cpp-gguf-q4-0-qat-ple-memory-bound",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    catalogRow.adapter.resident_weight_gb,
    4.21569376,
    0.000000001,
    "Unsloth Gemma 4 E4B QAT GGUF catalog selected UD-Q4_K_XL resident footprint",
  );
  assertNear(
    catalogRow.adapter.active_weight_gb,
    2.61442592,
    0.000000001,
    "Unsloth Gemma 4 E4B QAT GGUF catalog swept traffic",
  );
  assertNear(
    result.resident,
    4.21569376,
    0.000000001,
    "Unsloth Gemma 4 E4B QAT GGUF selected UD-Q4_K_XL resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    2.61442592,
    0.000000001,
    "Unsloth Gemma 4 E4B QAT GGUF swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    1.60126784,
    0.000000001,
    "Unsloth Gemma 4 E4B QAT GGUF resident PLE/header footprint",
  );
  assertNear(
    result.alloc,
    2.90390016,
    0.000000001,
    "Unsloth Gemma 4 E4B QAT GGUF layered FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.95420416,
    0.000000001,
    "Unsloth Gemma 4 E4B QAT GGUF layered FP16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    76.49994364223932,
    0.000000001,
    "Unsloth Gemma 4 E4B QAT GGUF DGX single-session tok/s",
  );
  assert.equal(result.bMem, 39);
  assert.equal(result.best.batch, 11);
  assertNear(
    result.best.aggregate,
    229.0500497072931,
    0.000000001,
    "Unsloth Gemma 4 E4B QAT GGUF DGX aggregate tok/s",
  );
  assertNear(
    result.best.perSession,
    20.8227317915721,
    0.000000001,
    "Unsloth Gemma 4 E4B QAT GGUF DGX per-session tok/s",
  );
  assertNear(
    result.dennard,
    4163.459300340137,
    0.000000001,
    "Unsloth Gemma 4 E4B QAT GGUF DGX Dennard bound",
  );
}

{
  const result = profiled(
    "unsloth/gemma-4-E4B-it-qat-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.single.aggregate,
    172.0548183015932,
    0.000000001,
    "Unsloth Gemma 4 E4B QAT GGUF M5 Max single-session tok/s",
  );
  assert.equal(result.bMem, 39);
  assert.equal(result.best.batch, 29);
  assertNear(
    result.best.aggregate,
    587.9216882341585,
    0.000000001,
    "Unsloth Gemma 4 E4B QAT GGUF M5 Max aggregate tok/s",
  );
  assertNear(
    result.best.perSession,
    20.273161663246846,
    0.000000001,
    "Unsloth Gemma 4 E4B QAT GGUF M5 Max per-session tok/s",
  );
  assertNear(
    result.dennard,
    9363.97073409833,
    0.000000001,
    "Unsloth Gemma 4 E4B QAT GGUF M5 Max Dennard bound",
  );
}

{
  const result = profiled(
    "lmstudio-community/gemma-4-E4B-it-MLX-4bit",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    6.828932052,
    0.000000001,
    "Gemma 4 E4B MLX 4-bit resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    4.295787092,
    0.000000001,
    "Gemma 4 E4B MLX 4-bit swept text-decode traffic",
  );
  assertNear(
    result.alloc,
    2.90390016,
    0.000000001,
    "Gemma 4 E4B MLX 4-bit layered BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.95420416,
    0.000000001,
    "Gemma 4 E4B MLX 4-bit layered BF16 KV read traffic",
  );
  assert.equal(result.best.batch, 9);
  assertNear(
    result.best.aggregate,
    190.70720307762537,
    0.000000001,
    "Gemma 4 E4B MLX 4-bit DGX Spark aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    21.189689230847264,
    0.000000001,
    "Gemma 4 E4B MLX 4-bit DGX Spark per-session throughput",
  );
}

{
  const result = profiled(
    "lmstudio-community/gemma-4-E4B-it-MLX-5bit",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    7.356480468,
    0.000000001,
    "Gemma 4 E4B MLX 5-bit resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    4.470276692,
    0.000000001,
    "Gemma 4 E4B MLX 5-bit swept text-decode traffic",
  );
  assertNear(
    result.alloc,
    2.90390016,
    0.000000001,
    "Gemma 4 E4B MLX 5-bit layered BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.95420416,
    0.000000001,
    "Gemma 4 E4B MLX 5-bit layered BF16 KV read traffic",
  );
  assert.equal(result.best.batch, 9);
  assertNear(
    result.best.aggregate,
    188.15887004532425,
    0.000000001,
    "Gemma 4 E4B MLX 5-bit DGX Spark aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    20.90654111614714,
    0.000000001,
    "Gemma 4 E4B MLX 5-bit DGX Spark per-session throughput",
  );
}

{
  const result = profiled(
    "lmstudio-community/gemma-4-E4B-it-MLX-6bit",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    7.884028884,
    0.000000001,
    "Gemma 4 E4B MLX 6-bit resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    4.644766292,
    0.000000001,
    "Gemma 4 E4B MLX 6-bit swept text-decode traffic",
  );
  assertNear(
    result.alloc,
    2.90390016,
    0.000000001,
    "Gemma 4 E4B MLX 6-bit layered BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.95420416,
    0.000000001,
    "Gemma 4 E4B MLX 6-bit layered BF16 KV read traffic",
  );
  assert.equal(result.best.batch, 9);
  assertNear(
    result.best.aggregate,
    185.6777433800358,
    0.000000001,
    "Gemma 4 E4B MLX 6-bit DGX Spark aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    20.630860375559532,
    0.000000001,
    "Gemma 4 E4B MLX 6-bit DGX Spark per-session throughput",
  );
}

{
  const result = profiled(
    "lmstudio-community/gemma-4-E4B-it-MLX-8bit",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    8.939125716,
    0.000000001,
    "Gemma 4 E4B MLX 8-bit resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    4.993745492,
    0.000000001,
    "Gemma 4 E4B MLX 8-bit swept text-decode traffic",
  );
  assertNear(
    result.alloc,
    2.90390016,
    0.000000001,
    "Gemma 4 E4B MLX 8-bit layered BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.95420416,
    0.000000001,
    "Gemma 4 E4B MLX 8-bit layered BF16 KV read traffic",
  );
  assert.equal(result.best.batch, 9);
  assertNear(
    result.best.aggregate,
    180.9067479322299,
    0.000000001,
    "Gemma 4 E4B MLX 8-bit DGX Spark aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    20.100749770247766,
    0.000000001,
    "Gemma 4 E4B MLX 8-bit DGX Spark per-session throughput",
  );
}

{
  const result = profiled("google/gemma-4-12B-it", "nvidia-dgx-spark");
  assertNear(
    result.resident,
    23.919460448,
    0.000000001,
    "Gemma 4 12B resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    23.81470064,
    0.000000001,
    "Gemma 4 12B swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    0.104759808,
    0.000000001,
    "Gemma 4 12B resident multimodal projection footprint",
  );
  assertNear(
    result.alloc,
    1.15474432,
    0.000000001,
    "Gemma 4 12B layered BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.59768832,
    0.000000001,
    "Gemma 4 12B layered BF16 KV read traffic",
  );
}

{
  const result = profiled("google/gemma-4-12B", "nvidia-dgx-spark");
  const m5Result = profiled(
    "google/gemma-4-12B",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    23.919460448,
    0.000000001,
    "Gemma 4 12B base resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    23.81470064,
    0.000000001,
    "Gemma 4 12B base swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    0.104759808,
    0.000000001,
    "Gemma 4 12B base resident multimodal projection footprint",
  );
  assertNear(
    result.alloc,
    1.15474432,
    0.000000001,
    "Gemma 4 12B base layered BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.59768832,
    0.000000001,
    "Gemma 4 12B base layered BF16 KV read traffic",
  );
  assert.equal(result.bMem, 83);
  assertNear(
    result.single.aggregate,
    11.182846563984944,
    0.000000001,
    "Gemma 4 12B base DGX Spark single-session tok/s",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 11);
  assertNear(
    m5Result.best.aggregate,
    222.24948213435593,
    0.000000001,
    "Gemma 4 12B base M5 Max aggregate tok/s at b*",
  );
}

{
  const repo = "google/gemma-4-12B-it-qat-q4_0-unquantized";
  const row = model(repo);
  const item = profile(repo);
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  const m1UltraResult = profiled(repo, "apple-mac-studio-m1-ultra-128gb");
  assert.equal(result.status_code, "no_floor");
  assert.equal(row.name, "gemma-4-12B-it-qat-q4_0-unquantized BF16");
  assert.equal(row.hf_downloads, 218747);
  assert.equal(row.adapter.weight_precision, "BF16");
  assertNear(
    row.architecture.total_params_b,
    11.959730224,
    0.000000001,
    "Gemma 4 12B QAT unquantized catalog stored parameters",
  );
  assertNear(
    row.architecture.active_params_b,
    11.90735032,
    0.000000001,
    "Gemma 4 12B QAT unquantized catalog swept parameters",
  );
  assertNear(
    row.adapter.resident_weight_gb,
    23.919460448,
    0.000000001,
    "Gemma 4 12B QAT unquantized catalog resident bytes",
  );
  assertNear(
    row.adapter.active_weight_gb,
    23.81470064,
    0.000000001,
    "Gemma 4 12B QAT unquantized catalog swept bytes",
  );
  assertNear(
    weightAdapter.resident_params_b,
    11.959730224,
    0.000000001,
    "Gemma 4 12B QAT unquantized stored tensor parameters",
  );
  assertNear(
    weightAdapter.swept_params_b,
    11.90735032,
    0.000000001,
    "Gemma 4 12B QAT unquantized swept language parameters",
  );
  assertNear(
    weightAdapter.auxiliary_resident_params_b,
    0.052379904,
    0.000000001,
    "Gemma 4 12B QAT unquantized resident-only multimodal parameters",
  );
  assertNear(
    result.resident,
    23.919460448,
    0.000000001,
    "Gemma 4 12B QAT unquantized resident tensor bytes",
  );
  assertNear(
    result.single.batchWeight,
    23.81470064,
    0.000000001,
    "Gemma 4 12B QAT unquantized swept text-decode bytes",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.104759808,
    0.000000001,
    "Gemma 4 12B QAT unquantized resident-only multimodal bytes",
  );
  assertNear(
    result.alloc,
    1.15474432,
    0.000000001,
    "Gemma 4 12B QAT unquantized layered BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.59768832,
    0.000000001,
    "Gemma 4 12B QAT unquantized layered BF16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    11.182846563984944,
    0.000000001,
    "Gemma 4 12B QAT unquantized DGX Spark single-session throughput",
  );
  assert.equal(result.bMem, 83);
  assert.equal(result.best, null);
  assertNear(
    result.dennard,
    953.8215249169874,
    0.000000001,
    "Gemma 4 12B QAT unquantized DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 11);
  assertNear(
    m5Result.best.aggregate,
    222.24948213435593,
    0.000000001,
    "Gemma 4 12B QAT unquantized M5 Max aggregate throughput",
  );
  assertNear(
    m5Result.best.perSession,
    20.204498375850537,
    0.000000001,
    "Gemma 4 12B QAT unquantized M5 Max per-session throughput",
  );
  assertNear(
    m5Result.dennard,
    2145.2249681283165,
    0.000000001,
    "Gemma 4 12B QAT unquantized M5 Max Dennard bound",
  );
  assert.equal(m1UltraResult.status_code, "ok");
  assert.equal(m1UltraResult.best.batch, 27);
  assertNear(
    m1UltraResult.best.aggregate,
    540.6449180220711,
    0.000000001,
    "Gemma 4 12B QAT unquantized M1 Ultra aggregate throughput",
  );
  assertNear(
    m1UltraResult.best.perSession,
    20.023885852669302,
    0.000000001,
    "Gemma 4 12B QAT unquantized M1 Ultra per-session throughput",
  );
}

{
  const result = profiled(
    "google/gemma-4-12B-it-qat-w4a16-ct",
    "nvidia-dgx-spark",
  );
  assertNear(
    result.resident,
    10.264057056,
    0.000000001,
    "Gemma 4 12B QAT W4A16 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    8.146031328,
    0.000000001,
    "Gemma 4 12B QAT W4A16 swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    2.118025728,
    0.000000001,
    "Gemma 4 12B QAT W4A16 resident-only input and multimodal footprint",
  );
  assertNear(
    result.alloc,
    1.15474432,
    0.000000001,
    "Gemma 4 12B QAT W4A16 layered BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.59768832,
    0.000000001,
    "Gemma 4 12B QAT W4A16 layered BF16 KV read traffic",
  );
}

{
  const repo = "nvidia/KVzap-mlp-Llama-3.1-8B-Instruct";
  const row = model(repo);
  const item = profile(repo);
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  assert.equal(item.status, "unsupported");
  assert.equal(row.hf_downloads, 140859);
  assert.equal(row.architecture.type, "KV cache pruning surrogate");
  assert.equal(row.architecture.max_context_tokens, null);
  assert.equal(row.adapter.weight_precision, "F32");
  assertNear(
    row.architecture.total_params_b,
    0.067256576,
    0.000000001,
    "NVIDIA KVzap MLP catalog stored parameters",
  );
  assertNear(
    row.adapter.resident_weight_gb,
    0.269026304,
    0.000000001,
    "NVIDIA KVzap MLP catalog resident bytes",
  );
  assertNear(
    weightAdapter.total_params_b,
    0.067256576,
    0.000000001,
    "NVIDIA KVzap MLP F32 sidecar parameters",
  );
  assert.equal(item.architecture.kv_adapter.kind, "unknown");
  assert.match(item.unsupported_reason, /KV-pruning sidecars/);
  assert.equal(result.status_code, "unsupported_profile");
  assert.equal(result.profile_resolution.model_profile_status, "unsupported");
  assert.equal(result.single.aggregate, 0);
  assert.equal(result.best, null);
  assert.equal(result.warnings.length, 1);
  assert.equal(
    result.warnings[0],
    "Model profile status is unsupported; production bounds require audited.",
  );
}

{
  const repo = "RedHatAI/gemma-4-12B-it-NVFP4";
  const row = model(repo);
  const item = profile(repo);
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  assert.equal(result.status_code, "ok");
  assert.equal(row.hf_downloads, 260994);
  assertNear(
    row.architecture.total_params_b,
    8.1976368,
    0.000000001,
    "RedHatAI Gemma 4 12B NVFP4 catalog storage elements",
  );
  assertNear(
    row.architecture.active_params_b,
    7.138623936,
    0.000000001,
    "RedHatAI Gemma 4 12B NVFP4 catalog swept storage elements",
  );
  assertNear(
    row.adapter.resident_weight_gb,
    10.264054432,
    0.000000001,
    "RedHatAI Gemma 4 12B NVFP4 catalog resident bytes",
  );
  assertNear(
    row.adapter.active_weight_gb,
    8.146028704,
    0.000000001,
    "RedHatAI Gemma 4 12B NVFP4 catalog swept bytes",
  );
  assertNear(
    weightAdapter.resident_params_b,
    8.1976368,
    0.000000001,
    "RedHatAI Gemma 4 12B NVFP4 storage elements",
  );
  assertNear(
    weightAdapter.swept_params_b,
    7.138623936,
    0.000000001,
    "RedHatAI Gemma 4 12B NVFP4 swept storage elements",
  );
  assertNear(
    result.resident,
    10.264054432,
    0.000000001,
    "RedHatAI Gemma 4 12B NVFP4 resident tensor bytes",
  );
  assertNear(
    result.single.batchWeight,
    8.146028704,
    0.000000001,
    "RedHatAI Gemma 4 12B NVFP4 swept text-decode bytes",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    2.118025728,
    0.000000001,
    "RedHatAI Gemma 4 12B NVFP4 resident-only multimodal/input bytes",
  );
  assertNear(
    result.alloc,
    1.15474432,
    0.000000001,
    "RedHatAI Gemma 4 12B NVFP4 layered BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.59768832,
    0.000000001,
    "RedHatAI Gemma 4 12B NVFP4 layered BF16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    31.22241939562567,
    0.000000001,
    "RedHatAI Gemma 4 12B NVFP4 DGX Spark single-session throughput",
  );
  assert.equal(result.bMem, 95);
  assert.equal(result.best.batch, 9);
  assertNear(
    result.best.aggregate,
    181.66058289096003,
    0.000000001,
    "RedHatAI Gemma 4 12B NVFP4 DGX Spark aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    20.18450921010667,
    0.000000001,
    "RedHatAI Gemma 4 12B NVFP4 DGX Spark per-session throughput",
  );
  assertNear(
    result.dennard,
    3184.7825608234134,
    0.000000001,
    "RedHatAI Gemma 4 12B NVFP4 DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 37);
  assertNear(
    m5Result.best.aggregate,
    750.7477601025844,
    0.000000001,
    "RedHatAI Gemma 4 12B NVFP4 M5 Max aggregate throughput",
  );
  assertNear(
    m5Result.best.perSession,
    20.29048000277255,
    0.000000001,
    "RedHatAI Gemma 4 12B NVFP4 M5 Max per-session throughput",
  );
}

{
  const repo = "lmstudio-community/gemma-4-31B-it-GGUF";
  const row = model(repo);
  const item = profile(repo);
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  assert.equal(result.status_code, "no_floor");
  assert.equal(row.hf_downloads, 115645);
  assertNear(
    row.architecture.total_params_b,
    30.697345596,
    0.000000001,
    "LM Studio Gemma 4 31B Q4_K_M GGUF catalog logical parameters",
  );
  assertNear(
    row.architecture.active_params_b,
    30.697345596,
    0.000000001,
    "LM Studio Gemma 4 31B Q4_K_M GGUF catalog swept parameters",
  );
  assertNear(
    row.adapter.resident_weight_gb,
    18.687061664,
    0.000000001,
    "LM Studio Gemma 4 31B Q4_K_M GGUF catalog resident file bytes",
  );
  assertNear(
    row.adapter.active_weight_gb,
    18.671230848,
    0.000000001,
    "LM Studio Gemma 4 31B Q4_K_M GGUF catalog swept tensor spans",
  );
  assertNear(
    weightAdapter.resident_params_b,
    30.697345596,
    0.000000001,
    "LM Studio Gemma 4 31B Q4_K_M GGUF logical parameters",
  );
  assertNear(
    weightAdapter.swept_params_b,
    30.697345596,
    0.000000001,
    "LM Studio Gemma 4 31B Q4_K_M GGUF swept logical parameters",
  );
  assertNear(
    result.resident,
    18.687061664,
    0.000000001,
    "LM Studio Gemma 4 31B Q4_K_M GGUF resident file footprint",
  );
  assertNear(
    result.single.batchWeight,
    18.671230848,
    0.000000001,
    "LM Studio Gemma 4 31B Q4_K_M GGUF swept text-decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.015830816,
    0.000000001,
    "LM Studio Gemma 4 31B Q4_K_M GGUF metadata/header footprint",
  );
  assertNear(
    result.alloc,
    4.9348608,
    0.000000001,
    "LM Studio Gemma 4 31B Q4_K_M GGUF layered FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    2.1495808,
    0.000000001,
    "LM Studio Gemma 4 31B Q4_K_M GGUF layered FP16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    13.111880776570196,
    0.000000001,
    "LM Studio Gemma 4 31B Q4_K_M GGUF DGX Spark single-session throughput",
  );
  assert.equal(result.bMem, 20);
  assert.equal(result.best, null);
  assertNear(
    result.dennard,
    300.17858280032874,
    0.000000001,
    "LM Studio Gemma 4 31B Q4_K_M GGUF DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.bMem, 20);
  assertNear(
    m5Result.single.aggregate,
    29.489724530454577,
    0.000000001,
    "LM Studio Gemma 4 31B Q4_K_M GGUF M5 Max single-session throughput",
  );
  assert.equal(m5Result.best.batch, 5);
  assertNear(
    m5Result.best.aggregate,
    104.35385050790194,
    0.000000001,
    "LM Studio Gemma 4 31B Q4_K_M GGUF M5 Max aggregate throughput",
  );
  assertNear(
    m5Result.best.perSession,
    20.870770101580387,
    0.000000001,
    "LM Studio Gemma 4 31B Q4_K_M GGUF M5 Max per-session throughput",
  );
  assertNear(
    m5Result.dennard,
    675.1269224886514,
    0.000000001,
    "LM Studio Gemma 4 31B Q4_K_M GGUF M5 Max Dennard bound",
  );
}

{
  const repo = "llmfan46/gemma-4-31B-it-uncensored-heretic-GGUF";
  const row = model(repo);
  const item = profile(repo);
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  const m1UltraResult = profiled(repo, "apple-mac-studio-m1-ultra-128gb");
  assert.equal(result.status_code, "no_floor");
  assert.equal(row.hf_downloads, 131249);
  assert.equal(row.adapter.weight_precision, "BF16 GGUF");
  assertNear(
    row.architecture.total_params_b,
    30.697345596,
    0.000000001,
    "llmfan46 Gemma 4 31B BF16 GGUF catalog logical parameters",
  );
  assertNear(
    row.adapter.resident_weight_gb,
    61.413188736,
    0.000000001,
    "llmfan46 Gemma 4 31B BF16 GGUF catalog resident file bytes",
  );
  assertNear(
    row.adapter.active_weight_gb,
    61.397356416,
    0.000000001,
    "llmfan46 Gemma 4 31B BF16 GGUF catalog swept tensor spans",
  );
  assertNear(
    row.adapter.kv_alloc_gb_per_1k_tokens,
    0.86016,
    0.000000001,
    "llmfan46 Gemma 4 31B BF16 GGUF catalog layered KV fallback",
  );
  assertNear(
    weightAdapter.resident_params_b,
    30.697345596,
    0.000000001,
    "llmfan46 Gemma 4 31B BF16 GGUF logical resident parameters",
  );
  assertNear(
    result.resident,
    61.413188736,
    0.000000001,
    "llmfan46 Gemma 4 31B BF16 GGUF resident file footprint",
  );
  assertNear(
    result.single.batchWeight,
    61.397356416,
    0.000000001,
    "llmfan46 Gemma 4 31B BF16 GGUF swept text-decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.01583232,
    0.000000001,
    "llmfan46 Gemma 4 31B BF16 GGUF metadata/header footprint",
  );
  assertNear(
    result.alloc,
    4.9348608,
    0.000000001,
    "llmfan46 Gemma 4 31B BF16 GGUF layered FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    2.1495808,
    0.000000001,
    "llmfan46 Gemma 4 31B BF16 GGUF layered FP16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    4.296037102025169,
    0.000000001,
    "llmfan46 Gemma 4 31B BF16 GGUF DGX Spark single-session throughput",
  );
  assert.equal(result.bMem, 11);
  assert.equal(result.best, null);
  assertNear(
    result.dennard,
    52.78833075034925,
    0.000000001,
    "llmfan46 Gemma 4 31B BF16 GGUF DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "no_floor");
  assertNear(
    m5Result.single.aggregate,
    9.662149379646351,
    0.000000001,
    "llmfan46 Gemma 4 31B BF16 GGUF M5 Max single-session throughput",
  );
  assert.equal(m5Result.best, null);
  assertNear(
    m5Result.dennard,
    118.72540322606022,
    0.000000001,
    "llmfan46 Gemma 4 31B BF16 GGUF M5 Max Dennard bound",
  );
  assert.equal(m1UltraResult.status_code, "no_floor");
  assertNear(
    m1UltraResult.single.aggregate,
    12.589119712894268,
    0.000000001,
    "llmfan46 Gemma 4 31B BF16 GGUF M1 Ultra single-session throughput",
  );
}

{
  const repo = "llmfan46/gemma-4-E4B-it-ultra-uncensored-heretic-GGUF";
  const row = model(repo);
  const item = profile(repo);
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  const m1UltraResult = profiled(repo, "apple-mac-studio-m1-ultra-128gb");
  assert.equal(result.status_code, "ok");
  assert.equal(row.hf_downloads, 102868);
  assert.equal(row.tags.includes("region:us"), true);
  assert.equal(row.adapter.weight_precision, "BF16 GGUF");
  assertNear(
    row.architecture.total_params_b,
    7.51806929,
    0.000000001,
    "llmfan46 Gemma 4 E4B BF16 GGUF catalog logical parameters",
  );
  assertNear(
    row.architecture.active_params_b,
    4.699497002,
    0.000000001,
    "llmfan46 Gemma 4 E4B BF16 GGUF catalog swept logical parameters",
  );
  assertNear(
    row.adapter.resident_weight_gb,
    15.053094752,
    0.000000001,
    "llmfan46 Gemma 4 E4B BF16 GGUF catalog resident file bytes",
  );
  assertNear(
    row.adapter.active_weight_gb,
    9.400126784,
    0.000000001,
    "llmfan46 Gemma 4 E4B BF16 GGUF catalog swept tensor spans",
  );
  assertNear(
    weightAdapter.resident_params_b,
    7.51806929,
    0.000000001,
    "llmfan46 Gemma 4 E4B BF16 GGUF logical resident parameters",
  );
  assertNear(
    weightAdapter.swept_params_b,
    4.699497002,
    0.000000001,
    "llmfan46 Gemma 4 E4B BF16 GGUF logical swept parameters",
  );
  assertNear(
    result.resident,
    15.053094752,
    0.000000001,
    "llmfan46 Gemma 4 E4B BF16 GGUF resident file footprint",
  );
  assertNear(
    result.single.batchWeight,
    9.400126784,
    0.000000001,
    "llmfan46 Gemma 4 E4B BF16 GGUF swept text-decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    5.652967968,
    0.000000001,
    "llmfan46 Gemma 4 E4B BF16 GGUF per-layer embedding plus metadata footprint",
  );
  assertNear(
    result.alloc,
    2.90390016,
    0.000000001,
    "llmfan46 Gemma 4 E4B BF16 GGUF layered FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.95420416,
    0.000000001,
    "llmfan46 Gemma 4 E4B BF16 GGUF layered FP16 KV read traffic",
  );
  assert.equal(result.bMem, 36);
  assert.equal(result.best?.batch, 4);
  assertNear(
    result.single.aggregate,
    26.365778868425554,
    0.000000001,
    "llmfan46 Gemma 4 E4B BF16 GGUF DGX Spark single-session throughput",
  );
  assertNear(
    result.best?.aggregate ?? 0,
    82.6212207292263,
    0.000000001,
    "llmfan46 Gemma 4 E4B BF16 GGUF DGX Spark aggregate throughput",
  );
  assertNear(
    result.dennard,
    1049.5832505179342,
    0.000000001,
    "llmfan46 Gemma 4 E4B BF16 GGUF DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best?.batch, 22);
  assertNear(
    m5Result.single.aggregate,
    59.29885796781425,
    0.000000001,
    "llmfan46 Gemma 4 E4B BF16 GGUF M5 Max single-session throughput",
  );
  assertNear(
    m5Result.best?.aggregate ?? 0,
    444.45002615066574,
    0.000000001,
    "llmfan46 Gemma 4 E4B BF16 GGUF M5 Max aggregate throughput",
  );
  assertNear(
    m5Result.dennard,
    2360.6011568425333,
    0.000000001,
    "llmfan46 Gemma 4 E4B BF16 GGUF M5 Max Dennard bound",
  );
  assert.equal(m1UltraResult.status_code, "ok");
  assert.equal(m1UltraResult.best?.batch, 32);
  assertNear(
    m1UltraResult.best?.aggregate ?? 0,
    641.0471520614054,
    0.000000001,
    "llmfan46 Gemma 4 E4B BF16 GGUF M1 Ultra aggregate throughput",
  );
}

{
  const item = profile("cyankiwi/gemma-4-12B-it-AWQ-INT4");
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(
    "cyankiwi/gemma-4-12B-it-AWQ-INT4",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    weightAdapter.resident_params_b,
    12.6409776,
    0.000000001,
    "cyankiwi Gemma 4 12B AWQ INT4 logical resident parameters",
  );
  assertNear(
    weightAdapter.swept_params_b,
    12.588597696,
    0.000000001,
    "cyankiwi Gemma 4 12B AWQ INT4 logical swept parameters",
  );
  assertNear(
    result.resident,
    11.221914944,
    0.000000001,
    "cyankiwi Gemma 4 12B AWQ INT4 resident tensor bytes",
  );
  assertNear(
    result.single.batchWeight,
    11.012395328,
    0.000000001,
    "cyankiwi Gemma 4 12B AWQ INT4 swept text-decode bytes",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.209519616,
    0.000000001,
    "cyankiwi Gemma 4 12B AWQ INT4 resident-only multimodal bytes",
  );
  assertNear(
    result.alloc,
    2.30948864,
    0.000000001,
    "cyankiwi Gemma 4 12B AWQ INT4 layered FP32 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.19537664,
    0.000000001,
    "cyankiwi Gemma 4 12B AWQ INT4 layered FP32 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    22.36280303364199,
    0.000000001,
    "cyankiwi Gemma 4 12B AWQ INT4 DGX Spark single-session throughput",
  );
  assert.equal(result.bMem, 47);
  assert.equal(result.best.batch, 2);
  assertNear(
    result.best.aggregate,
    40.736696724686496,
    0.000000001,
    "cyankiwi Gemma 4 12B AWQ INT4 DGX Spark aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    20.368348362343248,
    0.000000001,
    "cyankiwi Gemma 4 12B AWQ INT4 DGX Spark per-session throughput",
  );
  assertNear(
    result.dennard,
    1167.63319274316,
    0.000000001,
    "cyankiwi Gemma 4 12B AWQ INT4 DGX Spark Dennard bound",
  );
}

{
  const result = profiled("unsloth/gemma-4-12b-it-GGUF", "nvidia-dgx-spark");
  assertNear(
    result.resident,
    23.832065184,
    0.000000001,
    "Unsloth Gemma 4 12B GGUF BF16 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    23.816242688,
    0.000000001,
    "Unsloth Gemma 4 12B GGUF BF16 swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    0.015822496,
    0.000000001,
    "Unsloth Gemma 4 12B GGUF BF16 resident-only header footprint",
  );
  assertNear(
    result.alloc,
    1.15474432,
    0.000000001,
    "Unsloth Gemma 4 12B GGUF layered FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.59768832,
    0.000000001,
    "Unsloth Gemma 4 12B GGUF layered FP16 KV read traffic",
  );
}

{
  const result = profiled("ggml-org/gemma-4-12B-it-GGUF", "nvidia-dgx-spark");
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    23.832064928,
    0.000000001,
    "ggml-org Gemma 4 12B GGUF BF16 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    23.816242688,
    0.000000001,
    "ggml-org Gemma 4 12B GGUF BF16 swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    0.01582224,
    0.000000001,
    "ggml-org Gemma 4 12B GGUF BF16 resident-only header footprint",
  );
  assertNear(
    result.alloc,
    1.15474432,
    0.000000001,
    "ggml-org Gemma 4 12B GGUF layered FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.59768832,
    0.000000001,
    "ggml-org Gemma 4 12B GGUF layered FP16 KV read traffic",
  );
  assert.equal(result.bMem, 83);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    11.182140226,
    0.000000001,
    "ggml-org Gemma 4 12B GGUF DGX Spark single-session throughput",
  );
  assertNear(
    result.dennard,
    954.627313572,
    0.000000001,
    "ggml-org Gemma 4 12B GGUF DGX Spark Dennard bound",
  );
}

{
  const result = profiled(
    "ggml-org/gemma-4-12B-it-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(result.bMem, 83);
  assert.equal(result.best.batch, 11);
  assertNear(
    result.single.aggregate,
    25.149575453,
    0.000000001,
    "ggml-org Gemma 4 12B GGUF M5 Max single-session throughput",
  );
  assertNear(
    result.best.aggregate,
    222.238205063,
    0.000000001,
    "ggml-org Gemma 4 12B GGUF M5 Max aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    20.203473188,
    0.000000001,
    "ggml-org Gemma 4 12B GGUF M5 Max per-session throughput",
  );
  assertNear(
    result.dennard,
    2147.037254701,
    0.000000001,
    "ggml-org Gemma 4 12B GGUF M5 Max Dennard bound",
  );
}

{
  const result = profiled(
    "lmstudio-community/gemma-4-12B-it-GGUF",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    7.381384864,
    0.000000001,
    "LM Studio Gemma 4 12B GGUF Q4_K_M resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    7.365559808,
    0.000000001,
    "LM Studio Gemma 4 12B GGUF Q4_K_M swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    0.015825056,
    0.000000001,
    "LM Studio Gemma 4 12B GGUF Q4_K_M resident-only header footprint",
  );
  assertNear(
    result.alloc,
    1.15474432,
    0.000000001,
    "LM Studio Gemma 4 12B GGUF Q4_K_M layered FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.59768832,
    0.000000001,
    "LM Studio Gemma 4 12B GGUF Q4_K_M layered FP16 KV read traffic",
  );
  assert.equal(result.bMem, 97);
  assert.equal(result.best.batch, 10);
  assertNear(
    result.single.aggregate,
    34.2824932253574,
    0.000000001,
    "LM Studio Gemma 4 12B GGUF Q4_K_M DGX Spark single-session throughput",
  );
  assertNear(
    result.best.aggregate,
    204.610205069875,
    0.000000001,
    "LM Studio Gemma 4 12B GGUF Q4_K_M DGX Spark aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    20.461020506987502,
    0.000000001,
    "LM Studio Gemma 4 12B GGUF Q4_K_M DGX Spark per-session throughput",
  );
  assertNear(
    result.dennard,
    3614.7747050215776,
    0.000000001,
    "LM Studio Gemma 4 12B GGUF Q4_K_M DGX Spark Dennard bound",
  );
}

{
  const catalogRow = model("zaakirio/gemma-4-12b-it-uncensored-GGUF");
  const modelProfile = profile("zaakirio/gemma-4-12b-it-uncensored-GGUF");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  assert.equal(catalogRow.hf_downloads, 102022);
  assert.ok(catalogRow.tags.includes("region:us"));
  assert.equal(catalogRow.adapter.weight_precision, "GGUF Q4_K_M");
  assert.equal(modelProfile.base_model_proof.config_compatible, true);
  assertNear(
    weightAdapter.resident_weight_gb,
    7.38138176,
    0.000000001,
    "zaakirio Gemma 4 12B Uncensored GGUF Q4_K_M resident footprint",
  );
  assertNear(
    weightAdapter.swept_weight_gb,
    7.365559808,
    0.000000001,
    "zaakirio Gemma 4 12B Uncensored GGUF Q4_K_M swept text-decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.015821952,
    0.000000001,
    "zaakirio Gemma 4 12B Uncensored GGUF Q4_K_M resident-only header footprint",
  );

  const result = profiled(
    "zaakirio/gemma-4-12b-it-uncensored-GGUF",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    7.38138176,
    0.000000001,
    "zaakirio Gemma 4 12B Uncensored GGUF Q4_K_M DGX resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    7.365559808,
    0.000000001,
    "zaakirio Gemma 4 12B Uncensored GGUF Q4_K_M DGX swept traffic",
  );
  assertNear(
    result.alloc,
    1.15474432,
    0.000000001,
    "zaakirio Gemma 4 12B Uncensored GGUF Q4_K_M layered FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.59768832,
    0.000000001,
    "zaakirio Gemma 4 12B Uncensored GGUF Q4_K_M layered FP16 KV read traffic",
  );
  assert.equal(result.bMem, 97);
  assert.equal(result.best.batch, 10);
  assertNear(
    result.single.aggregate,
    34.2824932253574,
    0.000000001,
    "zaakirio Gemma 4 12B Uncensored GGUF Q4_K_M DGX single",
  );
  assertNear(
    result.best.aggregate,
    204.610205069875,
    0.000000001,
    "zaakirio Gemma 4 12B Uncensored GGUF Q4_K_M DGX aggregate",
  );
  assertNear(
    result.best.perSession,
    20.461020506987502,
    0.000000001,
    "zaakirio Gemma 4 12B Uncensored GGUF Q4_K_M DGX per-session",
  );
  assertNear(
    result.dennard,
    3614.774804652182,
    0.000000001,
    "zaakirio Gemma 4 12B Uncensored GGUF Q4_K_M DGX Dennard",
  );

  const m5Result = profiled(
    "zaakirio/gemma-4-12b-it-uncensored-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 39);
  assertNear(
    m5Result.best.aggregate,
    780.6254083949434,
    0.000000001,
    "zaakirio Gemma 4 12B Uncensored GGUF Q4_K_M M5 aggregate",
  );
  assertNear(
    m5Result.best.perSession,
    20.016036112690855,
    0.000000001,
    "zaakirio Gemma 4 12B Uncensored GGUF Q4_K_M M5 per-session",
  );

  const m1UltraResult = profiled(
    "zaakirio/gemma-4-12b-it-uncensored-GGUF",
    "apple-mac-studio-m1-ultra-128gb",
  );
  assert.equal(m1UltraResult.status_code, "ok");
  assert.equal(m1UltraResult.best.batch, 54);
  assertNear(
    m1UltraResult.best.aggregate,
    1089.7882302845296,
    0.000000001,
    "zaakirio Gemma 4 12B Uncensored GGUF Q4_K_M M1 Ultra aggregate",
  );
  assertNear(
    m1UltraResult.best.perSession,
    20.181263523787585,
    0.000000001,
    "zaakirio Gemma 4 12B Uncensored GGUF Q4_K_M M1 Ultra per-session",
  );
}

{
  const repo = "google/reformer-crime-and-punishment";
  const catalogRow = model(repo);
  const modelProfile = profile(repo);
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  assert.equal(catalogRow.hf_downloads, 105506);
  assert.ok(catalogRow.tags.includes("region:us"));
  assert.equal(catalogRow.adapter.weight_precision, "FP32");
  assert.equal(modelProfile.status, "unsupported");
  assert.equal(modelProfile.architecture.kv_adapter.kind, "unknown");
  assert.match(modelProfile.unsupported_reason, /Reformer local\/LSH/);
  assertNear(
    catalogRow.architecture.total_params_b,
    0.002748544,
    0.000000001,
    "Reformer Crime and Punishment catalog total params",
  );
  assertNear(
    catalogRow.architecture.active_params_b,
    0.002437248,
    0.000000001,
    "Reformer Crime and Punishment catalog naive active params",
  );
  assertNear(
    weightAdapter.resident_weight_gb,
    0.010994176,
    0.000000001,
    "Reformer Crime and Punishment FP32 resident checkpoint bytes",
  );
  assertNear(
    weightAdapter.swept_weight_gb,
    0.009748992,
    0.000000001,
    "Reformer Crime and Punishment FP32 non-embedding bytes",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.001245184,
    0.000000001,
    "Reformer Crime and Punishment FP32 embedding bytes",
  );
  assert.equal(result.status_code, "unsupported_profile");
  assert.equal(result.profile_resolution.model_profile_status, "unsupported");
  assert.equal(result.single.aggregate, 0);
  assert.equal(result.best, null);
  assert.equal(result.warnings.length, 1);
  assert.equal(
    result.warnings[0],
    "Model profile status is unsupported; production bounds require audited.",
  );
}

{
  const result = profiled(
    "lmstudio-community/gemma-4-12B-it-QAT-GGUF",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    6.97587856,
    0.000000001,
    "LM Studio Gemma 4 12B QAT GGUF Q4_0 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    6.960055808,
    0.000000001,
    "LM Studio Gemma 4 12B QAT GGUF Q4_0 swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    0.015822752,
    0.000000001,
    "LM Studio Gemma 4 12B QAT GGUF Q4_0 resident-only header footprint",
  );
  assertNear(
    result.alloc,
    1.15474432,
    0.000000001,
    "LM Studio Gemma 4 12B QAT GGUF Q4_0 layered FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.59768832,
    0.000000001,
    "LM Studio Gemma 4 12B QAT GGUF Q4_0 layered FP16 KV read traffic",
  );
  assert.equal(result.bMem, 97);
  assert.equal(result.best.batch, 11);
  assertNear(
    result.single.aggregate,
    36.12188973010969,
    0.000000001,
    "LM Studio Gemma 4 12B QAT GGUF Q4_0 DGX Spark single-session throughput",
  );
  assertNear(
    result.best.aggregate,
    221.87533703181398,
    0.000000001,
    "LM Studio Gemma 4 12B QAT GGUF Q4_0 DGX Spark aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    20.170485184710362,
    0.000000001,
    "LM Studio Gemma 4 12B QAT GGUF Q4_0 DGX Spark per-session throughput",
  );
  assertNear(
    result.dennard,
    3839.1513209264217,
    0.000000001,
    "LM Studio Gemma 4 12B QAT GGUF Q4_0 DGX Spark Dennard bound",
  );
}

{
  const result = profiled(
    "google/gemma-4-12B-it-qat-q4_0-gguf",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    6.975877728,
    0.000000001,
    "Google Gemma 4 12B QAT GGUF Q4_0 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    6.960055808,
    0.000000001,
    "Google Gemma 4 12B QAT GGUF Q4_0 swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    0.01582192,
    0.000000001,
    "Google Gemma 4 12B QAT GGUF Q4_0 resident-only header footprint",
  );
  assertNear(
    result.alloc,
    1.15474432,
    0.000000001,
    "Google Gemma 4 12B QAT GGUF Q4_0 layered FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.59768832,
    0.000000001,
    "Google Gemma 4 12B QAT GGUF Q4_0 layered FP16 KV read traffic",
  );
  assert.equal(result.bMem, 97);
  assert.equal(result.best.batch, 11);
  assertNear(
    result.single.aggregate,
    36.12188973010969,
    0.000000001,
    "Google Gemma 4 12B QAT GGUF Q4_0 DGX Spark single-session throughput",
  );
  assertNear(
    result.best.aggregate,
    221.87533703181398,
    0.000000001,
    "Google Gemma 4 12B QAT GGUF Q4_0 DGX Spark aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    20.170485184710362,
    0.000000001,
    "Google Gemma 4 12B QAT GGUF Q4_0 DGX Spark per-session throughput",
  );
  assertNear(
    result.dennard,
    3839.151349187415,
    0.000000001,
    "Google Gemma 4 12B QAT GGUF Q4_0 DGX Spark Dennard bound",
  );
}

{
  const result = profiled(
    "unsloth/gemma-4-12B-it-qat-GGUF",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    6.716355328,
    0.000000001,
    "Unsloth Gemma 4 12B QAT GGUF UD-Q4_K_XL resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    6.700533248,
    0.000000001,
    "Unsloth Gemma 4 12B QAT GGUF UD-Q4_K_XL swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    0.01582208,
    0.000000001,
    "Unsloth Gemma 4 12B QAT GGUF UD-Q4_K_XL resident-only header footprint",
  );
  assertNear(
    result.alloc,
    1.15474432,
    0.000000001,
    "Unsloth Gemma 4 12B QAT GGUF UD-Q4_K_XL layered FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.59768832,
    0.000000001,
    "Unsloth Gemma 4 12B QAT GGUF UD-Q4_K_XL layered FP16 KV read traffic",
  );
  assert.equal(result.bMem, 98);
  assert.equal(result.best.batch, 11);
  assertNear(
    result.single.aggregate,
    37.4063732453676,
    0.000000001,
    "Unsloth Gemma 4 12B QAT GGUF UD-Q4_K_XL DGX Spark single-session throughput",
  );
  assertNear(
    result.best.aggregate,
    226.21290396432974,
    0.000000001,
    "Unsloth Gemma 4 12B QAT GGUF UD-Q4_K_XL DGX Spark aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    20.564809451302704,
    0.000000001,
    "Unsloth Gemma 4 12B QAT GGUF UD-Q4_K_XL DGX Spark per-session throughput",
  );
  assertNear(
    result.dennard,
    3997.004700180158,
    0.000000001,
    "Unsloth Gemma 4 12B QAT GGUF UD-Q4_K_XL DGX Spark Dennard bound",
  );
}

{
  const result = profiled(
    "unsloth/gemma-4-12B-it-qat-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(result.bMem, 98);
  assert.equal(result.best.batch, 40);
  assertNear(
    result.single.aggregate,
    84.13008488152273,
    0.000000001,
    "Unsloth Gemma 4 12B QAT GGUF UD-Q4_K_XL M5 Max single-session throughput",
  );
  assertNear(
    result.best.aggregate,
    802.4028686256969,
    0.000000001,
    "Unsloth Gemma 4 12B QAT GGUF UD-Q4_K_XL M5 Max aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    20.060071715642422,
    0.000000001,
    "Unsloth Gemma 4 12B QAT GGUF UD-Q4_K_XL M5 Max per-session throughput",
  );
  assertNear(
    result.dennard,
    8989.600314690906,
    0.000000001,
    "Unsloth Gemma 4 12B QAT GGUF UD-Q4_K_XL M5 Max Dennard bound",
  );
}

{
  const modelProfile = profile("microsoft/Phi-tiny-MoE-instruct");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "microsoft/Phi-tiny-MoE-instruct",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    7.510440576,
    0.000000001,
    "Phi tiny MoE resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    2.315270784,
    0.000000001,
    "Phi tiny MoE single-session active text-decode traffic",
  );
  assertNear(
    result.alloc,
    0.134152192,
    0.000000001,
    "Phi tiny MoE sliding-window BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.134152192,
    0.000000001,
    "Phi tiny MoE sliding-window BF16 KV read traffic",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    1.610627712,
    0.000000001,
    "Phi tiny MoE fixed text traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.352321536,
    0.000000001,
    "Phi tiny MoE per-expert text traffic",
  );
  assert.equal(result.bMem, 838);
  assert.equal(result.best.batch, 47);
  assertNear(
    result.best.aggregate,
    947.474141462,
    0.000000001,
    "Phi tiny MoE DGX Spark aggregate throughput at b*",
  );
}

{
  const repo = "microsoft/Phi-mini-MoE-instruct";
  const catalogRow = model(repo);
  const modelProfile = profile(repo);
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  assert.equal(modelProfile.status, "audited");
  assert.equal(catalogRow.hf_downloads, 196717);
  assertNear(
    catalogRow.adapter.resident_weight_gb,
    15.295265408,
    0.000000001,
    "Phi mini MoE catalog resident footprint",
  );
  assertNear(
    catalogRow.adapter.active_weight_gb,
    4.46295104,
    0.000000001,
    "Phi mini MoE catalog single-session active traffic",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    15.295265408,
    0.000000001,
    "Phi mini MoE resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.262668288,
    0.000000001,
    "Phi mini MoE resident-only embedding",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    2.9530016,
    0.000000001,
    "Phi mini MoE fixed text traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.75497472,
    0.000000001,
    "Phi mini MoE per-expert text traffic",
  );
  assertNear(
    result.single.batchWeight,
    4.46295104,
    0.000000001,
    "Phi mini MoE single-session active text-decode traffic",
  );
  assertNear(
    result.alloc,
    0.268304384,
    0.000000001,
    "Phi mini MoE sliding-window BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.268304384,
    0.000000001,
    "Phi mini MoE sliding-window BF16 KV read traffic",
  );
  assert.equal(result.bMem, 390);
  assert.equal(result.best.batch, 8);
  assertNear(
    result.single.aggregate,
    57.7013869543307,
    0.000000001,
    "Phi mini MoE DGX Spark single-session throughput",
  );
  assertNear(
    result.best.aggregate,
    167.6341002524647,
    0.000000001,
    "Phi mini MoE DGX Spark aggregate throughput at b*",
  );
  assertNear(
    result.best.perSession,
    20.954262531558086,
    0.000000001,
    "Phi mini MoE DGX Spark per-session throughput at b*",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 58);
  assertNear(
    m5Result.best.aggregate,
    1164.2085502799887,
    0.000000001,
    "Phi mini MoE M5 Max aggregate throughput at b*",
  );
  assertNear(
    m5Result.best.perSession,
    20.072561211723944,
    0.000000001,
    "Phi mini MoE M5 Max per-session throughput at b*",
  );
}

{
  const modelProfile = profile("microsoft/phi-2");
  const result = profiled("microsoft/phi-2", "nvidia-dgx-spark");
  assert.equal(
    result.status_code,
    "no_floor",
    "Phi-2 should fit DGX Spark but miss the 20 tok/s floor at default context settings",
  );
  assertNear(
    result.resident,
    5.55936768,
    0.000000001,
    "Phi-2 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    5.29722368,
    0.000000001,
    "Phi-2 swept text-decode traffic",
  );
  assertNear(
    modelProfile.architecture.weight_adapter.auxiliary_resident_weight_gb,
    0.262144,
    0.000000001,
    "Phi-2 resident-only input embedding footprint",
  );
  assertNear(
    result.alloc,
    32.768,
    0.000000001,
    "Phi-2 full-context F16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    10.48576,
    0.000000001,
    "Phi-2 full-context F16 KV read traffic",
  );
  assert.equal(result.bMem, 3);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    17.29710969326682,
    0.000000001,
    "Phi-2 DGX Spark single-session throughput",
  );
  assertNear(
    result.dennard,
    179.98845499714673,
    0.000000001,
    "Phi-2 DGX Spark Dennard bound",
  );
}

{
  const modelProfile = profile("microsoft/DialoGPT-medium");
  const result = profiled("microsoft/DialoGPT-medium", "nvidia-dgx-spark");
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    0.709646336,
    0.000000001,
    "DialoGPT Medium FP16 serving resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    0.707549184,
    0.000000001,
    "DialoGPT Medium FP16 swept text-decode traffic",
  );
  assertNear(
    modelProfile.architecture.weight_adapter.auxiliary_resident_weight_gb,
    0.002097152,
    0.000000001,
    "DialoGPT Medium FP16 resident-only position embedding footprint",
  );
  assertNear(
    result.alloc,
    9.8304,
    0.000000001,
    "DialoGPT Medium FP16 full-context KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    3.145728,
    0.000000001,
    "DialoGPT Medium FP16 full-context KV read traffic",
  );
  assert.equal(result.bMem, 12);
  assert.equal(result.best?.batch, 4);
  assertNear(
    result.single.aggregate,
    70.84878324704502,
    0.000000001,
    "DialoGPT Medium FP16 DGX Spark single-session throughput",
  );
  assertNear(
    result.best?.aggregate ?? 0,
    82.16419166210929,
    0.000000001,
    "DialoGPT Medium FP16 DGX Spark aggregate throughput",
  );
  assertNear(
    result.best?.perSession ?? 0,
    20.541047915527322,
    0.000000001,
    "DialoGPT Medium FP16 DGX Spark per-session throughput",
  );
  assertNear(
    result.dennard,
    4682.094221205405,
    0.000000001,
    "DialoGPT Medium FP16 DGX Spark Dennard bound",
  );
}

{
  const modelProfile = profile("microsoft/biogpt");
  const modelRow = model("microsoft/biogpt");
  const result = profiled("microsoft/biogpt", "nvidia-dgx-spark");
  assert.equal(modelProfile.status, "audited");
  assert.equal(modelRow.hf_downloads, 122777);
  assert.ok(modelRow.tags.includes("region:us"));
  assert.equal(modelRow.architecture.total_params_b, 0.346763264);
  assert.equal(modelRow.architecture.active_params_b, 0.34571264);
  assert.equal(modelRow.adapter.weight_precision, "FP32");
  assert.equal(modelRow.adapter.resident_weight_gb, 1.387053056);
  assert.equal(modelRow.adapter.active_weight_gb, 1.38285056);
  assert.equal(modelRow.adapter.kv_alloc_gb_per_1k_tokens, 0.196608);
  assert.equal(modelRow.adapter.kv_read_gb_per_1k_tokens, 0.196608);
  assert.equal(modelProfile.architecture.kv_adapter.kind, "full_context");
  assert.equal(modelProfile.architecture.kv_adapter.layers, 24);
  assert.equal(modelProfile.architecture.kv_adapter.kv_heads, 16);
  assert.equal(modelProfile.architecture.kv_adapter.head_dim, 64);
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    1.387053056,
    0.000000001,
    "BioGPT FP32 unique serving resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    1.38285056,
    0.000000001,
    "BioGPT FP32 swept text-decode traffic",
  );
  assertNear(
    modelProfile.architecture.weight_adapter.auxiliary_resident_weight_gb,
    0.004202496,
    0.000000001,
    "BioGPT FP32 resident-only position embedding footprint",
  );
  assertNear(
    result.alloc,
    19.6608,
    0.000000001,
    "BioGPT FP32 full-context KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    6.291456,
    0.000000001,
    "BioGPT FP32 full-context KV read traffic",
  );
  assert.equal(result.bMem, 6);
  assert.equal(result.best?.batch, 1);
  assertNear(
    result.single.aggregate,
    35.573246633504304,
    0.000000001,
    "BioGPT FP32 DGX Spark single-session throughput",
  );
  assertNear(
    result.best?.aggregate ?? 0,
    35.573246633504304,
    0.000000001,
    "BioGPT FP32 DGX Spark aggregate throughput at b*",
  );
  assertNear(
    result.best?.perSession ?? 0,
    35.573246633504304,
    0.000000001,
    "BioGPT FP32 DGX Spark per-session throughput at b*",
  );
  assertNear(
    result.dennard,
    1191.0179528907304,
    0.000000001,
    "BioGPT FP32 DGX Spark Dennard bound",
  );
}

{
  const modelProfile = profile("microsoft/phi-4");
  const result = profiled("microsoft/phi-4", "nvidia-dgx-spark");
  assert.equal(
    result.status_code,
    "no_floor",
    "Phi-4 should fit DGX Spark but miss the 20 tok/s floor",
  );
  assertNear(
    result.resident,
    29.3190144,
    0.000000001,
    "Phi-4 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    28.29140992,
    0.000000001,
    "Phi-4 swept text-decode traffic",
  );
  assertNear(
    modelProfile.architecture.weight_adapter.auxiliary_resident_weight_gb,
    1.02760448,
    0.000000001,
    "Phi-4 resident-only input embedding footprint",
  );
  assertNear(
    result.alloc,
    20.48,
    0.000000001,
    "Phi-4 full-context BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    6.5536,
    0.000000001,
    "Phi-4 full-context BF16 KV read traffic",
  );
  assert.equal(result.bMem, 4);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    7.834694282675641,
    0.000000001,
    "Phi-4 DGX Spark single-session throughput",
  );
  assertNear(
    result.dennard,
    42.72620650289599,
    0.000000001,
    "Phi-4 DGX Spark Dennard bound",
  );
}

{
  const modelProfile = profile("MaziyarPanahi/phi-4-GGUF");
  const modelRow = model("MaziyarPanahi/phi-4-GGUF");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const kvAdapter = modelProfile.architecture.kv_adapter;
  const dgxResult = profiled("MaziyarPanahi/phi-4-GGUF", "nvidia-dgx-spark");
  const m5Result = profiled(
    "MaziyarPanahi/phi-4-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  const m1UltraResult = profiled(
    "MaziyarPanahi/phi-4-GGUF",
    "apple-mac-studio-m1-ultra-128gb",
  );
  assert.equal(modelProfile.status, "audited");
  assert.equal(modelRow.name, "phi-4-GGUF GGUF FP16");
  assert.equal(modelRow.license, "mit");
  assert.equal(modelRow.hf_downloads, 112039);
  assert.ok(modelRow.tags.includes("region:us"));
  assert.equal(modelRow.architecture.detail, "phi3 GGUF (Phi3ForCausalLM)");
  assert.equal(modelRow.architecture.total_params_b, 14.6595072);
  assert.equal(modelRow.architecture.active_params_b, 14.14570496);
  assert.equal(modelRow.architecture.layers, 40);
  assert.equal(modelRow.architecture.kv_heads, 10);
  assert.equal(modelRow.adapter.weight_precision, "GGUF FP16");
  assert.equal(modelRow.adapter.resident_weight_gb, 29.323399264);
  assert.equal(modelRow.adapter.active_weight_gb, 28.29223936);
  assert.equal(weightAdapter.kind, "dense_resident_swept");
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.031159904,
    0.000000001,
    "MaziyarPanahi Phi-4 GGUF metadata/header resident overhead",
  );
  assert.equal(kvAdapter.kind, "full_context");
  assert.equal(kvAdapter.layers, 40);
  assert.equal(kvAdapter.kv_heads, 10);
  assert.equal(kvAdapter.head_dim, 128);
  assert.equal(dgxResult.status_code, "no_floor");
  assertNear(
    dgxResult.resident,
    29.323399264,
    0.000000001,
    "MaziyarPanahi Phi-4 GGUF selected FP16 resident footprint",
  );
  assertNear(
    dgxResult.single.batchWeight,
    28.29223936,
    0.000000001,
    "MaziyarPanahi Phi-4 GGUF swept text-decode traffic",
  );
  assertNear(
    dgxResult.alloc,
    20.48,
    0.000000001,
    "MaziyarPanahi Phi-4 GGUF FP16 KV allocation",
  );
  assertNear(
    dgxResult.single.readTraffic,
    6.5536,
    0.000000001,
    "MaziyarPanahi Phi-4 GGUF FP16 KV read traffic",
  );
  assertNear(
    dgxResult.single.aggregate,
    7.8345077924390685,
    0.000000001,
    "MaziyarPanahi Phi-4 GGUF DGX single-session throughput",
  );
  assert.equal(dgxResult.bMem, 4);
  assert.equal(dgxResult.best, null);
  assert.equal(m5Result.status_code, "no_floor");
  assert.equal(m5Result.best, null);
  assert.equal(m1UltraResult.status_code, "ok");
  assert.equal(m1UltraResult.best?.batch, 1);
  assertNear(
    m1UltraResult.best?.aggregate ?? 0,
    22.95826459322804,
    0.000000001,
    "MaziyarPanahi Phi-4 GGUF M1 Ultra aggregate throughput",
  );
}

{
  const modelProfile = profile("LGAI-EXAONE/EXAONE-3.5-32B-Instruct-AWQ");
  const modelRow = model("LGAI-EXAONE/EXAONE-3.5-32B-Instruct-AWQ");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const kvAdapter = modelProfile.architecture.kv_adapter;
  const dgxResult = profiled(
    "LGAI-EXAONE/EXAONE-3.5-32B-Instruct-AWQ",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "LGAI-EXAONE/EXAONE-3.5-32B-Instruct-AWQ",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  const m1UltraResult = profiled(
    "LGAI-EXAONE/EXAONE-3.5-32B-Instruct-AWQ",
    "apple-mac-studio-m1-ultra-128gb",
  );
  assert.equal(modelProfile.status, "audited");
  assert.equal(modelRow.hf_downloads, 157661);
  assert.ok(modelRow.tags.includes("region:us"));
  assert.equal(modelRow.architecture.active_params_b, 31.478912);
  assert.equal(modelRow.adapter.resident_weight_gb, 18.18002432);
  assert.equal(modelRow.adapter.active_weight_gb, 17.13144832);
  assert.equal(weightAdapter.kind, "dense_resident_swept");
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.048576,
    0.000000001,
    "EXAONE 3.5 32B AWQ resident-only input embedding footprint",
  );
  assert.equal(kvAdapter.kind, "full_context");
  assert.equal(kvAdapter.layers, 64);
  assert.equal(kvAdapter.kv_heads, 8);
  assert.equal(kvAdapter.head_dim, 128);
  assert.equal(dgxResult.status_code, "no_floor");
  assertNear(
    dgxResult.resident,
    18.18002432,
    0.000000001,
    "EXAONE 3.5 32B AWQ resident stored footprint",
  );
  assertNear(
    dgxResult.single.batchWeight,
    17.13144832,
    0.000000001,
    "EXAONE 3.5 32B AWQ swept text-decode traffic",
  );
  assertNear(
    dgxResult.alloc,
    26.2144,
    0.000000001,
    "EXAONE 3.5 32B AWQ FP16 KV allocation",
  );
  assertNear(
    dgxResult.single.readTraffic,
    8.388608,
    0.000000001,
    "EXAONE 3.5 32B AWQ FP16 KV read traffic",
  );
  assertNear(
    dgxResult.single.aggregate,
    10.697468554802938,
    0.000000001,
    "EXAONE 3.5 32B AWQ DGX single-session throughput",
  );
  assert.equal(dgxResult.bMem, 3);
  assert.equal(dgxResult.best, null);
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best?.batch, 1);
  assertNear(
    m5Result.best?.aggregate ?? 0,
    24.059508031681332,
    0.000000001,
    "EXAONE 3.5 32B AWQ M5 Max aggregate throughput",
  );
  assert.equal(m1UltraResult.status_code, "ok");
  assert.equal(m1UltraResult.best?.batch, 2);
  assertNear(
    m1UltraResult.best?.aggregate ?? 0,
    47.18558020748368,
    0.000000001,
    "EXAONE 3.5 32B AWQ M1 Ultra aggregate throughput",
  );
}

{
  const modelProfile = profile("microsoft/Phi-3.5-MoE-instruct");
  const modelRow = model("microsoft/Phi-3.5-MoE-instruct");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const kvAdapter = modelProfile.architecture.kv_adapter;
  const dgxResult = profiled(
    "microsoft/Phi-3.5-MoE-instruct",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "microsoft/Phi-3.5-MoE-instruct",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  const m1UltraResult = profiled(
    "microsoft/Phi-3.5-MoE-instruct",
    "apple-mac-studio-m1-ultra-128gb",
  );
  assert.equal(modelProfile.status, "audited");
  assert.equal(modelRow.hf_downloads, 162753);
  assert.ok(modelRow.tags.includes("region:us"));
  assert.equal(modelRow.architecture.total_params_b, 41.873153344);
  assert.equal(modelRow.architecture.active_params_b, 6.5096656);
  assert.equal(modelRow.adapter.resident_weight_gb, 83.746306688);
  assert.equal(modelRow.adapter.active_weight_gb, 13.0193312);
  assert.equal(weightAdapter.kind, "moe_distinct_experts_exact");
  assertNear(
    weightAdapter.fixed_weight_gb,
    2.9530016,
    0.000000001,
    "Phi-3.5-MoE fixed ordinary decode traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    5.0331648,
    0.000000001,
    "Phi-3.5-MoE per-routed-expert traffic",
  );
  assert.equal(weightAdapter.routed_experts, 16);
  assert.equal(weightAdapter.routed_experts_per_token, 2);
  assert.equal(kvAdapter.kind, "full_context");
  assert.equal(kvAdapter.layers, 32);
  assert.equal(kvAdapter.kv_heads, 8);
  assert.equal(kvAdapter.head_dim, 128);
  assert.equal(dgxResult.status_code, "no_floor");
  assertNear(
    dgxResult.resident,
    83.746306688,
    0.000000001,
    "Phi-3.5-MoE resident BF16 footprint",
  );
  assertNear(
    dgxResult.single.batchWeight,
    13.0193312,
    0.000000001,
    "Phi-3.5-MoE single-session fixed plus two-expert traffic",
  );
  assertNear(
    dgxResult.alloc,
    13.1072,
    0.000000001,
    "Phi-3.5-MoE default-workload BF16 KV allocation",
  );
  assertNear(
    dgxResult.single.readTraffic,
    4.194304,
    0.000000001,
    "Phi-3.5-MoE default-workload BF16 KV read traffic",
  );
  assertNear(
    dgxResult.single.aggregate,
    15.859520480601333,
    0.000000001,
    "Phi-3.5-MoE DGX single-session throughput",
  );
  assert.equal(dgxResult.bMem, 2);
  assert.equal(dgxResult.best, null);
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best?.batch, 2);
  assertNear(
    m5Result.best?.aggregate ?? 0,
    40.64075027643653,
    0.000000001,
    "Phi-3.5-MoE M5 Max aggregate throughput",
  );
  assert.equal(m1UltraResult.status_code, "ok");
  assert.equal(m1UltraResult.best?.batch, 2);
  assertNear(
    m1UltraResult.best?.aggregate ?? 0,
    52.95211762402153,
    0.000000001,
    "Phi-3.5-MoE M1 Ultra aggregate throughput",
  );
}

{
  const modelProfile = profile(
    "MaziyarPanahi/Mistral-Large-Instruct-2411-GGUF",
  );
  const modelRow = model("MaziyarPanahi/Mistral-Large-Instruct-2411-GGUF");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const kvAdapter = modelProfile.architecture.kv_adapter;
  const dgxResult = profiled(
    "MaziyarPanahi/Mistral-Large-Instruct-2411-GGUF",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "MaziyarPanahi/Mistral-Large-Instruct-2411-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  const m1UltraResult = profiled(
    "MaziyarPanahi/Mistral-Large-Instruct-2411-GGUF",
    "apple-mac-studio-m1-ultra-128gb",
  );
  assert.equal(modelProfile.status, "audited");
  assert.equal(modelRow.license, "other");
  assert.equal(modelRow.hf_downloads, 111457);
  assert.ok(modelRow.tags.includes("region:us"));
  assert.equal(modelRow.architecture.total_params_b, 122.610069504);
  assert.equal(modelRow.architecture.active_params_b, 122.20741632);
  assert.equal(modelRow.adapter.resident_weight_gb, 45.196298272);
  assert.equal(modelRow.adapter.active_weight_gb, 45.063389184);
  assert.equal(weightAdapter.kind, "dense_resident_swept");
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.132909088,
    0.000000001,
    "Mistral Large Q2_K resident-only token embedding and GGUF overhead",
  );
  assert.equal(kvAdapter.kind, "full_context");
  assert.equal(kvAdapter.layers, 88);
  assert.equal(kvAdapter.kv_heads, 8);
  assert.equal(kvAdapter.head_dim, 128);
  assert.equal(dgxResult.status_code, "no_floor");
  assertNear(
    dgxResult.resident,
    45.196298272,
    0.000000001,
    "Mistral Large Q2_K resident linked-file footprint",
  );
  assertNear(
    dgxResult.single.batchWeight,
    45.063389184,
    0.000000001,
    "Mistral Large Q2_K swept text-decode traffic",
  );
  assertNear(
    dgxResult.alloc,
    36.0448,
    0.000000001,
    "Mistral Large Q2_K default-workload FP16 KV allocation",
  );
  assertNear(
    dgxResult.single.readTraffic,
    11.534336,
    0.000000001,
    "Mistral Large Q2_K default-workload FP16 KV read traffic",
  );
  assertNear(
    dgxResult.single.aggregate,
    4.823515417138642,
    0.000000001,
    "Mistral Large Q2_K DGX single-session throughput",
  );
  assert.equal(dgxResult.bMem, 2);
  assert.equal(dgxResult.best, null);
  assert.equal(m5Result.status_code, "no_floor");
  assertNear(
    m5Result.single.aggregate,
    10.848492549901563,
    0.000000001,
    "Mistral Large Q2_K M5 Max single-session throughput",
  );
  assert.equal(m5Result.best, null);
  assert.equal(m1UltraResult.status_code, "no_floor");
  assertNear(
    m1UltraResult.single.aggregate,
    14.134843713226791,
    0.000000001,
    "Mistral Large Q2_K M1 Ultra single-session throughput",
  );
  assert.equal(m1UltraResult.best, null);
}

{
  const modelProfile = profile("MaziyarPanahi/firefunction-v2-GGUF");
  const modelRow = model("MaziyarPanahi/firefunction-v2-GGUF");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const kvAdapter = modelProfile.architecture.kv_adapter;
  const dgxResult = profiled(
    "MaziyarPanahi/firefunction-v2-GGUF",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "MaziyarPanahi/firefunction-v2-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  const m1UltraResult = profiled(
    "MaziyarPanahi/firefunction-v2-GGUF",
    "apple-mac-studio-m1-ultra-128gb",
  );
  assert.equal(modelProfile.status, "audited");
  assert.equal(modelRow.hf_downloads, 111313);
  assert.ok(modelRow.tags.includes("region:us"));
  assert.equal(modelRow.architecture.total_params_b, 70.553706496);
  assert.equal(modelRow.architecture.active_params_b, 69.503033344);
  assert.equal(modelRow.adapter.resident_weight_gb, 16.751198848);
  assert.equal(modelRow.adapter.active_weight_gb, 16.39858176);
  assert.equal(weightAdapter.kind, "dense_resident_swept");
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.352617088,
    0.000000001,
    "Firefunction IQ1_M resident-only token embedding and GGUF overhead",
  );
  assert.equal(kvAdapter.kind, "full_context");
  assert.equal(kvAdapter.layers, 80);
  assert.equal(kvAdapter.kv_heads, 8);
  assert.equal(kvAdapter.head_dim, 128);
  assert.equal(dgxResult.status_code, "no_floor");
  assertNear(
    dgxResult.resident,
    16.751198848,
    0.000000001,
    "Firefunction IQ1_M resident linked-file footprint",
  );
  assertNear(
    dgxResult.single.batchWeight,
    16.39858176,
    0.000000001,
    "Firefunction IQ1_M swept text-decode traffic",
  );
  assertNear(
    dgxResult.alloc,
    32.768,
    0.000000001,
    "Firefunction IQ1_M default-workload FP16 KV allocation",
  );
  assertNear(
    dgxResult.single.readTraffic,
    10.48576,
    0.000000001,
    "Firefunction IQ1_M default-workload FP16 KV read traffic",
  );
  assertNear(
    dgxResult.single.aggregate,
    10.154609788742695,
    0.000000001,
    "Firefunction IQ1_M DGX single-session throughput",
  );
  assert.equal(dgxResult.bMem, 3);
  assert.equal(dgxResult.best, null);
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best?.batch, 1);
  assertNear(
    m5Result.best?.aggregate ?? 0,
    22.83857293145793,
    0.000000001,
    "Firefunction IQ1_M M5 Max aggregate throughput",
  );
  assert.equal(m1UltraResult.status_code, "ok");
  assert.equal(m1UltraResult.best?.batch, 2);
  assertNear(
    m1UltraResult.best?.aggregate ?? 0,
    42.8149757331568,
    0.000000001,
    "Firefunction IQ1_M M1 Ultra aggregate throughput",
  );
}

{
  const modelProfile = profile("MaziyarPanahi/INTELLECT-2-GGUF");
  const modelRow = model("MaziyarPanahi/INTELLECT-2-GGUF");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const kvAdapter = modelProfile.architecture.kv_adapter;
  const dgxResult = profiled(
    "MaziyarPanahi/INTELLECT-2-GGUF",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "MaziyarPanahi/INTELLECT-2-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  const m1UltraResult = profiled(
    "MaziyarPanahi/INTELLECT-2-GGUF",
    "apple-mac-studio-m1-ultra-128gb",
  );
  assert.equal(modelProfile.status, "audited");
  assert.equal(modelRow.license, "apache-2.0");
  assert.equal(modelRow.hf_downloads, 110740);
  assert.ok(modelRow.tags.includes("region:us"));
  assert.equal(modelRow.architecture.total_params_b, 32.763876352);
  assert.equal(modelRow.architecture.active_params_b, 31.985308672);
  assert.equal(modelRow.adapter.weight_precision, "GGUF Q2_K");
  assert.equal(modelRow.adapter.resident_weight_gb, 12.313098944);
  assert.equal(modelRow.adapter.active_weight_gb, 12.051652608);
  assert.equal(weightAdapter.kind, "dense_resident_swept");
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.261446336,
    0.000000001,
    "INTELLECT-2 Q2_K resident-only token embedding and GGUF overhead",
  );
  assert.equal(kvAdapter.kind, "full_context");
  assert.equal(kvAdapter.layers, 64);
  assert.equal(kvAdapter.kv_heads, 8);
  assert.equal(kvAdapter.head_dim, 128);
  assert.equal(dgxResult.status_code, "no_floor");
  assertNear(
    dgxResult.resident,
    12.313098944,
    0.000000001,
    "INTELLECT-2 Q2_K resident linked-file footprint",
  );
  assertNear(
    dgxResult.single.batchWeight,
    12.051652608,
    0.000000001,
    "INTELLECT-2 Q2_K swept text-decode traffic",
  );
  assertNear(
    dgxResult.alloc,
    26.2144,
    0.000000001,
    "INTELLECT-2 Q2_K default-workload FP16 KV allocation",
  );
  assertNear(
    dgxResult.single.readTraffic,
    8.388608,
    0.000000001,
    "INTELLECT-2 Q2_K default-workload FP16 KV read traffic",
  );
  assertNear(
    dgxResult.single.aggregate,
    13.35599409594377,
    0.000000001,
    "INTELLECT-2 Q2_K DGX single-session throughput",
  );
  assert.equal(dgxResult.bMem, 4);
  assert.equal(dgxResult.best, null);
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best?.batch, 2);
  assertNear(
    m5Result.best?.aggregate ?? 0,
    42.596191224071504,
    0.000000001,
    "INTELLECT-2 Q2_K M5 Max aggregate throughput",
  );
  assert.equal(m1UltraResult.status_code, "ok");
  assert.equal(m1UltraResult.best?.batch, 3);
  assertNear(
    m1UltraResult.best?.aggregate ?? 0,
    64.48583350447015,
    0.000000001,
    "INTELLECT-2 Q2_K M1 Ultra aggregate throughput",
  );
}

{
  const modelProfile = profile("nvidia/Phi-4-reasoning-plus-NVFP4");
  const result = profiled(
    "nvidia/Phi-4-reasoning-plus-NVFP4",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "nvidia/Phi-4-reasoning-plus-NVFP4",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(
    result.status_code,
    "ok",
    "NVIDIA Phi-4 reasoning plus NVFP4 should fit DGX Spark and satisfy the 20 tok/s floor",
  );
  assert.equal(modelProfile.serving.weight_format, "nvfp4");
  assert.equal(modelProfile.serving.kv_store_format, "fp8");
  assert.equal(modelProfile.serving.kv_read_format, "fp8");
  assertNear(
    result.resident,
    9.723752,
    0.000000001,
    "NVIDIA Phi-4 reasoning plus NVFP4 resident stored footprint",
  );
  assertNear(
    result.single.batchWeight,
    8.69614752,
    0.000000001,
    "NVIDIA Phi-4 reasoning plus NVFP4 swept text-decode traffic",
  );
  assertNear(
    modelProfile.architecture.weight_adapter.auxiliary_resident_weight_gb,
    1.02760448,
    0.000000001,
    "NVIDIA Phi-4 reasoning plus NVFP4 resident-only input embedding footprint",
  );
  assertNear(
    result.alloc,
    10.24,
    0.000000001,
    "NVIDIA Phi-4 reasoning plus NVFP4 full-context FP8 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    3.2768,
    0.000000001,
    "NVIDIA Phi-4 reasoning plus NVFP4 full-context FP8 KV read traffic",
  );
  assert.equal(result.bMem, 10);
  assert.equal(result.best.batch, 1);
  assertNear(
    result.single.aggregate,
    22.801402874603095,
    0.000000001,
    "NVIDIA Phi-4 reasoning plus NVFP4 DGX Spark single-session throughput",
  );
  assertNear(
    result.dennard,
    338.0786716856145,
    0.000000001,
    "NVIDIA Phi-4 reasoning plus NVFP4 DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 6);
  assertNear(
    m5Result.single.aggregate,
    51.282276062294144,
    0.000000001,
    "NVIDIA Phi-4 reasoning plus NVFP4 M5 Max single-session throughput",
  );
  assertNear(
    m5Result.best.aggregate,
    129.91525259909216,
    0.000000001,
    "NVIDIA Phi-4 reasoning plus NVFP4 M5 Max aggregate throughput at b*",
  );
  assertNear(
    m5Result.best.perSession,
    21.65254209984869,
    0.000000001,
    "NVIDIA Phi-4 reasoning plus NVFP4 M5 Max per-session throughput at b*",
  );
}

{
  const modelProfile = profile("microsoft/Phi-3-mini-128k-instruct");
  const result = profiled(
    "microsoft/Phi-3-mini-128k-instruct",
    "nvidia-dgx-spark",
  );
  assert.equal(
    result.status_code,
    "no_floor",
    "Phi-3 Mini 128K should fit DGX Spark but miss the 20 tok/s floor",
  );
  assertNear(
    result.resident,
    7.642159104,
    0.000000001,
    "Phi-3 Mini 128K resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    7.445157888,
    0.000000001,
    "Phi-3 Mini 128K swept text-decode traffic",
  );
  assertNear(
    modelProfile.architecture.weight_adapter.auxiliary_resident_weight_gb,
    0.197001216,
    0.000000001,
    "Phi-3 Mini 128K resident-only input embedding footprint",
  );
  assertNear(
    result.alloc,
    39.3216,
    0.000000001,
    "Phi-3 Mini 128K full-context BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    12.582912,
    0.000000001,
    "Phi-3 Mini 128K full-context BF16 KV read traffic",
  );
  assert.equal(result.bMem, 2);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    13.630869151,
    0.000000001,
    "Phi-3 Mini 128K DGX Spark single-session throughput",
  );
  assertNear(
    result.dennard,
    104.77578876,
    0.000000001,
    "Phi-3 Mini 128K DGX Spark Dennard bound",
  );
}

{
  const modelProfile = profile("microsoft/Phi-3.5-mini-instruct");
  const result = profiled(
    "microsoft/Phi-3.5-mini-instruct",
    "nvidia-dgx-spark",
  );
  assert.equal(
    result.status_code,
    "no_floor",
    "Phi-3.5 Mini should fit DGX Spark but miss the 20 tok/s floor",
  );
  assertNear(
    result.resident,
    7.642159104,
    0.000000001,
    "Phi-3.5 Mini resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    7.445157888,
    0.000000001,
    "Phi-3.5 Mini swept text-decode traffic",
  );
  assertNear(
    modelProfile.architecture.weight_adapter.auxiliary_resident_weight_gb,
    0.197001216,
    0.000000001,
    "Phi-3.5 Mini resident-only input embedding footprint",
  );
  assertNear(
    result.alloc,
    39.3216,
    0.000000001,
    "Phi-3.5 Mini full-context BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    12.582912,
    0.000000001,
    "Phi-3.5 Mini full-context BF16 KV read traffic",
  );
  assert.equal(result.bMem, 2);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    13.630869151,
    0.000000001,
    "Phi-3.5 Mini DGX Spark single-session throughput",
  );
  assertNear(
    result.dennard,
    104.77578876,
    0.000000001,
    "Phi-3.5 Mini DGX Spark Dennard bound",
  );
}

{
  const modelProfile = profile("MaziyarPanahi/Phi-3.5-mini-instruct-GGUF");
  const result = profiled(
    "MaziyarPanahi/Phi-3.5-mini-instruct-GGUF",
    "nvidia-dgx-spark",
  );
  assert.equal(modelProfile.status, "audited");
  assert.equal(modelProfile.serving.weight_format, "gguf_quantized");
  assert.equal(
    modelProfile.serving.runtime_format,
    "llama.cpp-gguf-q4-k-m-memory-bound",
  );
  assert.equal(
    result.status_code,
    "no_floor",
    "Phi-3.5 Mini Q4_K_M GGUF should fit DGX Spark but miss the 20 tok/s floor",
  );
  assertNear(
    modelProfile.architecture.weight_adapter.resident_params_b,
    3.821079648,
    0.000000001,
    "Phi-3.5 Mini Q4_K_M GGUF logical resident parameters",
  );
  assertNear(
    modelProfile.architecture.weight_adapter.swept_params_b,
    3.72257904,
    0.000000001,
    "Phi-3.5 Mini Q4_K_M GGUF logical swept parameters",
  );
  assertNear(
    result.resident,
    2.393232608,
    0.000000001,
    "Phi-3.5 Mini Q4_K_M GGUF resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    2.33708736,
    0.000000001,
    "Phi-3.5 Mini Q4_K_M GGUF swept text-decode traffic",
  );
  assertNear(
    modelProfile.architecture.weight_adapter.auxiliary_resident_weight_gb,
    0.056145248,
    0.000000001,
    "Phi-3.5 Mini Q4_K_M GGUF resident-only token embedding plus header footprint",
  );
  assertNear(
    result.alloc,
    39.3216,
    0.000000001,
    "Phi-3.5 Mini Q4_K_M GGUF full-context FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    12.582912,
    0.000000001,
    "Phi-3.5 Mini Q4_K_M GGUF full-context FP16 KV read traffic",
  );
  assert.equal(result.bMem, 2);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    18.297587916,
    0.000000001,
    "Phi-3.5 Mini Q4_K_M GGUF DGX Spark single-session throughput",
  );
  assertNear(
    result.dennard,
    349.372592328,
    0.000000001,
    "Phi-3.5 Mini Q4_K_M GGUF DGX Spark Dennard bound",
  );
}

{
  const modelProfile = profile(
    "VlSav/Vikhr-Nemo-12B-Instruct-R-21-09-24-Q8_0-GGUF",
  );
  const result = profiled(
    "VlSav/Vikhr-Nemo-12B-Instruct-R-21-09-24-Q8_0-GGUF",
    "nvidia-dgx-spark",
  );
  assert.equal(modelProfile.status, "audited");
  assert.equal(modelProfile.serving.weight_format, "gguf_quantized");
  assert.equal(
    modelProfile.serving.runtime_format,
    "llama.cpp-gguf-q8-0-memory-bound",
  );
  assert.equal(
    result.status_code,
    "no_floor",
    "Vikhr-Nemo 12B Q8_0 GGUF should fit DGX Spark but miss the 20 tok/s floor",
  );
  assertNear(
    modelProfile.architecture.weight_adapter.resident_params_b,
    12.24780288,
    0.000000001,
    "Vikhr-Nemo 12B Q8_0 GGUF logical resident parameters",
  );
  assertNear(
    modelProfile.architecture.weight_adapter.swept_params_b,
    11.576704,
    0.000000001,
    "Vikhr-Nemo 12B Q8_0 GGUF logical swept parameters",
  );
  assertNear(
    result.resident,
    13.02239104,
    0.000000001,
    "Vikhr-Nemo 12B Q8_0 GGUF resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    12.30146624,
    0.000000001,
    "Vikhr-Nemo 12B Q8_0 GGUF swept text-decode traffic",
  );
  assertNear(
    modelProfile.architecture.weight_adapter.auxiliary_resident_weight_gb,
    0.7209248,
    0.000000001,
    "Vikhr-Nemo 12B Q8_0 GGUF resident-only token embedding plus header footprint",
  );
  assertNear(
    result.alloc,
    16.384,
    0.000000001,
    "Vikhr-Nemo 12B Q8_0 GGUF full-context FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    5.24288,
    0.000000001,
    "Vikhr-Nemo 12B Q8_0 GGUF full-context FP16 KV read traffic",
  );
  assert.equal(result.bMem, 6);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    15.560568417,
    0.000000001,
    "Vikhr-Nemo 12B Q8_0 GGUF DGX Spark single-session throughput",
  );
  assertNear(
    result.dennard,
    144.903446593,
    0.000000001,
    "Vikhr-Nemo 12B Q8_0 GGUF DGX Spark Dennard bound",
  );
}

{
  const repo = "MaziyarPanahi/Ministral-3-3B-Reasoning-2512-GGUF";
  const catalogRow = model(repo);
  const modelProfile = profile(repo);
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  const m1UltraResult = profiled(repo, "apple-mac-studio-m1-ultra-128gb");
  assert.equal(catalogRow.name, "Ministral-3-3B-Reasoning-2512-GGUF FP16");
  assert.equal(catalogRow.hf_downloads, 113921);
  assert.equal(catalogRow.license, "apache-2.0");
  assert.ok(catalogRow.tags.includes("region:us"));
  assert.equal(catalogRow.architecture.detail, "mistral3 (GGUF FP16)");
  assert.equal(catalogRow.architecture.max_context_tokens, 262144);
  assert.equal(catalogRow.adapter.weight_precision, "GGUF FP16/F32");
  assert.equal(modelProfile.status, "audited");
  assert.equal(modelProfile.base_model_proof.config_compatible, true);
  assert.equal(modelProfile.serving.weight_format, "fp16");
  assert.equal(
    modelProfile.serving.runtime_format,
    "llama.cpp-gguf-f16-f32-memory-bound",
  );
  assert.equal(modelProfile.architecture.kv_adapter.kind, "full_context");
  assert.equal(modelProfile.architecture.kv_adapter.layers, 26);
  assert.equal(modelProfile.architecture.kv_adapter.kv_heads, 8);
  assert.equal(modelProfile.architecture.kv_adapter.head_dim, 128);
  assertNear(
    weightAdapter.resident_params_b,
    3.429006336,
    0.000000001,
    "MaziyarPanahi Ministral 3 3B FP16 GGUF logical resident parameters",
  );
  assertNear(
    weightAdapter.swept_params_b,
    3.429006336,
    0.000000001,
    "MaziyarPanahi Ministral 3 3B FP16 GGUF logical swept parameters",
  );
  assertNear(
    result.resident,
    6.8662192,
    0.000000001,
    "MaziyarPanahi Ministral 3 3B FP16 GGUF selected linked size",
  );
  assertNear(
    result.single.batchWeight,
    6.858338304,
    0.000000001,
    "MaziyarPanahi Ministral 3 3B FP16 GGUF swept text-decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.007880896,
    0.000000001,
    "MaziyarPanahi Ministral 3 3B FP16 GGUF GGUF header overhead",
  );
  assertNear(
    result.alloc,
    10.6496,
    0.000000001,
    "MaziyarPanahi Ministral 3 3B FP16 GGUF full-context FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    3.407872,
    0.000000001,
    "MaziyarPanahi Ministral 3 3B FP16 GGUF full-context FP16 KV read traffic",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(result.bMem, 10);
  assert.equal(result.best.batch, 1);
  assertNear(
    result.best.aggregate,
    26.592091133534606,
    0.000000001,
    "MaziyarPanahi Ministral 3 3B FP16 GGUF DGX aggregate",
  );
  assertNear(
    result.dennard,
    422.8659810185597,
    0.000000001,
    "MaziyarPanahi Ministral 3 3B FP16 GGUF DGX Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 6);
  assertNear(
    m5Result.best.aggregate,
    134.9175263136815,
    0.000000001,
    "MaziyarPanahi Ministral 3 3B FP16 GGUF M5 aggregate",
  );
  assertNear(
    m5Result.best.perSession,
    22.48625438561358,
    0.000000001,
    "MaziyarPanahi Ministral 3 3B FP16 GGUF M5 per-session",
  );
  assert.equal(m1UltraResult.status_code, "ok");
  assert.equal(m1UltraResult.best.batch, 9);
  assertNear(
    m1UltraResult.best.aggregate,
    191.85068233767163,
    0.000000001,
    "MaziyarPanahi Ministral 3 3B FP16 GGUF M1 Ultra aggregate",
  );
  assertNear(
    m1UltraResult.best.perSession,
    21.316742481963516,
    0.000000001,
    "MaziyarPanahi Ministral 3 3B FP16 GGUF M1 Ultra per-session",
  );
}

{
  const repo = "MaziyarPanahi/solar-pro-preview-instruct-GGUF";
  const catalogRow = model(repo);
  const modelProfile = profile(repo);
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  const m1UltraResult = profiled(repo, "apple-mac-studio-m1-ultra-128gb");
  assert.equal(catalogRow.name, "solar-pro-preview-instruct-GGUF FP16");
  assert.equal(catalogRow.hf_downloads, 111877);
  assert.equal(catalogRow.license, "mit");
  assert.ok(catalogRow.tags.includes("region:us"));
  assert.equal(catalogRow.architecture.detail, "llama GGUF / SolarForCausalLM");
  assert.equal(catalogRow.architecture.max_context_tokens, 4096);
  assert.equal(catalogRow.adapter.weight_precision, "GGUF FP16/F32");
  assert.equal(modelProfile.status, "audited");
  assert.equal(modelProfile.base_model_proof.config_compatible, false);
  assert.equal(modelProfile.serving.weight_format, "fp16");
  assert.equal(
    modelProfile.serving.runtime_format,
    "llama.cpp-gguf-f16-f32-memory-bound",
  );
  assert.equal(modelProfile.architecture.kv_adapter.kind, "full_context");
  assert.equal(modelProfile.architecture.kv_adapter.layers, 64);
  assert.equal(modelProfile.architecture.kv_adapter.kv_heads, 10);
  assert.equal(modelProfile.architecture.kv_adapter.head_dim, 128);
  assertNear(
    weightAdapter.resident_params_b,
    22.140032,
    0.000000001,
    "MaziyarPanahi Solar Pro FP16 GGUF logical resident parameters",
  );
  assertNear(
    weightAdapter.swept_params_b,
    21.97553664,
    0.000000001,
    "MaziyarPanahi Solar Pro FP16 GGUF logical swept parameters",
  );
  assertNear(
    result.resident,
    44.282148416,
    0.000000001,
    "MaziyarPanahi Solar Pro FP16 GGUF selected linked size",
  );
  assertNear(
    result.single.batchWeight,
    43.95239424,
    0.000000001,
    "MaziyarPanahi Solar Pro FP16 GGUF swept text-decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.329754176,
    0.000000001,
    "MaziyarPanahi Solar Pro FP16 GGUF resident input embedding and header overhead",
  );
  assertNear(
    result.alloc,
    32.768,
    0.000000001,
    "MaziyarPanahi Solar Pro FP16 GGUF full-context FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    10.48576,
    0.000000001,
    "MaziyarPanahi Solar Pro FP16 GGUF full-context FP16 KV read traffic",
  );
  assert.equal(result.status_code, "no_floor");
  assert.equal(result.bMem, 2);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    5.014865103552784,
    0.000000001,
    "MaziyarPanahi Solar Pro FP16 GGUF DGX single-session aggregate",
  );
  assertNear(
    result.dennard,
    14.352529801341761,
    0.000000001,
    "MaziyarPanahi Solar Pro FP16 GGUF DGX Dennard bound",
  );
  assert.equal(m5Result.status_code, "no_floor");
  assert.equal(m5Result.best, null);
  assertNear(
    m5Result.single.aggregate,
    11.278854115682819,
    0.000000001,
    "MaziyarPanahi Solar Pro FP16 GGUF M5 single-session aggregate",
  );
  assertNear(
    m5Result.dennard,
    32.28004871071004,
    0.000000001,
    "MaziyarPanahi Solar Pro FP16 GGUF M5 Dennard bound",
  );
  assert.equal(m1UltraResult.status_code, "no_floor");
  assert.equal(m1UltraResult.best, null);
  assertNear(
    m1UltraResult.single.aggregate,
    14.695575395026474,
    0.000000001,
    "MaziyarPanahi Solar Pro FP16 GGUF M1 Ultra single-session aggregate",
  );
  assertNear(
    m1UltraResult.dennard,
    42.05869538854728,
    0.000000001,
    "MaziyarPanahi Solar Pro FP16 GGUF M1 Ultra Dennard bound",
  );
}

{
  const repo = "MaziyarPanahi/Mistral-Nemo-Instruct-2407-GGUF";
  const catalogRow = model(repo);
  const modelProfile = profile(repo);
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  assert.equal(catalogRow.name, "Mistral-Nemo-Instruct-2407-GGUF GGUF F16");
  assert.equal(catalogRow.hf_downloads, 123676);
  assert.equal(catalogRow.architecture.max_context_tokens, 1024000);
  assert.equal(modelProfile.status, "audited");
  assert.equal(modelProfile.serving.weight_format, "fp16");
  assert.equal(
    modelProfile.serving.runtime_format,
    "llama.cpp-gguf-f16-memory-bound",
  );
  assert.equal(
    result.status_code,
    "no_floor",
    "MaziyarPanahi Mistral Nemo F16 GGUF should fit DGX Spark but miss the 20 tok/s floor",
  );
  assertNear(
    modelProfile.architecture.weight_adapter.resident_params_b,
    12.2477824,
    0.000000001,
    "MaziyarPanahi Mistral Nemo F16 GGUF logical resident parameters",
  );
  assertNear(
    modelProfile.architecture.weight_adapter.swept_params_b,
    11.57669376,
    0.000000001,
    "MaziyarPanahi Mistral Nemo F16 GGUF logical swept parameters",
  );
  assertNear(
    result.resident,
    24.504276704,
    0.000000001,
    "MaziyarPanahi Mistral Nemo F16 GGUF resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    23.15421696,
    0.000000001,
    "MaziyarPanahi Mistral Nemo F16 GGUF swept text-decode traffic",
  );
  assertNear(
    modelProfile.architecture.weight_adapter.auxiliary_resident_weight_gb,
    1.350059744,
    0.000000001,
    "MaziyarPanahi Mistral Nemo F16 GGUF resident-only token embedding plus header footprint",
  );
  assertNear(
    result.alloc,
    16.384,
    0.000000001,
    "MaziyarPanahi Mistral Nemo F16 GGUF full-context FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    5.24288,
    0.000000001,
    "MaziyarPanahi Mistral Nemo F16 GGUF full-context FP16 KV read traffic",
  );
  assert.equal(result.bMem, 5);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    9.61365876182859,
    0.000000001,
    "MaziyarPanahi Mistral Nemo F16 GGUF DGX Spark single-session throughput",
  );
  assertNear(
    result.dennard,
    68.72211735437708,
    0.000000001,
    "MaziyarPanahi Mistral Nemo F16 GGUF DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 1);
  assertNear(
    m5Result.best.aggregate,
    21.621928497299464,
    0.000000001,
    "MaziyarPanahi Mistral Nemo F16 GGUF M5 Max aggregate",
  );
}

{
  const modelProfile = profile("microsoft/Phi-3-mini-4k-instruct");
  const result = profiled(
    "microsoft/Phi-3-mini-4k-instruct",
    "nvidia-dgx-spark",
  );
  assert.equal(
    result.status_code,
    "ok",
    "Phi-3 Mini 4K should fit DGX Spark and satisfy the 20 tok/s floor",
  );
  assertNear(
    result.resident,
    7.642159104,
    0.000000001,
    "Phi-3 Mini 4K resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    7.445157888,
    0.000000001,
    "Phi-3 Mini 4K swept text-decode traffic",
  );
  assertNear(
    modelProfile.architecture.weight_adapter.auxiliary_resident_weight_gb,
    0.197001216,
    0.000000001,
    "Phi-3 Mini 4K resident-only input embedding footprint",
  );
  assertNear(
    result.alloc,
    0.804913152,
    0.000000001,
    "Phi-3 Mini 4K BF16 sliding-window KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.804913152,
    0.000000001,
    "Phi-3 Mini 4K BF16 sliding-window KV read traffic",
  );
  assert.equal(result.bMem, 139);
  assert.equal(result.best.batch, 7);
  assertNear(
    result.best.aggregate,
    146.10594454802234,
    0.000000001,
    "Phi-3 Mini 4K DGX Spark aggregate throughput at b*",
  );
  assertNear(
    result.best.perSession,
    20.872277792574618,
    0.000000001,
    "Phi-3 Mini 4K DGX Spark per-session throughput at b*",
  );
  assertNear(
    result.single.aggregate,
    33.09062415055277,
    0.000000001,
    "Phi-3 Mini 4K DGX Spark single-session throughput",
  );
  assertNear(
    result.dennard,
    5118.504580350444,
    0.000000001,
    "Phi-3 Mini 4K DGX Spark Dennard bound",
  );
}

{
  const modelProfile = profile("kaitchup/Phi-3-mini-4k-instruct-gptq-4bit");
  const result = profiled(
    "kaitchup/Phi-3-mini-4k-instruct-gptq-4bit",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "kaitchup/Phi-3-mini-4k-instruct-gptq-4bit",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(modelProfile.serving.weight_format, "int4");
  assertNear(
    result.resident,
    2.28137984,
    0.000000001,
    "Kaitchup Phi-3 Mini GPTQ resident payload",
  );
  assertNear(
    result.single.batchWeight,
    2.084378624,
    0.000000001,
    "Kaitchup Phi-3 Mini GPTQ swept text-decode traffic",
  );
  assertNear(
    modelProfile.architecture.weight_adapter.auxiliary_resident_weight_gb,
    0.197001216,
    0.000000001,
    "Kaitchup Phi-3 Mini GPTQ resident-only input embedding",
  );
  assertNear(
    result.alloc,
    0.805306368,
    0.000000001,
    "Kaitchup Phi-3 Mini GPTQ sliding-window KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.805306368,
    0.000000001,
    "Kaitchup Phi-3 Mini GPTQ sliding-window KV read traffic",
  );
  assert.equal(result.bMem, 146);
  assert.equal(result.best.batch, 14);
  assertNear(
    result.best.aggregate,
    286.106374085,
    0.000000001,
    "Kaitchup Phi-3 Mini GPTQ DGX aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    20.436169578,
    0.000000001,
    "Kaitchup Phi-3 Mini GPTQ DGX per-session throughput",
  );
  assertNear(
    result.single.aggregate,
    94.473965417,
    0.000000001,
    "Kaitchup Phi-3 Mini GPTQ DGX single-session throughput",
  );
  assertNear(
    result.dennard,
    19145.647820827,
    0.000001,
    "Kaitchup Phi-3 Mini GPTQ DGX Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 35);
  assertNear(
    m5Result.best.aggregate,
    709.941458147,
    0.000001,
    "Kaitchup Phi-3 Mini GPTQ M5 Max aggregate throughput",
  );
  assertNear(
    m5Result.best.perSession,
    20.284041661,
    0.000000001,
    "Kaitchup Phi-3 Mini GPTQ M5 Max per-session throughput",
  );
}

{
  const result = profiled(
    "microsoft/Phi-3.5-vision-instruct",
    "nvidia-dgx-spark",
  );
  assert.equal(
    result.status_code,
    "no_floor",
    "Phi-3.5 Vision should fit DGX Spark but miss the 20 tok/s floor",
  );
  assertNear(
    result.resident,
    8.29324288,
    0.000000001,
    "Phi-3.5 Vision resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    7.445157888,
    0.000000001,
    "Phi-3.5 Vision swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    0.848084992,
    0.000000001,
    "Phi-3.5 Vision resident-only vision and input-embedding footprint",
  );
  assertNear(
    result.alloc,
    39.3216,
    0.000000001,
    "Phi-3.5 Vision full-context BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    12.582912,
    0.000000001,
    "Phi-3.5 Vision full-context BF16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    13.630869151478766,
    0.000000001,
    "Phi-3.5 Vision DGX Spark single-session throughput",
  );
  assert.equal(result.bMem, 2);
  assert.equal(result.best, null);
}

{
  const result = profiled(
    "microsoft/Phi-3-vision-128k-instruct",
    "nvidia-dgx-spark",
  );
  assert.equal(
    result.status_code,
    "no_floor",
    "Phi-3 Vision 128K should fit DGX Spark but miss the 20 tok/s floor",
  );
  assertNear(
    result.resident,
    8.29324288,
    0.000000001,
    "Phi-3 Vision 128K resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    7.445157888,
    0.000000001,
    "Phi-3 Vision 128K swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    0.848084992,
    0.000000001,
    "Phi-3 Vision 128K resident-only vision and input-embedding footprint",
  );
  assertNear(
    result.alloc,
    39.3216,
    0.000000001,
    "Phi-3 Vision 128K full-context BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    12.582912,
    0.000000001,
    "Phi-3 Vision 128K full-context BF16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    13.630869151478766,
    0.000000001,
    "Phi-3 Vision 128K DGX Spark single-session throughput",
  );
  assert.equal(result.bMem, 2);
  assert.equal(result.best, null);
}

{
  const result = profiled("google/gemma-4-26B-A4B-it", "nvidia-dgx-spark");
  assertNear(
    result.resident,
    51.611872412,
    0.000000001,
    "Gemma 4 26B A4B BF16 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    7.64506118,
    0.000000001,
    "Gemma 4 26B A4B BF16 active text-decode traffic",
  );
  assertNear(
    result.alloc,
    0.7217152,
    0.000000001,
    "Gemma 4 26B A4B layered BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.3735552,
    0.000000001,
    "Gemma 4 26B A4B layered BF16 KV read traffic",
  );
}

{
  const result = profiled(
    "yuxinlu1/gemma-4-12B-coder-fable5-composer2.5-v1-GGUF",
    "nvidia-dgx-spark",
  );
  assertNear(
    result.resident,
    7.381381664,
    0.000000001,
    "Yuxinlu Gemma 4 12B Coder Q4_K_M GGUF resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    7.365559808,
    0.000000001,
    "Yuxinlu Gemma 4 12B Coder Q4_K_M GGUF swept text traffic",
  );
  assertNear(
    result.alloc,
    1.15474432,
    0.000000001,
    "Yuxinlu Gemma 4 12B Coder layered GGUF KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.59768832,
    0.000000001,
    "Yuxinlu Gemma 4 12B Coder layered GGUF KV read traffic",
  );
  assert.equal(result.bMem, 97);
  assert.equal(result.best.batch, 10);
}

{
  const item = profile(
    "yuxinlu1/gemma-4-12B-agentic-fable5-composer2.5-v2-3.5x-tau2-GGUF",
  );
  const result = profiled(
    "yuxinlu1/gemma-4-12B-agentic-fable5-composer2.5-v2-3.5x-tau2-GGUF",
    "nvidia-dgx-spark",
  );
  assert.equal(item.architecture.max_context_tokens, 262144);
  assertNear(
    result.resident,
    7.381381664,
    0.000000001,
    "Yuxinlu Gemma 4 12B Agentic v2 Q4_K_M GGUF resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    7.365559808,
    0.000000001,
    "Yuxinlu Gemma 4 12B Agentic v2 Q4_K_M GGUF swept text traffic",
  );
  assertNear(
    item.architecture.weight_adapter.auxiliary_resident_weight_gb,
    0.015821856,
    0.000000001,
    "Yuxinlu Gemma 4 12B Agentic v2 GGUF metadata/header overhead",
  );
  assertNear(
    result.alloc,
    1.15474432,
    0.000000001,
    "Yuxinlu Gemma 4 12B Agentic v2 layered GGUF KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.59768832,
    0.000000001,
    "Yuxinlu Gemma 4 12B Agentic v2 layered GGUF KV read traffic",
  );
  assert.equal(result.bMem, 97);
  assert.equal(result.best.batch, 10);
  assertNear(
    result.best.aggregate,
    204.610205069875,
    0.000000001,
    "Yuxinlu Gemma 4 12B Agentic v2 DGX Spark best aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    20.461020506987502,
    0.000000001,
    "Yuxinlu Gemma 4 12B Agentic v2 DGX Spark per-session throughput",
  );
}

{
  const result = profiled("microsoft/Phi-4-mini-instruct", "nvidia-dgx-spark");
  assertNear(
    result.resident,
    7.67204352,
    0.000000001,
    "Phi-4 Mini BF16 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    7.67204352,
    0.000000001,
    "Phi-4 Mini tied-embedding swept text traffic",
  );
  assertNear(
    result.alloc,
    13.1072,
    0.000000001,
    "Phi-4 Mini full-context BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    4.194304,
    0.000000001,
    "Phi-4 Mini full-context BF16 KV read traffic",
  );
  assert.equal(result.bMem, 8);
  assert.equal(result.best.batch, 1);
}

{
  const modelProfile = profile("MaziyarPanahi/Phi-4-mini-instruct-GGUF");
  const modelRow = model("MaziyarPanahi/Phi-4-mini-instruct-GGUF");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const kvAdapter = modelProfile.architecture.kv_adapter;
  const dgxResult = profiled(
    "MaziyarPanahi/Phi-4-mini-instruct-GGUF",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "MaziyarPanahi/Phi-4-mini-instruct-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(modelProfile.status, "audited");
  assert.equal(modelRow.name, "Phi-4-mini-instruct-GGUF GGUF FP16");
  assert.equal(modelRow.license, "mit");
  assert.equal(modelRow.hf_downloads, 126346);
  assert.equal(modelRow.architecture.detail, "phi3 GGUF (Phi3ForCausalLM)");
  assert.equal(modelRow.architecture.total_params_b, 3.836021856);
  assert.equal(modelRow.architecture.active_params_b, 3.836021856);
  assert.equal(modelRow.architecture.layers, 32);
  assert.equal(modelRow.architecture.attention_heads, 24);
  assert.equal(modelRow.architecture.kv_heads, 8);
  assert.equal(modelRow.architecture.head_dim, 128);
  assert.equal(modelRow.architecture.max_context_tokens, 131072);
  assert.equal(modelRow.adapter.weight_precision, "GGUF FP16");
  assert.equal(modelRow.adapter.resident_weight_gb, 7.680694592);
  assert.equal(modelRow.adapter.active_weight_gb, 7.672443264);
  assert.equal(modelRow.adapter.kv_alloc_gb_per_1k_tokens, 0.131072);
  assert.equal(weightAdapter.kind, "dense_resident_swept");
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.008251328,
    0.000000001,
    "MaziyarPanahi Phi-4 Mini GGUF metadata/header resident overhead",
  );
  assert.equal(kvAdapter.kind, "full_context");
  assert.equal(kvAdapter.layers, 32);
  assert.equal(kvAdapter.kv_heads, 8);
  assert.equal(kvAdapter.head_dim, 128);
  assert.equal(dgxResult.status_code, "ok");
  assertNear(
    dgxResult.resident,
    7.680694592,
    0.000000001,
    "MaziyarPanahi Phi-4 Mini GGUF selected FP16 resident footprint",
  );
  assertNear(
    dgxResult.single.batchWeight,
    7.672443264,
    0.000000001,
    "MaziyarPanahi Phi-4 Mini GGUF swept tied-output traffic",
  );
  assertNear(
    dgxResult.alloc,
    13.1072,
    0.000000001,
    "MaziyarPanahi Phi-4 Mini GGUF FP16 KV allocation",
  );
  assertNear(
    dgxResult.single.readTraffic,
    4.194304,
    0.000000001,
    "MaziyarPanahi Phi-4 Mini GGUF FP16 KV read traffic",
  );
  assertNear(
    dgxResult.single.aggregate,
    23.00546172649995,
    0.000000001,
    "MaziyarPanahi Phi-4 Mini GGUF DGX single-session throughput",
  );
  assert.equal(dgxResult.bMem, 8);
  assert.equal(dgxResult.best?.batch, 1);
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best?.batch, 5);
  assertNear(
    m5Result.best?.aggregate ?? 0,
    107.17790592401732,
    0.000000001,
    "MaziyarPanahi Phi-4 Mini GGUF M5 Max aggregate throughput",
  );
}

{
  const repo = "MaziyarPanahi/Yi-1.5-6B-Chat-GGUF";
  const modelProfile = profile(repo);
  const modelRow = model(repo);
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const kvAdapter = modelProfile.architecture.kv_adapter;
  const dgxResult = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  const m1UltraResult = profiled(repo, "apple-mac-studio-m1-ultra-128gb");

  assert.equal(modelProfile.status, "audited");
  assert.equal(modelRow.name, "Yi-1.5-6B-Chat-GGUF GGUF Q2_K");
  assert.equal(modelRow.license, "apache-2.0");
  assert.equal(modelRow.hf_downloads, 112573);
  assert.ok(modelRow.tags.includes("region:us"));
  assert.equal(modelRow.architecture.detail, "llama GGUF (LlamaForCausalLM)");
  assert.equal(modelRow.architecture.total_params_b, 6.06103552);
  assert.equal(modelRow.architecture.active_params_b, 5.79889152);
  assert.equal(modelRow.architecture.layers, 32);
  assert.equal(modelRow.architecture.attention_heads, 32);
  assert.equal(modelRow.architecture.kv_heads, 4);
  assert.equal(modelRow.architecture.head_dim, 128);
  assert.equal(modelRow.architecture.max_context_tokens, 4096);
  assert.equal(modelRow.adapter.weight_precision, "GGUF Q2_K");
  assert.equal(modelRow.adapter.resident_weight_gb, 2.33706688);
  assert.equal(modelRow.adapter.active_weight_gb, 2.249555968);
  assert.equal(modelRow.adapter.kv_alloc_gb_per_1k_tokens, 0.065536);
  assert.equal(weightAdapter.kind, "dense_resident_swept");
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.087510912,
    0.000000001,
    "MaziyarPanahi Yi 1.5 6B GGUF input embedding plus metadata/header resident overhead",
  );
  assert.equal(kvAdapter.kind, "full_context");
  assert.equal(kvAdapter.layers, 32);
  assert.equal(kvAdapter.kv_heads, 4);
  assert.equal(kvAdapter.head_dim, 128);
  assert.equal(dgxResult.status_code, "ok");
  assertNear(
    dgxResult.resident,
    2.33706688,
    0.000000001,
    "MaziyarPanahi Yi 1.5 6B GGUF selected Q2_K resident footprint",
  );
  assertNear(
    dgxResult.single.batchWeight,
    2.249555968,
    0.000000001,
    "MaziyarPanahi Yi 1.5 6B GGUF swept Q2_K text traffic",
  );
  assertNear(
    dgxResult.alloc,
    6.5536,
    0.000000001,
    "MaziyarPanahi Yi 1.5 6B GGUF FP16 KV allocation",
  );
  assertNear(
    dgxResult.single.readTraffic,
    2.097152,
    0.000000001,
    "MaziyarPanahi Yi 1.5 6B GGUF FP16 KV read traffic",
  );
  assertNear(
    dgxResult.single.aggregate,
    62.80615169222244,
    0.000000001,
    "MaziyarPanahi Yi 1.5 6B GGUF DGX Spark single-session throughput",
  );
  assert.equal(dgxResult.bMem, 17);
  assert.equal(dgxResult.best?.batch, 5);
  assertNear(
    dgxResult.best?.aggregate ?? 0,
    107.18226414090019,
    0.000000001,
    "MaziyarPanahi Yi 1.5 6B GGUF DGX Spark aggregate throughput",
  );
  assertNear(
    dgxResult.dennard,
    2178.8412263597575,
    0.000000001,
    "MaziyarPanahi Yi 1.5 6B GGUF DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best?.batch, 13);
  assertNear(
    m5Result.best?.aggregate ?? 0,
    270.46137582010124,
    0.000000001,
    "MaziyarPanahi Yi 1.5 6B GGUF M5 Max aggregate throughput",
  );
  assert.equal(m1UltraResult.status_code, "ok");
  assert.equal(m1UltraResult.best?.batch, 17);
  assertNear(
    m1UltraResult.best?.aggregate ?? 0,
    358.82825718388693,
    0.000000001,
    "MaziyarPanahi Yi 1.5 6B GGUF M1 Ultra aggregate throughput",
  );
}

{
  const repo = "MaziyarPanahi/mathstral-7B-v0.1-GGUF";
  const modelProfile = profile(repo);
  const modelRow = model(repo);
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const kvAdapter = modelProfile.architecture.kv_adapter;
  const dgxResult = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  const m1UltraResult = profiled(repo, "apple-mac-studio-m1-ultra-128gb");

  assert.equal(modelProfile.status, "audited");
  assert.equal(modelRow.name, "mathstral-7B-v0.1-GGUF GGUF FP16");
  assert.equal(modelRow.license, "unknown");
  assert.equal(modelRow.hf_downloads, 113042);
  assert.ok(modelRow.tags.includes("region:us"));
  assert.equal(modelRow.architecture.detail, "llama GGUF / MistralForCausalLM");
  assert.equal(modelRow.architecture.total_params_b, 7.248023552);
  assert.equal(modelRow.architecture.active_params_b, 7.113805824);
  assert.equal(modelRow.architecture.layers, 32);
  assert.equal(modelRow.architecture.attention_heads, 32);
  assert.equal(modelRow.architecture.kv_heads, 8);
  assert.equal(modelRow.architecture.head_dim, 128);
  assert.equal(modelRow.architecture.max_context_tokens, 32768);
  assert.equal(modelRow.adapter.weight_precision, "GGUF F16/F32");
  assert.equal(modelRow.adapter.resident_weight_gb, 14.497336928);
  assert.equal(modelRow.adapter.active_weight_gb, 14.228144128);
  assert.equal(modelRow.adapter.kv_alloc_gb_per_1k_tokens, 0.131072);
  assert.equal(weightAdapter.kind, "dense_resident_swept");
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.2691928,
    0.000000001,
    "MaziyarPanahi Mathstral 7B GGUF input embedding plus metadata/header resident overhead",
  );
  assert.equal(kvAdapter.kind, "full_context");
  assert.equal(kvAdapter.layers, 32);
  assert.equal(kvAdapter.kv_heads, 8);
  assert.equal(kvAdapter.head_dim, 128);
  assert.equal(dgxResult.status_code, "no_floor");
  assertNear(
    dgxResult.resident,
    14.497336928,
    0.000000001,
    "MaziyarPanahi Mathstral 7B GGUF selected F16 resident footprint",
  );
  assertNear(
    dgxResult.single.batchWeight,
    14.228144128,
    0.000000001,
    "MaziyarPanahi Mathstral 7B GGUF swept F16 text traffic",
  );
  assertNear(
    dgxResult.alloc,
    13.1072,
    0.000000001,
    "MaziyarPanahi Mathstral 7B GGUF FP16 KV allocation",
  );
  assertNear(
    dgxResult.single.readTraffic,
    4.194304,
    0.000000001,
    "MaziyarPanahi Mathstral 7B GGUF FP16 KV read traffic",
  );
  assertNear(
    dgxResult.single.aggregate,
    14.818877388237638,
    0.000000001,
    "MaziyarPanahi Mathstral 7B GGUF DGX Spark single-session throughput",
  );
  assert.equal(dgxResult.bMem, 8);
  assert.equal(dgxResult.best, null);
  assertNear(
    dgxResult.dennard,
    154.44287837337478,
    0.000000001,
    "MaziyarPanahi Mathstral 7B GGUF DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best?.batch, 3);
  assertNear(
    m5Result.best?.aggregate ?? 0,
    68.70300040423682,
    0.000000001,
    "MaziyarPanahi Mathstral 7B GGUF M5 Max aggregate throughput",
  );
  assert.equal(m1UltraResult.status_code, "ok");
  assert.equal(m1UltraResult.best?.batch, 6);
  assertNear(
    m1UltraResult.best?.aggregate ?? 0,
    121.84606497125915,
    0.000000001,
    "MaziyarPanahi Mathstral 7B GGUF M1 Ultra aggregate throughput",
  );
}

{
  const repo = "MaziyarPanahi/Mistral-Small-Instruct-2409-GGUF";
  const modelProfile = profile(repo);
  const modelRow = model(repo);
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const kvAdapter = modelProfile.architecture.kv_adapter;
  const dgxResult = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  const m1UltraResult = profiled(repo, "apple-mac-studio-m1-ultra-128gb");

  assert.equal(modelProfile.status, "audited");
  assert.equal(modelRow.name, "Mistral-Small-Instruct-2409-GGUF GGUF FP16");
  assert.equal(modelRow.license, "other");
  assert.equal(modelRow.hf_downloads, 113311);
  assert.ok(modelRow.tags.includes("region:us"));
  assert.equal(modelRow.architecture.detail, "llama GGUF / MistralForCausalLM");
  assert.equal(modelRow.architecture.total_params_b, 22.247282688);
  assert.equal(modelRow.architecture.active_params_b, 22.045956096);
  assert.equal(modelRow.architecture.layers, 56);
  assert.equal(modelRow.architecture.attention_heads, 48);
  assert.equal(modelRow.architecture.kv_heads, 8);
  assert.equal(modelRow.architecture.head_dim, 128);
  assert.equal(modelRow.architecture.max_context_tokens, 32768);
  assert.equal(modelRow.adapter.weight_precision, "GGUF F16/F32");
  assert.equal(modelRow.adapter.resident_weight_gb, 44.496728832);
  assert.equal(modelRow.adapter.active_weight_gb, 44.093300736);
  assert.equal(modelRow.adapter.kv_alloc_gb_per_1k_tokens, 0.229376);
  assert.equal(weightAdapter.kind, "dense_resident_swept");
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.403428096,
    0.000000001,
    "MaziyarPanahi Mistral Small 2409 GGUF input embedding plus metadata/header resident overhead",
  );
  assert.equal(kvAdapter.kind, "full_context");
  assert.equal(kvAdapter.layers, 56);
  assert.equal(kvAdapter.kv_heads, 8);
  assert.equal(kvAdapter.head_dim, 128);
  assert.equal(dgxResult.status_code, "no_floor");
  assertNear(
    dgxResult.resident,
    44.496728832,
    0.000000001,
    "MaziyarPanahi Mistral Small 2409 GGUF selected F16 resident footprint",
  );
  assertNear(
    dgxResult.single.batchWeight,
    44.093300736,
    0.000000001,
    "MaziyarPanahi Mistral Small 2409 GGUF swept F16 text traffic",
  );
  assertNear(
    dgxResult.alloc,
    22.9376,
    0.000000001,
    "MaziyarPanahi Mistral Small 2409 GGUF FP16 KV allocation",
  );
  assertNear(
    dgxResult.single.readTraffic,
    7.340032,
    0.000000001,
    "MaziyarPanahi Mistral Small 2409 GGUF FP16 KV read traffic",
  );
  assertNear(
    dgxResult.single.aggregate,
    5.307841928137736,
    0.000000001,
    "MaziyarPanahi Mistral Small 2409 GGUF DGX Spark single-session throughput",
  );
  assert.equal(dgxResult.bMem, 3);
  assert.equal(dgxResult.best, null);
  assertNear(
    dgxResult.dennard,
    20.380171270001767,
    0.000000001,
    "MaziyarPanahi Mistral Small 2409 GGUF DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "no_floor");
  assert.equal(m5Result.best, null);
  assertNear(
    m5Result.single.aggregate,
    11.937783677203553,
    0.000000001,
    "MaziyarPanahi Mistral Small 2409 GGUF M5 Max single-session throughput",
  );
  assert.equal(m1UltraResult.status_code, "no_floor");
  assert.equal(m1UltraResult.best, null);
  assertNear(
    m1UltraResult.single.aggregate,
    15.554115540330361,
    0.000000001,
    "MaziyarPanahi Mistral Small 2409 GGUF M1 Ultra single-session throughput",
  );
}

{
  const repo = "MaziyarPanahi/WizardLM-2-7B-GGUF";
  const modelProfile = profile(repo);
  const modelRow = model(repo);
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const dgxResult = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  const m1UltraResult = profiled(repo, "apple-mac-studio-m1-ultra-128gb");

  assert.equal(modelProfile.status, "audited");
  assert.equal(modelRow.name, "WizardLM-2-7B-GGUF GGUF FP16");
  assert.equal(modelRow.license, "apache-2.0");
  assert.equal(modelRow.hf_downloads, 112698);
  assert.ok(modelRow.tags.includes("region:us"));
  assert.equal(modelRow.architecture.detail, "llama GGUF / Mistral-derived");
  assert.equal(modelRow.architecture.total_params_b, 7.241732096);
  assert.equal(modelRow.architecture.active_params_b, 7.110660096);
  assert.equal(modelRow.architecture.layers, 32);
  assert.equal(modelRow.architecture.attention_heads, 32);
  assert.equal(modelRow.architecture.kv_heads, 8);
  assert.equal(modelRow.architecture.head_dim, 128);
  assert.equal(modelRow.architecture.max_context_tokens, 32768);
  assert.equal(modelRow.adapter.weight_precision, "GGUF F16/F32");
  assert.equal(modelRow.adapter.resident_weight_gb, 14.484731552);
  assert.equal(modelRow.adapter.active_weight_gb, 14.221852672);
  assert.equal(modelRow.adapter.kv_alloc_gb_per_1k_tokens, 0.131072);
  assert.equal(weightAdapter.kind, "dense_resident_swept");
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.26287888,
    0.000000001,
    "MaziyarPanahi WizardLM 2 7B GGUF input embedding plus metadata/header resident overhead",
  );
  assert.equal(dgxResult.status_code, "no_floor");
  assertNear(
    dgxResult.resident,
    14.484731552,
    0.000000001,
    "MaziyarPanahi WizardLM 2 7B GGUF selected F16 resident footprint",
  );
  assertNear(
    dgxResult.single.batchWeight,
    14.221852672,
    0.000000001,
    "MaziyarPanahi WizardLM 2 7B GGUF swept F16 text traffic",
  );
  assertNear(
    dgxResult.alloc,
    13.1072,
    0.000000001,
    "MaziyarPanahi WizardLM 2 7B GGUF FP16 KV allocation",
  );
  assertNear(
    dgxResult.single.readTraffic,
    4.194304,
    0.000000001,
    "MaziyarPanahi WizardLM 2 7B GGUF FP16 KV read traffic",
  );
  assertNear(
    dgxResult.single.aggregate,
    14.823939916577183,
    0.000000001,
    "MaziyarPanahi WizardLM 2 7B GGUF DGX Spark single-session throughput",
  );
  assert.equal(dgxResult.bMem, 8);
  assert.equal(dgxResult.best, null);
  assertNear(
    dgxResult.dennard,
    154.52966161378703,
    0.000000001,
    "MaziyarPanahi WizardLM 2 7B GGUF DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best?.batch, 3);
  assertNear(
    m5Result.best?.aggregate ?? 0,
    68.71912596659115,
    0.000000001,
    "MaziyarPanahi WizardLM 2 7B GGUF M5 Max aggregate throughput",
  );
  assert.equal(m1UltraResult.status_code, "ok");
  assert.equal(m1UltraResult.best?.batch, 6);
  assertNear(
    m1UltraResult.best?.aggregate ?? 0,
    121.86552763626788,
    0.000000001,
    "MaziyarPanahi WizardLM 2 7B GGUF M1 Ultra aggregate throughput",
  );
}

{
  const modelProfile = profile("MaziyarPanahi/Yi-Coder-1.5B-Chat-GGUF");
  const modelRow = model("MaziyarPanahi/Yi-Coder-1.5B-Chat-GGUF");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const kvAdapter = modelProfile.architecture.kv_adapter;
  const dgxResult = profiled(
    "MaziyarPanahi/Yi-Coder-1.5B-Chat-GGUF",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "MaziyarPanahi/Yi-Coder-1.5B-Chat-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(modelProfile.status, "audited");
  assert.equal(modelRow.name, "Yi-Coder-1.5B-Chat-GGUF GGUF Q2_K");
  assert.equal(modelRow.license, "apache-2.0");
  assert.equal(modelRow.hf_downloads, 124754);
  assert.equal(modelRow.architecture.detail, "llama GGUF (LlamaForCausalLM)");
  assert.equal(modelRow.architecture.total_params_b, 1.47649536);
  assert.equal(modelRow.architecture.active_params_b, 1.34542336);
  assert.equal(modelRow.architecture.layers, 24);
  assert.equal(modelRow.architecture.attention_heads, 16);
  assert.equal(modelRow.architecture.kv_heads, 16);
  assert.equal(modelRow.architecture.head_dim, 128);
  assert.equal(modelRow.architecture.max_context_tokens, 131072);
  assert.equal(modelRow.adapter.weight_precision, "GGUF Q2_K");
  assert.equal(modelRow.adapter.resident_weight_gb, 0.634699968);
  assert.equal(modelRow.adapter.active_weight_gb, 0.590200832);
  assert.equal(modelRow.adapter.kv_alloc_gb_per_1k_tokens, 0.196608);
  assert.equal(weightAdapter.kind, "dense_resident_swept");
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.044499136,
    0.000000001,
    "MaziyarPanahi Yi-Coder 1.5B GGUF input embedding plus metadata/header resident overhead",
  );
  assert.equal(kvAdapter.kind, "full_context");
  assert.equal(kvAdapter.layers, 24);
  assert.equal(kvAdapter.kv_heads, 16);
  assert.equal(kvAdapter.head_dim, 128);
  assert.equal(dgxResult.status_code, "ok");
  assertNear(
    dgxResult.resident,
    0.634699968,
    0.000000001,
    "MaziyarPanahi Yi-Coder 1.5B GGUF selected Q2_K resident footprint",
  );
  assertNear(
    dgxResult.single.batchWeight,
    0.590200832,
    0.000000001,
    "MaziyarPanahi Yi-Coder 1.5B GGUF swept Q2_K text traffic",
  );
  assertNear(
    dgxResult.alloc,
    19.6608,
    0.000000001,
    "MaziyarPanahi Yi-Coder 1.5B GGUF FP16 KV allocation",
  );
  assertNear(
    dgxResult.single.readTraffic,
    6.291456,
    0.000000001,
    "MaziyarPanahi Yi-Coder 1.5B GGUF FP16 KV read traffic",
  );
  assert.equal(dgxResult.bMem, 6);
  assert.equal(dgxResult.best?.batch, 2);
  assertNear(
    dgxResult.best?.aggregate ?? 0,
    41.44806219784757,
    0.000000001,
    "MaziyarPanahi Yi-Coder 1.5B GGUF DGX Spark aggregate throughput",
  );
  assertNear(
    dgxResult.dennard,
    2808.2756759973267,
    0.000000001,
    "MaziyarPanahi Yi-Coder 1.5B GGUF DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best?.batch, 4);
  assertNear(
    m5Result.best?.aggregate ?? 0,
    95.35632986921946,
    0.000000001,
    "MaziyarPanahi Yi-Coder 1.5B GGUF M5 Max aggregate throughput",
  );
  assertNear(
    m5Result.best?.perSession ?? 0,
    23.839082467304866,
    0.000000001,
    "MaziyarPanahi Yi-Coder 1.5B GGUF M5 Max per-session throughput",
  );
}

{
  const repo = "MaziyarPanahi/Yi-Coder-9B-Chat-GGUF";
  const modelProfile = profile(repo);
  const modelRow = model(repo);
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const kvAdapter = modelProfile.architecture.kv_adapter;
  const dgxResult = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");

  assert.equal(modelProfile.status, "audited");
  assert.equal(modelRow.name, "Yi-Coder-9B-Chat-GGUF GGUF Q2_K");
  assert.equal(modelRow.license, "apache-2.0");
  assert.equal(modelRow.hf_downloads, 118204);
  assert.equal(modelRow.architecture.detail, "llama GGUF (LlamaForCausalLM)");
  assert.equal(modelRow.architecture.total_params_b, 8.829407232);
  assert.equal(modelRow.architecture.active_params_b, 8.567263232);
  assert.equal(modelRow.architecture.layers, 48);
  assert.equal(modelRow.architecture.attention_heads, 32);
  assert.equal(modelRow.architecture.kv_heads, 4);
  assert.equal(modelRow.architecture.head_dim, 128);
  assert.equal(modelRow.architecture.max_context_tokens, 131072);
  assert.equal(modelRow.adapter.weight_precision, "GGUF Q2_K");
  assert.equal(modelRow.adapter.resident_weight_gb, 3.354325792);
  assert.equal(modelRow.adapter.active_weight_gb, 3.26680576);
  assert.equal(modelRow.adapter.kv_alloc_gb_per_1k_tokens, 0.098304);
  assert.equal(weightAdapter.kind, "dense_resident_swept");
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.087520032,
    0.000000001,
    "MaziyarPanahi Yi-Coder 9B GGUF input embedding plus metadata/header resident overhead",
  );
  assert.equal(kvAdapter.kind, "full_context");
  assert.equal(kvAdapter.layers, 48);
  assert.equal(kvAdapter.kv_heads, 4);
  assert.equal(kvAdapter.head_dim, 128);
  assert.equal(dgxResult.status_code, "ok");
  assertNear(
    dgxResult.resident,
    3.354325792,
    0.000000001,
    "MaziyarPanahi Yi-Coder 9B GGUF selected Q2_K resident footprint",
  );
  assertNear(
    dgxResult.single.batchWeight,
    3.26680576,
    0.000000001,
    "MaziyarPanahi Yi-Coder 9B GGUF swept Q2_K text traffic",
  );
  assertNear(
    dgxResult.alloc,
    9.8304,
    0.000000001,
    "MaziyarPanahi Yi-Coder 9B GGUF FP16 KV allocation",
  );
  assertNear(
    dgxResult.single.readTraffic,
    3.145728,
    0.000000001,
    "MaziyarPanahi Yi-Coder 9B GGUF FP16 KV read traffic",
  );
  assertNear(
    dgxResult.single.aggregate,
    42.57287528104959,
    0.000000001,
    "MaziyarPanahi Yi-Coder 9B GGUF DGX Spark single-session throughput",
  );
  assert.equal(dgxResult.bMem, 11);
  assert.equal(dgxResult.best?.batch, 3);
  assertNear(
    dgxResult.best?.aggregate ?? 0,
    64.46793609506184,
    0.000000001,
    "MaziyarPanahi Yi-Coder 9B GGUF DGX Spark aggregate throughput",
  );
  assertNear(
    dgxResult.dennard,
    991.6006033928395,
    0.000000001,
    "MaziyarPanahi Yi-Coder 9B GGUF DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best?.batch, 8);
  assertNear(
    m5Result.best?.aggregate ?? 0,
    172.75925728510595,
    0.000000001,
    "MaziyarPanahi Yi-Coder 9B GGUF M5 Max aggregate throughput",
  );
  assertNear(
    m5Result.best?.perSession ?? 0,
    21.594907160638243,
    0.000000001,
    "MaziyarPanahi Yi-Coder 9B GGUF M5 Max per-session throughput",
  );
}

{
  const result = profiled("google/gemma-4-26B-A4B", "nvidia-dgx-spark");
  assertNear(
    result.resident,
    51.611872412,
    0.000000001,
    "Gemma 4 26B A4B base BF16 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    7.64506118,
    0.000000001,
    "Gemma 4 26B A4B base BF16 active text-decode traffic",
  );
  assertNear(
    result.alloc,
    0.7217152,
    0.000000001,
    "Gemma 4 26B A4B base layered BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.3735552,
    0.000000001,
    "Gemma 4 26B A4B base layered BF16 KV read traffic",
  );
  assert.equal(result.bMem, 94);
  assert.equal(result.best.batch, 2);
}

{
  const result = profiled(
    "cyankiwi/gemma-4-26B-A4B-it-AWQ-4bit",
    "nvidia-dgx-spark",
  );
  assertNear(
    result.resident,
    17.186571212,
    0.000000001,
    "Gemma 4 26B A4B AWQ resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    3.99734078,
    0.000000001,
    "Gemma 4 26B A4B AWQ active text-decode traffic",
  );
  assertNear(
    result.alloc,
    0.7217152,
    0.000000001,
    "Gemma 4 26B A4B AWQ layered BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.3735552,
    0.000000001,
    "Gemma 4 26B A4B AWQ layered BF16 KV read traffic",
  );
}

{
  const modelRow = model("cyankiwi/gemma-4-26B-A4B-it-AWQ-8bit");
  const modelProfile = profile("cyankiwi/gemma-4-26B-A4B-it-AWQ-8bit");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const dgxResult = profiled(
    "cyankiwi/gemma-4-26B-A4B-it-AWQ-8bit",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "cyankiwi/gemma-4-26B-A4B-it-AWQ-8bit",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(modelRow.hf_downloads, 169666);
  assert.equal(modelRow.name, "gemma-4-26B-A4B-it-AWQ-8bit 8-bit");
  assert.equal(modelRow.architecture.routed_experts_per_token, 8);
  assert.equal(modelRow.architecture.shared_experts_per_token, 1);
  assert.equal(modelProfile.status, "audited");
  assert.equal(modelProfile.serving.weight_format, "int8");
  assert.equal(modelProfile.base_model_proof.config_compatible, true);
  assertNear(
    weightAdapter.resident_weight_gb,
    29.160467612,
    0.000000001,
    "Gemma 4 26B A4B AWQ 8-bit resident footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    28.01487878,
    0.000000001,
    "Gemma 4 26B A4B AWQ 8-bit language resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.145588832,
    0.000000001,
    "Gemma 4 26B A4B AWQ 8-bit vision resident footprint",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    3.74951942,
    0.000000001,
    "Gemma 4 26B A4B AWQ 8-bit fixed text traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.18957312,
    0.000000001,
    "Gemma 4 26B A4B AWQ 8-bit routed expert traffic",
  );
  assertNear(
    dgxResult.single.batchWeight,
    5.26610438,
    0.000000001,
    "Gemma 4 26B A4B AWQ 8-bit active text-decode traffic",
  );
  assertNear(
    dgxResult.alloc,
    0.7217152,
    0.000000001,
    "Gemma 4 26B A4B AWQ 8-bit layered BF16 KV allocation",
  );
  assertNear(
    dgxResult.single.readTraffic,
    0.3735552,
    0.000000001,
    "Gemma 4 26B A4B AWQ 8-bit layered BF16 KV read traffic",
  );
  assert.equal(dgxResult.bMem, 125);
  assert.equal(dgxResult.best.batch, 5);
  assertNear(
    dgxResult.single.aggregate,
    48.40717708709645,
    0.000000001,
    "Gemma 4 26B A4B AWQ 8-bit DGX single-session throughput",
  );
  assertNear(
    dgxResult.best.aggregate,
    110.8875482631466,
    0.000000001,
    "Gemma 4 26B A4B AWQ 8-bit DGX aggregate throughput",
  );
  assertNear(
    dgxResult.dennard,
    6525.025629876776,
    0.000000001,
    "Gemma 4 26B A4B AWQ 8-bit DGX Dennard bound",
  );
  assert.equal(m5Result.best.batch, 22);
  assertNear(
    m5Result.best.aggregate,
    444.82613214503766,
    0.000000001,
    "Gemma 4 26B A4B AWQ 8-bit M5 aggregate throughput",
  );
}

{
  const modelProfile = profile(
    "lmstudio-community/gemma-4-26B-A4B-it-QAT-MLX-4bit",
  );
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "lmstudio-community/gemma-4-26B-A4B-it-QAT-MLX-4bit",
    "nvidia-dgx-spark",
  );
  assertNear(
    result.resident,
    15.608614044,
    0.000000001,
    "Gemma 4 26B A4B QAT MLX resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    2.424219708,
    0.000000001,
    "Gemma 4 26B A4B QAT MLX single-token active text-decode traffic",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    1.621321788,
    0.000000001,
    "Gemma 4 26B A4B QAT MLX fixed text traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.10036224,
    0.000000001,
    "Gemma 4 26B A4B QAT MLX per-expert traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.140925536,
    0.000000001,
    "Gemma 4 26B A4B QAT MLX resident vision footprint",
  );
  assertNear(
    result.alloc,
    0.7217152,
    0.000000001,
    "Gemma 4 26B A4B QAT MLX layered BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.3735552,
    0.000000001,
    "Gemma 4 26B A4B QAT MLX layered BF16 KV read traffic",
  );
  assert.equal(result.bMem, 144);
  assert.equal(result.best?.batch, 12);
  assertNear(
    result.best?.aggregate ?? 0,
    251.44300055572901,
    0.000000001,
    "Gemma 4 26B A4B QAT MLX DGX Spark aggregate throughput",
  );
  assertNear(
    result.best?.perSession ?? 0,
    20.953583379644083,
    0.000000001,
    "Gemma 4 26B A4B QAT MLX DGX Spark per-session throughput",
  );
  assertNear(
    result.dennard,
    16288.814630623921,
    0.000000001,
    "Gemma 4 26B A4B QAT MLX DGX Spark Dennard bound",
  );
}

{
  const modelProfile = profile(
    "lmstudio-community/gemma-4-26B-A4B-it-MLX-4bit",
  );
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "lmstudio-community/gemma-4-26B-A4B-it-MLX-4bit",
    "nvidia-dgx-spark",
  );
  assertNear(
    result.resident,
    15.608614044,
    0.000000001,
    "Gemma 4 26B A4B MLX resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    2.424219708,
    0.000000001,
    "Gemma 4 26B A4B MLX single-token active text-decode traffic",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    1.621321788,
    0.000000001,
    "Gemma 4 26B A4B MLX fixed text traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.10036224,
    0.000000001,
    "Gemma 4 26B A4B MLX per-expert traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.140925536,
    0.000000001,
    "Gemma 4 26B A4B MLX resident vision footprint",
  );
  assertNear(
    result.alloc,
    0.7217152,
    0.000000001,
    "Gemma 4 26B A4B MLX layered BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.3735552,
    0.000000001,
    "Gemma 4 26B A4B MLX layered BF16 KV read traffic",
  );
  assert.equal(result.bMem, 144);
  assert.equal(result.best?.batch, 12);
  assertNear(
    result.best?.aggregate ?? 0,
    251.44300055572901,
    0.000000001,
    "Gemma 4 26B A4B MLX DGX Spark aggregate throughput",
  );
  assertNear(
    result.best?.perSession ?? 0,
    20.953583379644083,
    0.000000001,
    "Gemma 4 26B A4B MLX DGX Spark per-session throughput",
  );
  assertNear(
    result.dennard,
    16288.814630623921,
    0.000000001,
    "Gemma 4 26B A4B MLX DGX Spark Dennard bound",
  );
}

{
  const modelProfile = profile(
    "lmstudio-community/gemma-4-26B-A4B-it-MLX-5bit",
  );
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "lmstudio-community/gemma-4-26B-A4B-it-MLX-5bit",
    "nvidia-dgx-spark",
  );
  assertNear(
    result.resident,
    18.694814876,
    0.000000001,
    "Gemma 4 26B A4B MLX 5-bit resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    2.833688636,
    0.000000001,
    "Gemma 4 26B A4B MLX 5-bit single-token active text-decode traffic",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    1.852368956,
    0.000000001,
    "Gemma 4 26B A4B MLX 5-bit fixed text traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.12266496,
    0.000000001,
    "Gemma 4 26B A4B MLX 5-bit per-expert traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.14133104,
    0.000000001,
    "Gemma 4 26B A4B MLX 5-bit resident vision footprint",
  );
  assertNear(
    result.alloc,
    0.7217152,
    0.000000001,
    "Gemma 4 26B A4B MLX 5-bit layered BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.3735552,
    0.000000001,
    "Gemma 4 26B A4B MLX 5-bit layered BF16 KV read traffic",
  );
  assert.equal(result.bMem, 140);
  assert.equal(result.best?.batch, 10);
  assertNear(
    result.single.aggregate,
    85.11981438258192,
    0.000000001,
    "Gemma 4 26B A4B MLX 5-bit DGX Spark single-session throughput",
  );
  assertNear(
    result.best?.aggregate ?? 0,
    209.12454565879406,
    0.000000001,
    "Gemma 4 26B A4B MLX 5-bit DGX Spark aggregate throughput",
  );
  assertNear(
    result.best?.perSession ?? 0,
    20.912454565879408,
    0.000000001,
    "Gemma 4 26B A4B MLX 5-bit DGX Spark per-session throughput",
  );
  assertNear(
    result.dennard,
    13523.102536049713,
    0.000000001,
    "Gemma 4 26B A4B MLX 5-bit DGX Spark Dennard bound",
  );
}

{
  const modelProfile = profile(
    "lmstudio-community/gemma-4-26B-A4B-it-MLX-6bit",
  );
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "lmstudio-community/gemma-4-26B-A4B-it-MLX-6bit",
    "nvidia-dgx-spark",
  );
  assertNear(
    result.resident,
    21.781015708,
    0.000000001,
    "Gemma 4 26B A4B MLX 6-bit resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    3.243157564,
    0.000000001,
    "Gemma 4 26B A4B MLX 6-bit single-token active text-decode traffic",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    2.083416124,
    0.000000001,
    "Gemma 4 26B A4B MLX 6-bit fixed text traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.14496768,
    0.000000001,
    "Gemma 4 26B A4B MLX 6-bit per-expert traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.141736544,
    0.000000001,
    "Gemma 4 26B A4B MLX 6-bit resident vision footprint",
  );
  assertNear(
    result.alloc,
    0.7217152,
    0.000000001,
    "Gemma 4 26B A4B MLX 6-bit layered BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.3735552,
    0.000000001,
    "Gemma 4 26B A4B MLX 6-bit layered BF16 KV read traffic",
  );
  assert.equal(result.bMem, 136);
  assert.equal(result.best?.batch, 9);
  assertNear(
    result.single.aggregate,
    75.48290887719499,
    0.000000001,
    "Gemma 4 26B A4B MLX 6-bit DGX Spark single-session throughput",
  );
  assertNear(
    result.best?.aggregate ?? 0,
    180.38758305896198,
    0.000000001,
    "Gemma 4 26B A4B MLX 6-bit DGX Spark aggregate throughput",
  );
  assertNear(
    result.best?.perSession ?? 0,
    20.043064784329108,
    0.000000001,
    "Gemma 4 26B A4B MLX 6-bit DGX Spark per-session throughput",
  );
  assertNear(
    result.dennard,
    11455.76734372208,
    0.000000001,
    "Gemma 4 26B A4B MLX 6-bit DGX Spark Dennard bound",
  );
}

{
  const modelProfile = profile(
    "lmstudio-community/gemma-4-26B-A4B-it-MLX-8bit",
  );
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "lmstudio-community/gemma-4-26B-A4B-it-MLX-8bit",
    "nvidia-dgx-spark",
  );
  assertNear(
    result.resident,
    27.953417372,
    0.000000001,
    "Gemma 4 26B A4B MLX 8-bit resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    4.06209542,
    0.000000001,
    "Gemma 4 26B A4B MLX 8-bit single-token active text-decode traffic",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    2.54551046,
    0.000000001,
    "Gemma 4 26B A4B MLX 8-bit fixed text traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.18957312,
    0.000000001,
    "Gemma 4 26B A4B MLX 8-bit per-expert traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.142547552,
    0.000000001,
    "Gemma 4 26B A4B MLX 8-bit resident vision footprint",
  );
  assertNear(
    result.alloc,
    0.7217152,
    0.000000001,
    "Gemma 4 26B A4B MLX 8-bit layered BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.3735552,
    0.000000001,
    "Gemma 4 26B A4B MLX 8-bit layered BF16 KV read traffic",
  );
  assert.equal(result.bMem, 127);
  assert.equal(result.best?.batch, 6);
  assertNear(
    result.single.aggregate,
    61.54677709941004,
    0.000000001,
    "Gemma 4 26B A4B MLX 8-bit DGX Spark single-session throughput",
  );
  assertNear(
    result.best?.aggregate ?? 0,
    130.23131850955542,
    0.000000001,
    "Gemma 4 26B A4B MLX 8-bit DGX Spark aggregate throughput",
  );
  assertNear(
    result.best?.perSession ?? 0,
    21.70521975159257,
    0.000000001,
    "Gemma 4 26B A4B MLX 8-bit DGX Spark per-session throughput",
  );
  assertNear(
    result.dennard,
    8571.450932808382,
    0.000000001,
    "Gemma 4 26B A4B MLX 8-bit DGX Spark Dennard bound",
  );
}

{
  const modelProfile = profile("google/gemma-4-26B-A4B-it-qat-q4_0-gguf");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "google/gemma-4-26B-A4B-it-qat-q4_0-gguf",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "google/gemma-4-26B-A4B-it-qat-q4_0-gguf",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    14.43936144,
    0.000000001,
    "Google Gemma 4 26B A4B QAT Q4_0 GGUF resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    2.380070008,
    0.000000001,
    "Google Gemma 4 26B A4B QAT Q4_0 GGUF single-token active text-decode traffic",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    1.577172088,
    0.000000001,
    "Google Gemma 4 26B A4B QAT Q4_0 GGUF fixed text traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.10036224,
    0.000000001,
    "Google Gemma 4 26B A4B QAT Q4_0 GGUF per-expert traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.015822632,
    0.000000001,
    "Google Gemma 4 26B A4B QAT Q4_0 GGUF resident-only header footprint",
  );
  assertNear(
    result.alloc,
    0.7217152,
    0.000000001,
    "Google Gemma 4 26B A4B QAT Q4_0 GGUF layered FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.3735552,
    0.000000001,
    "Google Gemma 4 26B A4B QAT Q4_0 GGUF layered FP16 KV read traffic",
  );
  assert.equal(result.bMem, 146);
  assert.equal(result.best?.batch, 12);
  assertNear(
    result.single.aggregate,
    99.14203254926042,
    0.000000001,
    "Google Gemma 4 26B A4B QAT Q4_0 GGUF DGX Spark single-session throughput",
  );
  assertNear(
    result.best?.aggregate ?? 0,
    252.29794348514284,
    0.000000001,
    "Google Gemma 4 26B A4B QAT Q4_0 GGUF DGX Spark aggregate throughput",
  );
  assertNear(
    result.best?.perSession ?? 0,
    21.024828623761902,
    0.000000001,
    "Google Gemma 4 26B A4B QAT Q4_0 GGUF DGX Spark per-session throughput",
  );
  assertNear(
    result.dennard,
    16776.797866192403,
    0.000000001,
    "Google Gemma 4 26B A4B QAT Q4_0 GGUF DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best?.batch, 45);
  assertNear(
    m5Result.best?.aggregate ?? 0,
    905.0215302873786,
    0.000000001,
    "Google Gemma 4 26B A4B QAT Q4_0 GGUF M5 Max aggregate throughput",
  );
  assertNear(
    m5Result.best?.perSession ?? 0,
    20.111589561941745,
    0.000000001,
    "Google Gemma 4 26B A4B QAT Q4_0 GGUF M5 Max per-session throughput",
  );
}

{
  const modelProfile = profile(
    "lmstudio-community/gemma-4-26B-A4B-it-QAT-GGUF",
  );
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "lmstudio-community/gemma-4-26B-A4B-it-QAT-GGUF",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "lmstudio-community/gemma-4-26B-A4B-it-QAT-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    14.439362752,
    0.000000001,
    "LM Studio Gemma 4 26B A4B QAT Q4_0 GGUF resident footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    14.423538808,
    0.000000001,
    "LM Studio Gemma 4 26B A4B QAT Q4_0 GGUF tensor spans",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.015823944,
    0.000000001,
    "LM Studio Gemma 4 26B A4B QAT Q4_0 GGUF metadata/header overhead",
  );
  assertNear(
    result.single.batchWeight,
    2.380070008,
    0.000000001,
    "LM Studio Gemma 4 26B A4B QAT Q4_0 GGUF single-token active text-decode traffic",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    1.577172088,
    0.000000001,
    "LM Studio Gemma 4 26B A4B QAT Q4_0 GGUF fixed text traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.10036224,
    0.000000001,
    "LM Studio Gemma 4 26B A4B QAT Q4_0 GGUF per-expert traffic",
  );
  assertNear(
    result.alloc,
    0.7217152,
    0.000000001,
    "LM Studio Gemma 4 26B A4B QAT Q4_0 GGUF layered FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.3735552,
    0.000000001,
    "LM Studio Gemma 4 26B A4B QAT Q4_0 GGUF layered FP16 KV read traffic",
  );
  assert.equal(result.bMem, 146);
  assert.equal(result.best?.batch, 12);
  assertNear(
    result.single.aggregate,
    99.14203254926042,
    0.000000001,
    "LM Studio Gemma 4 26B A4B QAT Q4_0 GGUF DGX Spark single-session throughput",
  );
  assertNear(
    result.best?.aggregate ?? 0,
    252.29794348514284,
    0.000000001,
    "LM Studio Gemma 4 26B A4B QAT Q4_0 GGUF DGX Spark aggregate throughput",
  );
  assertNear(
    result.best?.perSession ?? 0,
    21.024828623761902,
    0.000000001,
    "LM Studio Gemma 4 26B A4B QAT Q4_0 GGUF DGX Spark per-session throughput",
  );
  assertNear(
    result.dennard,
    16776.797657675677,
    0.000000001,
    "LM Studio Gemma 4 26B A4B QAT Q4_0 GGUF DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best?.batch, 45);
  assertNear(
    m5Result.best?.aggregate ?? 0,
    905.0215302873786,
    0.000000001,
    "LM Studio Gemma 4 26B A4B QAT Q4_0 GGUF M5 Max aggregate throughput",
  );
  assertNear(
    m5Result.best?.perSession ?? 0,
    20.111589561941745,
    0.000000001,
    "LM Studio Gemma 4 26B A4B QAT Q4_0 GGUF M5 Max per-session throughput",
  );
}

{
  const result = profiled("google/gemma-4-31B", "nvidia-dgx-spark");
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    62.546177752,
    0.000000001,
    "Google Gemma 4 31B resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    61.39469068,
    0.000000001,
    "Google Gemma 4 31B swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    1.151487072,
    0.000000001,
    "Google Gemma 4 31B resident multimodal footprint",
  );
  assertNear(
    result.alloc,
    2.8868608,
    0.000000001,
    "Google Gemma 4 31B layered BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.4942208,
    0.000000001,
    "Google Gemma 4 31B layered BF16 KV read traffic",
  );
  assert.equal(result.bMem, 19);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    4.340987839912284,
    0.000000001,
    "Google Gemma 4 31B DGX Spark single-session throughput",
  );
  assertNear(
    result.dennard,
    88.49625946752622,
    0.000000001,
    "Google Gemma 4 31B DGX Spark Dennard bound",
  );
}

{
  const result = profiled(
    "RedHatAI/gemma-4-31B-it-FP8-block",
    "nvidia-dgx-spark",
  );
  assertNear(
    result.resident,
    33.263025112,
    0.000000001,
    "RedHatAI Gemma 4 31B FP8 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    32.11153804,
    0.000000001,
    "RedHatAI Gemma 4 31B FP8 swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    1.151487072,
    0.000000001,
    "RedHatAI Gemma 4 31B FP8 resident multimodal footprint",
  );
  assertNear(
    result.alloc,
    2.8868608,
    0.000000001,
    "RedHatAI Gemma 4 31B FP8 layered BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.4942208,
    0.000000001,
    "RedHatAI Gemma 4 31B FP8 layered BF16 KV read traffic",
  );
}

{
  const item = profile("RedHatAI/gemma-4-31B-it-FP8-Dynamic");
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(
    "RedHatAI/gemma-4-31B-it-FP8-Dynamic",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "no_floor");
  assertNear(
    weightAdapter.resident_params_b,
    31.277317996,
    0.000000001,
    "RedHatAI Gemma 4 31B FP8 Dynamic storage elements",
  );
  assertNear(
    weightAdapter.swept_params_b,
    30.70157446,
    0.000000001,
    "RedHatAI Gemma 4 31B FP8 Dynamic swept storage elements",
  );
  assertNear(
    result.resident,
    33.267908312,
    0.000000001,
    "RedHatAI Gemma 4 31B FP8 Dynamic resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    32.11642124,
    0.000000001,
    "RedHatAI Gemma 4 31B FP8 Dynamic swept text-decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.151487072,
    0.000000001,
    "RedHatAI Gemma 4 31B FP8 Dynamic resident multimodal footprint",
  );
  assertNear(
    result.alloc,
    2.8868608,
    0.000000001,
    "RedHatAI Gemma 4 31B FP8 Dynamic layered BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.4942208,
    0.000000001,
    "RedHatAI Gemma 4 31B FP8 Dynamic layered BF16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    8.122427404841089,
    0.000000001,
    "RedHatAI Gemma 4 31B FP8 Dynamic DGX Spark single-session throughput",
  );
  assert.equal(result.bMem, 30);
  assert.equal(result.best, null);
  assertNear(
    result.dennard,
    255.3815264144366,
    0.000000001,
    "RedHatAI Gemma 4 31B FP8 Dynamic DGX Spark Dennard bound",
  );

  const m5 = profiled(
    "RedHatAI/gemma-4-31B-it-FP8-Dynamic",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(m5.status_code, "no_floor");
  assertNear(
    m5.single.aggregate,
    18.268023540558346,
    0.000000001,
    "RedHatAI Gemma 4 31B FP8 Dynamic M5 Max single-session throughput",
  );
  assertNear(
    m5.dennard,
    574.3745685658024,
    0.000000001,
    "RedHatAI Gemma 4 31B FP8 Dynamic M5 Max Dennard bound",
  );
}

{
  const item = profile("allenai/OLMo-2-0425-1B");
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled("allenai/OLMo-2-0425-1B", "nvidia-dgx-spark");
  assert.equal(result.status_code, "ok");
  assertNear(
    weightAdapter.resident_params_b,
    1.484916736,
    0.000000001,
    "OLMo 2 0425 1B F32 storage elements",
  );
  assertNear(
    weightAdapter.swept_params_b,
    1.27939584,
    0.000000001,
    "OLMo 2 0425 1B F32 swept storage elements",
  );
  assertNear(
    result.resident,
    5.939666944,
    0.000000001,
    "OLMo 2 0425 1B resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    5.11758336,
    0.000000001,
    "OLMo 2 0425 1B swept text-decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.822083584,
    0.000000001,
    "OLMo 2 0425 1B resident input embedding footprint",
  );
  assertNear(
    result.alloc,
    26.2144,
    0.000000001,
    "OLMo 2 0425 1B FP32 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    8.388608,
    0.000000001,
    "OLMo 2 0425 1B FP32 KV read traffic",
  );
  assert.equal(result.bMem, 4);
  assert.equal(result.best.batch, 1);
  assertNear(
    result.best.aggregate,
    20.21295217306917,
    0.000000001,
    "OLMo 2 0425 1B DGX Spark aggregate at b*",
  );
  assertNear(
    result.dennard,
    232.1092428490017,
    0.000000001,
    "OLMo 2 0425 1B DGX Spark Dennard bound",
  );

  const m5 = profiled(
    "allenai/OLMo-2-0425-1B",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(m5.status_code, "ok");
  assert.equal(m5.best.batch, 3);
  assertNear(
    m5.best.aggregate,
    60.82538791301984,
    0.000000001,
    "OLMo 2 0425 1B M5 Max aggregate at b*",
  );
  assertNear(
    m5.best.perSession,
    20.275129304339945,
    0.000000001,
    "OLMo 2 0425 1B M5 Max per-session throughput at b*",
  );
  assertNear(
    m5.dennard,
    522.0332421585605,
    0.000000001,
    "OLMo 2 0425 1B M5 Max Dennard bound",
  );
}

{
  const item = profile("allenai/OLMoE-1B-7B-0924");
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled("allenai/OLMoE-1B-7B-0924", "nvidia-dgx-spark");
  assert.equal(result.status_code, "ok");
  assert.equal(weightAdapter.kind, "moe_distinct_experts_exact");
  assertNear(
    result.resident,
    13.838323712,
    0.000000001,
    "OLMoE 1B 7B resident footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    13.632278528,
    0.000000001,
    "OLMoE 1B 7B non-embedding resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.206045184,
    0.000000001,
    "OLMoE 1B 7B resident input embedding footprint",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    0.74737664,
    0.000000001,
    "OLMoE 1B 7B fixed text-decode traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.201326592,
    0.000000001,
    "OLMoE 1B 7B routed expert group",
  );
  assert.equal(weightAdapter.routed_experts, 64);
  assert.equal(weightAdapter.routed_experts_per_token, 8);
  assertNear(
    result.single.batchWeight,
    2.357989376,
    0.000000001,
    "OLMoE 1B 7B single-session decode traffic",
  );
  assertNear(
    result.alloc,
    13.1072,
    0.000000001,
    "OLMoE 1B 7B BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    4.194304,
    0.000000001,
    "OLMoE 1B 7B BF16 KV read traffic",
  );
  assert.equal(result.bMem, 8);
  assert.equal(result.best.batch, 2);
  assertNear(
    result.best.aggregate,
    44.916521213918315,
    0.000000001,
    "OLMoE 1B 7B DGX Spark aggregate at b*",
  );
  assertNear(
    result.best.perSession,
    22.458260606959158,
    0.000000001,
    "OLMoE 1B 7B DGX Spark per-session throughput at b*",
  );
}

{
  const item = profile("allenai/OLMoE-1B-7B-0125-Instruct");
  const modelRow = model("allenai/OLMoE-1B-7B-0125-Instruct");
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(
    "allenai/OLMoE-1B-7B-0125-Instruct",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "allenai/OLMoE-1B-7B-0125-Instruct",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  const m1UltraResult = profiled(
    "allenai/OLMoE-1B-7B-0125-Instruct",
    "apple-mac-studio-m1-ultra-128gb",
  );
  assert.equal(item.status, "audited");
  assert.equal(modelRow.name, "OLMoE-1B-7B-0125-Instruct BF16");
  assert.equal(modelRow.hf_downloads, 125412);
  assert.ok(modelRow.tags.includes("region:us"));
  assert.equal(modelRow.architecture.total_params_b, 6.919161856);
  assert.equal(modelRow.architecture.active_params_b, 1.178994688);
  assertNear(
    modelRow.adapter.resident_weight_gb,
    13.838323712,
    0.000000001,
    "OLMoE 1B 7B 0125 Instruct catalog resident footprint",
  );
  assertNear(
    modelRow.adapter.active_weight_gb,
    2.357989376,
    0.000000001,
    "OLMoE 1B 7B 0125 Instruct catalog single-session active traffic",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(weightAdapter.kind, "moe_distinct_experts_exact");
  assertNear(
    result.resident,
    13.838323712,
    0.000000001,
    "OLMoE 1B 7B 0125 Instruct resident footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    13.632278528,
    0.000000001,
    "OLMoE 1B 7B 0125 Instruct non-embedding resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.206045184,
    0.000000001,
    "OLMoE 1B 7B 0125 Instruct resident input embedding footprint",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    0.74737664,
    0.000000001,
    "OLMoE 1B 7B 0125 Instruct fixed text-decode traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.201326592,
    0.000000001,
    "OLMoE 1B 7B 0125 Instruct routed expert group",
  );
  assert.equal(weightAdapter.routed_experts, 64);
  assert.equal(weightAdapter.routed_experts_per_token, 8);
  assertNear(
    result.single.batchWeight,
    2.357989376,
    0.000000001,
    "OLMoE 1B 7B 0125 Instruct single-session decode traffic",
  );
  assertNear(
    result.alloc,
    13.1072,
    0.000000001,
    "OLMoE 1B 7B 0125 Instruct BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    4.194304,
    0.000000001,
    "OLMoE 1B 7B 0125 Instruct BF16 KV read traffic",
  );
  assert.equal(result.bMem, 8);
  assert.equal(result.best.batch, 2);
  assertNear(
    result.best.aggregate,
    44.916521213918315,
    0.000000001,
    "OLMoE 1B 7B 0125 Instruct DGX Spark aggregate at b*",
  );
  assertNear(
    result.best.perSession,
    22.458260606959158,
    0.000000001,
    "OLMoE 1B 7B 0125 Instruct DGX Spark per-session throughput at b*",
  );
  assertNear(
    result.dennard,
    937.7318005036676,
    0.000000001,
    "OLMoE 1B 7B 0125 Instruct DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 5);
  assertNear(
    m5Result.best.aggregate,
    109.66237228264329,
    0.000000001,
    "OLMoE 1B 7B 0125 Instruct M5 Max aggregate at b*",
  );
  assertNear(
    m5Result.best.perSession,
    21.93247445652866,
    0.000000001,
    "OLMoE 1B 7B 0125 Instruct M5 Max per-session throughput at b*",
  );
  assertNear(
    m5Result.dennard,
    2109.0378223782122,
    0.000000001,
    "OLMoE 1B 7B 0125 Instruct M5 Max Dennard bound",
  );
  assert.equal(m1UltraResult.status_code, "ok");
  assert.equal(m1UltraResult.best.batch, 7);
  assertNear(
    m1UltraResult.best.aggregate,
    147.6304326851929,
    0.000000001,
    "OLMoE 1B 7B 0125 Instruct M1 Ultra aggregate at b*",
  );
  assertNear(
    m1UltraResult.best.perSession,
    21.09006181217041,
    0.000000001,
    "OLMoE 1B 7B 0125 Instruct M1 Ultra per-session throughput at b*",
  );
}

{
  const item = profile("allenai/Olmo-3-7B-Instruct-SFT");
  const weightAdapter = item.architecture.weight_adapter;
  const kvAdapter = item.architecture.kv_adapter;
  const result = profiled("allenai/Olmo-3-7B-Instruct-SFT", "nvidia-dgx-spark");
  assert.equal(result.status_code, "no_floor");
  assert.equal(kvAdapter.kind, "layered_kv");
  assert.equal(kvAdapter.components.length, 2);
  assert.equal(kvAdapter.components[0].kind, "full_context");
  assert.equal(kvAdapter.components[0].layers, 8);
  assert.equal(kvAdapter.components[1].kind, "sliding_window");
  assert.equal(kvAdapter.components[1].layers, 24);
  assert.equal(kvAdapter.components[1].window_tokens, 4096);
  assertNear(
    weightAdapter.resident_params_b,
    7.298011136,
    0.000000001,
    "OLMo 3 7B Instruct SFT BF16 storage elements",
  );
  assertNear(
    weightAdapter.swept_params_b,
    6.887272448,
    0.000000001,
    "OLMo 3 7B Instruct SFT BF16 swept storage elements",
  );
  assertNear(
    result.resident,
    14.596022272,
    0.000000001,
    "OLMo 3 7B Instruct SFT resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    13.774544896,
    0.000000001,
    "OLMo 3 7B Instruct SFT swept text-decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.821477376,
    0.000000001,
    "OLMo 3 7B Instruct SFT resident input embedding footprint",
  );
  assertNear(
    result.alloc,
    14.717812736,
    0.000000001,
    "OLMo 3 7B Instruct SFT BF16 layered KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    5.804916736,
    0.000000001,
    "OLMo 3 7B Instruct SFT BF16 layered KV read traffic",
  );
  assert.equal(result.bMem, 7);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    13.943182153375359,
    0.000000001,
    "OLMo 3 7B Instruct SFT DGX Spark single-session bound",
  );
  assertNear(
    result.dennard,
    141.93814198806817,
    0.000000001,
    "OLMo 3 7B Instruct SFT DGX Spark Dennard bound",
  );

  const m5 = profiled(
    "allenai/Olmo-3-7B-Instruct-SFT",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(m5.status_code, "ok");
  assert.equal(m5.best.batch, 2);
  assertNear(
    m5.best.aggregate,
    48.37620926530305,
    0.000000001,
    "OLMo 3 7B Instruct SFT M5 Max aggregate at b*",
  );
  assertNear(
    m5.best.perSession,
    24.188104632651527,
    0.000000001,
    "OLMo 3 7B Instruct SFT M5 Max per-session throughput at b*",
  );
  assertNear(
    m5.dennard,
    319.2308394896478,
    0.000000001,
    "OLMo 3 7B Instruct SFT M5 Max Dennard bound",
  );
}

{
  const catalogRow = model("allenai/Olmo-3-7B-Instruct");
  const item = profile("allenai/Olmo-3-7B-Instruct");
  const weightAdapter = item.architecture.weight_adapter;
  const kvAdapter = item.architecture.kv_adapter;
  const result = profiled("allenai/Olmo-3-7B-Instruct", "nvidia-dgx-spark");

  assert.equal(catalogRow.hf_downloads, 144100);
  assert.equal(catalogRow.tags.includes("region:us"), true);
  assert.equal(catalogRow.adapter.resident_weight_gb, 14.596022272);
  assert.equal(catalogRow.adapter.active_weight_gb, 13.774544896);
  assert.equal(result.status_code, "no_floor");
  assert.equal(kvAdapter.kind, "layered_kv");
  assert.equal(kvAdapter.components.length, 2);
  assert.equal(kvAdapter.components[0].kind, "full_context");
  assert.equal(kvAdapter.components[0].layers, 8);
  assert.equal(kvAdapter.components[1].kind, "sliding_window");
  assert.equal(kvAdapter.components[1].layers, 24);
  assert.equal(kvAdapter.components[1].window_tokens, 4096);
  assertNear(
    weightAdapter.resident_params_b,
    7.298011136,
    0.000000001,
    "OLMo 3 7B Instruct BF16 storage elements",
  );
  assertNear(
    weightAdapter.swept_params_b,
    6.887272448,
    0.000000001,
    "OLMo 3 7B Instruct BF16 swept storage elements",
  );
  assertNear(
    result.resident,
    14.596022272,
    0.000000001,
    "OLMo 3 7B Instruct resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    13.774544896,
    0.000000001,
    "OLMo 3 7B Instruct swept text-decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.821477376,
    0.000000001,
    "OLMo 3 7B Instruct resident input embedding footprint",
  );
  assertNear(
    result.alloc,
    14.717812736,
    0.000000001,
    "OLMo 3 7B Instruct BF16 layered KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    5.804916736,
    0.000000001,
    "OLMo 3 7B Instruct BF16 layered KV read traffic",
  );
  assert.equal(result.bMem, 7);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    13.943182153375359,
    0.000000001,
    "OLMo 3 7B Instruct DGX Spark single-session bound",
  );
  assertNear(
    result.dennard,
    141.93814198806817,
    0.000000001,
    "OLMo 3 7B Instruct DGX Spark Dennard bound",
  );

  const m5 = profiled(
    "allenai/Olmo-3-7B-Instruct",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(m5.status_code, "ok");
  assert.equal(m5.best.batch, 2);
  assertNear(
    m5.best.aggregate,
    48.37620926530305,
    0.000000001,
    "OLMo 3 7B Instruct M5 Max aggregate at b*",
  );
  assertNear(
    m5.best.perSession,
    24.188104632651527,
    0.000000001,
    "OLMo 3 7B Instruct M5 Max per-session throughput at b*",
  );
  assertNear(
    m5.dennard,
    319.2308394896478,
    0.000000001,
    "OLMo 3 7B Instruct M5 Max Dennard bound",
  );
}

{
  const item = profile("google/gemma-4-31B-it-qat-w4a16-ct");
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(
    "google/gemma-4-31B-it-qat-w4a16-ct",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "no_floor");
  assertNear(
    weightAdapter.resident_params_b,
    33.59758608,
    0.000000001,
    "Google Gemma 4 31B QAT W4A16 CT logical resident parameters",
  );
  assertNear(
    weightAdapter.swept_params_b,
    31.6125564,
    0.000000001,
    "Google Gemma 4 31B QAT W4A16 CT logical swept parameters",
  );
  assertNear(
    result.resident,
    23.26508556,
    0.000000001,
    "Google Gemma 4 31B QAT W4A16 CT resident tensor bytes",
  );
  assertNear(
    result.single.batchWeight,
    19.2950262,
    0.000000001,
    "Google Gemma 4 31B QAT W4A16 CT swept text-decode bytes",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    3.97005936,
    0.000000001,
    "Google Gemma 4 31B QAT W4A16 CT resident-only multimodal/input bytes",
  );
  assertNear(
    result.alloc,
    2.8868608,
    0.000000001,
    "Google Gemma 4 31B QAT W4A16 CT layered BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.4942208,
    0.000000001,
    "Google Gemma 4 31B QAT W4A16 CT layered BF16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    13.131788755985246,
    0.000000001,
    "Google Gemma 4 31B QAT W4A16 CT DGX Spark single-session throughput",
  );
  assert.equal(result.bMem, 33);
  assert.equal(result.best, null);
  assertNear(
    result.dennard,
    474.10516093765483,
    0.000000001,
    "Google Gemma 4 31B QAT W4A16 CT DGX Spark Dennard bound",
  );
}

{
  const item = profile("google/gemma-4-31B-it-qat-q4_0-gguf");
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(
    "google/gemma-4-31B-it-qat-q4_0-gguf",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "google/gemma-4-31B-it-qat-q4_0-gguf",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "no_floor");
  assertNear(
    weightAdapter.resident_params_b,
    30.697345596,
    0.000000001,
    "Google Gemma 4 31B QAT Q4_0 GGUF logical resident parameters",
  );
  assertNear(
    weightAdapter.swept_params_b,
    30.697345596,
    0.000000001,
    "Google Gemma 4 31B QAT Q4_0 GGUF logical swept parameters",
  );
  assertNear(
    result.resident,
    17.650999456,
    0.000000001,
    "Google Gemma 4 31B QAT Q4_0 GGUF resident file footprint",
  );
  assertNear(
    result.single.batchWeight,
    17.635168128,
    0.000000001,
    "Google Gemma 4 31B QAT Q4_0 GGUF swept tensor spans",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.015831328,
    0.000000001,
    "Google Gemma 4 31B QAT Q4_0 GGUF metadata/header overhead",
  );
  assertNear(
    result.alloc,
    4.9348608,
    0.000000001,
    "Google Gemma 4 31B QAT Q4_0 GGUF layered FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    2.1495808,
    0.000000001,
    "Google Gemma 4 31B QAT Q4_0 GGUF layered FP16 KV read traffic",
  );
  assert.equal(result.bMem, 20);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    13.798507173049934,
    0.000000001,
    "Google Gemma 4 31B QAT Q4_0 GGUF DGX Spark single",
  );
  assertNear(
    result.dennard,
    321.0640959174081,
    0.000000001,
    "Google Gemma 4 31B QAT Q4_0 GGUF DGX Spark Dennard",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 6);
  assertNear(
    m5Result.best.aggregate,
    120.6577105725911,
    0.000000001,
    "Google Gemma 4 31B QAT Q4_0 GGUF M5 Max aggregate",
  );
  assertNear(
    m5Result.best.perSession,
    20.109618428765184,
    0.000000001,
    "Google Gemma 4 31B QAT Q4_0 GGUF M5 Max per-session",
  );
}

{
  const item = profile("lmstudio-community/gemma-4-31B-it-QAT-GGUF");
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(
    "lmstudio-community/gemma-4-31B-it-QAT-GGUF",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "lmstudio-community/gemma-4-31B-it-QAT-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "no_floor");
  assertNear(
    weightAdapter.resident_params_b,
    30.697345596,
    0.000000001,
    "LM Studio Gemma 4 31B QAT GGUF logical resident parameters",
  );
  assertNear(
    weightAdapter.swept_params_b,
    30.697345596,
    0.000000001,
    "LM Studio Gemma 4 31B QAT GGUF logical swept parameters",
  );
  assertNear(
    result.resident,
    17.651000768,
    0.000000001,
    "LM Studio Gemma 4 31B QAT GGUF resident file footprint",
  );
  assertNear(
    result.single.batchWeight,
    17.635168128,
    0.000000001,
    "LM Studio Gemma 4 31B QAT GGUF swept tensor spans",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.01583264,
    0.000000001,
    "LM Studio Gemma 4 31B QAT GGUF metadata/header overhead",
  );
  assertNear(
    result.alloc,
    4.9348608,
    0.000000001,
    "LM Studio Gemma 4 31B QAT GGUF layered FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    2.1495808,
    0.000000001,
    "LM Studio Gemma 4 31B QAT GGUF layered FP16 KV read traffic",
  );
  assert.equal(result.bMem, 20);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    13.798507173049934,
    0.000000001,
    "LM Studio Gemma 4 31B QAT GGUF DGX Spark single",
  );
  assertNear(
    result.dennard,
    321.0640918017246,
    0.000000001,
    "LM Studio Gemma 4 31B QAT GGUF DGX Spark Dennard",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 6);
  assertNear(
    m5Result.best.aggregate,
    120.6577105725911,
    0.000000001,
    "LM Studio Gemma 4 31B QAT GGUF M5 Max aggregate",
  );
  assertNear(
    m5Result.best.perSession,
    20.109618428765184,
    0.000000001,
    "LM Studio Gemma 4 31B QAT GGUF M5 Max per-session",
  );
}

{
  const item = profile("douyamv/Gemma-4-31B-JANG_4M-CRACK-GGUF");
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(
    "douyamv/Gemma-4-31B-JANG_4M-CRACK-GGUF",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "douyamv/Gemma-4-31B-JANG_4M-CRACK-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "no_floor");
  assert.equal(
    item.serving.runtime_format,
    "llama.cpp-gguf-q4-k-m-memory-bound",
  );
  assertNear(
    weightAdapter.resident_params_b,
    30.697345596,
    0.000000001,
    "douyamv Gemma 4 31B Q4_K_M GGUF logical resident parameters",
  );
  assertNear(
    weightAdapter.swept_params_b,
    30.697345596,
    0.000000001,
    "douyamv Gemma 4 31B Q4_K_M GGUF logical swept parameters",
  );
  assertNear(
    result.resident,
    18.687057344,
    0.000000001,
    "douyamv Gemma 4 31B Q4_K_M GGUF resident file footprint",
  );
  assertNear(
    result.single.batchWeight,
    18.671229168,
    0.000000001,
    "douyamv Gemma 4 31B Q4_K_M GGUF swept tensor spans",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.015828176,
    0.000000001,
    "douyamv Gemma 4 31B Q4_K_M GGUF metadata/header overhead",
  );
  assertNear(
    result.alloc,
    2.8868608,
    0.000000001,
    "douyamv Gemma 4 31B Q4_K_M GGUF layered FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.4942208,
    0.000000001,
    "douyamv Gemma 4 31B Q4_K_M GGUF layered FP16 KV read traffic",
  );
  assert.equal(result.bMem, 35);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    13.538006859912187,
    0.000000001,
    "douyamv Gemma 4 31B Q4_K_M GGUF DGX Spark single-session throughput",
  );
  assertNear(
    result.dennard,
    513.1316749714557,
    0.000000001,
    "douyamv Gemma 4 31B Q4_K_M GGUF DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 8);
  assertNear(
    m5Result.best.aggregate,
    160.39185994634198,
    0.000000001,
    "douyamv Gemma 4 31B Q4_K_M GGUF M5 Max aggregate",
  );
  assertNear(
    m5Result.best.perSession,
    20.048982493292748,
    0.000000001,
    "douyamv Gemma 4 31B Q4_K_M GGUF M5 Max per-session",
  );
}

{
  const item = profile("RedHatAI/gemma-4-31B-it-NVFP4");
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled("RedHatAI/gemma-4-31B-it-NVFP4", "nvidia-dgx-spark");
  assert.equal(result.status_code, "no_floor");
  assertNear(
    weightAdapter.resident_params_b,
    19.86943248,
    0.000000001,
    "RedHatAI Gemma 4 31B NVFP4 storage elements",
  );
  assertNear(
    weightAdapter.swept_params_b,
    17.8844028,
    0.000000001,
    "RedHatAI Gemma 4 31B NVFP4 swept storage elements",
  );
  assertNear(
    result.resident,
    23.26508228,
    0.000000001,
    "RedHatAI Gemma 4 31B NVFP4 resident tensor bytes",
  );
  assertNear(
    result.single.batchWeight,
    19.29502292,
    0.000000001,
    "RedHatAI Gemma 4 31B NVFP4 swept text-decode bytes",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    3.97005936,
    0.000000001,
    "RedHatAI Gemma 4 31B NVFP4 resident-only multimodal/input bytes",
  );
  assertNear(
    result.alloc,
    2.8868608,
    0.000000001,
    "RedHatAI Gemma 4 31B NVFP4 layered BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.4942208,
    0.000000001,
    "RedHatAI Gemma 4 31B NVFP4 layered BF16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    13.131790827838733,
    0.000000001,
    "RedHatAI Gemma 4 31B NVFP4 DGX Spark single-session throughput",
  );
  assert.equal(result.bMem, 33);
  assert.equal(result.best, null);
  assertNear(
    result.dennard,
    474.1052576072824,
    0.000000001,
    "RedHatAI Gemma 4 31B NVFP4 DGX Spark Dennard bound",
  );
}

{
  const result = profiled("nvidia/Gemma-4-31B-IT-NVFP4", "nvidia-dgx-spark");
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    32.633255032,
    0.000000001,
    "NVIDIA Gemma 4 31B NVFP4 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    31.48176796,
    0.000000001,
    "NVIDIA Gemma 4 31B NVFP4 swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    1.151487072,
    0.000000001,
    "NVIDIA Gemma 4 31B NVFP4 resident multimodal footprint",
  );
  assertNear(
    result.alloc,
    1.4434304,
    0.000000001,
    "NVIDIA Gemma 4 31B NVFP4 layered FP8 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.7471104,
    0.000000001,
    "NVIDIA Gemma 4 31B NVFP4 layered FP8 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    8.470664009791498,
    0.000000001,
    "NVIDIA Gemma 4 31B NVFP4 DGX Spark single-session throughput",
  );
  assert.equal(result.bMem, 60);
  assert.equal(result.best, null);
}

{
  const item = profile("LilaRest/gemma-4-31B-it-NVFP4-turbo");
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(
    "LilaRest/gemma-4-31B-it-NVFP4-turbo",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "LilaRest/gemma-4-31B-it-NVFP4-turbo",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "no_floor");
  assert.equal(item.model_family, "gemma4-dense-text");
  assert.equal(item.base_model_proof.config_compatible, false);
  assertNear(
    weightAdapter.resident_params_b,
    32.52776664,
    0.000000001,
    "LilaRest Gemma 4 31B NVFP4 storage elements",
  );
  assertNear(
    result.resident,
    19.29502292,
    0.000000001,
    "LilaRest Gemma 4 31B NVFP4 text-only resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    19.29502292,
    0.000000001,
    "LilaRest Gemma 4 31B NVFP4 tied-output swept traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0,
    0.000000001,
    "LilaRest Gemma 4 31B NVFP4 has no resident-only vision payload",
  );
  assertNear(
    result.alloc,
    1.4434304,
    0.000000001,
    "LilaRest Gemma 4 31B NVFP4 layered FP8 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.7471104,
    0.000000001,
    "LilaRest Gemma 4 31B NVFP4 layered FP8 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    13.621304461016328,
    0.000000001,
    "LilaRest Gemma 4 31B NVFP4 DGX Spark single-session throughput",
  );
  assert.equal(result.bMem, 69);
  assert.equal(result.best, null);
  assertNear(
    result.dennard,
    987.1256465849583,
    0.000000001,
    "LilaRest Gemma 4 31B NVFP4 DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 15);
  assertNear(
    m5Result.best.aggregate,
    301.950591774179,
    0.000000001,
    "LilaRest Gemma 4 31B NVFP4 M5 Max aggregate",
  );
  assertNear(
    m5Result.best.perSession,
    20.130039451611932,
    0.000000001,
    "LilaRest Gemma 4 31B NVFP4 M5 Max per-session",
  );
}

{
  const result = profiled(
    "cyankiwi/gemma-4-31B-it-AWQ-4bit",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    20.904118392,
    0.000000001,
    "cyankiwi Gemma 4 31B AWQ resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    19.75263132,
    0.000000001,
    "cyankiwi Gemma 4 31B AWQ swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    1.151487072,
    0.000000001,
    "cyankiwi Gemma 4 31B AWQ resident multimodal footprint",
  );
  assertNear(
    result.alloc,
    2.8868608,
    0.000000001,
    "cyankiwi Gemma 4 31B AWQ layered BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.4942208,
    0.000000001,
    "cyankiwi Gemma 4 31B AWQ layered BF16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    12.848962211348981,
    0.000000001,
    "cyankiwi Gemma 4 31B AWQ DGX Spark single-session throughput",
  );
  assert.equal(result.bMem, 34);
  assert.equal(result.best, null);
  assertNear(
    result.dennard,
    474.42487476783765,
    0.000000001,
    "cyankiwi Gemma 4 31B AWQ DGX Spark Dennard bound",
  );
}

{
  const result = profiled(
    "cyankiwi/gemma-4-31B-it-AWQ-4bit",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.single.aggregate,
    28.89839852662372,
    0.000000001,
    "cyankiwi Gemma 4 31B AWQ M5 Max single-session throughput",
  );
  assert.equal(result.bMem, 34);
  assert.equal(result.best?.batch, 7);
  assertNear(
    result.best?.aggregate ?? 0,
    142.26052003405255,
    0.000000001,
    "cyankiwi Gemma 4 31B AWQ M5 Max aggregate throughput",
  );
  assertNear(
    result.best?.perSession ?? 0,
    20.32293143343608,
    0.000000001,
    "cyankiwi Gemma 4 31B AWQ M5 Max per-session throughput",
  );
  assertNear(
    result.dennard,
    1067.021513214111,
    0.000000001,
    "cyankiwi Gemma 4 31B AWQ M5 Max Dennard bound",
  );
}

{
  const item = profile("QuantTrio/gemma-4-31B-it-AWQ");
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled("QuantTrio/gemma-4-31B-it-AWQ", "nvidia-dgx-spark");
  assert.equal(result.status_code, "no_floor");
  assertNear(
    weightAdapter.resident_params_b,
    31.273088876,
    0.000000001,
    "QuantTrio Gemma 4 31B AWQ logical resident parameters",
  );
  assertNear(
    result.resident,
    20.459796184,
    0.000000001,
    "QuantTrio Gemma 4 31B AWQ resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    19.308309112,
    0.000000001,
    "QuantTrio Gemma 4 31B AWQ swept text-decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.151487072,
    0.000000001,
    "QuantTrio Gemma 4 31B AWQ resident multimodal footprint",
  );
  assertNear(
    result.alloc,
    2.8868608,
    0.000000001,
    "QuantTrio Gemma 4 31B AWQ layered BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.4942208,
    0.000000001,
    "QuantTrio Gemma 4 31B AWQ layered BF16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    13.123403795348908,
    0.000000001,
    "QuantTrio Gemma 4 31B AWQ DGX Spark single-session throughput",
  );
  assert.equal(result.bMem, 34);
  assert.equal(result.best, null);
  assertNear(
    result.dennard,
    487.51848399937734,
    0.000000001,
    "QuantTrio Gemma 4 31B AWQ DGX Spark Dennard bound",
  );
}

{
  const result = profiled(
    "QuantTrio/gemma-4-31B-it-AWQ",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.single.aggregate,
    29.515640770491682,
    0.000000001,
    "QuantTrio Gemma 4 31B AWQ M5 Max single-session throughput",
  );
  assert.equal(result.bMem, 34);
  assert.equal(result.best?.batch, 7);
  assertNear(
    result.best?.aggregate ?? 0,
    144.38393500581665,
    0.000000001,
    "QuantTrio Gemma 4 31B AWQ M5 Max aggregate throughput",
  );
  assertNear(
    result.best?.perSession ?? 0,
    20.626276429402377,
    0.000000001,
    "QuantTrio Gemma 4 31B AWQ M5 Max per-session throughput",
  );
  assertNear(
    result.dennard,
    1096.470143500431,
    0.000000001,
    "QuantTrio Gemma 4 31B AWQ M5 Max Dennard bound",
  );
}

{
  const item = profile("unsloth/gemma-4-31B-it-GGUF");
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled("unsloth/gemma-4-31B-it-GGUF", "nvidia-dgx-spark");
  assert.equal(result.status_code, "no_floor");
  assertNear(
    weightAdapter.resident_params_b,
    30.697345596,
    0.000000001,
    "Unsloth Gemma 4 31B IQ4_NL GGUF logical parameters",
  );
  assertNear(
    result.resident,
    17.287668736,
    0.000000001,
    "Unsloth Gemma 4 31B IQ4_NL GGUF resident file footprint",
  );
  assertNear(
    result.single.batchWeight,
    17.271836544,
    0.000000001,
    "Unsloth Gemma 4 31B IQ4_NL GGUF swept text-decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.015832192,
    0.000000001,
    "Unsloth Gemma 4 31B IQ4_NL GGUF metadata/header footprint",
  );
  assertNear(
    result.alloc,
    2.8868608,
    0.000000001,
    "Unsloth Gemma 4 31B IQ4_NL GGUF layered FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.4942208,
    0.000000001,
    "Unsloth Gemma 4 31B IQ4_NL GGUF layered FP16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    14.547541606403822,
    0.000000001,
    "Unsloth Gemma 4 31B IQ4_NL GGUF DGX Spark single-session throughput",
  );
  assert.equal(result.bMem, 35);
  assert.equal(result.best, null);
  assertNear(
    result.dennard,
    562.3683502790444,
    0.000000001,
    "Unsloth Gemma 4 31B IQ4_NL GGUF DGX Spark Dennard bound",
  );
}

{
  const result = profiled(
    "unsloth/gemma-4-31B-it-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.single.aggregate,
    32.71864668986061,
    0.000000001,
    "Unsloth Gemma 4 31B IQ4_NL GGUF M5 Max single-session throughput",
  );
  assert.equal(result.bMem, 35);
  assert.equal(result.best?.batch, 8);
  assertNear(
    result.best?.aggregate ?? 0,
    168.07181050847853,
    0.000000001,
    "Unsloth Gemma 4 31B IQ4_NL GGUF M5 Max aggregate throughput",
  );
  assertNear(
    result.best?.perSession ?? 0,
    21.008976313559817,
    0.000000001,
    "Unsloth Gemma 4 31B IQ4_NL GGUF M5 Max per-session throughput",
  );
  assertNear(
    result.dennard,
    1264.8137987960927,
    0.000000001,
    "Unsloth Gemma 4 31B IQ4_NL GGUF M5 Max Dennard bound",
  );
}

{
  const result = profiled(
    "google/gemma-4-31B-it-qat-w4a16-ct",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.single.aggregate,
    29.534499253388063,
    0.000000001,
    "Google Gemma 4 31B QAT W4A16 CT M5 Max single-session throughput",
  );
  assert.equal(result.bMem, 33);
  assert.equal(result.best?.batch, 7);
  assertNear(
    result.best?.aggregate ?? 0,
    144.44839028064925,
    0.000000001,
    "Google Gemma 4 31B QAT W4A16 CT M5 Max aggregate throughput",
  );
  assertNear(
    result.best?.perSession ?? 0,
    20.635484325807035,
    0.000000001,
    "Google Gemma 4 31B QAT W4A16 CT M5 Max per-session throughput",
  );
  assertNear(
    result.dennard,
    1066.3024498744326,
    0.000000001,
    "Google Gemma 4 31B QAT W4A16 CT M5 Max Dennard bound",
  );
}

{
  const result = profiled("zai-org/GLM-4.7-Flash", "nvidia-dgx-spark");
  assert.equal(result.status_code, "no_session_capacity");
  assertNear(
    result.resident,
    62.442983168,
    0.000000001,
    "GLM 4.7 Flash resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    7.159149568,
    0.000000001,
    "GLM 4.7 Flash single-session MoE decode traffic",
  );
  assertNear(
    result.alloc,
    96.256,
    0.000000001,
    "GLM 4.7 Flash expanded BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    30.80192,
    0.000000001,
    "GLM 4.7 Flash expanded BF16 KV read traffic",
  );
}

{
  const repo = "unsloth/GLM-4.7-Flash-GGUF";
  const catalogRow = model(repo);
  const modelProfile = profile(repo);
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  assert.equal(catalogRow.hf_downloads, 112163);
  assert.equal(
    catalogRow.architecture.detail,
    "deepseek2 GGUF / glm4_moe_lite",
  );
  assert.equal(catalogRow.architecture.kv_heads, 1);
  assert.equal(catalogRow.architecture.head_dim, 576);
  assert.equal(catalogRow.adapter.weight_precision, "GGUF IQ4_NL");
  assert.equal(
    modelProfile.serving.runtime_format,
    "llama.cpp-gguf-iq4-nl-deepseek2-mla-memory-bound",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    17.165033824,
    0.000000001,
    "Unsloth GLM 4.7 Flash IQ4_NL GGUF resident footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    16.977136128,
    0.000000001,
    "Unsloth GLM 4.7 Flash IQ4_NL GGUF ordinary main resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.187897696,
    0.000000001,
    "Unsloth GLM 4.7 Flash IQ4_NL GGUF resident-only embedding/header footprint",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    1.349159424,
    0.000000001,
    "Unsloth GLM 4.7 Flash IQ4_NL GGUF fixed ordinary text traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.244187136,
    0.000000001,
    "Unsloth GLM 4.7 Flash IQ4_NL GGUF per-expert text traffic",
  );
  assertNear(
    result.single.batchWeight,
    2.325907968,
    0.000000001,
    "Unsloth GLM 4.7 Flash IQ4_NL GGUF single-session decode traffic",
  );
  assertNear(
    result.alloc,
    5.4144,
    0.000000001,
    "Unsloth GLM 4.7 Flash IQ4_NL GGUF compact MLA allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.732608,
    0.000000001,
    "Unsloth GLM 4.7 Flash IQ4_NL GGUF compact MLA read traffic",
  );
  assert.equal(result.bMem, 18);
  assert.equal(result.best.batch, 4);
  assertNear(
    result.single.aggregate,
    67.26596671111089,
    0.000000001,
    "Unsloth GLM 4.7 Flash IQ4_NL GGUF DGX Spark single-session throughput",
  );
  assertNear(
    result.best.aggregate,
    92.26613645096566,
    0.000000001,
    "Unsloth GLM 4.7 Flash IQ4_NL GGUF DGX Spark aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    23.066534112741415,
    0.000000001,
    "Unsloth GLM 4.7 Flash IQ4_NL GGUF DGX Spark per-session throughput",
  );
  assertNear(
    result.dennard,
    2229.2593307475668,
    0.000000001,
    "Unsloth GLM 4.7 Flash IQ4_NL GGUF DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 12);
  assertNear(
    m5Result.best.aggregate,
    241.06246966525197,
    0.000000001,
    "Unsloth GLM 4.7 Flash IQ4_NL GGUF M5 Max aggregate throughput",
  );
  assertNear(
    m5Result.best.perSession,
    20.088539138770997,
    0.000000001,
    "Unsloth GLM 4.7 Flash IQ4_NL GGUF M5 Max per-session throughput",
  );
}

{
  const modelProfile = profile("lmstudio-community/GLM-4.7-Flash-MLX-8bit");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "lmstudio-community/GLM-4.7-Flash-MLX-8bit",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "lmstudio-community/GLM-4.7-Flash-MLX-8bit",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    31.820755968,
    0.000000001,
    "LM Studio GLM 4.7 Flash MLX 8-bit resident footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    31.483737088,
    0.000000001,
    "LM Studio GLM 4.7 Flash MLX 8-bit ordinary main resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.33701888,
    0.000000001,
    "LM Studio GLM 4.7 Flash MLX 8-bit resident-only embedding footprint",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    1.964225536,
    0.000000001,
    "LM Studio GLM 4.7 Flash MLX 8-bit fixed ordinary text traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.461242368,
    0.000000001,
    "LM Studio GLM 4.7 Flash MLX 8-bit per-expert text traffic",
  );
  assertNear(
    result.single.batchWeight,
    3.809195008,
    0.000000001,
    "LM Studio GLM 4.7 Flash MLX 8-bit single-session decode traffic",
  );
  assertNear(
    result.alloc,
    5.4144,
    0.000000001,
    "LM Studio GLM 4.7 Flash MLX 8-bit latent MLA cache allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.732608,
    0.000000001,
    "LM Studio GLM 4.7 Flash MLX 8-bit latent MLA cache read traffic",
  );
  assert.equal(result.bMem, 16);
  assert.equal(result.best.batch, 3);
  assertNear(
    result.single.aggregate,
    49.26194590567445,
    0.000000001,
    "LM Studio GLM 4.7 Flash MLX 8-bit DGX Spark single-session throughput",
  );
  assertNear(
    result.best.aggregate,
    66.27160971702818,
    0.000000001,
    "LM Studio GLM 4.7 Flash MLX 8-bit DGX Spark aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    22.090536572342728,
    0.000000001,
    "LM Studio GLM 4.7 Flash MLX 8-bit DGX Spark per-session throughput",
  );
  assertNear(
    result.dennard,
    1167.2005264592126,
    0.000000001,
    "LM Studio GLM 4.7 Flash MLX 8-bit DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 9);
  assertNear(
    m5Result.best.aggregate,
    180.80525537271467,
    0.000000001,
    "LM Studio GLM 4.7 Flash MLX 8-bit M5 Max aggregate throughput",
  );
  assertNear(
    m5Result.best.perSession,
    20.08947281919052,
    0.000000001,
    "LM Studio GLM 4.7 Flash MLX 8-bit M5 Max per-session throughput",
  );
}

{
  const modelProfile = profile("lmstudio-community/GLM-4.7-Flash-MLX-6bit");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "lmstudio-community/GLM-4.7-Flash-MLX-6bit",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "lmstudio-community/GLM-4.7-Flash-MLX-6bit",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    24.336479232,
    0.000000001,
    "LM Studio GLM 4.7 Flash MLX 6-bit resident footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    24.058934272,
    0.000000001,
    "LM Studio GLM 4.7 Flash MLX 6-bit ordinary main resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.27754496,
    0.000000001,
    "LM Studio GLM 4.7 Flash MLX 6-bit resident-only embedding footprint",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    1.485190144,
    0.000000001,
    "LM Studio GLM 4.7 Flash MLX 6-bit fixed ordinary text traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.352714752,
    0.000000001,
    "LM Studio GLM 4.7 Flash MLX 6-bit per-expert text traffic",
  );
  assertNear(
    result.single.batchWeight,
    2.896049152,
    0.000000001,
    "LM Studio GLM 4.7 Flash MLX 6-bit single-session decode traffic",
  );
  assertNear(
    result.alloc,
    5.4144,
    0.000000001,
    "LM Studio GLM 4.7 Flash MLX 6-bit latent MLA cache allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.732608,
    0.000000001,
    "LM Studio GLM 4.7 Flash MLX 6-bit latent MLA cache read traffic",
  );
  assert.equal(result.bMem, 17);
  assert.equal(result.best.batch, 4);
  assertNear(
    result.single.aggregate,
    58.98038913554858,
    0.000000001,
    "LM Studio GLM 4.7 Flash MLX 6-bit DGX Spark single-session throughput",
  );
  assertNear(
    result.best.aggregate,
    80.58037782768412,
    0.000000001,
    "LM Studio GLM 4.7 Flash MLX 6-bit DGX Spark aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    20.14509445692103,
    0.000000001,
    "LM Studio GLM 4.7 Flash MLX 6-bit DGX Spark per-session throughput",
  );
  assertNear(
    result.dennard,
    1665.5310825155973,
    0.000000001,
    "LM Studio GLM 4.7 Flash MLX 6-bit DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 10);
  assertNear(
    m5Result.best.aggregate,
    207.81170492037626,
    0.000000001,
    "LM Studio GLM 4.7 Flash MLX 6-bit M5 Max aggregate throughput",
  );
  assertNear(
    m5Result.best.perSession,
    20.781170492037624,
    0.000000001,
    "LM Studio GLM 4.7 Flash MLX 6-bit M5 Max per-session throughput",
  );
}

{
  const result = profiled("zai-org/GLM-5-FP8", "nvidia-dgx-spark");
  assert.equal(result.status_code, "resident_not_fit");
  assertNear(
    result.resident,
    756.162687872,
    0.000000001,
    "GLM 5 FP8 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    41.928982272,
    0.000000001,
    "GLM 5 FP8 single-session MoE decode traffic",
  );
  assertNear(
    result.alloc,
    513.1776,
    0.000000001,
    "GLM 5 FP8 expanded BF16 KV plus DSA indexer allocation",
  );
  assertNear(
    result.single.readTraffic,
    164.216832,
    0.000000001,
    "GLM 5 FP8 expanded BF16 KV plus DSA indexer read traffic",
  );
}

{
  const result = profiled("zai-org/GLM-5.1-FP8", "nvidia-dgx-spark");
  assert.equal(result.status_code, "resident_not_fit");
  assertNear(
    result.resident,
    756.162687872,
    0.000000001,
    "GLM 5.1 FP8 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    41.928982272,
    0.000000001,
    "GLM 5.1 FP8 single-session MoE decode traffic",
  );
  assertNear(
    result.alloc,
    513.1776,
    0.000000001,
    "GLM 5.1 FP8 expanded BF16 KV plus DSA indexer allocation",
  );
  assertNear(
    result.single.readTraffic,
    164.216832,
    0.000000001,
    "GLM 5.1 FP8 expanded BF16 KV plus DSA indexer read traffic",
  );
}

{
  const result = profiled("zai-org/GLM-5.2-FP8", "nvidia-dgx-spark");
  assert.equal(result.status_code, "resident_not_fit");
  assertNear(
    result.resident,
    755.617140416,
    0.000000001,
    "GLM 5.2 FP8 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    41.383434816,
    0.000000001,
    "GLM 5.2 FP8 single-session MoE decode traffic",
  );
  assertNear(
    result.alloc,
    511.7184,
    0.000000001,
    "GLM 5.2 FP8 expanded BF16 KV plus IndexShare DSA indexer allocation",
  );
  assertNear(
    result.single.readTraffic,
    163.749888,
    0.000000001,
    "GLM 5.2 FP8 expanded BF16 KV plus IndexShare DSA indexer read traffic",
  );
}

{
  const repo = "nvidia/GLM-5.2-NVFP4";
  const catalogRow = model(repo);
  const item = profile(repo);
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  const gb300Result = profiled(
    repo,
    "nvidia-msi-xpertstation-ws300-dgx-station-gb300",
  );

  assert.equal(catalogRow.hf_downloads, 449881);
  assert.equal(catalogRow.tags.includes("region:us"), true);
  assert.equal(catalogRow.architecture.total_params_b, 753.32994048);
  assert.equal(catalogRow.architecture.active_params_b, 40);
  assert.equal(catalogRow.architecture.head_dim, 256);
  assert.equal(
    catalogRow.adapter.weight_precision,
    "ModelOpt NVFP4 + BF16 fixed tensors",
  );
  assertNear(
    catalogRow.adapter.active_weight_gb,
    48.643642944,
    0.000000001,
    "NVIDIA GLM 5.2 NVFP4 catalog active traffic",
  );
  assert.equal(item.status, "audited");
  assert.equal(item.serving.weight_format, "nvfp4");
  assert.equal(item.serving.kv_store_bytes_per_scalar, 1);
  assert.equal(item.base_model_proof.config_compatible, true);
  assertNear(
    item.architecture.weight_adapter.resident_weight_gb,
    464.795267072,
    0.000000001,
    "NVIDIA GLM 5.2 NVFP4 resident tensor payload",
  );
  assertNear(
    item.architecture.weight_adapter.main_resident_weight_gb,
    442.986259968,
    0.000000001,
    "NVIDIA GLM 5.2 NVFP4 ordinary main resident tensors",
  );
  assertNear(
    item.architecture.weight_adapter.auxiliary_resident_weight_gb,
    21.809007104,
    0.000000001,
    "NVIDIA GLM 5.2 NVFP4 resident-only embedding plus auxiliary layer",
  );
  assertNear(
    item.architecture.weight_adapter.fixed_weight_gb,
    35.299450368,
    0.000000001,
    "NVIDIA GLM 5.2 NVFP4 fixed ordinary traffic",
  );
  assertNear(
    item.architecture.weight_adapter.routed_expert_weight_gb,
    1.668024072,
    0.000000001,
    "NVIDIA GLM 5.2 NVFP4 routed expert group",
  );
  assert.equal(result.status_code, "resident_not_fit");
  assertNear(
    result.resident,
    464.795267072,
    0.000000001,
    "NVIDIA GLM 5.2 NVFP4 DGX resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    48.643642944,
    0.000000001,
    "NVIDIA GLM 5.2 NVFP4 DGX single-session MoE traffic",
  );
  assertNear(
    result.alloc,
    255.8592,
    0.000000001,
    "NVIDIA GLM 5.2 NVFP4 FP8 KV plus IndexShare DSA allocation",
  );
  assertNear(
    result.single.readTraffic,
    81.874944,
    0.000000001,
    "NVIDIA GLM 5.2 NVFP4 FP8 KV plus IndexShare DSA read traffic",
  );
  assertNear(
    result.single.aggregate,
    2.0916561111493857,
    0.000000001,
    "NVIDIA GLM 5.2 NVFP4 DGX single-session tok/s",
  );
  assert.equal(result.best, null);
  assert.equal(result.dennard, 0);
  assert.equal(m5Result.status_code, "resident_not_fit");
  assertNear(
    m5Result.single.aggregate,
    4.704310814086897,
    0.000000001,
    "NVIDIA GLM 5.2 NVFP4 M5 Max single-session tok/s",
  );
  assert.equal(gb300Result.status_code, "ok");
  assert.equal(gb300Result.bMem, 1);
  assert.equal(gb300Result.best.batch, 1);
  assertNear(
    gb300Result.single.aggregate,
    54.398382377877795,
    0.000000001,
    "NVIDIA GLM 5.2 NVFP4 GB300 single-session throughput",
  );
  assertNear(
    gb300Result.best.aggregate,
    54.398382377877795,
    0.000000001,
    "NVIDIA GLM 5.2 NVFP4 GB300 aggregate throughput",
  );
  assertNear(
    gb300Result.dennard,
    156.99546867673791,
    0.000000001,
    "NVIDIA GLM 5.2 NVFP4 GB300 Dennard bound",
  );
}

{
  const result = calculate("zai-org/GLM-5.2-FP8", "nvidia-dgx-spark");
  assert.equal(result.status.residentFit.code, "resident_not_fit");
  assertNear(
    result.resident,
    755.617140416,
    0.000000001,
    "GLM 5.2 FP8 legacy resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    41.383434816,
    0.000000001,
    "GLM 5.2 FP8 legacy MoE decode traffic",
  );
  assertNear(
    result.alloc,
    511.7184,
    0.000000001,
    "GLM 5.2 FP8 legacy expanded BF16 KV plus IndexShare DSA indexer allocation",
  );
  assertNear(
    result.single.readTraffic,
    163.749888,
    0.000000001,
    "GLM 5.2 FP8 legacy expanded BF16 KV plus IndexShare DSA indexer read traffic",
  );
}

{
  const repo = "zai-org/GLM-5.2";
  const item = profile(repo);
  const modelRow = model(repo);
  const result = profiled(repo, "nvidia-dgx-spark");
  const legacyResult = calculate(repo, "nvidia-dgx-spark");
  assert.equal(item.serving.weight_format, "bf16");
  assert.equal(modelRow.hf_downloads, 231218);
  assert.ok(modelRow.tags.includes("region:us"));
  assert.equal(modelRow.architecture.head_dim, 256);
  assert.equal(modelRow.adapter.weight_precision, "BF16/F32");
  assertNear(
    item.architecture.weight_adapter.resident_weight_gb,
    1506.659919872,
    0.000000001,
    "GLM 5.2 BF16 resident profile footprint",
  );
  assertNear(
    item.architecture.weight_adapter.fixed_weight_gb,
    15.972097536,
    0.000000001,
    "GLM 5.2 BF16 fixed ordinary traffic",
  );
  assertNear(
    item.architecture.weight_adapter.routed_expert_weight_gb,
    5.737807872,
    0.000000001,
    "GLM 5.2 BF16 routed expert group",
  );
  assertNear(
    item.architecture.weight_adapter.auxiliary_resident_weight_gb,
    21.809007104,
    0.000000001,
    "GLM 5.2 BF16 resident-only input plus auxiliary layer",
  );
  assert.equal(result.status_code, "resident_not_fit");
  assertNear(
    result.resident,
    1506.659919872,
    0.000000001,
    "GLM 5.2 BF16 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    61.874560512,
    0.000000001,
    "GLM 5.2 BF16 single-session MoE decode traffic",
  );
  assertNear(
    result.alloc,
    511.7184,
    0.000000001,
    "GLM 5.2 BF16 expanded BF16 KV plus IndexShare DSA indexer allocation",
  );
  assertNear(
    result.single.readTraffic,
    163.749888,
    0.000000001,
    "GLM 5.2 BF16 expanded BF16 KV plus IndexShare DSA indexer read traffic",
  );
  assertNear(
    result.single.aggregate,
    1.20997525667295,
    0.000000001,
    "GLM 5.2 BF16 DGX single-session tok/s",
  );
  assert.equal(legacyResult.status.residentFit.code, "resident_not_fit");
  assertNear(
    legacyResult.resident,
    1506.659919872,
    0.000000001,
    "GLM 5.2 BF16 legacy resident footprint",
  );
  assertNear(
    legacyResult.single.batchWeight,
    61.874560512,
    0.000000001,
    "GLM 5.2 BF16 legacy single-session MoE decode traffic",
  );
}

{
  const result = profiled("moonshotai/Kimi-K2.5", "nvidia-dgx-spark");
  assert.equal(result.status_code, "resident_not_fit");
  assertNear(
    result.resident,
    595.148192736,
    0.000000001,
    "Kimi K2.5 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    32.986516736,
    0.000000001,
    "Kimi K2.5 single-session MoE decode traffic",
  );
  assertNear(
    result.alloc,
    249.856,
    0.000000001,
    "Kimi K2.5 expanded BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    79.95392,
    0.000000001,
    "Kimi K2.5 expanded BF16 KV read traffic",
  );
}

{
  const modelProfile = profile("mlx-community/Kimi-K2.5");
  const result = profiled("mlx-community/Kimi-K2.5", "nvidia-dgx-spark");
  assert.equal(result.status_code, "resident_not_fit");
  assert.equal(modelProfile.serving.weight_format, "mlx_quantized");
  assertNear(
    result.resident,
    657.623228416,
    0.000000001,
    "MLX Kimi K2.5 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    34.307710976,
    0.000000001,
    "MLX Kimi K2.5 single-session MoE decode traffic",
  );
  assertNear(
    modelProfile.architecture.weight_adapter.auxiliary_resident_weight_gb,
    2.34881024,
    0.000000001,
    "MLX Kimi K2.5 resident-only input embedding footprint",
  );
  assertNear(
    modelProfile.architecture.weight_adapter.routed_expert_weight_gb,
    1.6515072,
    0.000000001,
    "MLX Kimi K2.5 per-expert switch_mlp traffic",
  );
  assertNear(
    result.alloc,
    249.856,
    0.000000001,
    "MLX Kimi K2.5 expanded BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    79.95392,
    0.000000001,
    "MLX Kimi K2.5 expanded BF16 KV read traffic",
  );
}

{
  const result = profiled("nvidia/Kimi-K2.5-NVFP4", "nvidia-dgx-spark");
  assert.equal(result.status_code, "resident_not_fit");
  assertNear(
    result.resident,
    590.779912064,
    0.000000001,
    "NVIDIA Kimi K2.5 NVFP4 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    28.618236064,
    0.000000001,
    "NVIDIA Kimi K2.5 NVFP4 single-session MoE decode traffic",
  );
  assertNear(
    result.alloc,
    124.928,
    0.000000001,
    "NVIDIA Kimi K2.5 NVFP4 expanded FP8 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    39.97696,
    0.000000001,
    "NVIDIA Kimi K2.5 NVFP4 expanded FP8 KV read traffic",
  );
}

{
  const result = profiled("moonshotai/Kimi-K2.6", "nvidia-dgx-spark");
  assert.equal(result.status_code, "resident_not_fit");
  assertNear(
    result.resident,
    595.148192736,
    0.000000001,
    "Kimi K2.6 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    32.986516736,
    0.000000001,
    "Kimi K2.6 single-session MoE decode traffic",
  );
  assertNear(
    result.alloc,
    249.856,
    0.000000001,
    "Kimi K2.6 expanded BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    79.95392,
    0.000000001,
    "Kimi K2.6 expanded BF16 KV read traffic",
  );
}

{
  const result = profiled("nvidia/Kimi-K2.6-NVFP4", "nvidia-dgx-spark");
  assert.equal(result.status_code, "resident_not_fit");
  assertNear(
    result.resident,
    595.148146656,
    0.000000001,
    "NVIDIA Kimi K2.6 NVFP4 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    32.986470656,
    0.000000001,
    "NVIDIA Kimi K2.6 NVFP4 single-session MoE decode traffic",
  );
  assertNear(
    result.alloc,
    124.928,
    0.000000001,
    "NVIDIA Kimi K2.6 NVFP4 expanded FP8 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    39.97696,
    0.000000001,
    "NVIDIA Kimi K2.6 NVFP4 expanded FP8 KV read traffic",
  );
}

{
  const result = profiled("moonshotai/Kimi-K2.7-Code", "nvidia-dgx-spark");
  assert.equal(result.status_code, "resident_not_fit");
  assertNear(
    result.resident,
    595.148192736,
    0.000000001,
    "Kimi K2.7 Code resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    32.986516736,
    0.000000001,
    "Kimi K2.7 Code single-session MoE decode traffic",
  );
  assertNear(
    result.alloc,
    249.856,
    0.000000001,
    "Kimi K2.7 Code expanded BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    79.95392,
    0.000000001,
    "Kimi K2.7 Code expanded BF16 KV read traffic",
  );
}

{
  const repo = "unsloth/Kimi-K2.7-Code-GGUF";
  const item = profile(repo);
  const modelRow = model(repo);
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  const gb300Result = profiled(
    repo,
    "nvidia-msi-xpertstation-ws300-dgx-station-gb300",
  );
  assert.equal(item.status, "audited");
  assert.equal(item.base_model_proof.config_compatible, true);
  assert.equal(modelRow.hf_downloads, 291513);
  assertNear(
    modelRow.architecture.total_params_b,
    1026.408232448,
    0.000000001,
    "Unsloth Kimi K2.7 Code GGUF catalog logical tensor parameters",
  );
  assert.equal(modelRow.architecture.active_params_b, 32);
  assert.equal(modelRow.adapter.weight_precision, "GGUF UD-IQ1_M split");
  assertNear(
    modelRow.adapter.resident_weight_gb,
    303.909170464,
    0.000000001,
    "Unsloth Kimi K2.7 Code GGUF catalog resident split size",
  );
  assertNear(
    modelRow.adapter.active_weight_gb,
    14.664554496,
    0.000000001,
    "Unsloth Kimi K2.7 Code GGUF catalog single-token path traffic",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    303.241582592,
    0.000000001,
    "Unsloth Kimi K2.7 Code GGUF main tensor spans",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.667587872,
    0.000000001,
    "Unsloth Kimi K2.7 Code GGUF input embedding plus header overhead",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    8.524617728,
    0.000000001,
    "Unsloth Kimi K2.7 Code GGUF fixed ordinary text traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.767492096,
    0.000000001,
    "Unsloth Kimi K2.7 Code GGUF per-expert routed traffic",
  );
  assert.equal(result.status_code, "resident_not_fit");
  assert.equal(result.best, null);
  assertNear(
    result.resident,
    303.909170464,
    0.000000001,
    "Unsloth Kimi K2.7 Code GGUF resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    14.664554496,
    0.000000001,
    "Unsloth Kimi K2.7 Code GGUF single-session MoE decode traffic",
  );
  assertNear(
    result.single.batchWeight - weightAdapter.fixed_weight_gb,
    6.139936768,
    0.000000001,
    "Unsloth Kimi K2.7 Code GGUF eight routed expert indexes traffic",
  );
  assertNear(
    result.alloc,
    7.0272,
    0.000000001,
    "Unsloth Kimi K2.7 Code GGUF compact MLA allocation",
  );
  assertNear(
    result.single.readTraffic,
    2.248704,
    0.000000001,
    "Unsloth Kimi K2.7 Code GGUF compact MLA read traffic",
  );
  assertNear(
    result.single.aggregate,
    16.141182969831895,
    0.000000001,
    "Unsloth Kimi K2.7 Code GGUF DGX Spark single-session tok/s",
  );
  assert.equal(gb300Result.status_code, "ok");
  assert.equal(gb300Result.bMem, 62);
  assert.equal(gb300Result.best.batch, 60);
  assertNear(
    gb300Result.best.aggregate,
    1200.5626307655423,
    0.000000001,
    "Unsloth Kimi K2.7 Code GGUF GB300 aggregate tok/s at b*",
  );
  assertNear(
    gb300Result.best.perSession,
    20.009377179425705,
    0.000000001,
    "Unsloth Kimi K2.7 Code GGUF GB300 per-session tok/s at b*",
  );
  assertNear(
    gb300Result.dennard,
    30045.823720252985,
    0.000000001,
    "Unsloth Kimi K2.7 Code GGUF GB300 Dennard bound",
  );
}

{
  const repo = "decart-ai/Kimi-K2.7-Code-NVFP4";
  const item = profile(repo);
  const modelRow = model(repo);
  const result = profiled(repo, "nvidia-dgx-spark");
  assert.equal(item.status, "audited");
  assert.equal(item.base_model_proof.config_compatible, true);
  assert.equal(modelRow.hf_downloads, 352463);
  assert.equal(modelRow.architecture.active_params_b, 32);
  assert.equal(result.status_code, "resident_not_fit");
  assert.equal(result.best, null);
  assertNear(
    result.resident,
    595.148146656,
    0.000000001,
    "Decart Kimi K2.7 Code NVFP4 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    32.986470656,
    0.000000001,
    "Decart Kimi K2.7 Code NVFP4 single-session MoE decode traffic",
  );
  assertNear(
    item.architecture.weight_adapter.auxiliary_resident_weight_gb,
    3.29109808,
    0.000000001,
    "Decart Kimi K2.7 Code NVFP4 resident-only embedding/vision/projector footprint",
  );
  assertNear(
    item.architecture.weight_adapter.routed_expert_weight_gb,
    1.48635792,
    0.000000001,
    "Decart Kimi K2.7 Code NVFP4 per-expert routed traffic",
  );
  assertNear(
    result.alloc,
    124.928,
    0.000000001,
    "Decart Kimi K2.7 Code NVFP4 expanded FP8 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    39.97696,
    0.000000001,
    "Decart Kimi K2.7 Code NVFP4 expanded FP8 KV read traffic",
  );
}

{
  const result = profiled("moonshotai/Kimi-K2-Instruct", "nvidia-dgx-spark");
  assert.equal(result.status_code, "resident_not_fit");
  assertNear(
    result.resident,
    1029.17325672,
    0.000000001,
    "Kimi K2 Instruct resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    33.03514984,
    0.000000001,
    "Kimi K2 Instruct single-session MoE decode traffic",
  );
  assertNear(
    result.alloc,
    249.856,
    0.000000001,
    "Kimi K2 Instruct expanded BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    79.95392,
    0.000000001,
    "Kimi K2 Instruct expanded BF16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    2.416162911922241,
    0.000000001,
    "Kimi K2 Instruct DGX Spark single-session throughput",
  );
  assert.equal(result.bMem, 0);
  assert.equal(result.best, null);
  assert.equal(result.dennard, 0);
}

{
  const result = profiled(
    "moonshotai/Kimi-K2-Instruct-0905",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "resident_not_fit");
  assertNear(
    result.resident,
    1029.173265504,
    0.000000001,
    "Kimi K2 Instruct 0905 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    33.035158624,
    0.000000001,
    "Kimi K2 Instruct 0905 single-session MoE decode traffic",
  );
  assertNear(
    result.alloc,
    249.856,
    0.000000001,
    "Kimi K2 Instruct 0905 expanded BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    79.95392,
    0.000000001,
    "Kimi K2 Instruct 0905 expanded BF16 KV read traffic",
  );
  assert.equal(result.bMem, 0);
}

{
  const repo = "moonshotai/Kimi-K2-Thinking";
  const modelRow = model(repo);
  const modelProfile = profile(repo);
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  assert.equal(modelRow.hf_downloads, 139650);
  assert.equal(modelRow.tags.includes("region:us"), true);
  assert.equal(modelRow.architecture.active_params_b, 32);
  assert.equal(modelRow.architecture.head_dim, 192);
  assert.equal(modelProfile.status, "audited");
  assert.equal(modelProfile.serving.weight_format, "int4");
  assertNear(
    modelRow.adapter.active_weight_gb,
    32.986532352,
    0.000000001,
    "Kimi K2 Thinking catalog active traffic",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    21.095668992,
    0.000000001,
    "Kimi K2 Thinking fixed decode traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    1.48635792,
    0.000000001,
    "Kimi K2 Thinking per-expert routed traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    2.34881024,
    0.000000001,
    "Kimi K2 Thinking resident-only input embedding",
  );
  assert.equal(result.status_code, "resident_not_fit");
  assertNear(
    result.resident,
    594.205920512,
    0.000000001,
    "Kimi K2 Thinking resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    32.986532352,
    0.000000001,
    "Kimi K2 Thinking single-session MoE decode traffic",
  );
  assertNear(
    result.alloc,
    249.856,
    0.000000001,
    "Kimi K2 Thinking expanded BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    79.95392,
    0.000000001,
    "Kimi K2 Thinking expanded BF16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    2.4172029978164464,
    0.000000001,
    "Kimi K2 Thinking DGX Spark single-session throughput",
  );
  assert.equal(result.bMem, 0);
  assert.equal(result.best, null);
  assert.equal(result.dennard, 0);
}

{
  const result = profiled("Qwen/Qwen3-1.7B", "nvidia-dgx-spark");
  assertNear(
    result.resident,
    4.063479808,
    0.000000001,
    "Qwen3 1.7B resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    3.441149952,
    0.000000001,
    "Qwen3 1.7B swept BF16 decode traffic",
  );
  assertNear(
    result.alloc,
    11.4688,
    0.000000001,
    "Qwen3 1.7B BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    3.670016,
    0.000000001,
    "Qwen3 1.7B BF16 KV read traffic",
  );
}

{
  const result = profiled("Qwen/Qwen3-1.7B-Base", "nvidia-dgx-spark");
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    3.441149952,
    0.000000001,
    "Qwen3 1.7B Base resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    3.441149952,
    0.000000001,
    "Qwen3 1.7B Base swept tied-output BF16 decode traffic",
  );
  assertNear(
    result.alloc,
    11.4688,
    0.000000001,
    "Qwen3 1.7B Base BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    3.670016,
    0.000000001,
    "Qwen3 1.7B Base BF16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    38.390328934,
    0.000000001,
    "Qwen3 1.7B Base DGX single-session tok/s",
  );
  assert.equal(result.bMem, 10);
  assert.equal(result.best.batch, 2);
  assertNear(
    result.best.aggregate,
    50.643797909,
    0.000000001,
    "Qwen3 1.7B Base DGX aggregate tok/s at b*",
  );
  assertNear(
    result.dennard,
    806.280810907,
    0.000000001,
    "Qwen3 1.7B Base DGX Dennard bound",
  );
}

{
  const item = profile("MaziyarPanahi/Qwen3-1.7B-GGUF");
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled("MaziyarPanahi/Qwen3-1.7B-GGUF", "nvidia-dgx-spark");
  const m5Result = profiled(
    "MaziyarPanahi/Qwen3-1.7B-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    weightAdapter.resident_params_b,
    2.031739904,
    0.000000001,
    "MaziyarPanahi Qwen3 1.7B GGUF logical resident parameters",
  );
  assertNear(
    weightAdapter.swept_params_b,
    1.720574976,
    0.000000001,
    "MaziyarPanahi Qwen3 1.7B GGUF logical swept parameters",
  );
  assertNear(
    result.resident,
    4.069679232,
    0.000000001,
    "MaziyarPanahi Qwen3 1.7B GGUF resident file footprint",
  );
  assertNear(
    result.single.batchWeight,
    3.44139776,
    0.000000001,
    "MaziyarPanahi Qwen3 1.7B GGUF swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    0.628281472,
    0.000000001,
    "MaziyarPanahi Qwen3 1.7B GGUF resident-only input embedding plus header footprint",
  );
  assertNear(
    result.alloc,
    11.4688,
    0.000000001,
    "MaziyarPanahi Qwen3 1.7B GGUF full-context FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    3.670016,
    0.000000001,
    "MaziyarPanahi Qwen3 1.7B GGUF full-context FP16 KV read traffic",
  );
  assert.equal(result.bMem, 10);
  assert.equal(result.best.batch, 2);
  assertNear(
    result.single.aggregate,
    38.38899116453604,
    0.000000001,
    "MaziyarPanahi Qwen3 1.7B GGUF DGX single-session tok/s",
  );
  assertNear(
    result.best.aggregate,
    50.64263387641826,
    0.000000001,
    "MaziyarPanahi Qwen3 1.7B GGUF DGX aggregate tok/s at b*",
  );
  assertNear(
    result.dennard,
    801.8752951280834,
    0.000000001,
    "MaziyarPanahi Qwen3 1.7B GGUF DGX Dennard bound",
  );
  assert.equal(m5Result.best.batch, 7);
  assertNear(
    m5Result.best.aggregate,
    147.53783910992192,
    0.000000001,
    "MaziyarPanahi Qwen3 1.7B GGUF M5 Max aggregate tok/s at b*",
  );
}

{
  const item = profile("Qwen/Qwen3-1.7B-GPTQ-Int8");
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled("Qwen/Qwen3-1.7B-GPTQ-Int8", "nvidia-dgx-spark");
  const m5Result = profiled(
    "Qwen/Qwen3-1.7B-GPTQ-Int8",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(item.serving.weight_format, "int8");
  assert.equal(result.status_code, "ok");
  assertNear(
    weightAdapter.resident_params_b,
    1.720574976,
    0.000000001,
    "Qwen3 1.7B GPTQ Int8 logical resident parameters",
  );
  assertNear(
    weightAdapter.swept_params_b,
    1.720574976,
    0.000000001,
    "Qwen3 1.7B GPTQ Int8 logical swept tied-output parameters",
  );
  assertNear(
    result.resident,
    2.066958336,
    0.000000001,
    "Qwen3 1.7B GPTQ Int8 resident payload",
  );
  assertNear(
    result.single.batchWeight,
    2.066958336,
    0.000000001,
    "Qwen3 1.7B GPTQ Int8 swept tied-output payload",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0,
    0.000000001,
    "Qwen3 1.7B GPTQ Int8 resident-only tensor payload",
  );
  assertNear(
    result.alloc,
    11.4688,
    0.000000001,
    "Qwen3 1.7B GPTQ Int8 FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    3.670016,
    0.000000001,
    "Qwen3 1.7B GPTQ Int8 FP16 KV read traffic",
  );
  assert.equal(result.bMem, 10);
  assert.equal(result.best.batch, 3);
  assertNear(
    result.single.aggregate,
    47.58605913345331,
    0.000000001,
    "Qwen3 1.7B GPTQ Int8 DGX Spark single-session throughput",
  );
  assertNear(
    result.best.aggregate,
    62.62901301388496,
    0.000000001,
    "Qwen3 1.7B GPTQ Int8 DGX Spark aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    20.876337671294987,
    0.000000001,
    "Qwen3 1.7B GPTQ Int8 DGX Spark per-session throughput",
  );
  assertNear(
    result.dennard,
    1358.152210838758,
    0.000000001,
    "Qwen3 1.7B GPTQ Int8 DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 7);
  assertNear(
    m5Result.best.aggregate,
    154.84343080781247,
    0.000000001,
    "Qwen3 1.7B GPTQ Int8 M5 Max aggregate",
  );
  assertNear(
    m5Result.best.perSession,
    22.120490115401783,
    0.000000001,
    "Qwen3 1.7B GPTQ Int8 M5 Max per-session",
  );
}

{
  const result = profiled("Qwen/Qwen3-4B", "nvidia-dgx-spark");
  assertNear(
    result.resident,
    8.044936192,
    0.000000001,
    "Qwen3 4B resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    8.044936192,
    0.000000001,
    "Qwen3 4B swept BF16 decode traffic",
  );
  assertNear(result.alloc, 14.7456, 0.000000001, "Qwen3 4B BF16 KV allocation");
  assertNear(
    result.single.readTraffic,
    4.718592,
    0.000000001,
    "Qwen3 4B BF16 KV read traffic",
  );
}

{
  const result = profiled("Qwen/Qwen3-4B-AWQ", "nvidia-dgx-spark");
  const m5Result = profiled(
    "Qwen/Qwen3-4B-AWQ",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    2.665925632,
    0.000000001,
    "Qwen3 4B AWQ resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    2.665925632,
    0.000000001,
    "Qwen3 4B AWQ swept decode traffic",
  );
  assertNear(result.alloc, 14.7456, 0.000000001, "Qwen3 4B AWQ KV allocation");
  assertNear(
    result.single.readTraffic,
    4.718592,
    0.000000001,
    "Qwen3 4B AWQ KV read traffic",
  );
  assert.equal(result.bMem, 7);
  assert.equal(result.best.batch, 2);
  assertNear(
    result.best.aggregate,
    45.11237331573069,
    0.000000001,
    "Qwen3 4B AWQ DGX Spark aggregate throughput",
  );
  assert.equal(m5Result.best.batch, 5);
  assertNear(
    m5Result.best.aggregate,
    116.91280593639473,
    0.000000001,
    "Qwen3 4B AWQ M5 Max aggregate throughput",
  );
}

{
  const modelProfile = profile("Qwen/Qwen3-4B-GGUF");
  const result = profiled("Qwen/Qwen3-4B-GGUF", "nvidia-dgx-spark");
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    2.497280256,
    0.000000001,
    "Qwen3 4B Q4_K_M GGUF resident selected-file footprint",
  );
  assertNear(
    result.single.batchWeight,
    2.491323904,
    0.000000001,
    "Qwen3 4B Q4_K_M GGUF swept tensor-span traffic",
  );
  assertNear(
    modelProfile.architecture.weight_adapter.auxiliary_resident_weight_gb,
    0.005956352,
    0.000000001,
    "Qwen3 4B Q4_K_M GGUF metadata/header/file overhead",
  );
  assertNear(
    result.alloc,
    14.7456,
    0.000000001,
    "Qwen3 4B Q4_K_M GGUF FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    4.718592,
    0.000000001,
    "Qwen3 4B Q4_K_M GGUF FP16 KV read traffic",
  );
  assert.equal(result.bMem, 7);
  assert.equal(result.best?.batch, 2);
  assertNear(
    result.single.aggregate,
    37.86451931409379,
    0.000000001,
    "Qwen3 4B Q4_K_M GGUF DGX Spark single-session throughput",
  );
  assertNear(
    result.best?.aggregate ?? 0,
    45.7726988483538,
    0.000000001,
    "Qwen3 4B Q4_K_M GGUF DGX Spark aggregate throughput",
  );
  assertNear(
    result.best?.perSession ?? 0,
    22.8863494241769,
    0.000000001,
    "Qwen3 4B Q4_K_M GGUF DGX Spark per-session throughput",
  );
  assertNear(
    result.dennard,
    873.2084350216029,
    0.000000001,
    "Qwen3 4B Q4_K_M GGUF DGX Spark Dennard bound",
  );
}

{
  const result = profiled(
    "Qwen/Qwen3-4B-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(result.bMem, 7);
  assert.equal(result.best?.batch, 5);
  assertNear(
    result.single.aggregate,
    85.16049398847467,
    0.000000001,
    "Qwen3 4B Q4_K_M GGUF M5 Max single-session throughput",
  );
  assertNear(
    result.best?.aggregate ?? 0,
    117.6953912669697,
    0.000000001,
    "Qwen3 4B Q4_K_M GGUF M5 Max aggregate throughput",
  );
  assertNear(
    result.best?.perSession ?? 0,
    23.53907825339394,
    0.000000001,
    "Qwen3 4B Q4_K_M GGUF M5 Max per-session throughput",
  );
  assertNear(
    result.dennard,
    1963.9193373745943,
    0.000000001,
    "Qwen3 4B Q4_K_M GGUF M5 Max Dennard bound",
  );
}

{
  const modelProfile = profile("MaziyarPanahi/Qwen3-4B-GGUF");
  const result = profiled("MaziyarPanahi/Qwen3-4B-GGUF", "nvidia-dgx-spark");
  const m5Result = profiled(
    "MaziyarPanahi/Qwen3-4B-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  const m1UltraResult = profiled(
    "MaziyarPanahi/Qwen3-4B-GGUF",
    "apple-mac-studio-m1-ultra-128gb",
  );
  assert.equal(modelProfile.serving.weight_format, "fp16");
  assert.equal(
    modelProfile.serving.runtime_format,
    "llama.cpp-gguf-f16-memory-bound",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    8.051285152,
    0.000000001,
    "MaziyarPanahi Qwen3 4B GGUF selected F16 resident linked file",
  );
  assertNear(
    result.single.batchWeight,
    8.045328384,
    0.000000001,
    "MaziyarPanahi Qwen3 4B GGUF selected F16 swept tensor-span traffic",
  );
  assertNear(
    modelProfile.architecture.weight_adapter.auxiliary_resident_weight_gb,
    0.005956768,
    0.000000001,
    "MaziyarPanahi Qwen3 4B GGUF metadata/header/file overhead",
  );
  assertNear(
    result.alloc,
    14.7456,
    0.000000001,
    "MaziyarPanahi Qwen3 4B GGUF FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    4.718592,
    0.000000001,
    "MaziyarPanahi Qwen3 4B GGUF FP16 KV read traffic",
  );
  assert.equal(result.bMem, 7);
  assert.equal(result.best?.batch, 1);
  assertNear(
    result.single.aggregate,
    21.388412947342935,
    0.000000001,
    "MaziyarPanahi Qwen3 4B GGUF DGX Spark single-session throughput",
  );
  assertNear(
    result.best?.aggregate ?? 0,
    21.388412947342935,
    0.000000001,
    "MaziyarPanahi Qwen3 4B GGUF DGX Spark aggregate throughput",
  );
  assertNear(
    result.dennard,
    257.6176031900255,
    0.000000001,
    "MaziyarPanahi Qwen3 4B GGUF DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best?.batch, 4);
  assertNear(
    m5Result.best?.aggregate ?? 0,
    91.23431278592537,
    0.000000001,
    "MaziyarPanahi Qwen3 4B GGUF M5 Max aggregate throughput",
  );
  assertNear(
    m5Result.best?.perSession ?? 0,
    22.808578196481342,
    0.000000001,
    "MaziyarPanahi Qwen3 4B GGUF M5 Max per-session throughput",
  );
  assertNear(
    m5Result.dennard,
    579.4036936215224,
    0.000000001,
    "MaziyarPanahi Qwen3 4B GGUF M5 Max Dennard bound",
  );
  assert.equal(m1UltraResult.status_code, "ok");
  assert.equal(m1UltraResult.best?.batch, 6);
  assertNear(
    m1UltraResult.best?.aggregate ?? 0,
    132.0245287632652,
    0.000000001,
    "MaziyarPanahi Qwen3 4B GGUF M1 Ultra aggregate throughput",
  );
  assertNear(
    m1UltraResult.best?.perSession ?? 0,
    22.004088127210867,
    0.000000001,
    "MaziyarPanahi Qwen3 4B GGUF M1 Ultra per-session throughput",
  );
}

{
  const repo = "unsloth/Qwen3-4B-GGUF";
  const item = model(repo);
  const modelProfile = profile(repo);
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  const m1UltraResult = profiled(repo, "apple-mac-studio-m1-ultra-128gb");
  assert.equal(item.hf_downloads, 131101);
  assert.ok(item.tags.includes("region:us"));
  assert.equal(item.architecture.detail, "qwen3 GGUF selected BF16 artifact");
  assert.equal(item.adapter.weight_precision, "GGUF BF16 selected artifact");
  assert.equal(modelProfile.serving.weight_format, "bf16");
  assert.equal(
    modelProfile.serving.runtime_format,
    "llama.cpp-gguf-bf16-memory-bound",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    item.adapter.resident_weight_gb,
    8.051285536,
    0.000000001,
    "Unsloth Qwen3 4B GGUF catalog selected BF16 resident linked file",
  );
  assertNear(
    item.adapter.active_weight_gb,
    8.045328384,
    0.000000001,
    "Unsloth Qwen3 4B GGUF catalog selected BF16 swept tensor-span traffic",
  );
  assertNear(
    result.resident,
    8.051285536,
    0.000000001,
    "Unsloth Qwen3 4B GGUF selected BF16 resident linked file",
  );
  assertNear(
    result.single.batchWeight,
    8.045328384,
    0.000000001,
    "Unsloth Qwen3 4B GGUF selected BF16 swept tensor-span traffic",
  );
  assertNear(
    modelProfile.architecture.weight_adapter.auxiliary_resident_weight_gb,
    0.005957152,
    0.000000001,
    "Unsloth Qwen3 4B GGUF metadata/header/file overhead",
  );
  assertNear(
    result.alloc,
    14.7456,
    0.000000001,
    "Unsloth Qwen3 4B GGUF FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    4.718592,
    0.000000001,
    "Unsloth Qwen3 4B GGUF FP16 KV read traffic",
  );
  assert.equal(result.bMem, 7);
  assert.equal(result.best?.batch, 1);
  assertNear(
    result.single.aggregate,
    21.388412947342935,
    0.000000001,
    "Unsloth Qwen3 4B GGUF DGX Spark single-session throughput",
  );
  assertNear(
    result.best?.aggregate ?? 0,
    21.388412947342935,
    0.000000001,
    "Unsloth Qwen3 4B GGUF DGX Spark aggregate throughput",
  );
  assertNear(
    result.dennard,
    257.6176023063605,
    0.000000001,
    "Unsloth Qwen3 4B GGUF DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best?.batch, 4);
  assertNear(
    m5Result.best?.aggregate ?? 0,
    91.23431278592537,
    0.000000001,
    "Unsloth Qwen3 4B GGUF M5 Max aggregate throughput",
  );
  assertNear(
    m5Result.best?.perSession ?? 0,
    22.808578196481342,
    0.000000001,
    "Unsloth Qwen3 4B GGUF M5 Max per-session throughput",
  );
  assertNear(
    m5Result.dennard,
    579.4036916340854,
    0.000000001,
    "Unsloth Qwen3 4B GGUF M5 Max Dennard bound",
  );
  assert.equal(m1UltraResult.status_code, "ok");
  assert.equal(m1UltraResult.best?.batch, 6);
  assertNear(
    m1UltraResult.best?.aggregate ?? 0,
    132.0245287632652,
    0.000000001,
    "Unsloth Qwen3 4B GGUF M1 Ultra aggregate throughput",
  );
  assertNear(
    m1UltraResult.best?.perSession ?? 0,
    22.004088127210867,
    0.000000001,
    "Unsloth Qwen3 4B GGUF M1 Ultra per-session throughput",
  );
}

{
  const repo = "MaziyarPanahi/Qwen3-4B-Instruct-2507-GGUF";
  const item = model(repo);
  const modelProfile = profile(repo);
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  const m1UltraResult = profiled(repo, "apple-mac-studio-m1-ultra-128gb");
  assert.equal(item.hf_downloads, 149675);
  assert.ok(item.tags.includes("region:us"));
  assert.equal(item.architecture.detail, "qwen3 GGUF (Qwen3ForCausalLM)");
  assert.equal(item.architecture.max_context_tokens, 262144);
  assert.equal(item.adapter.weight_precision, "GGUF F16");
  assertNear(
    item.adapter.resident_weight_gb,
    8.051284928,
    0.000000001,
    "MaziyarPanahi Qwen3 4B Instruct 2507 catalog selected F16 resident linked file",
  );
  assertNear(
    item.adapter.active_weight_gb,
    8.045328384,
    0.000000001,
    "MaziyarPanahi Qwen3 4B Instruct 2507 catalog selected F16 swept tensor-span traffic",
  );
  assert.equal(modelProfile.serving.weight_format, "fp16");
  assert.equal(
    modelProfile.serving.runtime_format,
    "llama.cpp-gguf-f16-memory-bound",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    8.051284928,
    0.000000001,
    "MaziyarPanahi Qwen3 4B Instruct 2507 GGUF selected F16 resident linked file",
  );
  assertNear(
    result.single.batchWeight,
    8.045328384,
    0.000000001,
    "MaziyarPanahi Qwen3 4B Instruct 2507 GGUF selected F16 swept tensor-span traffic",
  );
  assertNear(
    modelProfile.architecture.weight_adapter.auxiliary_resident_weight_gb,
    0.005956544,
    0.000000001,
    "MaziyarPanahi Qwen3 4B Instruct 2507 GGUF metadata/header/file overhead",
  );
  assertNear(
    result.alloc,
    14.7456,
    0.000000001,
    "MaziyarPanahi Qwen3 4B Instruct 2507 GGUF FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    4.718592,
    0.000000001,
    "MaziyarPanahi Qwen3 4B Instruct 2507 GGUF FP16 KV read traffic",
  );
  assert.equal(result.bMem, 7);
  assert.equal(result.best?.batch, 1);
  assertNear(
    result.single.aggregate,
    21.388412947342935,
    0.000000001,
    "MaziyarPanahi Qwen3 4B Instruct 2507 GGUF DGX Spark single-session throughput",
  );
  assertNear(
    result.best?.aggregate ?? 0,
    21.388412947342935,
    0.000000001,
    "MaziyarPanahi Qwen3 4B Instruct 2507 GGUF DGX Spark aggregate throughput",
  );
  assertNear(
    result.dennard,
    257.6176037054967,
    0.000000001,
    "MaziyarPanahi Qwen3 4B Instruct 2507 GGUF DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best?.batch, 4);
  assertNear(
    m5Result.best?.aggregate ?? 0,
    91.23431278592537,
    0.000000001,
    "MaziyarPanahi Qwen3 4B Instruct 2507 GGUF M5 Max aggregate throughput",
  );
  assertNear(
    m5Result.best?.perSession ?? 0,
    22.808578196481342,
    0.000000001,
    "MaziyarPanahi Qwen3 4B Instruct 2507 GGUF M5 Max per-session throughput",
  );
  assertNear(
    m5Result.dennard,
    579.4036947808606,
    0.000000001,
    "MaziyarPanahi Qwen3 4B Instruct 2507 GGUF M5 Max Dennard bound",
  );
  assert.equal(m1UltraResult.status_code, "ok");
  assert.equal(m1UltraResult.best?.batch, 6);
  assertNear(
    m1UltraResult.best?.aggregate ?? 0,
    132.0245287632652,
    0.000000001,
    "MaziyarPanahi Qwen3 4B Instruct 2507 GGUF M1 Ultra aggregate throughput",
  );
  assertNear(
    m1UltraResult.best?.perSession ?? 0,
    22.004088127210867,
    0.000000001,
    "MaziyarPanahi Qwen3 4B Instruct 2507 GGUF M1 Ultra per-session throughput",
  );
}

{
  const result = profiled("Qwen/Qwen3-4B-Base", "nvidia-dgx-spark");
  assertNear(
    result.resident,
    8.044936192,
    0.000000001,
    "Qwen3 4B Base resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    8.044936192,
    0.000000001,
    "Qwen3 4B Base swept BF16 decode traffic",
  );
  assertNear(
    result.alloc,
    14.7456,
    0.000000001,
    "Qwen3 4B Base BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    4.718592,
    0.000000001,
    "Qwen3 4B Base BF16 KV read traffic",
  );
}

{
  const result = profiled("Qwen/Qwen3-4B-Instruct-2507", "nvidia-dgx-spark");
  assertNear(
    result.resident,
    8.044936192,
    0.000000001,
    "Qwen3 4B Instruct 2507 resident footprint",
  );
  assertNear(
    result.alloc,
    14.7456,
    0.000000001,
    "Qwen3 4B Instruct 2507 BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    4.718592,
    0.000000001,
    "Qwen3 4B Instruct 2507 BF16 KV read traffic",
  );
}

{
  const modelProfile = profile("Qwen/Qwen3-4B-Thinking-2507");
  const result = profiled("Qwen/Qwen3-4B-Thinking-2507", "nvidia-dgx-spark");
  assert.equal(
    result.status_code,
    "ok",
    "Qwen3 4B Thinking 2507 should fit DGX Spark and satisfy the 20 tok/s floor",
  );
  assertNear(
    result.resident,
    8.044936192,
    0.000000001,
    "Qwen3 4B Thinking 2507 resident footprint",
  );
  assertNear(
    modelProfile.architecture.weight_adapter.embedding_params_b,
    0.38895616,
    0.000000001,
    "Qwen3 4B Thinking 2507 tied embedding parameter count",
  );
  assertNear(
    result.alloc,
    14.7456,
    0.000000001,
    "Qwen3 4B Thinking 2507 BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    4.718592,
    0.000000001,
    "Qwen3 4B Thinking 2507 BF16 KV read traffic",
  );
  assert.equal(result.bMem, 7);
  assert.equal(result.best.batch, 1);
  assertNear(
    result.single.aggregate,
    21.389070160953818,
    0.000000001,
    "Qwen3 4B Thinking 2507 DGX Spark single-session throughput",
  );
  assertNear(
    result.dennard,
    257.6447730999812,
    0.000000001,
    "Qwen3 4B Thinking 2507 DGX Spark Dennard bound",
  );
}

{
  const result = profiled("Qwen/Qwen3-8B", "nvidia-dgx-spark");
  assertNear(
    result.resident,
    16.38147072,
    0.000000001,
    "Qwen3 8B resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    15.136811008,
    0.000000001,
    "Qwen3 8B swept BF16 decode traffic",
  );
  assertNear(result.alloc, 14.7456, 0.000000001, "Qwen3 8B BF16 KV allocation");
  assertNear(
    result.single.readTraffic,
    4.718592,
    0.000000001,
    "Qwen3 8B BF16 KV read traffic",
  );
}

{
  const item = profile("Qwen/Qwen3-8B-Base");
  const result = profiled("Qwen/Qwen3-8B-Base", "nvidia-dgx-spark");
  const m5Result = profiled(
    "Qwen/Qwen3-8B-Base",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(item.architecture.max_context_tokens, 32768);
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    16.38147072,
    0.000000001,
    "Qwen3 8B Base resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    15.136811008,
    0.000000001,
    "Qwen3 8B Base swept BF16 decode traffic",
  );
  assertNear(
    item.architecture.weight_adapter.auxiliary_resident_weight_gb,
    1.244659712,
    0.000000001,
    "Qwen3 8B Base resident input embedding footprint",
  );
  assertNear(
    result.alloc,
    14.7456,
    0.000000001,
    "Qwen3 8B Base BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    4.718592,
    0.000000001,
    "Qwen3 8B Base BF16 KV read traffic",
  );
  assert.equal(result.bMem, 7);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    13.749406138470459,
    0.000000001,
    "Qwen3 8B Base DGX Spark single-session throughput",
  );
  assertNear(
    result.dennard,
    126.73694480535593,
    0.000000001,
    "Qwen3 8B Base DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.bMem, 7);
  assert.equal(m5Result.best.batch, 3);
  assertNear(
    m5Result.best.aggregate,
    62.882803744747356,
    0.000000001,
    "Qwen3 8B Base M5 Max aggregate throughput",
  );
  assertNear(
    m5Result.best.perSession,
    20.960934581582453,
    0.000000001,
    "Qwen3 8B Base M5 Max per-session throughput",
  );
  assertNear(
    m5Result.dennard,
    285.04206633878584,
    0.000000001,
    "Qwen3 8B Base M5 Max Dennard bound",
  );
}

{
  const result = profiled("Qwen/Qwen3-8B-FP8", "nvidia-dgx-spark");
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    9.436551168,
    0.000000001,
    "Qwen3 8B FP8 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    8.191891456,
    0.000000001,
    "Qwen3 8B FP8 swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    1.244659712,
    0.000000001,
    "Qwen3 8B FP8 resident input embedding footprint",
  );
  assertNear(
    result.alloc,
    14.7456,
    0.000000001,
    "Qwen3 8B FP8 BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    4.718592,
    0.000000001,
    "Qwen3 8B FP8 BF16 KV read traffic",
  );
  assert.equal(result.bMem, 7);
  assert.equal(result.best.batch, 1);
  assertNear(
    result.best.aggregate,
    21.145606,
    0.000001,
    "Qwen3 8B FP8 aggregate throughput at b*",
  );
  assertNear(
    result.best.perSession,
    21.145606,
    0.000001,
    "Qwen3 8B FP8 per-session throughput at b*",
  );
  assertNear(result.dennard, 249.87775, 0.000001, "Qwen3 8B FP8 Dennard bound");
}

{
  const item = profile("Qwen/Qwen3-8B-AWQ");
  const result = profiled("Qwen/Qwen3-8B-AWQ", "nvidia-dgx-spark");
  const m5Result = profiled(
    "Qwen/Qwen3-8B-AWQ",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(item.serving.weight_format, "int4");
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    6.098479104,
    0.000000001,
    "Qwen3 8B AWQ resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    4.853819392,
    0.000000001,
    "Qwen3 8B AWQ swept text-decode traffic",
  );
  assertNear(
    item.architecture.weight_adapter.auxiliary_resident_weight_gb,
    1.244659712,
    0.000000001,
    "Qwen3 8B AWQ resident input embedding footprint",
  );
  assertNear(
    result.alloc,
    14.7456,
    0.000000001,
    "Qwen3 8B AWQ FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    4.718592,
    0.000000001,
    "Qwen3 8B AWQ FP16 KV read traffic",
  );
  assert.equal(result.bMem, 7);
  assert.equal(result.best.batch, 1);
  assertNear(
    result.best.aggregate,
    28.519459603,
    0.000001,
    "Qwen3 8B AWQ DGX Spark aggregate throughput at b*",
  );
  assertNear(
    result.dennard,
    434.456309752,
    0.000001,
    "Qwen3 8B AWQ DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 5);
  assertNear(
    m5Result.best.aggregate,
    107.920828495,
    0.000001,
    "Qwen3 8B AWQ M5 Max aggregate throughput at b*",
  );
  assertNear(
    m5Result.best.perSession,
    21.584165699,
    0.000001,
    "Qwen3 8B AWQ M5 Max per-session throughput at b*",
  );
  assertNear(
    m5Result.dennard,
    977.128843178,
    0.000001,
    "Qwen3 8B AWQ M5 Max Dennard bound",
  );
}

{
  const item = profile("MaziyarPanahi/Qwen3-8B-GGUF");
  const result = profiled("MaziyarPanahi/Qwen3-8B-GGUF", "nvidia-dgx-spark");
  const m5Result = profiled(
    "MaziyarPanahi/Qwen3-8B-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  const m1UltraResult = profiled(
    "MaziyarPanahi/Qwen3-8B-GGUF",
    "apple-mac-studio-m1-ultra-128gb",
  );
  assert.equal(item.serving.weight_format, "fp16");
  assert.equal(item.serving.runtime_format, "llama.cpp-gguf-f16-memory-bound");
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    16.388044,
    0.000000001,
    "MaziyarPanahi Qwen3 8B GGUF selected F16 resident linked file",
  );
  assertNear(
    result.single.batchWeight,
    15.137427456,
    0.000000001,
    "MaziyarPanahi Qwen3 8B GGUF selected F16 swept text-decode traffic",
  );
  assertNear(
    item.architecture.weight_adapter.auxiliary_resident_weight_gb,
    1.250616544,
    0.000000001,
    "MaziyarPanahi Qwen3 8B GGUF resident input embedding plus GGUF overhead",
  );
  assertNear(
    result.alloc,
    14.7456,
    0.000000001,
    "MaziyarPanahi Qwen3 8B GGUF FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    4.718592,
    0.000000001,
    "MaziyarPanahi Qwen3 8B GGUF FP16 KV read traffic",
  );
  assert.equal(result.bMem, 7);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    13.748979275778566,
    0.000000001,
    "MaziyarPanahi Qwen3 8B GGUF DGX Spark single-session throughput",
  );
  assertNear(
    result.dennard,
    126.72374411947092,
    0.000000001,
    "MaziyarPanahi Qwen3 8B GGUF DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.bMem, 7);
  assert.equal(m5Result.best.batch, 3);
  assertNear(
    m5Result.best.aggregate,
    62.88148043510452,
    0.000000001,
    "MaziyarPanahi Qwen3 8B GGUF M5 Max aggregate throughput",
  );
  assertNear(
    m5Result.best.perSession,
    20.960493478368175,
    0.000000001,
    "MaziyarPanahi Qwen3 8B GGUF M5 Max per-session throughput",
  );
  assertNear(
    m5Result.dennard,
    285.0123768840848,
    0.000000001,
    "MaziyarPanahi Qwen3 8B GGUF M5 Max Dennard bound",
  );
  assert.equal(m1UltraResult.status_code, "ok");
  assert.equal(m1UltraResult.bMem, 7);
  assert.equal(m1UltraResult.best.batch, 5);
  assertNear(
    m1UltraResult.best.aggregate,
    103.27807860286025,
    0.000000001,
    "MaziyarPanahi Qwen3 8B GGUF M1 Ultra aggregate throughput",
  );
  assertNear(
    m1UltraResult.best.perSession,
    20.65561572057205,
    0.000000001,
    "MaziyarPanahi Qwen3 8B GGUF M1 Ultra per-session throughput",
  );
}

{
  const item = profile("unsloth/Qwen3-8B-GGUF");
  const modelRow = model("unsloth/Qwen3-8B-GGUF");
  const result = profiled("unsloth/Qwen3-8B-GGUF", "nvidia-dgx-spark");
  const m5Result = profiled(
    "unsloth/Qwen3-8B-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  const m1UltraResult = profiled(
    "unsloth/Qwen3-8B-GGUF",
    "apple-mac-studio-m1-ultra-128gb",
  );
  assert.equal(item.status, "audited");
  assert.equal(modelRow.name, "Qwen3-8B-GGUF GGUF BF16");
  assert.equal(modelRow.hf_downloads, 110310);
  assert.ok(modelRow.tags.includes("region:us"));
  assert.equal(modelRow.architecture.total_params_b, 8.19073536);
  assert.equal(modelRow.architecture.active_params_b, 7.568405504);
  assert.equal(
    modelRow.adapter.weight_precision,
    "GGUF BF16 selected artifact",
  );
  assertNear(
    modelRow.adapter.resident_weight_gb,
    16.388044384,
    0.000000001,
    "Unsloth Qwen3 8B GGUF catalog selected BF16 resident linked file",
  );
  assertNear(
    modelRow.adapter.active_weight_gb,
    15.137427456,
    0.000000001,
    "Unsloth Qwen3 8B GGUF catalog ordinary swept text-decode traffic",
  );
  assert.equal(item.serving.weight_format, "bf16");
  assert.equal(item.serving.runtime_format, "llama.cpp-gguf-bf16-memory-bound");
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    16.388044384,
    0.000000001,
    "Unsloth Qwen3 8B GGUF selected BF16 resident linked file",
  );
  assertNear(
    result.single.batchWeight,
    15.137427456,
    0.000000001,
    "Unsloth Qwen3 8B GGUF selected BF16 swept text-decode traffic",
  );
  assertNear(
    item.architecture.weight_adapter.auxiliary_resident_weight_gb,
    1.250616928,
    0.000000001,
    "Unsloth Qwen3 8B GGUF resident input embedding plus GGUF overhead",
  );
  assertNear(
    result.alloc,
    14.7456,
    0.000000001,
    "Unsloth Qwen3 8B GGUF FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    4.718592,
    0.000000001,
    "Unsloth Qwen3 8B GGUF FP16 KV read traffic",
  );
  assert.equal(result.bMem, 7);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    13.748979275778566,
    0.000000001,
    "Unsloth Qwen3 8B GGUF DGX Spark single-session throughput",
  );
  assertNear(
    result.dennard,
    126.72374364981552,
    0.000000001,
    "Unsloth Qwen3 8B GGUF DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.bMem, 7);
  assert.equal(m5Result.best.batch, 3);
  assertNear(
    m5Result.best.aggregate,
    62.88148043510452,
    0.000000001,
    "Unsloth Qwen3 8B GGUF M5 Max aggregate throughput",
  );
  assertNear(
    m5Result.best.perSession,
    20.960493478368175,
    0.000000001,
    "Unsloth Qwen3 8B GGUF M5 Max per-session throughput",
  );
  assertNear(
    m5Result.dennard,
    285.0123758277902,
    0.000000001,
    "Unsloth Qwen3 8B GGUF M5 Max Dennard bound",
  );
  assert.equal(m1UltraResult.status_code, "ok");
  assert.equal(m1UltraResult.bMem, 7);
  assert.equal(m1UltraResult.best.batch, 5);
  assertNear(
    m1UltraResult.best.aggregate,
    103.27807860286025,
    0.000000001,
    "Unsloth Qwen3 8B GGUF M1 Ultra aggregate throughput",
  );
  assertNear(
    m1UltraResult.best.perSession,
    20.65561572057205,
    0.000000001,
    "Unsloth Qwen3 8B GGUF M1 Ultra per-session throughput",
  );
}

{
  const result = profiled(
    "deepseek-ai/DeepSeek-R1-0528-Qwen3-8B",
    "nvidia-dgx-spark",
  );
  assertNear(
    result.resident,
    16.38147072,
    0.000000001,
    "DeepSeek R1 Qwen3 8B resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    15.136811008,
    0.000000001,
    "DeepSeek R1 Qwen3 8B swept BF16 decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    1.244659712,
    0.000000001,
    "DeepSeek R1 Qwen3 8B resident input embedding footprint",
  );
  assertNear(
    result.alloc,
    14.7456,
    0.000000001,
    "DeepSeek R1 Qwen3 8B BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    4.718592,
    0.000000001,
    "DeepSeek R1 Qwen3 8B BF16 KV read traffic",
  );
}

{
  const modelProfile = profile("MaziyarPanahi/DeepSeek-R1-0528-Qwen3-8B-GGUF");
  const modelRow = model("MaziyarPanahi/DeepSeek-R1-0528-Qwen3-8B-GGUF");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const kvAdapter = modelProfile.architecture.kv_adapter;
  const dgxResult = profiled(
    "MaziyarPanahi/DeepSeek-R1-0528-Qwen3-8B-GGUF",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "MaziyarPanahi/DeepSeek-R1-0528-Qwen3-8B-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(modelProfile.status, "audited");
  assert.equal(modelRow.name, "DeepSeek-R1-0528-Qwen3-8B-GGUF GGUF Q2_K");
  assert.equal(modelRow.license, "mit");
  assert.equal(modelRow.hf_downloads, 124510);
  assert.equal(modelRow.architecture.detail, "qwen3 GGUF (Qwen3ForCausalLM)");
  assert.equal(modelRow.architecture.total_params_b, 8.19073536);
  assert.equal(modelRow.architecture.active_params_b, 7.568405504);
  assert.equal(modelRow.architecture.layers, 36);
  assert.equal(modelRow.architecture.attention_heads, 32);
  assert.equal(modelRow.architecture.kv_heads, 8);
  assert.equal(modelRow.architecture.head_dim, 128);
  assert.equal(modelRow.architecture.max_context_tokens, 131072);
  assert.equal(modelRow.adapter.weight_precision, "GGUF Q2_K");
  assert.equal(modelRow.adapter.resident_weight_gb, 3.281731712);
  assert.equal(modelRow.adapter.active_weight_gb, 3.071574016);
  assert.equal(modelRow.adapter.kv_alloc_gb_per_1k_tokens, 0.147456);
  assert.equal(weightAdapter.kind, "dense_resident_swept");
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.210157696,
    0.000000001,
    "MaziyarPanahi DeepSeek R1 Qwen3 8B GGUF input embedding plus metadata/header resident overhead",
  );
  assert.equal(kvAdapter.kind, "full_context");
  assert.equal(kvAdapter.layers, 36);
  assert.equal(kvAdapter.kv_heads, 8);
  assert.equal(kvAdapter.head_dim, 128);
  assert.equal(dgxResult.status_code, "ok");
  assertNear(
    dgxResult.resident,
    3.281731712,
    0.000000001,
    "MaziyarPanahi DeepSeek R1 Qwen3 8B GGUF selected Q2_K resident footprint",
  );
  assertNear(
    dgxResult.single.batchWeight,
    3.071574016,
    0.000000001,
    "MaziyarPanahi DeepSeek R1 Qwen3 8B GGUF swept Q2_K text traffic",
  );
  assertNear(
    dgxResult.alloc,
    14.7456,
    0.000000001,
    "MaziyarPanahi DeepSeek R1 Qwen3 8B GGUF FP16 KV allocation",
  );
  assertNear(
    dgxResult.single.readTraffic,
    4.718592,
    0.000000001,
    "MaziyarPanahi DeepSeek R1 Qwen3 8B GGUF FP16 KV read traffic",
  );
  assert.equal(dgxResult.bMem, 7);
  assert.equal(dgxResult.best?.batch, 2);
  assertNear(
    dgxResult.best?.aggregate ?? 0,
    43.649417416310186,
    0.000000001,
    "MaziyarPanahi DeepSeek R1 Qwen3 8B GGUF DGX Spark aggregate throughput",
  );
  assertNear(
    dgxResult.dennard,
    703.5225926101233,
    0.000000001,
    "MaziyarPanahi DeepSeek R1 Qwen3 8B GGUF DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best?.batch, 5);
  assertNear(
    m5Result.best?.aggregate ?? 0,
    115.13420778918741,
    0.000000001,
    "MaziyarPanahi DeepSeek R1 Qwen3 8B GGUF M5 Max aggregate throughput",
  );
  assertNear(
    m5Result.best?.perSession ?? 0,
    23.026841557837482,
    0.000000001,
    "MaziyarPanahi DeepSeek R1 Qwen3 8B GGUF M5 Max per-session throughput",
  );
}

{
  const result = profiled("Qwen/Qwen3-14B", "nvidia-dgx-spark");
  assertNear(
    result.resident,
    29.5366144,
    0.000000001,
    "Qwen3 14B resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    27.98078976,
    0.000000001,
    "Qwen3 14B swept BF16 text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    1.55582464,
    0.000000001,
    "Qwen3 14B resident input embedding footprint",
  );
  assertNear(result.alloc, 16.384, 0.000000001, "Qwen3 14B BF16 KV allocation");
  assertNear(
    result.single.readTraffic,
    5.24288,
    0.000000001,
    "Qwen3 14B BF16 KV read traffic",
  );
}

{
  const result = profiled("Qwen/Qwen3-14B-FP8", "nvidia-dgx-spark");
  const m5Result = profiled(
    "Qwen/Qwen3-14B-FP8",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    16.3261696,
    0.000000001,
    "Qwen3 14B FP8 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    14.77034496,
    0.000000001,
    "Qwen3 14B FP8 swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    1.55582464,
    0.000000001,
    "Qwen3 14B FP8 resident input embedding footprint",
  );
  assertNear(
    result.alloc,
    16.384,
    0.000000001,
    "Qwen3 14B FP8 BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    5.24288,
    0.000000001,
    "Qwen3 14B FP8 BF16 KV read traffic",
  );
  assert.equal(result.bMem, 6);
  assertNear(
    result.single.aggregate,
    13.64097992930371,
    0.000000001,
    "Qwen3 14B FP8 DGX single-session throughput",
  );
  assertNear(
    result.dennard,
    116.9556518900355,
    0.000000001,
    "Qwen3 14B FP8 DGX Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 3);
  assertNear(
    m5Result.best.aggregate,
    60.3954525836128,
    0.000000001,
    "Qwen3 14B FP8 M5 Max aggregate throughput",
  );
  assertNear(
    m5Result.best.perSession,
    20.131817527870933,
    0.000000001,
    "Qwen3 14B FP8 M5 Max per-session throughput",
  );
}

{
  const result = profiled("Qwen/Qwen3-14B-AWQ", "nvidia-dgx-spark");
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    9.976576,
    0.000000001,
    "Qwen3 14B AWQ stored resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    8.42075136,
    0.000000001,
    "Qwen3 14B AWQ stored swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    1.55582464,
    0.000000001,
    "Qwen3 14B AWQ resident input embedding footprint",
  );
  assertNear(
    result.alloc,
    16.384,
    0.000000001,
    "Qwen3 14B AWQ FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    5.24288,
    0.000000001,
    "Qwen3 14B AWQ FP16 KV read traffic",
  );
  assert.equal(result.bMem, 6);
  assertNear(
    result.single.aggregate,
    19.980047236871588,
    0.000000001,
    "Qwen3 14B AWQ single-session throughput",
  );
}

{
  const repo = "JunHowie/Qwen3-14B-GPTQ-Int4";
  const item = profile(repo);
  const catalogRow = model(repo);
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  const m1UltraResult = profiled(repo, "apple-mac-studio-m1-ultra-128gb");
  assert.equal(item.serving.weight_format, "int4");
  assert.equal(catalogRow.hf_downloads, 184023);
  assert.ok(catalogRow.tags.includes("region:us"));
  assert.equal(catalogRow.adapter.weight_precision, "GPTQ Int4/BF16/F16");
  assertNear(
    item.architecture.weight_adapter.resident_params_b,
    14.7683072,
    0.000000001,
    "JunHowie Qwen3 14B GPTQ Int4 logical resident parameters",
  );
  assertNear(
    item.architecture.weight_adapter.swept_params_b,
    13.99039488,
    0.000000001,
    "JunHowie Qwen3 14B GPTQ Int4 logical swept text parameters",
  );
  assertNear(
    result.resident,
    9.98427648,
    0.000000001,
    "JunHowie Qwen3 14B GPTQ Int4 resident tensor payload",
  );
  assertNear(
    result.single.batchWeight,
    8.42845184,
    0.000000001,
    "JunHowie Qwen3 14B GPTQ Int4 swept text-decode traffic",
  );
  assertNear(
    item.architecture.weight_adapter.auxiliary_resident_weight_gb,
    1.55582464,
    0.000000001,
    "JunHowie Qwen3 14B GPTQ Int4 resident-only input embedding",
  );
  assertNear(
    result.alloc,
    16.384,
    0.000000001,
    "JunHowie Qwen3 14B GPTQ Int4 FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    5.24288,
    0.000000001,
    "JunHowie Qwen3 14B GPTQ Int4 FP16 KV read traffic",
  );
  assert.equal(result.status_code, "no_floor");
  assert.equal(result.bMem, 6);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    19.968793325698396,
    0.000000001,
    "JunHowie Qwen3 14B GPTQ Int4 DGX single-session tok/s",
  );
  assertNear(
    result.dennard,
    217.49519029997802,
    0.000000001,
    "JunHowie Qwen3 14B GPTQ Int4 DGX Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 4);
  assertNear(
    m5Result.best.aggregate,
    83.53749498013124,
    0.000000001,
    "JunHowie Qwen3 14B GPTQ Int4 M5 Max aggregate",
  );
  assertNear(
    m5Result.best.perSession,
    20.88437374503281,
    0.000000001,
    "JunHowie Qwen3 14B GPTQ Int4 M5 Max per-session",
  );
  assert.equal(m1UltraResult.status_code, "ok");
  assert.equal(m1UltraResult.best.batch, 6);
  assertNear(
    m1UltraResult.best.aggregate,
    120.34378657648818,
    0.000000001,
    "JunHowie Qwen3 14B GPTQ Int4 M1 Ultra aggregate",
  );
  assertNear(
    m1UltraResult.best.perSession,
    20.057297762748032,
    0.000000001,
    "JunHowie Qwen3 14B GPTQ Int4 M1 Ultra per-session",
  );
}

{
  const repo = "MaziyarPanahi/Llama-3-8B-Instruct-64k-GGUF";
  const item = profile(repo);
  const modelRow = model(repo);
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  const m1UltraResult = profiled(repo, "apple-mac-studio-m1-ultra-128gb");
  assert.equal(item.status, "audited");
  assert.equal(item.serving.weight_format, "fp16");
  assert.equal(item.base_model_proof.config_compatible, false);
  assert.equal(modelRow.name, "Llama-3-8B-Instruct-64k-GGUF FP16");
  assert.equal(modelRow.license, "llama3");
  assert.equal(modelRow.hf_downloads, 113638);
  assert.ok(modelRow.tags.includes("region:us"));
  assert.equal(modelRow.architecture.detail, "llama GGUF / LlamaForCausalLM");
  assert.equal(modelRow.architecture.layers, 32);
  assert.equal(modelRow.architecture.attention_heads, 32);
  assert.equal(modelRow.architecture.kv_heads, 8);
  assert.equal(modelRow.architecture.head_dim, 128);
  assert.equal(modelRow.architecture.max_context_tokens, 64000);
  assert.equal(modelRow.adapter.weight_precision, "GGUF FP16/F32");
  assert.equal(item.architecture.kv_adapter.kind, "full_context");
  assert.equal(item.architecture.kv_adapter.layers, 32);
  assert.equal(item.architecture.kv_adapter.kv_heads, 8);
  assert.equal(item.architecture.kv_adapter.head_dim, 128);
  assertNear(
    item.architecture.weight_adapter.resident_params_b,
    8.030261248,
    0.000000001,
    "Llama 3 8B Instruct 64k GGUF logical resident parameters",
  );
  assertNear(
    item.architecture.weight_adapter.swept_params_b,
    7.504924672,
    0.000000001,
    "Llama 3 8B Instruct 64k GGUF logical swept text parameters",
  );
  assertNear(
    result.resident,
    16.068890848,
    0.000000001,
    "Llama 3 8B Instruct 64k GGUF FP16 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    15.010381824,
    0.000000001,
    "Llama 3 8B Instruct 64k GGUF FP16 swept text-decode traffic",
  );
  assertNear(
    item.architecture.weight_adapter.auxiliary_resident_weight_gb,
    1.058509024,
    0.000000001,
    "Llama 3 8B Instruct 64k GGUF FP16 resident input/header footprint",
  );
  assertNear(
    result.alloc,
    13.1072,
    0.000000001,
    "Llama 3 8B Instruct 64k GGUF FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    4.194304,
    0.000000001,
    "Llama 3 8B Instruct 64k GGUF FP16 KV read traffic",
  );
  assert.equal(result.status_code, "no_floor");
  assert.equal(result.bMem, 7);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    14.215280713357638,
    0.000000001,
    "Llama 3 8B Instruct 64k GGUF FP16 DGX single-session tok/s",
  );
  assertNear(
    result.dennard,
    144.2137078917169,
    0.000000001,
    "Llama 3 8B Instruct 64k GGUF FP16 DGX Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 3);
  assertNear(
    m5Result.best.aggregate,
    66.7553504756968,
    0.000000001,
    "Llama 3 8B Instruct 64k GGUF FP16 M5 Max aggregate",
  );
  assertNear(
    m5Result.best.perSession,
    22.251783491898934,
    0.000000001,
    "Llama 3 8B Instruct 64k GGUF FP16 M5 Max per-session",
  );
  assert.equal(m1UltraResult.status_code, "ok");
  assert.equal(m1UltraResult.best.batch, 5);
  assertNear(
    m1UltraResult.best.aggregate,
    111.16699777475331,
    0.000000001,
    "Llama 3 8B Instruct 64k GGUF FP16 M1 Ultra aggregate",
  );
  assertNear(
    m1UltraResult.best.perSession,
    22.233399554950662,
    0.000000001,
    "Llama 3 8B Instruct 64k GGUF FP16 M1 Ultra per-session",
  );
}

{
  const item = profile("MaziyarPanahi/Qwen3-14B-GGUF");
  const result = profiled("MaziyarPanahi/Qwen3-14B-GGUF", "nvidia-dgx-spark");
  const m5Result = profiled(
    "MaziyarPanahi/Qwen3-14B-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  const m1UltraResult = profiled(
    "MaziyarPanahi/Qwen3-14B-GGUF",
    "apple-mac-studio-m1-ultra-128gb",
  );
  assert.equal(item.serving.weight_format, "fp16");
  assert.equal(result.status_code, "no_floor");
  assertNear(
    item.architecture.weight_adapter.resident_params_b,
    14.7683072,
    0.000000001,
    "MaziyarPanahi Qwen3 14B GGUF logical resident parameters",
  );
  assertNear(
    item.architecture.weight_adapter.swept_params_b,
    13.99039488,
    0.000000001,
    "MaziyarPanahi Qwen3 14B GGUF logical swept text parameters",
  );
  assertNear(
    result.resident,
    29.543423744,
    0.000000001,
    "MaziyarPanahi Qwen3 14B GGUF resident linked file footprint",
  );
  assertNear(
    result.single.batchWeight,
    27.98163968,
    0.000000001,
    "MaziyarPanahi Qwen3 14B GGUF swept text-decode traffic",
  );
  assertNear(
    item.architecture.weight_adapter.auxiliary_resident_weight_gb,
    1.561784064,
    0.000000001,
    "MaziyarPanahi Qwen3 14B GGUF resident input embedding plus GGUF overhead",
  );
  assertNear(
    result.alloc,
    16.384,
    0.000000001,
    "MaziyarPanahi Qwen3 14B GGUF FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    5.24288,
    0.000000001,
    "MaziyarPanahi Qwen3 14B GGUF FP16 KV read traffic",
  );
  assert.equal(result.bMem, 5);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    8.216823076131224,
    0.000000001,
    "MaziyarPanahi Qwen3 14B GGUF DGX single-session tok/s",
  );
  assertNear(
    result.dennard,
    53.865375751833895,
    0.000000001,
    "MaziyarPanahi Qwen3 14B GGUF DGX Dennard bound",
  );
  assert.equal(m5Result.status_code, "no_floor");
  assert.equal(m5Result.best, null);
  assertNear(
    m5Result.single.aggregate,
    18.480327358038725,
    0.000000001,
    "MaziyarPanahi Qwen3 14B GGUF M5 single-session tok/s",
  );
  assert.equal(m1UltraResult.status_code, "ok");
  assert.equal(m1UltraResult.best.batch, 2);
  assertNear(
    m1UltraResult.best.aggregate,
    41.593661472050925,
    0.000000001,
    "MaziyarPanahi Qwen3 14B GGUF M1 Ultra aggregate",
  );
  assertNear(
    m1UltraResult.best.perSession,
    20.796830736025463,
    0.000000001,
    "MaziyarPanahi Qwen3 14B GGUF M1 Ultra per-session",
  );
}

{
  const result = profiled("cyankiwi/Hermes-4-14B-AWQ-4bit", "nvidia-dgx-spark");
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    10.54428608,
    0.000000001,
    "Hermes 4 14B AWQ compressed-tensors resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    8.98846144,
    0.000000001,
    "Hermes 4 14B AWQ swept stored text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    1.55582464,
    0.000000001,
    "Hermes 4 14B AWQ resident input embedding footprint",
  );
  assertNear(
    result.alloc,
    16.384,
    0.000000001,
    "Hermes 4 14B AWQ BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    5.24288,
    0.000000001,
    "Hermes 4 14B AWQ BF16 KV read traffic",
  );
  assert.equal(result.bMem, 6);
  assertNear(
    result.single.aggregate,
    19.18301244833319,
    0.000000001,
    "Hermes 4 14B AWQ DGX single-session tok/s",
  );
  assertNear(
    result.dennard,
    202.90641890171614,
    0.000000001,
    "Hermes 4 14B AWQ DGX Dennard bound",
  );
}

{
  const result = profiled("Qwen/Qwen3-32B", "nvidia-dgx-spark");
  assertNear(
    result.resident,
    65.524246528,
    0.000000001,
    "Qwen3 32B resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    63.968421888,
    0.000000001,
    "Qwen3 32B swept BF16 decode traffic",
  );
  assertNear(
    result.alloc,
    26.2144,
    0.000000001,
    "Qwen3 32B BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    8.388608,
    0.000000001,
    "Qwen3 32B BF16 KV read traffic",
  );
}

{
  const repo = "Qwen/Qwen3-32B-FP8";
  const row = model(repo);
  const item = profile(repo);
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  const m1Result = profiled(repo, "apple-mac-studio-m1-ultra-128gb");

  assert.equal(row.hf_downloads, 101235);
  assert.ok(row.tags.includes("region:us"));
  assert.equal(row.adapter.weight_precision, "FP8");
  assertNear(
    row.architecture.total_params_b,
    32.764027904,
    0.000000001,
    "Qwen3 32B FP8 catalog total params",
  );
  assertNear(
    row.architecture.active_params_b,
    31.986115584,
    0.000000001,
    "Qwen3 32B FP8 catalog swept params",
  );
  assert.equal(item.status, "audited");
  assert.equal(item.base_model_proof.config_compatible, true);
  assert.equal(
    item.serving.runtime_format,
    "transformers-fp8-bf16-memory-bound",
  );
  assert.equal(item.architecture.kv_adapter.kind, "full_context");
  assert.equal(item.architecture.kv_adapter.layers, 64);
  assert.equal(item.architecture.kv_adapter.kv_heads, 8);
  assert.equal(item.architecture.kv_adapter.head_dim, 128);
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    34.322434048,
    0.000000001,
    "Qwen3 32B FP8 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    32.766609408,
    0.000000001,
    "Qwen3 32B FP8 swept decode traffic",
  );
  assertNear(
    item.architecture.weight_adapter.auxiliary_resident_weight_gb,
    1.55582464,
    0.000000001,
    "Qwen3 32B FP8 resident input embedding footprint",
  );
  assertNear(
    result.alloc,
    26.2144,
    0.000000001,
    "Qwen3 32B FP8 BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    8.388608,
    0.000000001,
    "Qwen3 32B FP8 BF16 KV read traffic",
  );
  assert.equal(result.bMem, 3);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    6.633423832841486,
    0.000000001,
    "Qwen3 32B FP8 DGX single-session tok/s",
  );
  assertNear(
    result.dennard,
    27.23067086086056,
    0.000000001,
    "Qwen3 32B FP8 DGX Dennard bound",
  );
  assert.equal(m5Result.status_code, "no_floor");
  assert.equal(m5Result.bMem, 3);
  assertNear(
    m5Result.single.aggregate,
    14.919129059943856,
    0.000000001,
    "Qwen3 32B FP8 M5 Max single-session tok/s",
  );
  assert.equal(m1Result.status_code, "no_floor");
  assert.equal(m1Result.bMem, 3);
  assertNear(
    m1Result.single.aggregate,
    19.43860463836333,
    0.000000001,
    "Qwen3 32B FP8 M1 Ultra single-session tok/s",
  );
}

{
  const item = profile("Qwen/Qwen3-32B-AWQ");
  const result = profiled("Qwen/Qwen3-32B-AWQ", "nvidia-dgx-spark");
  const m5Result = profiled(
    "Qwen/Qwen3-32B-AWQ",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(item.serving.weight_format, "int4");
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    19.325298688,
    0.000000001,
    "Qwen3 32B AWQ resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    17.769474048,
    0.000000001,
    "Qwen3 32B AWQ swept decode traffic",
  );
  assertNear(
    item.architecture.weight_adapter.auxiliary_resident_weight_gb,
    1.55582464,
    0.000000001,
    "Qwen3 32B AWQ resident input embedding footprint",
  );
  assertNear(
    result.alloc,
    26.2144,
    0.000000001,
    "Qwen3 32B AWQ FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    8.388608,
    0.000000001,
    "Qwen3 32B AWQ FP16 KV read traffic",
  );
  assert.equal(result.bMem, 3);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    10.43654498441613,
    0.000000001,
    "Qwen3 32B AWQ DGX single-session tok/s",
  );
  assertNear(
    result.dennard,
    59.00224021802882,
    0.000000001,
    "Qwen3 32B AWQ DGX Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 1);
  assertNear(
    m5Result.best.aggregate,
    23.47266893930954,
    0.000000001,
    "Qwen3 32B AWQ M5 aggregate",
  );
}

{
  const item = profile("MaziyarPanahi/Qwen3-32B-GGUF");
  const result = profiled("MaziyarPanahi/Qwen3-32B-GGUF", "nvidia-dgx-spark");
  const m5Result = profiled(
    "MaziyarPanahi/Qwen3-32B-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  const m1UltraResult = profiled(
    "MaziyarPanahi/Qwen3-32B-GGUF",
    "apple-mac-studio-m1-ultra-128gb",
  );
  assert.equal(item.serving.weight_format, "gguf_quantized");
  assert.equal(item.serving.runtime_format, "llama.cpp-gguf-q2-k-memory-bound");
  assert.equal(result.status_code, "no_floor");
  assertNear(
    item.architecture.weight_adapter.resident_params_b,
    32.762123264,
    0.000000001,
    "MaziyarPanahi Qwen3 32B GGUF logical resident parameters",
  );
  assertNear(
    item.architecture.weight_adapter.swept_params_b,
    31.984210944,
    0.000000001,
    "MaziyarPanahi Qwen3 32B GGUF logical swept text parameters",
  );
  assertNear(
    result.resident,
    12.344651584,
    0.000000001,
    "MaziyarPanahi Qwen3 32B GGUF selected Q2_K resident linked file",
  );
  assertNear(
    result.single.batchWeight,
    12.083424256,
    0.000000001,
    "MaziyarPanahi Qwen3 32B GGUF selected Q2_K swept text-decode traffic",
  );
  assertNear(
    item.architecture.weight_adapter.auxiliary_resident_weight_gb,
    0.261227328,
    0.000000001,
    "MaziyarPanahi Qwen3 32B GGUF resident input embedding plus GGUF overhead",
  );
  assertNear(
    result.alloc,
    26.2144,
    0.000000001,
    "MaziyarPanahi Qwen3 32B GGUF FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    8.388608,
    0.000000001,
    "MaziyarPanahi Qwen3 32B GGUF FP16 KV read traffic",
  );
  assert.equal(result.bMem, 4);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    13.335266210319126,
    0.000000001,
    "MaziyarPanahi Qwen3 32B GGUF DGX Spark single-session throughput",
  );
  assertNear(
    result.dennard,
    92.78297888678482,
    0.000000001,
    "MaziyarPanahi Qwen3 32B GGUF DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.bMem, 4);
  assert.equal(m5Result.best.batch, 2);
  assertNear(
    m5Result.best.aggregate,
    42.54929859862358,
    0.000000001,
    "MaziyarPanahi Qwen3 32B GGUF M5 Max aggregate throughput",
  );
  assertNear(
    m5Result.best.perSession,
    21.27464929931179,
    0.000000001,
    "MaziyarPanahi Qwen3 32B GGUF M5 Max per-session throughput",
  );
  assertNear(
    m5Result.dennard,
    208.6767363973842,
    0.000000001,
    "MaziyarPanahi Qwen3 32B GGUF M5 Max Dennard bound",
  );
  assert.equal(m1UltraResult.status_code, "ok");
  assert.equal(m1UltraResult.bMem, 4);
  assert.equal(m1UltraResult.best.batch, 3);
  assertNear(
    m1UltraResult.best.aggregate,
    64.43083048295921,
    0.000000001,
    "MaziyarPanahi Qwen3 32B GGUF M1 Ultra aggregate throughput",
  );
  assertNear(
    m1UltraResult.best.perSession,
    21.476943494319737,
    0.000000001,
    "MaziyarPanahi Qwen3 32B GGUF M1 Ultra per-session throughput",
  );
}

{
  const item = profile("nvidia/Qwen3-8B-NVFP4");
  const row = model("nvidia/Qwen3-8B-NVFP4");
  const result = profiled("nvidia/Qwen3-8B-NVFP4", "nvidia-dgx-spark");
  const m5Result = profiled(
    "nvidia/Qwen3-8B-NVFP4",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  const m1UltraResult = profiled(
    "nvidia/Qwen3-8B-NVFP4",
    "apple-mac-studio-m1-ultra-128gb",
  );
  assert.equal(item.serving.weight_format, "nvfp4");
  assert.equal(item.serving.kv_store_format, "fp8");
  assert.equal(row.hf_downloads, 150764);
  assert.ok(row.tags.includes("region:us"));
  assert.equal(result.status_code, "ok");
  assertNear(
    row.architecture.total_params_b,
    8.19073536,
    0.000000001,
    "NVIDIA Qwen3 8B NVFP4 logical total parameters",
  );
  assertNear(
    row.architecture.active_params_b,
    7.568405504,
    0.000000001,
    "NVIDIA Qwen3 8B NVFP4 logical swept text parameters",
  );
  assertNear(
    item.architecture.weight_adapter.resident_params_b,
    4.717851648,
    0.000000001,
    "NVIDIA Qwen3 8B NVFP4 storage-accounting resident parameters",
  );
  assertNear(
    item.architecture.weight_adapter.swept_params_b,
    4.095521792,
    0.000000001,
    "NVIDIA Qwen3 8B NVFP4 storage-accounting swept text parameters",
  );
  assertNear(
    result.resident,
    6.396932352,
    0.000000001,
    "NVIDIA Qwen3 8B NVFP4 resident tensor payload",
  );
  assertNear(
    result.single.batchWeight,
    5.15227264,
    0.000000001,
    "NVIDIA Qwen3 8B NVFP4 swept text-decode traffic",
  );
  assertNear(
    item.architecture.weight_adapter.auxiliary_resident_weight_gb,
    1.244659712,
    0.000000001,
    "NVIDIA Qwen3 8B NVFP4 resident input embedding footprint",
  );
  assertNear(
    result.alloc,
    7.3728,
    0.000000001,
    "NVIDIA Qwen3 8B NVFP4 FP8 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    2.359296,
    0.000000001,
    "NVIDIA Qwen3 8B NVFP4 FP8 KV read traffic",
  );
  assert.equal(result.bMem, 15);
  assert.equal(result.best.batch, 3);
  assertNear(
    result.single.aggregate,
    36.343940005585836,
    0.000000001,
    "NVIDIA Qwen3 8B NVFP4 DGX single-session tok/s",
  );
  assertNear(
    result.best.aggregate,
    66.9655962916281,
    0.000000001,
    "NVIDIA Qwen3 8B NVFP4 DGX aggregate",
  );
  assertNear(
    result.best.perSession,
    22.3218654305427,
    0.000000001,
    "NVIDIA Qwen3 8B NVFP4 DGX per-session",
  );
  assertNear(
    result.dennard,
    816.434628193026,
    0.000000001,
    "NVIDIA Qwen3 8B NVFP4 DGX Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 10);
  assertNear(
    m5Result.best.aggregate,
    213.60063690895214,
    0.000000001,
    "NVIDIA Qwen3 8B NVFP4 M5 aggregate",
  );
  assertNear(
    m5Result.best.perSession,
    21.360063690895213,
    0.000000001,
    "NVIDIA Qwen3 8B NVFP4 M5 per-session",
  );
  assert.equal(m1UltraResult.status_code, "ok");
  assert.equal(m1UltraResult.best.batch, 14);
  assertNear(
    m1UltraResult.best.aggregate,
    293.3287357266656,
    0.000000001,
    "NVIDIA Qwen3 8B NVFP4 M1 Ultra aggregate",
  );
  assertNear(
    m1UltraResult.best.perSession,
    20.95205255190469,
    0.000000001,
    "NVIDIA Qwen3 8B NVFP4 M1 Ultra per-session",
  );
}

{
  const item = profile("nvidia/Qwen3-32B-NVFP4");
  const result = profiled("nvidia/Qwen3-32B-NVFP4", "nvidia-dgx-spark");
  const m5Result = profiled(
    "nvidia/Qwen3-32B-NVFP4",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  const m1UltraResult = profiled(
    "nvidia/Qwen3-32B-NVFP4",
    "apple-mac-studio-m1-ultra-128gb",
  );
  assert.equal(item.serving.weight_format, "nvfp4");
  assert.equal(item.serving.kv_store_format, "fp8");
  assert.equal(result.status_code, "no_floor");
  assertNear(
    item.architecture.weight_adapter.resident_params_b,
    17.159312384,
    0.000000001,
    "NVIDIA Qwen3 32B NVFP4 storage-accounting resident parameters",
  );
  assertNear(
    item.architecture.weight_adapter.swept_params_b,
    16.381400064,
    0.000000001,
    "NVIDIA Qwen3 32B NVFP4 storage-accounting swept text parameters",
  );
  assertNear(
    result.resident,
    20.666169344,
    0.000000001,
    "NVIDIA Qwen3 32B NVFP4 resident tensor payload",
  );
  assertNear(
    result.single.batchWeight,
    19.110344704,
    0.000000001,
    "NVIDIA Qwen3 32B NVFP4 swept text-decode traffic",
  );
  assertNear(
    item.architecture.weight_adapter.auxiliary_resident_weight_gb,
    1.55582464,
    0.000000001,
    "NVIDIA Qwen3 32B NVFP4 resident input embedding footprint",
  );
  assertNear(
    result.alloc,
    13.1072,
    0.000000001,
    "NVIDIA Qwen3 32B NVFP4 FP8 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    4.194304,
    0.000000001,
    "NVIDIA Qwen3 32B NVFP4 FP8 KV read traffic",
  );
  assert.equal(result.bMem, 7);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    11.71440099644765,
    0.000000001,
    "NVIDIA Qwen3 32B NVFP4 DGX single-session tok/s",
  );
  assertNear(
    result.dennard,
    108.26333064053506,
    0.000000001,
    "NVIDIA Qwen3 32B NVFP4 DGX Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 2);
  assertNear(
    m5Result.best.aggregate,
    44.656246120288614,
    0.000000001,
    "NVIDIA Qwen3 32B NVFP4 M5 aggregate",
  );
  assertNear(
    m5Result.best.perSession,
    22.328123060144307,
    0.000000001,
    "NVIDIA Qwen3 32B NVFP4 M5 per-session",
  );
  assert.equal(m1UltraResult.status_code, "ok");
  assert.equal(m1UltraResult.best.batch, 4);
  assertNear(
    m1UltraResult.best.aggregate,
    89.1673866160352,
    0.000000001,
    "NVIDIA Qwen3 32B NVFP4 M1 Ultra aggregate",
  );
  assertNear(
    m1UltraResult.best.perSession,
    22.2918466540088,
    0.000000001,
    "NVIDIA Qwen3 32B NVFP4 M1 Ultra per-session",
  );
}

{
  const item = profile("TheBloke/Mistral-7B-Instruct-v0.2-AWQ");
  const result = profiled(
    "TheBloke/Mistral-7B-Instruct-v0.2-AWQ",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "TheBloke/Mistral-7B-Instruct-v0.2-AWQ",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(item.serving.weight_format, "int4");
  assert.equal(result.status_code, "ok");
  assertNear(
    item.architecture.weight_adapter.resident_params_b,
    7.241732096,
    0.000000001,
    "TheBloke Mistral 7B AWQ logical resident parameters",
  );
  assertNear(
    item.architecture.weight_adapter.swept_params_b,
    7.110660096,
    0.000000001,
    "TheBloke Mistral 7B AWQ logical swept text parameters",
  );
  assertNear(
    result.resident,
    4.150796288,
    0.000000001,
    "TheBloke Mistral 7B AWQ resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    3.888652288,
    0.000000001,
    "TheBloke Mistral 7B AWQ swept text-decode traffic",
  );
  assertNear(
    item.architecture.weight_adapter.auxiliary_resident_weight_gb,
    0.262144,
    0.000000001,
    "TheBloke Mistral 7B AWQ resident input embedding footprint",
  );
  assertNear(
    result.alloc,
    13.1072,
    0.000000001,
    "TheBloke Mistral 7B AWQ FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    4.194304,
    0.000000001,
    "TheBloke Mistral 7B AWQ FP16 KV read traffic",
  );
  assert.equal(result.bMem, 8);
  assert.equal(result.best.batch, 2);
  assertNear(
    result.single.aggregate,
    33.77477129318357,
    0.000000001,
    "TheBloke Mistral 7B AWQ DGX single-session tok/s",
  );
  assertNear(
    result.best.aggregate,
    44.47246268238441,
    0.000000001,
    "TheBloke Mistral 7B AWQ DGX aggregate tok/s",
  );
  assertNear(
    result.best.perSession,
    22.236231341192205,
    0.000000001,
    "TheBloke Mistral 7B AWQ DGX per-session tok/s",
  );
  assertNear(
    result.dennard,
    620.506967223216,
    0.000000001,
    "TheBloke Mistral 7B AWQ DGX Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 6);
  assertNear(
    m5Result.best.aggregate,
    126.79629684192778,
    0.000000001,
    "TheBloke Mistral 7B AWQ M5 aggregate",
  );
  assertNear(
    m5Result.best.perSession,
    21.132716140321296,
    0.000000001,
    "TheBloke Mistral 7B AWQ M5 per-session",
  );
}

{
  const modelRow = model("TheBloke/Mistral-7B-Instruct-v0.2-GGUF");
  const item = profile("TheBloke/Mistral-7B-Instruct-v0.2-GGUF");
  const weightAdapter = item.architecture.weight_adapter;
  const kvAdapter = item.architecture.kv_adapter;
  const result = profiled(
    "TheBloke/Mistral-7B-Instruct-v0.2-GGUF",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "TheBloke/Mistral-7B-Instruct-v0.2-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  const m1UltraResult = profiled(
    "TheBloke/Mistral-7B-Instruct-v0.2-GGUF",
    "apple-mac-studio-m1-ultra-128gb",
  );
  assert.equal(modelRow.name, "Mistral-7B-Instruct-v0.2-GGUF GGUF Q4_K_M");
  assert.equal(modelRow.hf_downloads, 150845);
  assert.equal(modelRow.tags.includes("region:us"), true);
  assert.equal(item.status, "audited");
  assert.equal(item.serving.weight_format, "gguf_quantized");
  assert.equal(
    item.serving.runtime_format,
    "llama.cpp-gguf-q4-k-m-memory-bound",
  );
  assert.equal(kvAdapter.kind, "full_context");
  assert.equal(kvAdapter.layers, 32);
  assert.equal(kvAdapter.kv_heads, 8);
  assert.equal(kvAdapter.head_dim, 128);
  assertNear(
    weightAdapter.resident_params_b,
    7.241732096,
    0.000000001,
    "TheBloke Mistral 7B GGUF logical resident parameters",
  );
  assertNear(
    weightAdapter.swept_params_b,
    7.110660096,
    0.000000001,
    "TheBloke Mistral 7B GGUF logical swept text parameters",
  );
  assertNear(
    result.resident,
    4.368439584,
    0.000000001,
    "TheBloke Mistral 7B GGUF selected Q4_K_M resident linked file",
  );
  assertNear(
    result.single.batchWeight,
    4.293976064,
    0.000000001,
    "TheBloke Mistral 7B GGUF selected Q4_K_M swept text traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.07446352,
    0.000000001,
    "TheBloke Mistral 7B GGUF resident input embedding and header overhead",
  );
  assertNear(
    result.alloc,
    13.1072,
    0.000000001,
    "TheBloke Mistral 7B GGUF FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    4.194304,
    0.000000001,
    "TheBloke Mistral 7B GGUF FP16 KV read traffic",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(result.bMem, 8);
  assert.equal(result.best.batch, 2);
  assertNear(
    result.single.aggregate,
    32.161992528714,
    0.000000001,
    "TheBloke Mistral 7B GGUF DGX single-session tok/s",
  );
  assertNear(
    result.best.aggregate,
    43.05116348882259,
    0.000000001,
    "TheBloke Mistral 7B GGUF DGX aggregate tok/s",
  );
  assertNear(
    result.best.perSession,
    21.525581744411294,
    0.000000001,
    "TheBloke Mistral 7B GGUF DGX per-session tok/s",
  );
  assertNear(
    result.dennard,
    560.8793979225626,
    0.000000001,
    "TheBloke Mistral 7B GGUF DGX Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 6);
  assertNear(
    m5Result.best.aggregate,
    125.05176518498725,
    0.000000001,
    "TheBloke Mistral 7B GGUF M5 aggregate",
  );
  assertNear(
    m5Result.best.perSession,
    20.84196086416454,
    0.000000001,
    "TheBloke Mistral 7B GGUF M5 per-session",
  );
  assert.equal(m1UltraResult.status_code, "ok");
  assert.equal(m1UltraResult.best.batch, 8);
  assertNear(
    m1UltraResult.best.aggregate,
    169.09561927090516,
    0.000000001,
    "TheBloke Mistral 7B GGUF M1 Ultra aggregate",
  );
  assertNear(
    m1UltraResult.best.perSession,
    21.136952408863145,
    0.000000001,
    "TheBloke Mistral 7B GGUF M1 Ultra per-session",
  );
}

{
  const item = profile("MaziyarPanahi/Mistral-7B-Instruct-v0.3-GGUF");
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(
    "MaziyarPanahi/Mistral-7B-Instruct-v0.3-GGUF",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "MaziyarPanahi/Mistral-7B-Instruct-v0.3-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(item.serving.weight_format, "fp16");
  assert.equal(item.base_model_proof.config_compatible, true);
  assert.equal(result.status_code, "no_floor");
  assertNear(
    weightAdapter.resident_params_b,
    7.248023552,
    0.000000001,
    "MaziyarPanahi Mistral 7B v0.3 GGUF logical resident parameters",
  );
  assertNear(
    weightAdapter.swept_params_b,
    7.113805824,
    0.000000001,
    "MaziyarPanahi Mistral 7B v0.3 GGUF logical swept parameters",
  );
  assertNear(
    result.resident,
    14.497337312,
    0.000000001,
    "MaziyarPanahi Mistral 7B v0.3 GGUF selected FP16 linked size",
  );
  assertNear(
    result.single.batchWeight,
    14.228144128,
    0.000000001,
    "MaziyarPanahi Mistral 7B v0.3 GGUF swept text-decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.269193184,
    0.000000001,
    "MaziyarPanahi Mistral 7B v0.3 GGUF resident input embedding and header overhead",
  );
  assertNear(
    result.alloc,
    13.1072,
    0.000000001,
    "MaziyarPanahi Mistral 7B v0.3 GGUF FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    4.194304,
    0.000000001,
    "MaziyarPanahi Mistral 7B v0.3 GGUF FP16 KV read traffic",
  );
  assert.equal(result.bMem, 8);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    14.818877388237638,
    0.000000001,
    "MaziyarPanahi Mistral 7B v0.3 GGUF DGX single-session tok/s",
  );
  assertNear(
    result.dennard,
    154.44287781124618,
    0.000000001,
    "MaziyarPanahi Mistral 7B v0.3 GGUF DGX Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 3);
  assertNear(
    m5Result.best.aggregate,
    68.70300040423682,
    0.000000001,
    "MaziyarPanahi Mistral 7B v0.3 GGUF M5 aggregate",
  );
  assertNear(
    m5Result.best.perSession,
    22.901000134745605,
    0.000000001,
    "MaziyarPanahi Mistral 7B v0.3 GGUF M5 per-session",
  );
}

{
  const item = profile("stelterlab/Mistral-Small-24B-Instruct-2501-AWQ");
  const result = profiled(
    "stelterlab/Mistral-Small-24B-Instruct-2501-AWQ",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "stelterlab/Mistral-Small-24B-Instruct-2501-AWQ",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  const m1UltraResult = profiled(
    "stelterlab/Mistral-Small-24B-Instruct-2501-AWQ",
    "apple-mac-studio-m1-ultra-128gb",
  );
  assert.equal(item.serving.weight_format, "int4");
  assert.equal(result.status_code, "no_floor");
  assertNear(
    item.architecture.weight_adapter.resident_params_b,
    23.5724032,
    0.000000001,
    "Mistral Small 24B AWQ logical resident parameters",
  );
  assertNear(
    item.architecture.weight_adapter.swept_params_b,
    22.90131456,
    0.000000001,
    "Mistral Small 24B AWQ logical swept text parameters",
  );
  assertNear(
    result.resident,
    14.2342656,
    0.000000001,
    "Mistral Small 24B AWQ resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    12.89208832,
    0.000000001,
    "Mistral Small 24B AWQ swept text-decode traffic",
  );
  assertNear(
    item.architecture.weight_adapter.auxiliary_resident_weight_gb,
    1.34217728,
    0.000000001,
    "Mistral Small 24B AWQ resident input embedding footprint",
  );
  assertNear(
    result.alloc,
    16.384,
    0.000000001,
    "Mistral Small 24B AWQ FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    5.24288,
    0.000000001,
    "Mistral Small 24B AWQ FP16 KV read traffic",
  );
  assert.equal(result.bMem, 6);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    15.053789738299361,
    0.000000001,
    "Mistral Small 24B AWQ DGX single-session tok/s",
  );
  assertNear(
    result.dennard,
    136.6987127594391,
    0.000000001,
    "Mistral Small 24B AWQ DGX Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 3);
  assertNear(
    m5Result.best.aggregate,
    64.358949199515,
    0.000000001,
    "Mistral Small 24B AWQ M5 aggregate",
  );
  assertNear(
    m5Result.best.perSession,
    21.452983066505,
    0.000000001,
    "Mistral Small 24B AWQ M5 per-session",
  );
  assert.equal(m1UltraResult.status_code, "ok");
  assert.equal(m1UltraResult.best.batch, 5);
  assertNear(
    m1UltraResult.best.aggregate,
    102.28481696614787,
    0.000000001,
    "Mistral Small 24B AWQ M1 Ultra aggregate",
  );
  assertNear(
    m1UltraResult.best.perSession,
    20.456963393229575,
    0.000000001,
    "Mistral Small 24B AWQ M1 Ultra per-session",
  );
}

{
  const repo = "MaziyarPanahi/Mistral-Small-24B-Instruct-2501-GGUF";
  const item = profile(repo);
  const modelRow = model(repo);
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  assert.equal(item.serving.weight_format, "fp16");
  assert.equal(modelRow.name, "Mistral-Small-24B-Instruct-2501-GGUF GGUF F16");
  assert.equal(modelRow.hf_downloads, 116025);
  assert.equal(modelRow.architecture.layers, 40);
  assert.equal(modelRow.architecture.kv_heads, 8);
  assert.equal(modelRow.architecture.max_context_tokens, 32768);
  assertNear(
    item.architecture.weight_adapter.resident_params_b,
    23.5724032,
    0.000000001,
    "Mistral Small 24B GGUF logical resident parameters",
  );
  assertNear(
    item.architecture.weight_adapter.swept_params_b,
    22.90131456,
    0.000000001,
    "Mistral Small 24B GGUF logical swept text parameters",
  );
  assertNear(
    result.resident,
    47.153518016,
    0.000000001,
    "Mistral Small 24B GGUF F16 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    45.80345856,
    0.000000001,
    "Mistral Small 24B GGUF F16 swept text-decode traffic",
  );
  assertNear(
    item.architecture.weight_adapter.auxiliary_resident_weight_gb,
    1.350059456,
    0.000000001,
    "Mistral Small 24B GGUF F16 resident input/header footprint",
  );
  assertNear(
    result.alloc,
    16.384,
    0.000000001,
    "Mistral Small 24B GGUF F16 FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    5.24288,
    0.000000001,
    "Mistral Small 24B GGUF F16 FP16 KV read traffic",
  );
  assert.equal(result.status_code, "no_floor");
  assert.equal(result.bMem, 4);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    5.3480819134386115,
    0.000000001,
    "Mistral Small 24B GGUF F16 DGX single-session tok/s",
  );
  assertNear(
    result.dennard,
    26.50043595250848,
    0.000000001,
    "Mistral Small 24B GGUF F16 DGX Dennard bound",
  );
  assert.equal(m5Result.status_code, "no_floor");
  assert.equal(m5Result.best, null);
  assertNear(
    m5Result.single.aggregate,
    12.028286794327133,
    0.000000001,
    "Mistral Small 24B GGUF F16 M5 single-session tok/s",
  );
}

{
  const repo = "jeffcookio/Mistral-Small-3.2-24B-Instruct-2506-awq-sym";
  const item = profile(repo);
  const modelRow = model(repo);
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  const m1UltraResult = profiled(repo, "apple-mac-studio-m1-ultra-128gb");
  assert.equal(item.serving.weight_format, "int4");
  assert.equal(modelRow.hf_downloads, 105570);
  assert.ok(modelRow.tags.includes("region:us"));
  assert.equal(modelRow.architecture.layers, 40);
  assert.equal(modelRow.architecture.attention_heads, 32);
  assert.equal(modelRow.architecture.kv_heads, 8);
  assert.equal(modelRow.architecture.head_dim, 128);
  assert.equal(modelRow.architecture.max_context_tokens, 131072);
  assert.equal(
    modelRow.adapter.weight_precision,
    "compressed-tensors INT4 symmetric",
  );
  assert.equal(item.status, "audited");
  assert.equal(item.base_model_proof.config_compatible, true);
  assert.equal(item.architecture.kv_adapter.kind, "full_context");
  assert.equal(item.architecture.kv_adapter.layers, 40);
  assert.equal(item.architecture.kv_adapter.kv_heads, 8);
  assert.equal(item.architecture.kv_adapter.head_dim, 128);
  assert.equal(item.architecture.kv_adapter.kv_scalar_multiplier, 2);
  assertNear(
    modelRow.architecture.total_params_b,
    24.01136128,
    0.000000001,
    "Mistral Small 3.2 AWQ catalog true resident parameters",
  );
  assertNear(
    modelRow.architecture.active_params_b,
    22.90131456,
    0.000000001,
    "Mistral Small 3.2 AWQ catalog active text parameters",
  );
  assertNear(
    item.architecture.weight_adapter.resident_params_b,
    24.01136128,
    0.000000001,
    "Mistral Small 3.2 AWQ true resident parameters",
  );
  assertNear(
    item.architecture.weight_adapter.swept_params_b,
    22.90131456,
    0.000000001,
    "Mistral Small 3.2 AWQ true swept text parameters",
  );
  assertNear(
    result.resident,
    15.02535104,
    0.000000001,
    "Mistral Small 3.2 AWQ compressed-tensors resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    12.8052576,
    0.000000001,
    "Mistral Small 3.2 AWQ swept text-decode traffic",
  );
  assertNear(
    item.architecture.weight_adapter.auxiliary_resident_weight_gb,
    2.22009344,
    0.000000001,
    "Mistral Small 3.2 AWQ resident input and multimodal footprint",
  );
  assertNear(
    result.alloc,
    16.384,
    0.000000001,
    "Mistral Small 3.2 AWQ BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    5.24288,
    0.000000001,
    "Mistral Small 3.2 AWQ BF16 KV read traffic",
  );
  assert.equal(result.status_code, "no_floor");
  assert.equal(result.bMem, 6);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    15.126214463258524,
    0.000000001,
    "Mistral Small 3.2 AWQ DGX single-session tok/s",
  );
  assertNear(
    result.dennard,
    136.59626337595603,
    0.000000001,
    "Mistral Small 3.2 AWQ DGX Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 3);
  assertNear(
    m5Result.best.aggregate,
    64.55479814997304,
    0.000000001,
    "Mistral Small 3.2 AWQ M5 aggregate",
  );
  assertNear(
    m5Result.best.perSession,
    21.518266049991013,
    0.000000001,
    "Mistral Small 3.2 AWQ M5 per-session",
  );
  assert.equal(m1UltraResult.status_code, "ok");
  assert.equal(m1UltraResult.best.batch, 5);
  assertNear(
    m1UltraResult.best.aggregate,
    102.5124320926896,
    0.000000001,
    "Mistral Small 3.2 AWQ M1 Ultra aggregate",
  );
  assertNear(
    m1UltraResult.best.perSession,
    20.50248641853792,
    0.000000001,
    "Mistral Small 3.2 AWQ M1 Ultra per-session",
  );
}

{
  const repo = "MaziyarPanahi/mistral-small-3.1-24b-instruct-2503-hf-GGUF";
  const item = profile(repo);
  const modelRow = model(repo);
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  const m1UltraResult = profiled(repo, "apple-mac-studio-m1-ultra-128gb");
  assert.equal(item.serving.weight_format, "fp16");
  assert.equal(
    modelRow.name,
    "mistral-small-3.1-24b-instruct-2503-hf-GGUF F16",
  );
  assert.equal(modelRow.hf_downloads, 113869);
  assert.equal(modelRow.license, "apache-2.0");
  assert.ok(modelRow.tags.includes("region:us"));
  assert.equal(modelRow.architecture.layers, 40);
  assert.equal(modelRow.architecture.attention_heads, 32);
  assert.equal(modelRow.architecture.kv_heads, 8);
  assert.equal(modelRow.architecture.head_dim, 128);
  assert.equal(modelRow.architecture.max_context_tokens, 32768);
  assert.equal(modelRow.adapter.weight_precision, "GGUF FP16/F32");
  assert.equal(item.status, "audited");
  assert.equal(item.base_model_proof.config_compatible, true);
  assert.equal(item.architecture.kv_adapter.kind, "full_context");
  assert.equal(item.architecture.kv_adapter.layers, 40);
  assert.equal(item.architecture.kv_adapter.kv_heads, 8);
  assert.equal(item.architecture.kv_adapter.head_dim, 128);
  assertNear(
    item.architecture.weight_adapter.resident_params_b,
    23.5724032,
    0.000000001,
    "Mistral Small 3.1 24B HF GGUF logical resident parameters",
  );
  assertNear(
    item.architecture.weight_adapter.swept_params_b,
    22.90131456,
    0.000000001,
    "Mistral Small 3.1 24B HF GGUF logical swept text parameters",
  );
  assertNear(
    result.resident,
    47.153519136,
    0.000000001,
    "Mistral Small 3.1 24B HF GGUF F16 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    45.80345856,
    0.000000001,
    "Mistral Small 3.1 24B HF GGUF F16 swept text-decode traffic",
  );
  assertNear(
    item.architecture.weight_adapter.auxiliary_resident_weight_gb,
    1.350060576,
    0.000000001,
    "Mistral Small 3.1 24B HF GGUF F16 resident input/header footprint",
  );
  assertNear(
    result.alloc,
    16.384,
    0.000000001,
    "Mistral Small 3.1 24B HF GGUF F16 FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    5.24288,
    0.000000001,
    "Mistral Small 3.1 24B HF GGUF F16 FP16 KV read traffic",
  );
  assert.equal(result.status_code, "no_floor");
  assert.equal(result.bMem, 4);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    5.3480819134386115,
    0.000000001,
    "Mistral Small 3.1 24B HF GGUF F16 DGX single-session tok/s",
  );
  assertNear(
    result.dennard,
    26.500435545069607,
    0.000000001,
    "Mistral Small 3.1 24B HF GGUF F16 DGX Dennard bound",
  );
  assert.equal(m5Result.status_code, "no_floor");
  assert.equal(m5Result.best, null);
  assertNear(
    m5Result.single.aggregate,
    12.028286794327133,
    0.000000001,
    "Mistral Small 3.1 24B HF GGUF F16 M5 single-session tok/s",
  );
  assert.equal(m1UltraResult.status_code, "no_floor");
  assert.equal(m1UltraResult.best, null);
  assertNear(
    m1UltraResult.single.aggregate,
    15.67203491117542,
    0.000000001,
    "Mistral Small 3.1 24B HF GGUF F16 M1 Ultra single-session tok/s",
  );
}

{
  const result = profiled("Qwen/Qwen3-30B-A3B", "nvidia-dgx-spark");
  assertNear(
    result.resident,
    61.064245248,
    0.000000001,
    "Qwen3 30B A3B resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    6.083735552,
    0.000000001,
    "Qwen3 30B A3B single-session MoE decode traffic",
  );
  assertNear(
    result.single.batchWeight - 2.459856896,
    3.623878656,
    0.000000001,
    "Qwen3 30B A3B eight routed experts traffic",
  );
  assertNear(
    result.alloc,
    9.8304,
    0.000000001,
    "Qwen3 30B A3B BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    3.145728,
    0.000000001,
    "Qwen3 30B A3B BF16 KV read traffic",
  );
}

{
  const modelProfile = profile("MaziyarPanahi/Qwen3-30B-A3B-GGUF");
  const result = profiled(
    "MaziyarPanahi/Qwen3-30B-A3B-GGUF",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    modelProfile.architecture.weight_adapter.fixed_weight_gb,
    0.656390144,
    0.000000001,
    "MaziyarPanahi Qwen3 30B A3B Q2_K GGUF fixed traffic",
  );
  assertNear(
    modelProfile.architecture.weight_adapter.routed_expert_weight_gb,
    0.081985536,
    0.000000001,
    "MaziyarPanahi Qwen3 30B A3B Q2_K GGUF routed expert group",
  );
  assertNear(
    result.resident,
    11.2586096,
    0.000000001,
    "MaziyarPanahi Qwen3 30B A3B Q2_K GGUF resident file footprint",
  );
  assertNear(
    result.single.batchWeight,
    1.312274432,
    0.000000001,
    "MaziyarPanahi Qwen3 30B A3B Q2_K GGUF single-session traffic",
  );
  assertNear(
    result.alloc,
    9.8304,
    0.000000001,
    "MaziyarPanahi Qwen3 30B A3B Q2_K GGUF FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    3.145728,
    0.000000001,
    "MaziyarPanahi Qwen3 30B A3B Q2_K GGUF FP16 KV read traffic",
  );
  assert.equal(result.bMem, 11);
  assert.equal(result.best.batch, 3);
  assertNear(
    result.single.aggregate,
    61.238190010929095,
    0.000000001,
    "MaziyarPanahi Qwen3 30B A3B Q2_K GGUF DGX single-session tok/s",
  );
  assertNear(
    result.best.aggregate,
    68.58830752868464,
    0.000000001,
    "MaziyarPanahi Qwen3 30B A3B Q2_K GGUF DGX aggregate tok/s at b*",
  );
  assertNear(
    result.best.perSession,
    22.862769176228213,
    0.000000001,
    "MaziyarPanahi Qwen3 30B A3B Q2_K GGUF DGX per-session tok/s at b*",
  );
  assertNear(
    result.dennard,
    2301.238715308098,
    0.000000001,
    "MaziyarPanahi Qwen3 30B A3B Q2_K GGUF DGX Dennard bound",
  );

  const m5Result = profiled(
    "MaziyarPanahi/Qwen3-30B-A3B-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 8);
  assertNear(
    m5Result.best.aggregate,
    163.43751189276193,
    0.000000001,
    "MaziyarPanahi Qwen3 30B A3B Q2_K GGUF M5 aggregate tok/s at b*",
  );
  assertNear(
    m5Result.best.perSession,
    20.42968898659524,
    0.000000001,
    "MaziyarPanahi Qwen3 30B A3B Q2_K GGUF M5 per-session tok/s at b*",
  );
}

{
  const result = profiled("Qwen/Qwen3-30B-A3B-FP8", "nvidia-dgx-spark");
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    32.444792832,
    0.000000001,
    "Qwen3 30B A3B FP8 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    4.01440768,
    0.000000001,
    "Qwen3 30B A3B FP8 single-session MoE decode traffic",
  );
  assertNear(
    result.single.batchWeight - 2.202025984,
    1.812381696,
    0.000000001,
    "Qwen3 30B A3B FP8 eight routed experts traffic",
  );
  assertNear(
    result.alloc,
    9.8304,
    0.000000001,
    "Qwen3 30B A3B FP8 BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    3.145728,
    0.000000001,
    "Qwen3 30B A3B FP8 BF16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    38.12776911,
    0.000000001,
    "Qwen3 30B A3B FP8 DGX Spark single-session tok/s",
  );
  assert.equal(result.bMem, 8);
  assert.equal(result.best.batch, 2);
  assertNear(
    result.best.aggregate,
    45.48115746,
    0.000000001,
    "Qwen3 30B A3B FP8 DGX Spark aggregate tok/s",
  );
  assertNear(
    result.best.perSession,
    22.74057873,
    0.000000001,
    "Qwen3 30B A3B FP8 DGX Spark per-session tok/s",
  );
  assertNear(
    result.dennard,
    605.692174306,
    0.000000001,
    "Qwen3 30B A3B FP8 DGX Spark Dennard bound",
  );
}

{
  const repo = "Qwen/Qwen3-30B-A3B-GPTQ-Int4";
  const catalogRow = model(repo);
  const modelProfile = profile(repo);
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  assert.equal(modelProfile.status, "audited");
  assert.equal(catalogRow.hf_downloads, 136678);
  assertNear(
    catalogRow.adapter.resident_weight_gb,
    16.924176384,
    0.000000001,
    "Qwen3 30B A3B GPTQ Int4 catalog resident footprint",
  );
  assertNear(
    catalogRow.adapter.active_weight_gb,
    2.069393408,
    0.000000001,
    "Qwen3 30B A3B GPTQ Int4 catalog single-session traffic",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    weightAdapter.fixed_weight_gb,
    1.1205632,
    0.000000001,
    "Qwen3 30B A3B GPTQ Int4 fixed decode traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.118603776,
    0.000000001,
    "Qwen3 30B A3B GPTQ Int4 routed expert group",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.622329856,
    0.000000001,
    "Qwen3 30B A3B GPTQ Int4 resident-only embedding",
  );
  assertNear(
    result.resident,
    16.924176384,
    0.000000001,
    "Qwen3 30B A3B GPTQ Int4 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    2.069393408,
    0.000000001,
    "Qwen3 30B A3B GPTQ Int4 single-session MoE decode traffic",
  );
  assertNear(
    result.single.batchWeight - weightAdapter.fixed_weight_gb,
    0.948830208,
    0.000000001,
    "Qwen3 30B A3B GPTQ Int4 eight routed experts traffic",
  );
  assertNear(
    result.alloc,
    9.8304,
    0.000000001,
    "Qwen3 30B A3B GPTQ Int4 FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    3.145728,
    0.000000001,
    "Qwen3 30B A3B GPTQ Int4 FP16 KV read traffic",
  );
  assert.equal(result.bMem, 10);
  assert.equal(result.best.batch, 3);
  assertNear(
    result.single.aggregate,
    52.34777460429163,
    0.000000001,
    "Qwen3 30B A3B GPTQ Int4 DGX single-session tok/s",
  );
  assertNear(
    result.best.aggregate,
    61.904581628139,
    0.000000001,
    "Qwen3 30B A3B GPTQ Int4 DGX aggregate tok/s at b*",
  );
  assertNear(
    result.best.perSession,
    20.634860542713,
    0.000000001,
    "Qwen3 30B A3B GPTQ Int4 DGX per-session tok/s at b*",
  );
  assertNear(
    result.dennard,
    1383.2644309844059,
    0.000000001,
    "Qwen3 30B A3B GPTQ Int4 DGX Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 7);
  assertNear(
    m5Result.best.aggregate,
    149.9701108220708,
    0.000000001,
    "Qwen3 30B A3B GPTQ Int4 M5 aggregate tok/s at b*",
  );
  assertNear(
    m5Result.best.perSession,
    21.424301546010117,
    0.000000001,
    "Qwen3 30B A3B GPTQ Int4 M5 per-session tok/s at b*",
  );
}

{
  const result = profiled(
    "Qwen/Qwen3-30B-A3B-Instruct-2507",
    "nvidia-dgx-spark",
  );
  assertNear(
    result.resident,
    61.064245248,
    0.000000001,
    "Qwen3 30B A3B Instruct 2507 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    6.083735552,
    0.000000001,
    "Qwen3 30B A3B Instruct 2507 single-session MoE decode traffic",
  );
  assertNear(
    result.single.batchWeight - 2.459856896,
    3.623878656,
    0.000000001,
    "Qwen3 30B A3B Instruct 2507 eight routed experts traffic",
  );
  assertNear(
    result.alloc,
    9.8304,
    0.000000001,
    "Qwen3 30B A3B Instruct 2507 BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    3.145728,
    0.000000001,
    "Qwen3 30B A3B Instruct 2507 BF16 KV read traffic",
  );
}

{
  const modelProfile = profile("Qwen/Qwen3-30B-A3B-Thinking-2507");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "Qwen/Qwen3-30B-A3B-Thinking-2507",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    weightAdapter.fixed_weight_gb,
    2.459856896,
    0.000000001,
    "Qwen3 30B A3B Thinking 2507 fixed decode traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.452984832,
    0.000000001,
    "Qwen3 30B A3B Thinking 2507 routed expert group",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.622329856,
    0.000000001,
    "Qwen3 30B A3B Thinking 2507 resident-only embedding",
  );
  assertNear(
    result.resident,
    61.064245248,
    0.000000001,
    "Qwen3 30B A3B Thinking 2507 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    6.083735552,
    0.000000001,
    "Qwen3 30B A3B Thinking 2507 single-session MoE decode traffic",
  );
  assertNear(
    result.single.batchWeight - weightAdapter.fixed_weight_gb,
    3.623878656,
    0.000000001,
    "Qwen3 30B A3B Thinking 2507 eight routed experts traffic",
  );
  assertNear(
    result.alloc,
    9.8304,
    0.000000001,
    "Qwen3 30B A3B Thinking 2507 BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    3.145728,
    0.000000001,
    "Qwen3 30B A3B Thinking 2507 BF16 KV read traffic",
  );
  assert.equal(result.bMem, 5);
  assert.equal(result.best.batch, 1);
  assertNear(
    result.single.aggregate,
    29.579183932184403,
    0.000000001,
    "Qwen3 30B A3B Thinking 2507 DGX single-session tok/s",
  );
  assertNear(
    result.best.aggregate,
    29.579183932184403,
    0.000000001,
    "Qwen3 30B A3B Thinking 2507 DGX aggregate tok/s at b*",
  );
  assertNear(
    result.best.perSession,
    29.579183932184403,
    0.000000001,
    "Qwen3 30B A3B Thinking 2507 DGX per-session tok/s at b*",
  );
  assertNear(
    result.dennard,
    269.0295462402111,
    0.000000001,
    "Qwen3 30B A3B Thinking 2507 DGX Dennard bound",
  );
}

{
  const modelProfile = profile("Qwen/Qwen3-30B-A3B-Instruct-2507-FP8");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "Qwen/Qwen3-30B-A3B-Instruct-2507-FP8",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    weightAdapter.fixed_weight_gb,
    1.553997824,
    0.000000001,
    "Qwen3 30B A3B Instruct 2507 FP8 fixed decode traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.226520064,
    0.000000001,
    "Qwen3 30B A3B Instruct 2507 FP8 routed expert group",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.622329856,
    0.000000001,
    "Qwen3 30B A3B Instruct 2507 FP8 resident-only embedding",
  );
  assertNear(
    result.resident,
    31.170895872,
    0.000000001,
    "Qwen3 30B A3B Instruct 2507 FP8 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    3.366158336,
    0.000000001,
    "Qwen3 30B A3B Instruct 2507 FP8 single-session MoE decode traffic",
  );
  assertNear(
    result.single.batchWeight - weightAdapter.fixed_weight_gb,
    1.812160512,
    0.000000001,
    "Qwen3 30B A3B Instruct 2507 FP8 eight routed experts traffic",
  );
  assertNear(
    result.alloc,
    9.8304,
    0.000000001,
    "Qwen3 30B A3B Instruct 2507 FP8 BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    3.145728,
    0.000000001,
    "Qwen3 30B A3B Instruct 2507 FP8 BF16 KV read traffic",
  );
  assert.equal(result.bMem, 9);
  assert.equal(result.best.batch, 2);
  assertNear(
    result.single.aggregate,
    41.9233361753813,
    0.000000001,
    "Qwen3 30B A3B Instruct 2507 FP8 DGX single-session tok/s",
  );
  assertNear(
    result.best.aggregate,
    48.07813038122839,
    0.000000001,
    "Qwen3 30B A3B Instruct 2507 FP8 DGX aggregate tok/s at b*",
  );
  assertNear(
    result.best.perSession,
    24.039065190614195,
    0.000000001,
    "Qwen3 30B A3B Instruct 2507 FP8 DGX per-session tok/s at b*",
  );
  assertNear(
    result.dennard,
    732.8451182368863,
    0.000000001,
    "Qwen3 30B A3B Instruct 2507 FP8 DGX Dennard bound",
  );
}

{
  const modelProfile = profile("cyankiwi/Qwen3-30B-A3B-Instruct-2507-AWQ-4bit");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "cyankiwi/Qwen3-30B-A3B-Instruct-2507-AWQ-4bit",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    weightAdapter.fixed_weight_gb,
    1.157528576,
    0.000000001,
    "cyankiwi Qwen3 30B A3B Instruct 2507 AWQ fixed traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.127404288,
    0.000000001,
    "cyankiwi Qwen3 30B A3B Instruct 2507 AWQ routed expert group",
  );
  assertNear(
    result.resident,
    18.087607296,
    0.000000001,
    "cyankiwi Qwen3 30B A3B Instruct 2507 AWQ resident package",
  );
  assertNear(
    result.single.batchWeight,
    2.17676288,
    0.000000001,
    "cyankiwi Qwen3 30B A3B Instruct 2507 AWQ single-session traffic",
  );
  assertNear(
    result.resident - weightAdapter.main_resident_weight_gb,
    0.622329856,
    0.000000001,
    "cyankiwi Qwen3 30B A3B Instruct 2507 AWQ resident-only embedding",
  );
  assertNear(
    result.alloc,
    9.8304,
    0.000000001,
    "cyankiwi Qwen3 30B A3B Instruct 2507 AWQ BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    3.145728,
    0.000000001,
    "cyankiwi Qwen3 30B A3B Instruct 2507 AWQ BF16 KV read traffic",
  );
  assert.equal(result.bMem, 10);
  assert.equal(result.best.batch, 3);
  assertNear(
    result.single.aggregate,
    51.291774125125414,
    0.000000001,
    "cyankiwi Qwen3 30B A3B Instruct 2507 AWQ DGX single-session tok/s",
  );
  assertNear(
    result.best.aggregate,
    60.82304749751837,
    0.000000001,
    "cyankiwi Qwen3 30B A3B Instruct 2507 AWQ DGX aggregate tok/s at b*",
  );
  assertNear(
    result.best.perSession,
    20.274349165839457,
    0.000000001,
    "cyankiwi Qwen3 30B A3B Instruct 2507 AWQ DGX per-session tok/s at b*",
  );
  assertNear(
    result.dennard,
    1300.1915301346467,
    0.000000001,
    "cyankiwi Qwen3 30B A3B Instruct 2507 AWQ DGX Dennard bound",
  );
}

{
  const modelProfile = profile("cyankiwi/Qwen3-30B-A3B-Thinking-2507-AWQ-4bit");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "cyankiwi/Qwen3-30B-A3B-Thinking-2507-AWQ-4bit",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    weightAdapter.fixed_weight_gb,
    1.157528576,
    0.000000001,
    "cyankiwi Qwen3 30B A3B Thinking 2507 AWQ fixed traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.127404288,
    0.000000001,
    "cyankiwi Qwen3 30B A3B Thinking 2507 AWQ routed expert group",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.622329856,
    0.000000001,
    "cyankiwi Qwen3 30B A3B Thinking 2507 AWQ resident-only embedding",
  );
  assertNear(
    result.resident,
    18.087607296,
    0.000000001,
    "cyankiwi Qwen3 30B A3B Thinking 2507 AWQ resident package",
  );
  assertNear(
    result.single.batchWeight,
    2.17676288,
    0.000000001,
    "cyankiwi Qwen3 30B A3B Thinking 2507 AWQ single-session traffic",
  );
  assertNear(
    result.single.batchWeight - weightAdapter.fixed_weight_gb,
    1.019234304,
    0.000000001,
    "cyankiwi Qwen3 30B A3B Thinking 2507 AWQ eight routed experts traffic",
  );
  assertNear(
    result.alloc,
    9.8304,
    0.000000001,
    "cyankiwi Qwen3 30B A3B Thinking 2507 AWQ BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    3.145728,
    0.000000001,
    "cyankiwi Qwen3 30B A3B Thinking 2507 AWQ BF16 KV read traffic",
  );
  assert.equal(result.bMem, 10);
  assert.equal(result.best.batch, 3);
  assertNear(
    result.single.aggregate,
    51.291774125125414,
    0.000000001,
    "cyankiwi Qwen3 30B A3B Thinking 2507 AWQ DGX single-session tok/s",
  );
  assertNear(
    result.best.aggregate,
    60.82304749751837,
    0.000000001,
    "cyankiwi Qwen3 30B A3B Thinking 2507 AWQ DGX aggregate tok/s at b*",
  );
  assertNear(
    result.best.perSession,
    20.274349165839457,
    0.000000001,
    "cyankiwi Qwen3 30B A3B Thinking 2507 AWQ DGX per-session tok/s at b*",
  );
  assertNear(
    result.dennard,
    1300.1915301346467,
    0.000000001,
    "cyankiwi Qwen3 30B A3B Thinking 2507 AWQ DGX Dennard bound",
  );
}

{
  const modelProfile = profile("unsloth/Qwen3-30B-A3B-Instruct-2507-GGUF");
  const result = profiled(
    "unsloth/Qwen3-30B-A3B-Instruct-2507-GGUF",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    modelProfile.architecture.weight_adapter.fixed_weight_gb,
    0.822327296,
    0.000000001,
    "Unsloth Qwen3 30B A3B Instruct 2507 IQ4_NL GGUF fixed traffic",
  );
  assertNear(
    modelProfile.architecture.weight_adapter.routed_expert_weight_gb,
    0.127401984,
    0.000000001,
    "Unsloth Qwen3 30B A3B Instruct 2507 IQ4_NL GGUF routed expert group",
  );
  assertNear(
    result.resident,
    17.310781856,
    0.000000001,
    "Unsloth Qwen3 30B A3B Instruct 2507 IQ4_NL GGUF resident file footprint",
  );
  assertNear(
    result.single.batchWeight,
    1.841543168,
    0.000000001,
    "Unsloth Qwen3 30B A3B Instruct 2507 IQ4_NL GGUF single-session traffic",
  );
  assertNear(
    result.alloc,
    9.8304,
    0.000000001,
    "Unsloth Qwen3 30B A3B Instruct 2507 IQ4_NL GGUF FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    3.145728,
    0.000000001,
    "Unsloth Qwen3 30B A3B Instruct 2507 IQ4_NL GGUF FP16 KV read traffic",
  );
  assert.equal(result.best.batch, 3);
  assertNear(
    result.single.aggregate,
    54.739354,
    0.000001,
    "Unsloth Qwen3 30B A3B Instruct 2507 IQ4_NL GGUF DGX single-session tok/s",
  );
  assertNear(
    result.best.aggregate,
    62.376061,
    0.000001,
    "Unsloth Qwen3 30B A3B Instruct 2507 IQ4_NL GGUF DGX aggregate tok/s at b*",
  );
  assertNear(
    result.best.perSession,
    20.79202,
    0.000001,
    "Unsloth Qwen3 30B A3B Instruct 2507 IQ4_NL GGUF DGX per-session tok/s at b*",
  );
  assertNear(
    result.dennard,
    1548.582692,
    0.000001,
    "Unsloth Qwen3 30B A3B Instruct 2507 IQ4_NL GGUF DGX Dennard bound",
  );
}

{
  const modelProfile = profile("unsloth/Qwen3-Coder-30B-A3B-Instruct-GGUF");
  const result = profiled(
    "unsloth/Qwen3-Coder-30B-A3B-Instruct-GGUF",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "unsloth/Qwen3-Coder-30B-A3B-Instruct-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    modelProfile.architecture.weight_adapter.fixed_weight_gb,
    0.822327296,
    0.000000001,
    "Unsloth Qwen3-Coder 30B A3B IQ4_NL GGUF fixed traffic",
  );
  assertNear(
    modelProfile.architecture.weight_adapter.routed_expert_weight_gb,
    0.127401984,
    0.000000001,
    "Unsloth Qwen3-Coder 30B A3B IQ4_NL GGUF routed expert group",
  );
  assertNear(
    result.resident,
    17.310784672,
    0.000000001,
    "Unsloth Qwen3-Coder 30B A3B IQ4_NL GGUF resident file footprint",
  );
  assertNear(
    result.single.batchWeight,
    1.841543168,
    0.000000001,
    "Unsloth Qwen3-Coder 30B A3B IQ4_NL GGUF single-session traffic",
  );
  assertNear(
    modelProfile.architecture.weight_adapter.auxiliary_resident_weight_gb,
    0.181003424,
    0.000000001,
    "Unsloth Qwen3-Coder 30B A3B IQ4_NL GGUF resident-only token/header bytes",
  );
  assertNear(
    result.alloc,
    9.8304,
    0.000000001,
    "Unsloth Qwen3-Coder 30B A3B IQ4_NL GGUF FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    3.145728,
    0.000000001,
    "Unsloth Qwen3-Coder 30B A3B IQ4_NL GGUF FP16 KV read traffic",
  );
  assert.equal(result.best.batch, 3);
  assertNear(
    result.single.aggregate,
    54.73935360717086,
    0.000000001,
    "Unsloth Qwen3-Coder 30B A3B IQ4_NL GGUF DGX single-session tok/s",
  );
  assertNear(
    result.best.aggregate,
    62.376060671476935,
    0.000000001,
    "Unsloth Qwen3-Coder 30B A3B IQ4_NL GGUF DGX aggregate tok/s at b*",
  );
  assertNear(
    result.best.perSession,
    20.792020223825645,
    0.000000001,
    "Unsloth Qwen3-Coder 30B A3B IQ4_NL GGUF DGX per-session tok/s at b*",
  );
  assertNear(
    result.dennard,
    1548.5826492144122,
    0.000000001,
    "Unsloth Qwen3-Coder 30B A3B IQ4_NL GGUF DGX Dennard bound",
  );
  assert.equal(m5Result.best.batch, 7);
  assertNear(
    m5Result.best.aggregate,
    149.39084362794986,
    0.000000001,
    "Unsloth Qwen3-Coder 30B A3B IQ4_NL GGUF M5 aggregate tok/s at b*",
  );
}

{
  const result = profiled(
    "Qwen/Qwen3-Coder-30B-A3B-Instruct",
    "nvidia-dgx-spark",
  );
  assertNear(
    result.resident,
    61.064245248,
    0.000000001,
    "Qwen3-Coder 30B A3B resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    6.083735552,
    0.000000001,
    "Qwen3-Coder 30B A3B single-session MoE decode traffic",
  );
  assertNear(
    result.single.batchWeight - 2.459856896,
    3.623878656,
    0.000000001,
    "Qwen3-Coder 30B A3B eight routed experts traffic",
  );
  assertNear(
    result.alloc,
    9.8304,
    0.000000001,
    "Qwen3-Coder 30B A3B BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    3.145728,
    0.000000001,
    "Qwen3-Coder 30B A3B BF16 KV read traffic",
  );
}

{
  const result = profiled(
    "Qwen/Qwen3-Coder-30B-A3B-Instruct-FP8",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    31.170895872,
    0.000000001,
    "Qwen3-Coder 30B A3B FP8 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    3.366158336,
    0.000000001,
    "Qwen3-Coder 30B A3B FP8 single-session MoE decode traffic",
  );
  assertNear(
    result.single.batchWeight - 1.553997824,
    1.812160512,
    0.000000001,
    "Qwen3-Coder 30B A3B FP8 eight routed experts traffic",
  );
  assertNear(
    result.alloc,
    9.8304,
    0.000000001,
    "Qwen3-Coder 30B A3B FP8 BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    3.145728,
    0.000000001,
    "Qwen3-Coder 30B A3B FP8 BF16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    42,
    1,
    "Qwen3-Coder 30B A3B FP8 DGX single",
  );
  assert.equal(result.best.batch, 2);
  assertNear(
    result.best.aggregate,
    48,
    1,
    "Qwen3-Coder 30B A3B FP8 DGX aggregate",
  );
  assertNear(result.dennard, 733, 50, "Qwen3-Coder 30B A3B FP8 DGX Dennard");
}

{
  const modelProfile = profile("QuantTrio/Qwen3-Coder-30B-A3B-Instruct-AWQ");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "QuantTrio/Qwen3-Coder-30B-A3B-Instruct-AWQ",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(
    modelProfile.base_model_proof.config_compatible,
    false,
    "QuantTrio Qwen3-Coder AWQ records served-config differences from the BF16 base",
  );
  assertNear(
    weightAdapter.resident_weight_gb,
    16.80267264,
    0.000000001,
    "QuantTrio Qwen3-Coder AWQ resident footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    16.180342784,
    0.000000001,
    "QuantTrio Qwen3-Coder AWQ main resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.622329856,
    0.000000001,
    "QuantTrio Qwen3-Coder AWQ resident-only input embedding footprint",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    1.11859712,
    0.000000001,
    "QuantTrio Qwen3-Coder AWQ fixed ordinary decode traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.117669888,
    0.000000001,
    "QuantTrio Qwen3-Coder AWQ per-expert traffic",
  );
  assertNear(
    result.single.batchWeight,
    2.059956224,
    0.000000001,
    "QuantTrio Qwen3-Coder AWQ single-session MoE decode traffic",
  );
  assertNear(
    result.single.batchWeight - weightAdapter.fixed_weight_gb,
    0.941359104,
    0.000000001,
    "QuantTrio Qwen3-Coder AWQ eight routed experts traffic",
  );
  assertNear(
    result.alloc,
    9.8304,
    0.000000001,
    "QuantTrio Qwen3-Coder AWQ BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    3.145728,
    0.000000001,
    "QuantTrio Qwen3-Coder AWQ BF16 KV read traffic",
  );
  assert.equal(result.bMem, 10);
  assert.equal(result.best.batch, 3);
  assertNear(
    result.single.aggregate,
    52.442674,
    0.000001,
    "QuantTrio Qwen3-Coder AWQ DGX single-session throughput",
  );
  assertNear(
    result.best.aggregate,
    62.012425,
    0.000001,
    "QuantTrio Qwen3-Coder AWQ DGX aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    20.670808,
    0.000001,
    "QuantTrio Qwen3-Coder AWQ DGX per-session throughput",
  );
  assertNear(
    result.dennard,
    1391.239552,
    0.000001,
    "QuantTrio Qwen3-Coder AWQ DGX Dennard bound",
  );
}

{
  const result = profiled(
    "QuantTrio/Qwen3-Coder-30B-A3B-Instruct-AWQ",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(result.best.batch, 7);
  assertNear(
    result.single.aggregate,
    117.947992,
    0.000001,
    "QuantTrio Qwen3-Coder AWQ M5 Max single-session throughput",
  );
  assertNear(
    result.best.aggregate,
    150.208156,
    0.000001,
    "QuantTrio Qwen3-Coder AWQ M5 Max aggregate throughput",
  );
  assertNear(
    result.dennard,
    3129.014964,
    0.000001,
    "QuantTrio Qwen3-Coder AWQ M5 Max Dennard bound",
  );
}

{
  const catalogRow = model("nm-testing/Qwen3-Coder-30B-A3B-Instruct-W4A16-awq");
  const modelProfile = profile(
    "nm-testing/Qwen3-Coder-30B-A3B-Instruct-W4A16-awq",
  );
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "nm-testing/Qwen3-Coder-30B-A3B-Instruct-W4A16-awq",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(
    catalogRow.hf_downloads,
    115566,
    "nm-testing Qwen3-Coder W4A16 retains the older scrape count that qualified it for the audit queue",
  );
  assert.ok(catalogRow.tags.includes("region:us"));
  assert.equal(
    modelProfile.base_model_proof.config_compatible,
    false,
    "nm-testing Qwen3-Coder W4A16 records served-config differences from the BF16 base",
  );
  assert.equal(modelProfile.serving.weight_format, "int4");
  assertNear(
    weightAdapter.resident_weight_gb,
    16.686185472,
    0.000000001,
    "nm-testing Qwen3-Coder W4A16 resident footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    16.063855616,
    0.000000001,
    "nm-testing Qwen3-Coder W4A16 main resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.622329856,
    0.000000001,
    "nm-testing Qwen3-Coder W4A16 resident-only input embedding footprint",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    1.115061248,
    0.000000001,
    "nm-testing Qwen3-Coder W4A16 fixed ordinary decode traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.116787456,
    0.000000001,
    "nm-testing Qwen3-Coder W4A16 per-expert traffic",
  );
  assertNear(
    catalogRow.adapter.active_weight_gb,
    2.049360896,
    0.000000001,
    "nm-testing Qwen3-Coder W4A16 catalog active traffic",
  );
  assertNear(
    result.single.batchWeight,
    2.049360896,
    0.000000001,
    "nm-testing Qwen3-Coder W4A16 single-session MoE decode traffic",
  );
  assertNear(
    result.single.batchWeight - weightAdapter.fixed_weight_gb,
    0.934299648,
    0.000000001,
    "nm-testing Qwen3-Coder W4A16 eight routed experts traffic",
  );
  assertNear(
    result.alloc,
    9.8304,
    0.000000001,
    "nm-testing Qwen3-Coder W4A16 BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    3.145728,
    0.000000001,
    "nm-testing Qwen3-Coder W4A16 BF16 KV read traffic",
  );
  assert.equal(result.bMem, 10);
  assert.equal(result.best.batch, 3);
  assertNear(
    result.single.aggregate,
    52.549630134375285,
    0.000000001,
    "nm-testing Qwen3-Coder W4A16 DGX single-session throughput",
  );
  assertNear(
    result.best.aggregate,
    62.12257776795101,
    0.000000001,
    "nm-testing Qwen3-Coder W4A16 DGX aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    20.707525922650337,
    0.000000001,
    "nm-testing Qwen3-Coder W4A16 DGX per-session throughput",
  );
  assertNear(
    result.dennard,
    1400.0108742620898,
    0.000000001,
    "nm-testing Qwen3-Coder W4A16 DGX Dennard bound",
  );
}

{
  const result = profiled(
    "nm-testing/Qwen3-Coder-30B-A3B-Instruct-W4A16-awq",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(result.best.batch, 7);
  assertNear(
    result.single.aggregate,
    118.18854543042646,
    0.000000001,
    "nm-testing Qwen3-Coder W4A16 M5 Max single-session throughput",
  );
  assertNear(
    result.best.aggregate,
    150.4426167099775,
    0.000000001,
    "nm-testing Qwen3-Coder W4A16 M5 Max aggregate throughput",
  );
  assertNear(
    result.dennard,
    3148.742405849535,
    0.000000001,
    "nm-testing Qwen3-Coder W4A16 M5 Max Dennard bound",
  );
}

{
  const catalogRow = model("cyankiwi/Qwen3-Coder-30B-A3B-Instruct-AWQ-4bit");
  const modelProfile = profile(
    "cyankiwi/Qwen3-Coder-30B-A3B-Instruct-AWQ-4bit",
  );
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "cyankiwi/Qwen3-Coder-30B-A3B-Instruct-AWQ-4bit",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(
    catalogRow.hf_downloads,
    245223,
    "cyankiwi Qwen3-Coder AWQ records current live downloads",
  );
  assert.ok(catalogRow.tags.includes("region:us"));
  assert.equal(
    modelProfile.base_model_proof.config_compatible,
    false,
    "cyankiwi Qwen3-Coder AWQ records served-config differences from the BF16 base",
  );
  assert.equal(modelProfile.serving.weight_format, "int4");
  assertNear(
    weightAdapter.resident_weight_gb,
    18.087607296,
    0.000000001,
    "cyankiwi Qwen3-Coder AWQ resident footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    17.46527744,
    0.000000001,
    "cyankiwi Qwen3-Coder AWQ main resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.622329856,
    0.000000001,
    "cyankiwi Qwen3-Coder AWQ resident-only input embedding footprint",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    1.157528576,
    0.000000001,
    "cyankiwi Qwen3-Coder AWQ fixed ordinary decode traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.127404288,
    0.000000001,
    "cyankiwi Qwen3-Coder AWQ per-expert traffic",
  );
  assertNear(
    catalogRow.adapter.active_weight_gb,
    2.17676288,
    0.000000001,
    "cyankiwi Qwen3-Coder AWQ catalog active traffic",
  );
  assertNear(
    result.single.batchWeight,
    2.17676288,
    0.000000001,
    "cyankiwi Qwen3-Coder AWQ single-session MoE decode traffic",
  );
  assertNear(
    result.single.batchWeight - weightAdapter.fixed_weight_gb,
    1.019234304,
    0.000000001,
    "cyankiwi Qwen3-Coder AWQ eight routed experts traffic",
  );
  assertNear(
    result.alloc,
    9.8304,
    0.000000001,
    "cyankiwi Qwen3-Coder AWQ BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    3.145728,
    0.000000001,
    "cyankiwi Qwen3-Coder AWQ BF16 KV read traffic",
  );
  assert.equal(result.bMem, 10);
  assert.equal(result.best.batch, 3);
  assertNear(
    result.single.aggregate,
    51.291774125125414,
    0.000000001,
    "cyankiwi Qwen3-Coder AWQ DGX single-session throughput",
  );
  assertNear(
    result.best.aggregate,
    60.82304749751837,
    0.000000001,
    "cyankiwi Qwen3-Coder AWQ DGX aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    20.274349165839457,
    0.000000001,
    "cyankiwi Qwen3-Coder AWQ DGX per-session throughput",
  );
  assertNear(
    result.dennard,
    1300.1915301346467,
    0.000000001,
    "cyankiwi Qwen3-Coder AWQ DGX Dennard bound",
  );
}

{
  const result = profiled(
    "cyankiwi/Qwen3-Coder-30B-A3B-Instruct-AWQ-4bit",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(result.best.batch, 7);
  assertNear(
    result.single.aggregate,
    115.35952129240661,
    0.000000001,
    "cyankiwi Qwen3-Coder AWQ M5 Max single-session throughput",
  );
  assertNear(
    result.best.aggregate,
    147.66979250672637,
    0.000000001,
    "cyankiwi Qwen3-Coder AWQ M5 Max aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    21.095684643818053,
    0.000000001,
    "cyankiwi Qwen3-Coder AWQ M5 Max per-session throughput",
  );
  assertNear(
    result.dennard,
    2924.2402912185826,
    0.000000001,
    "cyankiwi Qwen3-Coder AWQ M5 Max Dennard bound",
  );
}

{
  const catalogRow = model(
    "lmstudio-community/Qwen3-Coder-30B-A3B-Instruct-MLX-4bit",
  );
  const modelProfile = profile(
    "lmstudio-community/Qwen3-Coder-30B-A3B-Instruct-MLX-4bit",
  );
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "lmstudio-community/Qwen3-Coder-30B-A3B-Instruct-MLX-4bit",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(catalogRow.hf_downloads, 183045);
  assert.ok(catalogRow.tags.includes("region:us"));
  assert.equal(
    modelProfile.base_model_proof.config_compatible,
    false,
    "LM Studio Qwen3-Coder MLX records served-config differences from the BF16 base",
  );
  assert.equal(modelProfile.serving.weight_format, "mlx_quantized");
  assertNear(
    weightAdapter.resident_weight_gb,
    17.174622208,
    0.000000001,
    "LM Studio Qwen3-Coder MLX 4-bit resident footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    16.999591936,
    0.000000001,
    "LM Studio Qwen3-Coder MLX 4-bit main resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.175030272,
    0.000000001,
    "LM Studio Qwen3-Coder MLX 4-bit resident-only input embedding footprint",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    0.692137984,
    0.000000001,
    "LM Studio Qwen3-Coder MLX 4-bit fixed ordinary decode traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.127401984,
    0.000000001,
    "LM Studio Qwen3-Coder MLX 4-bit per-expert traffic",
  );
  assertNear(
    catalogRow.adapter.active_weight_gb,
    1.711353856,
    0.000000001,
    "LM Studio Qwen3-Coder MLX 4-bit catalog active traffic",
  );
  assertNear(
    result.single.batchWeight,
    1.7113538560000001,
    0.000000001,
    "LM Studio Qwen3-Coder MLX 4-bit single-session MoE decode traffic",
  );
  assertNear(
    result.single.batchWeight - weightAdapter.fixed_weight_gb,
    1.019215872,
    0.000000001,
    "LM Studio Qwen3-Coder MLX 4-bit eight routed experts traffic",
  );
  assertNear(
    result.alloc,
    9.8304,
    0.000000001,
    "LM Studio Qwen3-Coder MLX 4-bit BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    3.145728,
    0.000000001,
    "LM Studio Qwen3-Coder MLX 4-bit BF16 KV read traffic",
  );
  assert.equal(result.bMem, 10);
  assert.equal(result.best.batch, 3);
  assertNear(
    result.single.aggregate,
    56.20658825478933,
    0.000000001,
    "LM Studio Qwen3-Coder MLX 4-bit DGX single-session throughput",
  );
  assertNear(
    result.best.aggregate,
    63.00073693415855,
    0.000000001,
    "LM Studio Qwen3-Coder MLX 4-bit DGX aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    21.000245644719516,
    0.000000001,
    "LM Studio Qwen3-Coder MLX 4-bit DGX per-session throughput",
  );
  assertNear(
    result.dennard,
    1668.5989019678234,
    0.000000001,
    "LM Studio Qwen3-Coder MLX 4-bit DGX Dennard bound",
  );
}

{
  const result = profiled(
    "lmstudio-community/Qwen3-Coder-30B-A3B-Instruct-MLX-4bit",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(result.best.batch, 7);
  assertNear(
    result.single.aggregate,
    126.41335233861044,
    0.000000001,
    "LM Studio Qwen3-Coder MLX 4-bit M5 Max single-session throughput",
  );
  assertNear(
    result.best.aggregate,
    150.06993245889936,
    0.000000001,
    "LM Studio Qwen3-Coder MLX 4-bit M5 Max aggregate throughput",
  );
  assertNear(
    result.dennard,
    3752.819508455104,
    0.000000001,
    "LM Studio Qwen3-Coder MLX 4-bit M5 Max Dennard bound",
  );
}

for (const spec of [
  {
    repo: "lmstudio-community/Qwen3-Coder-30B-A3B-Instruct-MLX-5bit",
    label: "5-bit",
    downloads: 160568,
    resident: 20.991111168,
    mainResident: 20.77718528,
    auxiliary: 0.213925888,
    fixed: 0.845852672,
    routed: 0.155713536,
    active: 2.09156096,
    bMem: 10,
    dgxSingle: 52.12620538699472,
    dgxBatch: 2,
    dgxAggregate: 57.16757603178721,
    dgxPerSession: 28.583788015893607,
    dgxDennard: 1314.6045071523997,
    m5Single: 117.23622750042036,
    m5Batch: 7,
    m5Aggregate: 142.73866356906686,
    m5Dennard: 2956.6562908116243,
  },
  {
    repo: "lmstudio-community/Qwen3-Coder-30B-A3B-Instruct-MLX-6bit",
    label: "6-bit",
    downloads: 159385,
    resident: 24.807600128,
    mainResident: 24.554778624,
    auxiliary: 0.252821504,
    fixed: 0.99956736,
    routed: 0.184025088,
    active: 2.471768064,
    bMem: 9,
    dgxSingle: 48.59816489227895,
    dgxBatch: 2,
    dgxAggregate: 53.828040105491034,
    dgxPerSession: 26.914020052745517,
    dgxDennard: 1069.5128735994545,
    m5Single: 109.30136719362372,
    m5Batch: 6,
    m5Aggregate: 134.2726630715874,
    m5Dennard: 2405.4245582053663,
  },
]) {
  const catalogRow = model(spec.repo);
  const modelProfile = profile(spec.repo);
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(spec.repo, "nvidia-dgx-spark");
  const m5Result = profiled(spec.repo, "apple-macbook-pro-16-m5-max-128gb");
  assert.equal(result.status_code, "ok");
  assert.equal(catalogRow.hf_downloads, spec.downloads);
  assert.ok(catalogRow.tags.includes("region:us"));
  assert.equal(
    modelProfile.base_model_proof.config_compatible,
    false,
    `LM Studio Qwen3-Coder MLX ${spec.label} records served-config differences from the BF16 base`,
  );
  assert.equal(modelProfile.serving.weight_format, "mlx_quantized");
  assertNear(
    weightAdapter.resident_weight_gb,
    spec.resident,
    0.000000001,
    `LM Studio Qwen3-Coder MLX ${spec.label} resident footprint`,
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    spec.mainResident,
    0.000000001,
    `LM Studio Qwen3-Coder MLX ${spec.label} main resident footprint`,
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    spec.auxiliary,
    0.000000001,
    `LM Studio Qwen3-Coder MLX ${spec.label} resident-only input embedding footprint`,
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    spec.fixed,
    0.000000001,
    `LM Studio Qwen3-Coder MLX ${spec.label} fixed ordinary decode traffic`,
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    spec.routed,
    0.000000001,
    `LM Studio Qwen3-Coder MLX ${spec.label} per-expert traffic`,
  );
  assertNear(
    catalogRow.adapter.active_weight_gb,
    spec.active,
    0.000000001,
    `LM Studio Qwen3-Coder MLX ${spec.label} catalog active traffic`,
  );
  assertNear(
    result.single.batchWeight,
    spec.active,
    0.000000001,
    `LM Studio Qwen3-Coder MLX ${spec.label} single-session MoE decode traffic`,
  );
  assertNear(
    result.alloc,
    9.8304,
    0.000000001,
    `LM Studio Qwen3-Coder MLX ${spec.label} BF16 KV allocation`,
  );
  assertNear(
    result.single.readTraffic,
    3.145728,
    0.000000001,
    `LM Studio Qwen3-Coder MLX ${spec.label} BF16 KV read traffic`,
  );
  assert.equal(result.bMem, spec.bMem);
  assert.equal(result.best.batch, spec.dgxBatch);
  assertNear(
    result.single.aggregate,
    spec.dgxSingle,
    0.000000001,
    `LM Studio Qwen3-Coder MLX ${spec.label} DGX single-session throughput`,
  );
  assertNear(
    result.best.aggregate,
    spec.dgxAggregate,
    0.000000001,
    `LM Studio Qwen3-Coder MLX ${spec.label} DGX aggregate throughput`,
  );
  assertNear(
    result.best.perSession,
    spec.dgxPerSession,
    0.000000001,
    `LM Studio Qwen3-Coder MLX ${spec.label} DGX per-session throughput`,
  );
  assertNear(
    result.dennard,
    spec.dgxDennard,
    0.000000001,
    `LM Studio Qwen3-Coder MLX ${spec.label} DGX Dennard bound`,
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, spec.m5Batch);
  assertNear(
    m5Result.single.aggregate,
    spec.m5Single,
    0.000000001,
    `LM Studio Qwen3-Coder MLX ${spec.label} M5 Max single-session throughput`,
  );
  assertNear(
    m5Result.best.aggregate,
    spec.m5Aggregate,
    0.000000001,
    `LM Studio Qwen3-Coder MLX ${spec.label} M5 Max aggregate throughput`,
  );
  assertNear(
    m5Result.dennard,
    spec.m5Dennard,
    0.000000001,
    `LM Studio Qwen3-Coder MLX ${spec.label} M5 Max Dennard bound`,
  );
}

{
  const catalogRow = model(
    "lmstudio-community/Qwen3-Coder-30B-A3B-Instruct-MLX-8bit",
  );
  const modelProfile = profile(
    "lmstudio-community/Qwen3-Coder-30B-A3B-Instruct-MLX-8bit",
  );
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "lmstudio-community/Qwen3-Coder-30B-A3B-Instruct-MLX-8bit",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(catalogRow.hf_downloads, 163274);
  assert.ok(catalogRow.tags.includes("region:us"));
  assert.equal(
    modelProfile.base_model_proof.config_compatible,
    false,
    "LM Studio Qwen3-Coder MLX 8-bit records served-config differences from the BF16 base",
  );
  assert.equal(modelProfile.serving.weight_format, "mlx_quantized");
  assertNear(
    weightAdapter.resident_weight_gb,
    32.440578048,
    0.000000001,
    "LM Studio Qwen3-Coder MLX 8-bit resident footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    32.109965312,
    0.000000001,
    "LM Studio Qwen3-Coder MLX 8-bit main resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.330612736,
    0.000000001,
    "LM Studio Qwen3-Coder MLX 8-bit resident-only input embedding footprint",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    1.306996736,
    0.000000001,
    "LM Studio Qwen3-Coder MLX 8-bit fixed ordinary decode traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.240648192,
    0.000000001,
    "LM Studio Qwen3-Coder MLX 8-bit per-expert traffic",
  );
  assertNear(
    catalogRow.adapter.active_weight_gb,
    3.232182272,
    0.000000001,
    "LM Studio Qwen3-Coder MLX 8-bit catalog active traffic",
  );
  assertNear(
    result.single.batchWeight,
    3.232182272,
    0.000000001,
    "LM Studio Qwen3-Coder MLX 8-bit single-session MoE decode traffic",
  );
  assertNear(
    result.alloc,
    9.8304,
    0.000000001,
    "LM Studio Qwen3-Coder MLX 8-bit BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    3.145728,
    0.000000001,
    "LM Studio Qwen3-Coder MLX 8-bit BF16 KV read traffic",
  );
  assert.equal(result.bMem, 8);
  assert.equal(result.best.batch, 2);
  assertNear(
    result.single.aggregate,
    42.8039888235041,
    0.000000001,
    "LM Studio Qwen3-Coder MLX 8-bit DGX single-session throughput",
  );
  assertNear(
    result.best.aggregate,
    48.1970264272184,
    0.000000001,
    "LM Studio Qwen3-Coder MLX 8-bit DGX aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    24.0985132136092,
    0.000000001,
    "LM Studio Qwen3-Coder MLX 8-bit DGX per-session throughput",
  );
  assertNear(
    result.dennard,
    752.3128834857988,
    0.000000001,
    "LM Studio Qwen3-Coder MLX 8-bit DGX Dennard bound",
  );
}

{
  const result = profiled(
    "lmstudio-community/Qwen3-Coder-30B-A3B-Instruct-MLX-8bit",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(result.best.batch, 6);
  assertNear(
    result.single.aggregate,
    96.26977706092131,
    0.000000001,
    "LM Studio Qwen3-Coder MLX 8-bit M5 Max single-session throughput",
  );
  assertNear(
    result.best.aggregate,
    122.50946548667548,
    0.000000001,
    "LM Studio Qwen3-Coder MLX 8-bit M5 Max aggregate throughput",
  );
  assertNear(
    result.dennard,
    1692.0150566310638,
    0.000000001,
    "LM Studio Qwen3-Coder MLX 8-bit M5 Max Dennard bound",
  );
}

{
  const modelProfile = profile("Qwen/Qwen3-Coder-480B-A35B-Instruct-FP8");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "Qwen/Qwen3-Coder-480B-A35B-Instruct-FP8",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "resident_not_fit");
  assertNear(
    result.resident,
    482.141974528,
    0.000000001,
    "Qwen3-Coder 480B A35B FP8 DGX resident footprint",
  );
  assertNear(
    result.alloc,
    25.3952,
    0.000000001,
    "Qwen3-Coder 480B A35B FP8 BF16 KV allocation",
  );
  assertNear(
    result.single.batchWeight,
    35.54059264,
    0.000000001,
    "Qwen3-Coder 480B A35B FP8 single-session MoE decode traffic",
  );
  assertNear(
    result.single.readTraffic,
    8.126464,
    0.000000001,
    "Qwen3-Coder 480B A35B FP8 BF16 KV read traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.866989568,
    0.000000001,
    "Qwen3-Coder 480B A35B FP8 resident-only input embedding footprint",
  );
  assert.equal(result.bMem, 0);
  assert.equal(result.best, null);
  assert.equal(result.dennard, 0);
}

{
  const result = profiled(
    "Qwen/Qwen3-Coder-480B-A35B-Instruct-FP8",
    "nvidia-msi-xpertstation-ws300-dgx-station-gb300",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(result.bMem, 10);
  assert.equal(result.best?.batch, 10);
  assertNear(
    result.single.aggregate,
    162.59396777149018,
    0.000000001,
    "Qwen3-Coder 480B A35B FP8 GB300 single-session throughput",
  );
  assertNear(
    result.best?.batchWeight ?? 0,
    199.98139671608732,
    0.000000001,
    "Qwen3-Coder 480B A35B FP8 GB300 expected distinct expert traffic",
  );
  assertNear(
    result.best?.aggregate ?? 0,
    252.44800185992733,
    0.000000001,
    "Qwen3-Coder 480B A35B FP8 GB300 aggregate throughput",
  );
  assertNear(
    result.best?.perSession ?? 0,
    25.244800185992734,
    0.000000001,
    "Qwen3-Coder 480B A35B FP8 GB300 per-session throughput",
  );
  assertNear(
    result.dennard,
    2028.4424873646885,
    0.000000001,
    "Qwen3-Coder 480B A35B FP8 GB300 Dennard bound",
  );
}

{
  const result = profiled("MiniMaxAI/MiniMax-M2.7", "nvidia-dgx-spark");
  assert.equal(result.status_code, "resident_not_fit");
  assertNear(
    result.resident,
    230.12163072,
    0.000000001,
    "MiniMax M2.7 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    11.180086272,
    0.000000001,
    "MiniMax M2.7 single-session MoE decode traffic",
  );
  assertNear(
    result.single.batchWeight - 4.1571072,
    7.022979072,
    0.000000001,
    "MiniMax M2.7 eight routed experts traffic",
  );
  assertNear(
    result.alloc,
    25.3952,
    0.000000001,
    "MiniMax M2.7 BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    8.126464,
    0.000000001,
    "MiniMax M2.7 BF16 KV read traffic",
  );
}

{
  const result = profiled("lukealonso/MiniMax-M2.7-NVFP4", "nvidia-dgx-spark");
  assert.equal(result.status_code, "resident_not_fit");
  assertNear(
    result.resident,
    134.401725368,
    0.000000001,
    "MiniMax M2.7 NVFP4 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    10.738856574,
    0.000000001,
    "MiniMax M2.7 NVFP4 single-session MoE decode traffic",
  );
  assertNear(
    result.single.batchWeight - 6.789383168,
    3.949473406,
    0.000000001,
    "MiniMax M2.7 NVFP4 eight routed experts traffic",
  );
  assertNear(
    result.alloc,
    25.3952,
    0.000000001,
    "MiniMax M2.7 NVFP4 BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    8.126464,
    0.000000001,
    "MiniMax M2.7 NVFP4 BF16 KV read traffic",
  );
  assert.equal(result.bMem, 0);
  assert.equal(result.best, null);
}

{
  const repo = "nvidia/MiniMax-M2.7-NVFP4";
  const catalogRow = model(repo);
  const item = profile(repo);
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  assert.equal(item.status, "audited");
  assert.equal(item.base_model_proof.config_compatible, false);
  assert.equal(catalogRow.hf_downloads, 100248);
  assert.equal(catalogRow.tags.includes("region:us"), true);
  assert.equal(catalogRow.adapter.kv_alloc_gb_per_1k_tokens, 0.126976);
  assert.equal(result.status_code, "resident_not_fit");
  assertNear(
    result.resident,
    139.862709248,
    0.000000001,
    "NVIDIA MiniMax M2.7 NVFP4 resident footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    138.633516032,
    0.000000001,
    "NVIDIA MiniMax M2.7 NVFP4 main resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.229193216,
    0.000000001,
    "NVIDIA MiniMax M2.7 NVFP4 resident-only embedding footprint",
  );
  assertNear(
    result.single.batchWeight,
    16.199840384,
    0.000000001,
    "NVIDIA MiniMax M2.7 NVFP4 single-session MoE decode traffic",
  );
  assertNear(
    result.single.batchWeight - 12.250366976,
    3.949473408,
    0.000000001,
    "NVIDIA MiniMax M2.7 NVFP4 eight routed experts traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.493684176,
    0.000000001,
    "NVIDIA MiniMax M2.7 NVFP4 single routed expert traffic",
  );
  assertNear(
    result.alloc,
    12.6976,
    0.000000001,
    "NVIDIA MiniMax M2.7 NVFP4 FP8 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    4.063232,
    0.000000001,
    "NVIDIA MiniMax M2.7 NVFP4 FP8 KV read traffic",
  );
  assert.equal(result.bMem, 0);
  assert.equal(result.best, null);
}

{
  const item = profile("MiniMaxAI/MiniMax-M2.5");
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled("MiniMaxAI/MiniMax-M2.5", "nvidia-dgx-spark");
  assert.equal(result.status_code, "resident_not_fit");
  assert.equal(result.bMem, 0);
  assert.equal(result.best, null);
  assertNear(
    result.resident,
    230.12163072,
    0.000000001,
    "MiniMax M2.5 resident footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    228.892437504,
    0.000000001,
    "MiniMax M2.5 main resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.229193216,
    0.000000001,
    "MiniMax M2.5 resident-only embedding footprint",
  );
  assertNear(
    result.single.batchWeight,
    11.180086272,
    0.000000001,
    "MiniMax M2.5 single-session MoE decode traffic",
  );
  assertNear(
    result.single.batchWeight - 4.1571072,
    7.022979072,
    0.000000001,
    "MiniMax M2.5 eight routed experts traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.877872384,
    0.000000001,
    "MiniMax M2.5 single routed expert traffic",
  );
  assertNear(
    result.alloc,
    25.3952,
    0.000000001,
    "MiniMax M2.5 BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    8.126464,
    0.000000001,
    "MiniMax M2.5 BF16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    14.1402786180775,
    0.000000001,
    "MiniMax M2.5 DGX single-session bound despite non-fit resident payload",
  );
}

{
  const repo = "MiniMaxAI/MiniMax-M2";
  const item = profile(repo);
  const catalogRow = model(repo);
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  assert.equal(item.status, "audited");
  assert.equal(catalogRow.hf_downloads, 113607);
  assert.equal(catalogRow.tags.includes("region:us"), true);
  assert.equal(catalogRow.architecture.total_params_b, 228.703644928);
  assert.equal(catalogRow.architecture.active_params_b, 10.41655168);
  assert.equal(catalogRow.adapter.resident_weight_gb, 230.12163072);
  assert.equal(catalogRow.adapter.active_weight_gb, 11.180086272);
  assert.equal(result.status_code, "resident_not_fit");
  assert.equal(result.bMem, 0);
  assert.equal(result.best, null);
  assertNear(
    result.resident,
    230.12163072,
    0.000000001,
    "MiniMax M2 resident footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    228.892437504,
    0.000000001,
    "MiniMax M2 main resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.229193216,
    0.000000001,
    "MiniMax M2 resident-only embedding footprint",
  );
  assertNear(
    result.single.batchWeight,
    11.180086272,
    0.000000001,
    "MiniMax M2 single-session MoE decode traffic",
  );
  assertNear(
    result.single.batchWeight - 4.1571072,
    7.022979072,
    0.000000001,
    "MiniMax M2 eight routed experts traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.877872384,
    0.000000001,
    "MiniMax M2 single routed expert traffic",
  );
  assertNear(
    result.alloc,
    25.3952,
    0.000000001,
    "MiniMax M2 BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    8.126464,
    0.000000001,
    "MiniMax M2 BF16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    14.1402786180775,
    0.000000001,
    "MiniMax M2 DGX single-session bound despite non-fit resident payload",
  );
}

{
  const result = profiled(
    "Qwen/Qwen3-Omni-30B-A3B-Instruct",
    "nvidia-dgx-spark",
  );
  assertNear(
    result.resident,
    70.51963709,
    0.000000001,
    "Qwen3 Omni 30B A3B Instruct full package resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    6.08425984,
    0.000000001,
    "Qwen3 Omni 30B A3B Instruct single-session Thinker text decode traffic",
  );
  assertNear(
    result.single.batchWeight - 2.460381184,
    3.623878656,
    0.000000001,
    "Qwen3 Omni 30B A3B Instruct eight routed Thinker experts traffic",
  );
  assertNear(
    result.alloc,
    9.8304,
    0.000000001,
    "Qwen3 Omni 30B A3B Instruct BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    3.145728,
    0.000000001,
    "Qwen3 Omni 30B A3B Instruct BF16 KV read traffic",
  );
}

{
  const modelProfile = profile("Qwen/Qwen3-Omni-30B-A3B-Thinking");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "Qwen/Qwen3-Omni-30B-A3B-Thinking",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    63.438410976,
    0.000000001,
    "Qwen3 Omni 30B A3B Thinking thinker package resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    2.995971296,
    0.000000001,
    "Qwen3 Omni 30B A3B Thinking resident-only embedding/audio/vision footprint",
  );
  assertNear(
    result.single.batchWeight,
    6.08425984,
    0.000000001,
    "Qwen3 Omni 30B A3B Thinking single-session Thinker text decode traffic",
  );
  assertNear(
    result.single.batchWeight - 2.460381184,
    3.623878656,
    0.000000001,
    "Qwen3 Omni 30B A3B Thinking eight routed Thinker experts traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.452984832,
    0.000000001,
    "Qwen3 Omni 30B A3B Thinking single routed expert traffic",
  );
  assertNear(
    result.alloc,
    9.8304,
    0.000000001,
    "Qwen3 Omni 30B A3B Thinking BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    3.145728,
    0.000000001,
    "Qwen3 Omni 30B A3B Thinking BF16 KV read traffic",
  );
  assert.equal(result.bMem, 5);
  assert.equal(result.best.batch, 1);
  assertNear(
    result.dennard,
    258.169721404,
    0.000000001,
    "Qwen3 Omni 30B A3B Thinking DGX Dennard bound",
  );
}

{
  const modelProfile = profile("moonshotai/Kimi-VL-A3B-Instruct");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "moonshotai/Kimi-VL-A3B-Instruct",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    32.815315552,
    0.000000001,
    "Kimi VL A3B Instruct full multimodal package resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.56618032,
    0.000000001,
    "Kimi VL A3B Instruct resident-only embedding/vision/projector footprint",
  );
  assertNear(
    result.single.batchWeight,
    5.1584672,
    0.000000001,
    "Kimi VL A3B Instruct single-session text decode traffic",
  );
  assertNear(
    result.single.batchWeight - weightAdapter.fixed_weight_gb,
    2.699034624,
    0.000000001,
    "Kimi VL A3B Instruct six routed expert traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.449839104,
    0.000000001,
    "Kimi VL A3B Instruct single routed expert traffic",
  );
  assertNear(
    result.alloc,
    27.648,
    0.000000001,
    "Kimi VL A3B Instruct expanded BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    8.84736,
    0.000000001,
    "Kimi VL A3B Instruct expanded BF16 KV read traffic",
  );
  assert.equal(result.bMem, 3);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    19.491886919752943,
    0.000000001,
    "Kimi VL A3B Instruct DGX Spark single-session throughput",
  );
  assertNear(
    result.dennard,
    166.88544181773716,
    0.000000001,
    "Kimi VL A3B Instruct DGX Spark Dennard bound",
  );
}

{
  const result = profiled(
    "moonshotai/Kimi-VL-A3B-Instruct",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(result.bMem, 3);
  assert.equal(result.best?.batch, 2);
  assertNear(
    result.single.aggregate,
    43.838895856147644,
    0.000000001,
    "Kimi VL A3B Instruct M5 Max single-session throughput",
  );
  assertNear(
    result.best?.aggregate ?? 0,
    48.53910855234883,
    0.000000001,
    "Kimi VL A3B Instruct M5 Max aggregate throughput",
  );
  assertNear(
    result.best?.perSession ?? 0,
    24.269554276174414,
    0.000000001,
    "Kimi VL A3B Instruct M5 Max per-session throughput",
  );
  assertNear(
    result.dennard,
    375.3394185937385,
    0.000000001,
    "Kimi VL A3B Instruct M5 Max Dennard bound",
  );
}

{
  const repo = "moonshotai/Kimi-VL-A3B-Thinking";
  const modelProfile = profile(repo);
  const modelRow = model(repo);
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const dgxResult = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  const m1UltraResult = profiled(repo, "apple-mac-studio-m1-ultra-128gb");

  assert.equal(modelProfile.status, "audited");
  assert.equal(modelRow.hf_downloads, 145860);
  assert.ok(modelRow.tags.includes("region:us"));
  assert.equal(
    modelRow.architecture.detail,
    "kimi_vl with DeepseekV3 language model",
  );
  assert.equal(modelRow.architecture.total_params_b, 16.407657776);
  assert.equal(modelRow.architecture.active_params_b, 2.5792336);
  assert.equal(modelRow.adapter.resident_weight_gb, 32.815315552);
  assert.equal(modelRow.adapter.active_weight_gb, 5.1584672);
  assert.equal(modelRow.adapter.kv_alloc_gb_per_1k_tokens, 0.27648);
  assert.equal(weightAdapter.kind, "moe_distinct_experts_exact");
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.56618032,
    0.000000001,
    "Kimi VL A3B Thinking resident-only embedding/vision/projector footprint",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    2.459432576,
    0.000000001,
    "Kimi VL A3B Thinking fixed ordinary text traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.449839104,
    0.000000001,
    "Kimi VL A3B Thinking single routed expert traffic",
  );
  assert.equal(dgxResult.status_code, "no_floor");
  assertNear(
    dgxResult.resident,
    32.815315552,
    0.000000001,
    "Kimi VL A3B Thinking full multimodal package resident footprint",
  );
  assertNear(
    dgxResult.single.batchWeight,
    5.1584672,
    0.000000001,
    "Kimi VL A3B Thinking single-session text decode traffic",
  );
  assertNear(
    dgxResult.alloc,
    27.648,
    0.000000001,
    "Kimi VL A3B Thinking expanded BF16 KV allocation",
  );
  assertNear(
    dgxResult.single.readTraffic,
    8.84736,
    0.000000001,
    "Kimi VL A3B Thinking expanded BF16 KV read traffic",
  );
  assert.equal(dgxResult.bMem, 3);
  assert.equal(dgxResult.best, null);
  assertNear(
    dgxResult.single.aggregate,
    19.491886919752943,
    0.000000001,
    "Kimi VL A3B Thinking DGX Spark single-session throughput",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best?.batch, 2);
  assertNear(
    m5Result.best?.aggregate ?? 0,
    48.53910855234883,
    0.000000001,
    "Kimi VL A3B Thinking M5 Max aggregate throughput",
  );
  assert.equal(m1UltraResult.status_code, "ok");
  assert.equal(m1UltraResult.best?.batch, 3);
  assertNear(
    m1UltraResult.best?.aggregate ?? 0,
    66.00072858468288,
    0.000000001,
    "Kimi VL A3B Thinking M1 Ultra aggregate throughput",
  );
}

{
  const result = profiled("deepseek-ai/DeepSeek-V4-Flash", "nvidia-dgx-spark");
  assert.equal(result.status_code, "resident_not_fit");
  assertNear(
    result.resident,
    159.609485896,
    0.000000001,
    "DeepSeek V4 Flash official checkpoint resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    11.23618838,
    0.000000001,
    "DeepSeek V4 Flash mixed FP4/FP8 active text-decode traffic",
  );
  assertNear(
    result.single.batchWeight - 7.786897628,
    3.449290752,
    0.000000001,
    "DeepSeek V4 Flash six routed expert indexes traffic",
  );
  assertNear(
    result.alloc,
    0.705842176,
    0.000000001,
    "DeepSeek V4 Flash CSA/HCA KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.064774144,
    0.000000001,
    "DeepSeek V4 Flash CSA/HCA KV read traffic",
  );
}

{
  const result = profiled(
    "sgl-project/DeepSeek-V4-Flash-FP8",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "resident_not_fit");
  assertNear(
    result.resident,
    294.03138004,
    0.000000001,
    "SGL DeepSeek V4 Flash FP8 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    15.724826204,
    0.000000001,
    "SGL DeepSeek V4 Flash FP8 active text-decode traffic",
  );
  assertNear(
    result.single.batchWeight - 9.23045846,
    6.494367744,
    0.000000001,
    "SGL DeepSeek V4 Flash FP8 six routed expert indexes traffic",
  );
  assertNear(
    result.alloc,
    0.705842176,
    0.000000001,
    "SGL DeepSeek V4 Flash FP8 CSA/HCA KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.064774144,
    0.000000001,
    "SGL DeepSeek V4 Flash FP8 CSA/HCA KV read traffic",
  );
}

{
  const result = profiled("nvidia/DeepSeek-V4-Flash-NVFP4", "nvidia-dgx-spark");
  assert.equal(result.status_code, "resident_not_fit");
  assertNear(
    result.resident,
    168.266793544,
    0.000000001,
    "NVIDIA DeepSeek V4 Flash NVFP4 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    11.439094028,
    0.000000001,
    "NVIDIA DeepSeek V4 Flash NVFP4 active text-decode traffic",
  );
  assertNear(
    result.single.batchWeight - 7.786897628,
    3.6521964,
    0.000000001,
    "NVIDIA DeepSeek V4 Flash NVFP4 six routed expert indexes traffic",
  );
  assertNear(
    result.alloc,
    0.705842176,
    0.000000001,
    "NVIDIA DeepSeek V4 Flash NVFP4 CSA/HCA KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.064774144,
    0.000000001,
    "NVIDIA DeepSeek V4 Flash NVFP4 CSA/HCA KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    23.73114816,
    0.000000001,
    "NVIDIA DeepSeek V4 Flash NVFP4 DGX Spark single-session tok/s",
  );
  assert.equal(result.bMem, 0);
  assert.equal(result.best, null);
  assert.equal(result.dennard, 0);
}

{
  const result = profiled(
    "nvidia/DeepSeek-V4-Flash-NVFP4",
    "nvidia-4x-rtx-pro-6000-blackwell-workstation-2026-bom",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.single.aggregate,
    623.094761938,
    0.000000001,
    "NVIDIA DeepSeek V4 Flash NVFP4 4x RTX PRO single-session tok/s",
  );
  assert.equal(result.bMem, 294);
  assert.equal(result.best?.batch, 294);
  assertNear(
    result.best?.batchWeight ?? 0,
    163.467909488,
    0.000000001,
    "NVIDIA DeepSeek V4 Flash NVFP4 4x RTX PRO expected distinct expert traffic",
  );
  assertNear(
    result.best?.aggregate ?? 0,
    11546.625334068,
    0.000000001,
    "NVIDIA DeepSeek V4 Flash NVFP4 4x RTX PRO aggregate throughput",
  );
  assertNear(
    result.best?.perSession ?? 0,
    39.27423583,
    0.000000001,
    "NVIDIA DeepSeek V4 Flash NVFP4 4x RTX PRO per-session throughput",
  );
  assertNear(
    result.dennard,
    184418.585401121,
    0.000000001,
    "NVIDIA DeepSeek V4 Flash NVFP4 4x RTX PRO Dennard bound",
  );
}

{
  const result = profiled("deepseek-ai/DeepSeek-V4-Pro", "nvidia-dgx-spark");
  assert.equal(result.status_code, "resident_not_fit");
  assertNear(
    result.resident,
    864.704792696,
    0.000000001,
    "DeepSeek V4 Pro official checkpoint resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    39.6852203,
    0.000000001,
    "DeepSeek V4 Pro mixed FP4/FP8 active text-decode traffic",
  );
  assertNear(
    result.single.batchWeight - 26.840623052,
    12.844597248,
    0.000000001,
    "DeepSeek V4 Pro six routed expert indexes traffic",
  );
  assertNear(
    result.alloc,
    1.01150592,
    0.000000001,
    "DeepSeek V4 Pro CSA/HCA KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.108828672,
    0.000000001,
    "DeepSeek V4 Pro CSA/HCA KV read traffic",
  );
}

{
  const proNvfp4Profile = profile("nvidia/DeepSeek-V4-Pro-NVFP4");
  const weightAdapter = proNvfp4Profile.architecture.weight_adapter;
  assertNear(
    weightAdapter.resident_weight_gb,
    913.061485688,
    0.000000001,
    "NVIDIA DeepSeek V4 Pro NVFP4 resident tensor payload",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    897.251539916,
    0.000000001,
    "NVIDIA DeepSeek V4 Pro NVFP4 main resident payload",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    15.809945772,
    0.000000001,
    "NVIDIA DeepSeek V4 Pro NVFP4 auxiliary resident payload",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    26.84016428,
    0.000000001,
    "NVIDIA DeepSeek V4 Pro NVFP4 fixed ordinary traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    2.266695096,
    0.000000001,
    "NVIDIA DeepSeek V4 Pro NVFP4 routed expert traffic",
  );

  const dgx = profiled("nvidia/DeepSeek-V4-Pro-NVFP4", "nvidia-dgx-spark");
  assert.equal(dgx.status_code, "resident_not_fit");
  assertNear(
    dgx.resident,
    913.061485688,
    0.000000001,
    "NVIDIA DeepSeek V4 Pro NVFP4 DGX Spark resident footprint",
  );
  assertNear(
    dgx.single.batchWeight,
    40.440334856,
    0.000000001,
    "NVIDIA DeepSeek V4 Pro NVFP4 active text-decode traffic",
  );
  assertNear(
    dgx.single.batchWeight - 26.84016428,
    13.600170576,
    0.000000001,
    "NVIDIA DeepSeek V4 Pro NVFP4 six routed expert indexes traffic",
  );
  assertNear(
    dgx.alloc,
    1.01150592,
    0.000000001,
    "NVIDIA DeepSeek V4 Pro NVFP4 CSA/HCA KV allocation",
  );
  assertNear(
    dgx.single.readTraffic,
    0.108828672,
    0.000000001,
    "NVIDIA DeepSeek V4 Pro NVFP4 CSA/HCA KV read traffic",
  );
  assertNear(
    dgx.single.aggregate,
    6.73256798,
    0.000000001,
    "NVIDIA DeepSeek V4 Pro NVFP4 DGX Spark single-session tok/s",
  );
  assert.equal(dgx.bMem, 0);
  assert.equal(dgx.best, null);
  assert.equal(dgx.dennard, 0);

  const gb300 = profiled(
    "nvidia/DeepSeek-V4-Pro-NVFP4",
    "nvidia-msi-xpertstation-ws300-dgx-station-gb300",
  );
  assert.equal(gb300.status_code, "resident_not_fit");
  assertNear(
    gb300.free,
    -173.061485688,
    0.000000001,
    "NVIDIA DeepSeek V4 Pro NVFP4 GB300 resident overage",
  );
  assert.equal(gb300.bMem, 0);
  assert.equal(gb300.best, null);
}

{
  const result = profiled("Qwen/Qwen3-VL-2B-Instruct", "nvidia-dgx-spark");
  assertNear(
    result.resident,
    4.255064064,
    0.000000001,
    "Qwen3 VL 2B Instruct resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    3.441149952,
    0.000000001,
    "Qwen3 VL 2B Instruct swept BF16 text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    0.813914112,
    0.000000001,
    "Qwen3 VL 2B Instruct resident visual footprint",
  );
  assertNear(
    result.alloc,
    11.4688,
    0.000000001,
    "Qwen3 VL 2B Instruct BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    3.670016,
    0.000000001,
    "Qwen3 VL 2B Instruct BF16 KV read traffic",
  );
}

{
  const modelProfile = profile("cyankiwi/Qwen3-VL-2B-Instruct-AWQ-4bit");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "cyankiwi/Qwen3-VL-2B-Instruct-AWQ-4bit",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    weightAdapter.resident_params_b,
    2.171572616,
    0.000000001,
    "cyankiwi Qwen3 VL 2B AWQ logical resident parameters",
  );
  assertNear(
    weightAdapter.swept_params_b,
    1.76461556,
    0.000000001,
    "cyankiwi Qwen3 VL 2B AWQ logical swept parameters",
  );
  assertNear(
    result.resident,
    2.229218368,
    0.000000001,
    "cyankiwi Qwen3 VL 2B AWQ resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    1.415304256,
    0.000000001,
    "cyankiwi Qwen3 VL 2B AWQ swept text-decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.813914112,
    0.000000001,
    "cyankiwi Qwen3 VL 2B AWQ resident visual footprint",
  );
  assertNear(
    result.alloc,
    11.4688,
    0.000000001,
    "cyankiwi Qwen3 VL 2B AWQ BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    3.670016,
    0.000000001,
    "cyankiwi Qwen3 VL 2B AWQ BF16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    53.68393459151297,
    0.000000001,
    "cyankiwi Qwen3 VL 2B AWQ DGX single-session throughput",
  );
  assert.equal(result.bMem, 10);
  assert.equal(result.best.batch, 3);
  assertNear(
    result.best.aggregate,
    65.91362426803781,
    0.000000001,
    "cyankiwi Qwen3 VL 2B AWQ DGX aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    21.971208089345936,
    0.000000001,
    "cyankiwi Qwen3 VL 2B AWQ DGX per-session throughput",
  );
  assertNear(
    result.dennard,
    1980.762532838425,
    0.000000001,
    "cyankiwi Qwen3 VL 2B AWQ DGX Dennard bound",
  );
}

{
  const modelProfile = profile("unsloth/Qwen3-VL-2B-Instruct-GGUF");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "unsloth/Qwen3-VL-2B-Instruct-GGUF",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    3.44735072,
    0.000000001,
    "Unsloth Qwen3 VL 2B GGUF resident selected-artifact footprint",
  );
  assertNear(
    result.single.batchWeight,
    3.44139776,
    0.000000001,
    "Unsloth Qwen3 VL 2B GGUF swept BF16/F32 text-decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.00595296,
    0.000000001,
    "Unsloth Qwen3 VL 2B GGUF resident metadata/header footprint",
  );
  assertNear(
    result.alloc,
    11.4688,
    0.000000001,
    "Unsloth Qwen3 VL 2B GGUF FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    3.670016,
    0.000000001,
    "Unsloth Qwen3 VL 2B GGUF FP16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    38.38899116453604,
    0.000000001,
    "Unsloth Qwen3 VL 2B GGUF DGX single-session throughput",
  );
  assert.equal(result.bMem, 10);
  assert.equal(result.best.batch, 2);
  assertNear(
    result.best.aggregate,
    50.64263387641826,
    0.000000001,
    "Unsloth Qwen3 VL 2B GGUF DGX aggregate throughput",
  );
  assertNear(
    result.dennard,
    806.1798623536436,
    0.000000001,
    "Unsloth Qwen3 VL 2B GGUF DGX Dennard bound",
  );
}

{
  const result = profiled("Qwen/Qwen3-VL-4B-Instruct", "nvidia-dgx-spark");
  assertNear(
    result.resident,
    8.875631616,
    0.000000001,
    "Qwen3 VL 4B Instruct resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    8.044936192,
    0.000000001,
    "Qwen3 VL 4B Instruct swept BF16 text-decode traffic",
  );
  assertNear(
    result.alloc,
    14.7456,
    0.000000001,
    "Qwen3 VL 4B Instruct BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    4.718592,
    0.000000001,
    "Qwen3 VL 4B Instruct BF16 KV read traffic",
  );
}

{
  const modelProfile = profile("cyankiwi/Qwen3-VL-4B-Instruct-AWQ-4bit");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "cyankiwi/Qwen3-VL-4B-Instruct-AWQ-4bit",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    weightAdapter.resident_params_b,
    4.940313592,
    0.000000001,
    "cyankiwi Qwen3 VL 4B AWQ logical resident parameters",
  );
  assertNear(
    weightAdapter.swept_params_b,
    4.13600972,
    0.000000001,
    "cyankiwi Qwen3 VL 4B AWQ logical swept parameters",
  );
  assertNear(
    result.resident,
    4.430656448,
    0.000000001,
    "cyankiwi Qwen3 VL 4B AWQ resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    2.822048704,
    0.000000001,
    "cyankiwi Qwen3 VL 4B AWQ swept text-decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.608607744,
    0.000000001,
    "cyankiwi Qwen3 VL 4B AWQ resident visual plus input embedding footprint",
  );
  assertNear(
    result.alloc,
    14.7456,
    0.000000001,
    "cyankiwi Qwen3 VL 4B AWQ BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    4.718592,
    0.000000001,
    "cyankiwi Qwen3 VL 4B AWQ BF16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    36.20382016811711,
    0.000000001,
    "cyankiwi Qwen3 VL 4B AWQ DGX single-session throughput",
  );
  assert.equal(result.bMem, 7);
  assert.equal(result.best.batch, 2);
  assertNear(
    result.best.aggregate,
    44.53786082564927,
    0.000000001,
    "cyankiwi Qwen3 VL 4B AWQ DGX aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    22.268930412824634,
    0.000000001,
    "cyankiwi Qwen3 VL 4B AWQ DGX per-session throughput",
  );
  assertNear(
    result.dennard,
    758.1905027107199,
    0.000000001,
    "cyankiwi Qwen3 VL 4B AWQ DGX Dennard bound",
  );
}

{
  const result = profiled(
    "cyankiwi/Qwen3-VL-4B-Instruct-AWQ-4bit",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.single.aggregate,
    81.42544169679086,
    0.000000001,
    "cyankiwi Qwen3 VL 4B AWQ M5 Max single-session throughput",
  );
  assert.equal(result.bMem, 7);
  assert.equal(result.best.batch, 5);
  assertNear(
    result.best.aggregate,
    116.22180535322377,
    0.000000001,
    "cyankiwi Qwen3 VL 4B AWQ M5 Max aggregate throughput at b*",
  );
  assertNear(
    result.best.perSession,
    23.244361070644754,
    0.000000001,
    "cyankiwi Qwen3 VL 4B AWQ M5 Max per-session throughput at b*",
  );
  assertNear(
    result.dennard,
    1705.2343174519488,
    0.000000001,
    "cyankiwi Qwen3 VL 4B AWQ M5 Max Dennard bound",
  );
}

{
  const modelProfile = profile(
    "lmstudio-community/Qwen3-VL-4B-Instruct-MLX-4bit",
  );
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "lmstudio-community/Qwen3-VL-4B-Instruct-MLX-4bit",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    weightAdapter.resident_params_b,
    4.563511808,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX logical resident stored elements",
  );
  assertNear(
    weightAdapter.swept_params_b,
    4.148164096,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX logical swept stored elements",
  );
  assertNear(
    result.resident,
    3.093615616,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    2.262920192,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX swept text-decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.830695424,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX resident visual footprint",
  );
  assertNear(
    result.alloc,
    14.7456,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    4.718592,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX BF16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    39.1032762662545,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX DGX single-session throughput",
  );
  assert.equal(result.bMem, 7);
  assert.equal(result.best.batch, 2);
  assertNear(
    result.best.aggregate,
    46.66625108974072,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX DGX aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    23.33312554487036,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX DGX per-session throughput",
  );
  assertNear(
    result.dennard,
    956.4652362435886,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX DGX Dennard bound",
  );
}

{
  const result = profiled(
    "lmstudio-community/Qwen3-VL-4B-Instruct-MLX-4bit",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.single.aggregate,
    87.94656273802293,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX M5 Max single-session throughput",
  );
  assert.equal(result.bMem, 7);
  assert.equal(result.best.batch, 6);
  assertNear(
    result.best.aggregate,
    120.4926769255543,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX M5 Max aggregate throughput at b*",
  );
  assertNear(
    result.best.perSession,
    20.08211282092572,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX M5 Max per-session throughput at b*",
  );
  assertNear(
    result.dennard,
    2151.1708976321,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX M5 Max Dennard bound",
  );
}

{
  const modelProfile = profile(
    "lmstudio-community/Qwen3-VL-4B-Instruct-MLX-8bit",
  );
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "lmstudio-community/Qwen3-VL-4B-Instruct-MLX-8bit",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    weightAdapter.resident_params_b,
    4.563511808,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX 8-bit logical resident stored elements",
  );
  assertNear(
    weightAdapter.swept_params_b,
    4.148164096,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX 8-bit logical swept stored elements",
  );
  assertNear(
    result.resident,
    5.104751616,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX 8-bit resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    4.274056192,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX 8-bit swept text-decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.830695424,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX 8-bit resident visual footprint",
  );
  assertNear(
    result.alloc,
    14.7456,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX 8-bit BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    4.718592,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX 8-bit BF16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    30.35813190633489,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX 8-bit DGX single-session throughput",
  );
  assert.equal(result.bMem, 7);
  assert.equal(result.best.batch, 1);
  assertNear(
    result.best.aggregate,
    30.35813190633489,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX 8-bit DGX aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    30.35813190633489,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX 8-bit DGX per-session throughput",
  );
  assertNear(
    result.dennard,
    497.69358048135837,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX 8-bit DGX Dennard bound",
  );
}

{
  const result = profiled(
    "lmstudio-community/Qwen3-VL-4B-Instruct-MLX-8bit",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.single.aggregate,
    68.27799630215979,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX 8-bit M5 Max single-session throughput",
  );
  assert.equal(result.bMem, 7);
  assert.equal(result.best.batch, 5);
  assertNear(
    result.best.aggregate,
    110.16608232643611,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX 8-bit M5 Max aggregate throughput at b*",
  );
  assertNear(
    result.best.perSession,
    22.03321646528722,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX 8-bit M5 Max per-session throughput at b*",
  );
  assertNear(
    result.dennard,
    1119.3547927309671,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX 8-bit M5 Max Dennard bound",
  );
}

{
  const modelProfile = profile(
    "lmstudio-community/Qwen3-VL-4B-Instruct-MLX-6bit",
  );
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "lmstudio-community/Qwen3-VL-4B-Instruct-MLX-6bit",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    weightAdapter.resident_params_b,
    4.563511808,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX 6-bit logical resident stored elements",
  );
  assertNear(
    weightAdapter.swept_params_b,
    4.148164096,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX 6-bit logical swept stored elements",
  );
  assertNear(
    result.resident,
    4.099183616,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX 6-bit resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    3.268488192,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX 6-bit swept text-decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.830695424,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX 6-bit resident visual footprint",
  );
  assertNear(
    result.alloc,
    14.7456,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX 6-bit BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    4.718592,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX 6-bit BF16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    34.18020020300304,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX 6-bit DGX single-session throughput",
  );
  assert.equal(result.bMem, 7);
  assert.equal(result.best.batch, 2);
  assertNear(
    result.best.aggregate,
    42.97293301363335,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX 6-bit DGX aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    21.486466506816676,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX 6-bit DGX per-session throughput",
  );
  assertNear(
    result.dennard,
    656.5076226863522,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX 6-bit DGX Dennard bound",
  );
}

{
  const result = profiled(
    "lmstudio-community/Qwen3-VL-4B-Instruct-MLX-6bit",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.single.aggregate,
    76.8741499071204,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX 6-bit M5 Max single-session throughput",
  );
  assert.equal(result.bMem, 7);
  assert.equal(result.best.batch, 5);
  assertNear(
    result.best.aggregate,
    114.29018934706289,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX 6-bit M5 Max aggregate throughput at b*",
  );
  assertNear(
    result.best.perSession,
    22.858037869412577,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX 6-bit M5 Max per-session throughput at b*",
  );
  assertNear(
    result.dennard,
    1476.54095358762,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX 6-bit M5 Max Dennard bound",
  );
}

{
  const modelProfile = profile(
    "lmstudio-community/Qwen3-VL-4B-Instruct-MLX-5bit",
  );
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "lmstudio-community/Qwen3-VL-4B-Instruct-MLX-5bit",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    weightAdapter.resident_params_b,
    4.563511808,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX 5-bit logical resident stored elements",
  );
  assertNear(
    weightAdapter.swept_params_b,
    4.148164096,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX 5-bit logical swept stored elements",
  );
  assertNear(
    result.resident,
    3.596399616,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX 5-bit resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    2.765704192,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX 5-bit swept text-decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.830695424,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX 5-bit resident visual footprint",
  );
  assertNear(
    result.alloc,
    14.7456,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX 5-bit BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    4.718592,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX 5-bit BF16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    36.47637573347391,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX 5-bit DGX single-session throughput",
  );
  assert.equal(result.bMem, 7);
  assert.equal(result.best.batch, 2);
  assertNear(
    result.best.aggregate,
    44.74350591509542,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX 5-bit DGX aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    22.37175295754771,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX 5-bit DGX per-session throughput",
  );
  assertNear(
    result.dennard,
    779.2214223808791,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX 5-bit DGX Dennard bound",
  );
}

{
  const result = profiled(
    "lmstudio-community/Qwen3-VL-4B-Instruct-MLX-5bit",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.single.aggregate,
    82.03844212583509,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX 5-bit M5 Max single-session throughput",
  );
  assert.equal(result.bMem, 7);
  assert.equal(result.best.batch, 5);
  assertNear(
    result.best.aggregate,
    116.47024210474831,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX 5-bit M5 Max aggregate throughput at b*",
  );
  assertNear(
    result.best.perSession,
    23.29404842094966,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX 5-bit M5 Max per-session throughput at b*",
  );
  assertNear(
    result.dennard,
    1752.53462762586,
    0.000000001,
    "LM Studio Qwen3 VL 4B MLX 5-bit M5 Max Dennard bound",
  );
}

{
  const result = profiled("Qwen/Qwen3-VL-4B-Instruct-FP8", "nvidia-dgx-spark");
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    6.021115136,
    0.000000001,
    "Qwen3 VL 4B Instruct FP8 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    4.412507392,
    0.000000001,
    "Qwen3 VL 4B Instruct FP8 swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    1.608607744,
    0.000000001,
    "Qwen3 VL 4B Instruct FP8 resident visual plus input embedding footprint",
  );
  assertNear(
    result.alloc,
    14.7456,
    0.000000001,
    "Qwen3 VL 4B Instruct FP8 BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    4.718592,
    0.000000001,
    "Qwen3 VL 4B Instruct FP8 BF16 KV read traffic",
  );
  assert.equal(result.bMem, 7);
  assert.equal(result.best.batch, 1);
  assertNear(
    result.best.aggregate,
    29.89782372089637,
    0.000000001,
    "Qwen3 VL 4B Instruct FP8 DGX aggregate throughput at b*",
  );
  assertNear(
    result.dennard,
    478.23257619419377,
    0.000000001,
    "Qwen3 VL 4B Instruct FP8 DGX Dennard bound",
  );
}

{
  const result = profiled(
    "Qwen/Qwen3-VL-4B-Instruct-FP8",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.single.aggregate,
    67.24272441256547,
    0.000000001,
    "Qwen3 VL 4B Instruct FP8 M5 Max single-session throughput",
  );
  assert.equal(result.bMem, 7);
  assert.equal(result.best.batch, 5);
  assertNear(
    result.best.aggregate,
    109.62145201964998,
    0.000000001,
    "Qwen3 VL 4B Instruct FP8 M5 Max aggregate throughput at b*",
  );
  assertNear(
    result.best.perSession,
    21.924290403929994,
    0.000000001,
    "Qwen3 VL 4B Instruct FP8 M5 Max per-session throughput at b*",
  );
  assertNear(
    result.dennard,
    1075.5853545173443,
    0.000000001,
    "Qwen3 VL 4B Instruct FP8 M5 Max Dennard bound",
  );
}

{
  const result = profiled("Qwen/Qwen3-VL-8B-Instruct", "nvidia-dgx-spark");
  assertNear(
    result.resident,
    17.534247392,
    0.000000001,
    "Qwen3 VL 8B Instruct resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    15.136811008,
    0.000000001,
    "Qwen3 VL 8B Instruct swept BF16 text-decode traffic",
  );
  assertNear(
    result.alloc,
    14.7456,
    0.000000001,
    "Qwen3 VL 8B Instruct BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    4.718592,
    0.000000001,
    "Qwen3 VL 8B Instruct BF16 KV read traffic",
  );
}

{
  const result = profiled("Qwen/Qwen3-VL-8B-Instruct-FP8", "nvidia-dgx-spark");
  assertNear(
    result.resident,
    10.590175712,
    0.000000001,
    "Qwen3 VL 8B Instruct FP8 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    8.192739328,
    0.000000001,
    "Qwen3 VL 8B Instruct FP8 swept text-decode traffic",
  );
  assertNear(
    result.alloc,
    14.7456,
    0.000000001,
    "Qwen3 VL 8B Instruct FP8 BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    4.718592,
    0.000000001,
    "Qwen3 VL 8B Instruct FP8 BF16 KV read traffic",
  );
}

{
  const result = profiled("Qwen/Qwen3-VL-32B-Instruct", "nvidia-dgx-spark");
  assertNear(
    result.resident,
    66.714780128,
    0.000000001,
    "Qwen3 VL 32B Instruct resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    63.968421888,
    0.000000001,
    "Qwen3 VL 32B Instruct swept BF16 text-decode traffic",
  );
  assertNear(
    result.alloc,
    26.2144,
    0.000000001,
    "Qwen3 VL 32B Instruct BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    8.388608,
    0.000000001,
    "Qwen3 VL 32B Instruct BF16 KV read traffic",
  );
}

{
  const item = profile("Qwen/Qwen3-VL-32B-Instruct-FP8");
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled("Qwen/Qwen3-VL-32B-Instruct-FP8", "nvidia-dgx-spark");
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    35.516776928,
    0.000000001,
    "Qwen3 VL 32B Instruct FP8 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    32.770418688,
    0.000000001,
    "Qwen3 VL 32B Instruct FP8 swept text-decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    2.74635824,
    0.000000001,
    "Qwen3 VL 32B Instruct FP8 resident visual/input footprint",
  );
  assertNear(
    result.alloc,
    26.2144,
    0.000000001,
    "Qwen3 VL 32B Instruct FP8 BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    8.388608,
    0.000000001,
    "Qwen3 VL 32B Instruct FP8 BF16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    6.632809907518871,
    0.000000001,
    "Qwen3 VL 32B Instruct FP8 DGX Spark single-session throughput",
  );
  assert.equal(result.bMem, 3);
  assert.equal(result.best, null);
  assertNear(
    result.dennard,
    26.847954861258643,
    0.000000001,
    "Qwen3 VL 32B Instruct FP8 DGX Spark Dennard bound",
  );
}

{
  const row = model("QuantTrio/Qwen3-VL-32B-Instruct-AWQ");
  const item = profile("QuantTrio/Qwen3-VL-32B-Instruct-AWQ");
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(
    "QuantTrio/Qwen3-VL-32B-Instruct-AWQ",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "QuantTrio/Qwen3-VL-32B-Instruct-AWQ",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(row.hf_downloads, 259994);
  assert.equal(row.adapter.weight_precision, "AWQ INT4");
  assert.equal(item.serving.weight_format, "int4");
  assert.equal(item.base_model_proof.config_compatible, true);
  assert.equal(item.architecture.kv_adapter.kind, "full_context");
  assertNear(
    result.resident,
    20.515832288,
    0.000000001,
    "QuantTrio Qwen3 VL 32B AWQ resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    17.769474048,
    0.000000001,
    "QuantTrio Qwen3 VL 32B AWQ swept text-decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    2.74635824,
    0.000000001,
    "QuantTrio Qwen3 VL 32B AWQ resident visual/input footprint",
  );
  assertNear(
    result.alloc,
    26.2144,
    0.000000001,
    "QuantTrio Qwen3 VL 32B AWQ BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    8.388608,
    0.000000001,
    "QuantTrio Qwen3 VL 32B AWQ BF16 KV read traffic",
  );
  assert.equal(result.status_code, "no_floor");
  assert.equal(result.bMem, 3);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    10.436544984,
    0.000001,
    "QuantTrio Qwen3 VL 32B AWQ DGX Spark single-session throughput",
  );
  assertNear(
    result.dennard,
    58.304506343,
    0.000001,
    "QuantTrio Qwen3 VL 32B AWQ DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 1);
  assertNear(
    m5Result.single.aggregate,
    23.472668939,
    0.000001,
    "QuantTrio Qwen3 VL 32B AWQ M5 Max single-session throughput",
  );
  assertNear(
    m5Result.best.aggregate,
    23.472668939,
    0.000001,
    "QuantTrio Qwen3 VL 32B AWQ M5 Max aggregate throughput",
  );
  assertNear(
    m5Result.dennard,
    131.131746867,
    0.000001,
    "QuantTrio Qwen3 VL 32B AWQ M5 Max Dennard bound",
  );
}

{
  const result = profiled(
    "Qwen/Qwen3-VL-32B-Instruct-FP8",
    "nvidia-msi-xpertstation-ws300-dgx-station-gb300",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(result.bMem, 26);
  assert.equal(result.best?.batch, 26);
  assertNear(
    result.single.aggregate,
    172.50164960946515,
    0.000000001,
    "Qwen3 VL 32B Instruct FP8 GB300 single-session throughput",
  );
  assertNear(
    result.best?.aggregate ?? 0,
    735.826882008003,
    0.000000001,
    "Qwen3 VL 32B Instruct FP8 GB300 aggregate throughput",
  );
  assertNear(
    result.best?.perSession ?? 0,
    28.301033923384733,
    0.000000001,
    "Qwen3 VL 32B Instruct FP8 GB300 per-session throughput",
  );
  assertNear(
    result.dennard,
    5822.4677497270495,
    0.000000001,
    "Qwen3 VL 32B Instruct FP8 GB300 Dennard bound",
  );
}

{
  const item = profile("Qwen/Qwen3-VL-32B-Thinking-FP8");
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled("Qwen/Qwen3-VL-32B-Thinking-FP8", "nvidia-dgx-spark");
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    35.516776928,
    0.000000001,
    "Qwen3 VL 32B Thinking FP8 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    32.770418688,
    0.000000001,
    "Qwen3 VL 32B Thinking FP8 swept text-decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    2.74635824,
    0.000000001,
    "Qwen3 VL 32B Thinking FP8 resident visual/input footprint",
  );
  assertNear(
    result.alloc,
    26.2144,
    0.000000001,
    "Qwen3 VL 32B Thinking FP8 BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    8.388608,
    0.000000001,
    "Qwen3 VL 32B Thinking FP8 BF16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    6.632809907518871,
    0.000000001,
    "Qwen3 VL 32B Thinking FP8 DGX Spark single-session throughput",
  );
  assert.equal(result.bMem, 3);
  assert.equal(result.best, null);
  assertNear(
    result.dennard,
    26.847954861258643,
    0.000000001,
    "Qwen3 VL 32B Thinking FP8 DGX Spark Dennard bound",
  );
}

{
  const result = profiled(
    "Qwen/Qwen3-VL-32B-Thinking-FP8",
    "nvidia-msi-xpertstation-ws300-dgx-station-gb300",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(result.bMem, 26);
  assert.equal(result.best?.batch, 26);
  assertNear(
    result.single.aggregate,
    172.50164960946515,
    0.000000001,
    "Qwen3 VL 32B Thinking FP8 GB300 single-session throughput",
  );
  assertNear(
    result.best?.aggregate ?? 0,
    735.826882008003,
    0.000000001,
    "Qwen3 VL 32B Thinking FP8 GB300 aggregate throughput",
  );
  assertNear(
    result.best?.perSession ?? 0,
    28.301033923384733,
    0.000000001,
    "Qwen3 VL 32B Thinking FP8 GB300 per-session throughput",
  );
  assertNear(
    result.dennard,
    5822.4677497270495,
    0.000000001,
    "Qwen3 VL 32B Thinking FP8 GB300 Dennard bound",
  );
}

{
  const item = profile("Qwen/Qwen3-235B-A22B");
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled("Qwen/Qwen3-235B-A22B", "nvidia-dgx-spark");
  assert.equal(result.status_code, "resident_not_fit");
  assertNear(
    result.resident,
    470.18726912,
    0.000000001,
    "Qwen3 235B A22B resident footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    468.942609408,
    0.000000001,
    "Qwen3 235B A22B main resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.244659712,
    0.000000001,
    "Qwen3 235B A22B resident input embedding footprint",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    14.749817856,
    0.000000001,
    "Qwen3 235B A22B fixed BF16 text-decode traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    3.548381184,
    0.000000001,
    "Qwen3 235B A22B routed expert group",
  );
  assertNear(
    result.single.batchWeight,
    43.136867328,
    0.000000001,
    "Qwen3 235B A22B active BF16 text-decode traffic",
  );
  assertNear(
    result.alloc,
    19.2512,
    0.000000001,
    "Qwen3 235B A22B BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    6.160384,
    0.000000001,
    "Qwen3 235B A22B BF16 KV read traffic",
  );
  assert.equal(result.bMem, 0);
}

{
  const catalogRow = model("Qwen/Qwen3-235B-A22B-Instruct-2507-FP8");
  const item = profile("Qwen/Qwen3-235B-A22B-Instruct-2507-FP8");
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(
    "Qwen/Qwen3-235B-A22B-Instruct-2507-FP8",
    "nvidia-dgx-spark",
  );
  assert.equal(item.base_model_proof.config_compatible, true);
  assert.equal(weightAdapter.kind, "moe_distinct_experts_exact");
  assertNear(
    catalogRow.adapter.resident_weight_gb,
    236.416915456,
    0.000000001,
    "Qwen3 235B A22B Instruct 2507 FP8 catalog resident footprint",
  );
  assertNear(
    catalogRow.adapter.active_weight_gb,
    22.243395584,
    0.000000001,
    "Qwen3 235B A22B Instruct 2507 FP8 catalog active traffic",
  );
  assert.equal(result.status_code, "resident_not_fit");
  assertNear(
    result.resident,
    236.416915456,
    0.000000001,
    "Qwen3 235B A22B Instruct 2507 FP8 resident footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    235.172255744,
    0.000000001,
    "Qwen3 235B A22B Instruct 2507 FP8 main resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.244659712,
    0.000000001,
    "Qwen3 235B A22B Instruct 2507 FP8 resident input embedding footprint",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    8.04813824,
    0.000000001,
    "Qwen3 235B A22B Instruct 2507 FP8 fixed FP8/BF16 text-decode traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    1.774407168,
    0.000000001,
    "Qwen3 235B A22B Instruct 2507 FP8 routed expert group",
  );
  assertNear(
    result.single.batchWeight,
    22.243395584,
    0.000000001,
    "Qwen3 235B A22B Instruct 2507 FP8 active FP8/BF16 text-decode traffic",
  );
  assertNear(
    result.alloc,
    19.2512,
    0.000000001,
    "Qwen3 235B A22B Instruct 2507 FP8 BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    6.160384,
    0.000000001,
    "Qwen3 235B A22B Instruct 2507 FP8 BF16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    9.611396933729987,
    0.000000001,
    "Qwen3 235B A22B Instruct 2507 FP8 DGX single-session bound",
  );
  assert.equal(result.bMem, 0);
  assert.equal(result.best, null);
}

{
  const result = profiled(
    "Qwen/Qwen3-235B-A22B-Instruct-2507-FP8",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "resident_not_fit");
  assertNear(
    result.single.aggregate,
    21.616841455348762,
    0.000000001,
    "Qwen3 235B A22B Instruct 2507 FP8 M5 Max single-session bound",
  );
  assert.equal(result.bMem, 0);
  assert.equal(result.best, null);
}

{
  const result = profiled(
    "Qwen/Qwen3-235B-A22B-Instruct-2507-FP8",
    "nvidia-msi-xpertstation-ws300-dgx-station-gb300",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(result.bMem, 26);
  assert.equal(result.best?.batch, 26);
  assertNear(
    result.single.aggregate,
    249.96673344132932,
    0.000000001,
    "Qwen3 235B A22B Instruct 2507 FP8 GB300 single-session throughput",
  );
  assertNear(
    result.best?.batchWeight ?? 0,
    192.75755186904627,
    0.000000001,
    "Qwen3 235B A22B Instruct 2507 FP8 GB300 expected distinct expert traffic",
  );
  assertNear(
    result.best?.aggregate ?? 0,
    523.0535485009473,
    0.000000001,
    "Qwen3 235B A22B Instruct 2507 FP8 GB300 aggregate throughput",
  );
  assertNear(
    result.best?.perSession ?? 0,
    20.117444173113356,
    0.000000001,
    "Qwen3 235B A22B Instruct 2507 FP8 GB300 per-session throughput",
  );
  assertNear(
    result.dennard,
    8349.694599340693,
    0.000000001,
    "Qwen3 235B A22B Instruct 2507 FP8 GB300 Dennard bound",
  );
}

{
  const result = profiled(
    "Qwen/Qwen3-VL-235B-A22B-Instruct",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "resident_not_fit");
  assertNear(
    result.resident,
    471.340045792,
    0.000000001,
    "Qwen3 VL 235B A22B Instruct resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    43.136867328,
    0.000000001,
    "Qwen3 VL 235B A22B Instruct active BF16 text-decode traffic",
  );
  assertNear(
    result.alloc,
    19.2512,
    0.000000001,
    "Qwen3 VL 235B A22B Instruct BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    6.160384,
    0.000000001,
    "Qwen3 VL 235B A22B Instruct BF16 KV read traffic",
  );
  assert.equal(result.bMem, 0);
}

{
  const repo = "Qwen/Qwen3-VL-235B-A22B-Instruct-FP8";
  const modelRow = model(repo);
  const modelProfile = profile(repo);
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  const gb300Result = profiled(
    repo,
    "nvidia-msi-xpertstation-ws300-dgx-station-gb300",
  );
  assert.equal(modelRow.hf_downloads, 113778);
  assert.equal(modelRow.tags.includes("region:us"), true);
  assert.equal(modelRow.architecture.total_params_b, 235.684292848);
  assert.equal(modelRow.architecture.active_params_b, 21.568433664);
  assert.equal(
    modelRow.adapter.weight_precision,
    "FP8 E4M3 + BF16/F32 side tensors",
  );
  assert.equal(modelProfile.serving.weight_format, "fp8");
  assertNear(
    modelProfile.serving.weight_bytes_per_param,
    1.0081207753001782,
    0.000000001,
    "Qwen3 VL 235B A22B FP8 mixed stored bytes per API parameter",
  );
  assertNear(
    result.resident,
    237.598232032,
    0.000000001,
    "Qwen3 VL 235B A22B FP8 resident footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    235.200795648,
    0.000000001,
    "Qwen3 VL 235B A22B FP8 ordinary text resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    2.397436384,
    0.000000001,
    "Qwen3 VL 235B A22B FP8 resident-only visual and input embedding footprint",
  );
  assertNear(
    result.single.batchWeight,
    22.245946368,
    0.000000001,
    "Qwen3 VL 235B A22B FP8 single-session decode traffic",
  );
  assertNear(
    result.single.batchWeight - weightAdapter.fixed_weight_gb,
    14.196989952,
    0.000000001,
    "Qwen3 VL 235B A22B FP8 eight routed experts traffic",
  );
  assertNear(
    result.alloc,
    19.2512,
    0.000000001,
    "Qwen3 VL 235B A22B FP8 BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    6.160384,
    0.000000001,
    "Qwen3 VL 235B A22B FP8 BF16 KV read traffic",
  );
  assert.equal(result.status_code, "resident_not_fit");
  assert.equal(result.bMem, 0);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    9.610533865632187,
    0.000000001,
    "Qwen3 VL 235B A22B FP8 DGX single-session bound",
  );
  assert.equal(m5Result.status_code, "resident_not_fit");
  assertNear(
    m5Result.single.aggregate,
    21.614900342484113,
    0.000000001,
    "Qwen3 VL 235B A22B FP8 M5 Max single-session bound",
  );
  assert.equal(gb300Result.status_code, "ok");
  assert.equal(gb300Result.bMem, 26);
  assert.equal(gb300Result.best?.batch, 26);
  assertNear(
    gb300Result.best?.batchWeight ?? 0,
    192.78091482884088,
    0.000000001,
    "Qwen3 VL 235B A22B FP8 GB300 expected distinct expert traffic",
  );
  assertNear(
    gb300Result.best?.aggregate ?? 0,
    523.0189258974503,
    0.000000001,
    "Qwen3 VL 235B A22B FP8 GB300 aggregate throughput",
  );
  assertNear(
    gb300Result.best?.perSession ?? 0,
    20.11611253451732,
    0.000000001,
    "Qwen3 VL 235B A22B FP8 GB300 per-session throughput",
  );
  assertNear(
    gb300Result.dennard,
    8329.152543089573,
    0.000000001,
    "Qwen3 VL 235B A22B FP8 GB300 Dennard",
  );
}

{
  const repo =
    "nvidia/Qwen3-VL-235B-A22B-Instruct-NVFP4-MLPerf-Inference-Closed-V6.0";
  const modelRow = model(repo);
  const modelProfile = profile(repo);
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  const gb300Result = profiled(
    repo,
    "nvidia-msi-xpertstation-ws300-dgx-station-gb300",
  );
  assert.equal(modelRow.hf_downloads, 106913);
  assert.equal(modelRow.tags.includes("region:us"), true);
  assert.equal(modelRow.architecture.total_params_b, 133.383079904);
  assert.equal(modelRow.architecture.active_params_b, 22);
  assert.equal(
    modelRow.adapter.weight_precision,
    "NVFP4 compressed-tensors + BF16/F8/F32 side tensors",
  );
  assert.equal(modelProfile.serving.weight_format, "nvfp4");
  assertNear(
    modelProfile.serving.weight_bytes_per_param,
    1.0140298766631184,
    0.000000001,
    "NVIDIA Qwen3 VL 235B A22B NVFP4 mixed stored bytes per API parameter",
  );
  assertNear(
    result.resident,
    135.254428064,
    0.000000001,
    "NVIDIA Qwen3 VL 235B A22B NVFP4 resident footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    132.85699168,
    0.000000001,
    "NVIDIA Qwen3 VL 235B A22B NVFP4 ordinary text resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    2.397436384,
    0.000000001,
    "NVIDIA Qwen3 VL 235B A22B NVFP4 resident-only visual and input embedding footprint",
  );
  assertNear(
    result.single.batchWeight,
    13.098856,
    0.000000001,
    "NVIDIA Qwen3 VL 235B A22B NVFP4 single-session decode traffic",
  );
  assertNear(
    result.single.batchWeight - weightAdapter.fixed_weight_gb,
    7.983875712,
    0.000000001,
    "NVIDIA Qwen3 VL 235B A22B NVFP4 eight routed experts traffic",
  );
  assertNear(
    result.alloc,
    19.2512,
    0.000000001,
    "NVIDIA Qwen3 VL 235B A22B NVFP4 BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    6.160384,
    0.000000001,
    "NVIDIA Qwen3 VL 235B A22B NVFP4 BF16 KV read traffic",
  );
  assert.equal(result.status_code, "resident_not_fit");
  assert.equal(result.bMem, 0);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    14.175014175014176,
    0.000000001,
    "NVIDIA Qwen3 VL 235B A22B NVFP4 DGX single-session bound",
  );
  assert.equal(m5Result.status_code, "resident_not_fit");
  assertNear(
    m5Result.single.aggregate,
    31.880801111570346,
    0.000000001,
    "NVIDIA Qwen3 VL 235B A22B NVFP4 M5 Max single-session bound",
  );
  assert.equal(gb300Result.status_code, "ok");
  assert.equal(gb300Result.bMem, 31);
  assert.equal(gb300Result.best?.batch, 31);
  assertNear(
    gb300Result.best?.batchWeight ?? 0,
    115.58098678000145,
    0.000000001,
    "NVIDIA Qwen3 VL 235B A22B NVFP4 GB300 expected distinct expert traffic",
  );
  assertNear(
    gb300Result.best?.aggregate ?? 0,
    717.9837692607355,
    0.000000001,
    "NVIDIA Qwen3 VL 235B A22B NVFP4 GB300 aggregate throughput",
  );
  assertNear(
    gb300Result.best?.perSession ?? 0,
    23.160766750346305,
    0.000000001,
    "NVIDIA Qwen3 VL 235B A22B NVFP4 GB300 per-session throughput",
  );
  assertNear(
    gb300Result.dennard,
    17027.068062667946,
    0.000000001,
    "NVIDIA Qwen3 VL 235B A22B NVFP4 GB300 Dennard",
  );
}

{
  const modelProfile = profile("Qwen/Qwen3-VL-30B-A3B-Instruct");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled("Qwen/Qwen3-VL-30B-A3B-Instruct", "nvidia-dgx-spark");
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    62.141508064,
    0.000000001,
    "Qwen3 VL 30B A3B BF16 resident footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    60.441915392,
    0.000000001,
    "Qwen3 VL 30B A3B BF16 ordinary text resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.699592672,
    0.000000001,
    "Qwen3 VL 30B A3B BF16 resident-only visual and input embedding footprint",
  );
  assertNear(
    result.single.batchWeight,
    6.083735552,
    0.000000001,
    "Qwen3 VL 30B A3B BF16 single-session decode traffic",
  );
  assertNear(
    result.single.batchWeight - weightAdapter.fixed_weight_gb,
    3.623878656,
    0.000000001,
    "Qwen3 VL 30B A3B BF16 eight routed experts traffic",
  );
  assertNear(
    result.alloc,
    9.8304,
    0.000000001,
    "Qwen3 VL 30B A3B BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    3.145728,
    0.000000001,
    "Qwen3 VL 30B A3B BF16 KV read traffic",
  );
  assert.equal(result.bMem, 5);
  assert.equal(result.best.batch, 1);
  assertNear(
    result.best.aggregate,
    29.579183932184403,
    0.000000001,
    "Qwen3 VL 30B A3B BF16 DGX aggregate",
  );
  assertNear(
    result.dennard,
    264.11206401249603,
    0.000000001,
    "Qwen3 VL 30B A3B BF16 Dennard",
  );
}

{
  const modelProfile = profile("Qwen/Qwen3-VL-30B-A3B-Instruct-FP8");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "Qwen/Qwen3-VL-30B-A3B-Instruct-FP8",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "Qwen/Qwen3-VL-30B-A3B-Instruct-FP8",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(modelProfile.serving.weight_format, "fp8");
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    32.251808224,
    0.000000001,
    "Qwen3 VL 30B A3B FP8 resident footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    30.552215552,
    0.000000001,
    "Qwen3 VL 30B A3B FP8 ordinary text resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.699592672,
    0.000000001,
    "Qwen3 VL 30B A3B FP8 resident-only visual and input embedding footprint",
  );
  assertNear(
    result.single.batchWeight,
    3.366490112,
    0.000000001,
    "Qwen3 VL 30B A3B FP8 single-session decode traffic",
  );
  assertNear(
    result.single.batchWeight - weightAdapter.fixed_weight_gb,
    1.812381696,
    0.000000001,
    "Qwen3 VL 30B A3B FP8 eight routed experts traffic",
  );
  assertNear(
    result.alloc,
    9.8304,
    0.000000001,
    "Qwen3 VL 30B A3B FP8 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    3.145728,
    0.000000001,
    "Qwen3 VL 30B A3B FP8 KV read traffic",
  );
  assert.equal(result.bMem, 8);
  assert.equal(result.best.batch, 2);
  assertNear(
    result.best.aggregate,
    48.07584804189895,
    0.000000001,
    "Qwen3 VL 30B A3B FP8 DGX aggregate",
  );
  assertNear(
    result.dennard,
    723.8561855145952,
    0.000000001,
    "Qwen3 VL 30B A3B FP8 Dennard",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 6);
  assertNear(
    m5Result.best.aggregate,
    123.87866050307576,
    0.000000001,
    "Qwen3 VL 30B A3B FP8 M5 aggregate",
  );
  assertNear(
    m5Result.best.perSession,
    20.646443417179295,
    0.000000001,
    "Qwen3 VL 30B A3B FP8 M5 per-session throughput",
  );
}

{
  const result = profiled(
    "QuantTrio/Qwen3-VL-30B-A3B-Instruct-AWQ",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    17.879935456,
    0.000000001,
    "QuantTrio Qwen3 VL 30B A3B AWQ resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    2.059956224,
    0.000000001,
    "QuantTrio Qwen3 VL 30B A3B AWQ single-session decode traffic",
  );
  assertNear(
    result.single.batchWeight - 1.11859712,
    0.941359104,
    0.000000001,
    "QuantTrio Qwen3 VL 30B A3B AWQ eight routed experts traffic",
  );
  assertNear(
    result.alloc,
    9.8304,
    0.000000001,
    "QuantTrio Qwen3 VL 30B A3B AWQ BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    3.145728,
    0.000000001,
    "QuantTrio Qwen3 VL 30B A3B AWQ BF16 KV read traffic",
  );
  assert.equal(result.bMem, 10);
  assert.equal(result.best.batch, 3);
  assertNear(
    result.best.aggregate,
    62.01242454830944,
    0.000000001,
    "QuantTrio Qwen3 VL 30B A3B AWQ DGX aggregate",
  );
  assertNear(
    result.dennard,
    1376.7165925681934,
    0.000000001,
    "QuantTrio Qwen3 VL 30B A3B AWQ Dennard",
  );
}

{
  const modelProfile = profile("cyankiwi/Qwen3-VL-30B-A3B-Instruct-AWQ-4bit");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "cyankiwi/Qwen3-VL-30B-A3B-Instruct-AWQ-4bit",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "cyankiwi/Qwen3-VL-30B-A3B-Instruct-AWQ-4bit",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    19.164870112,
    0.000000001,
    "cyankiwi Qwen3 VL 30B A3B AWQ resident footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    17.46527744,
    0.000000001,
    "cyankiwi Qwen3 VL 30B A3B AWQ ordinary text resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.699592672,
    0.000000001,
    "cyankiwi Qwen3 VL 30B A3B AWQ resident-only visual and input embedding footprint",
  );
  assertNear(
    result.single.batchWeight,
    2.17676288,
    0.000000001,
    "cyankiwi Qwen3 VL 30B A3B AWQ single-session decode traffic",
  );
  assertNear(
    result.single.batchWeight - weightAdapter.fixed_weight_gb,
    1.019234304,
    0.000000001,
    "cyankiwi Qwen3 VL 30B A3B AWQ eight routed experts traffic",
  );
  assertNear(
    result.alloc,
    9.8304,
    0.000000001,
    "cyankiwi Qwen3 VL 30B A3B AWQ BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    3.145728,
    0.000000001,
    "cyankiwi Qwen3 VL 30B A3B AWQ BF16 KV read traffic",
  );
  assert.equal(result.bMem, 10);
  assert.equal(result.best.batch, 3);
  assertNear(
    result.best.aggregate,
    60.82304749751837,
    0.000000001,
    "cyankiwi Qwen3 VL 30B A3B AWQ DGX aggregate",
  );
  assertNear(
    result.dennard,
    1286.447882753505,
    0.000000001,
    "cyankiwi Qwen3 VL 30B A3B AWQ Dennard",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 7);
  assertNear(
    m5Result.best.aggregate,
    147.66979250672637,
    0.000000001,
    "cyankiwi Qwen3 VL 30B A3B AWQ M5 aggregate",
  );
  assertNear(
    m5Result.best.perSession,
    21.095684643818053,
    0.000000001,
    "cyankiwi Qwen3 VL 30B A3B AWQ M5 per-session throughput",
  );
}

{
  const modelProfile = profile("baidu/ERNIE-4.5-VL-28B-A3B-PT");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled("baidu/ERNIE-4.5-VL-28B-A3B-PT", "nvidia-dgx-spark");
  const m5Result = profiled(
    "baidu/ERNIE-4.5-VL-28B-A3B-PT",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(modelProfile.serving.weight_format, "mixed_bf16_f16_f32");
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    58.816290304,
    0.000000001,
    "ERNIE 4.5 VL 28B A3B resident footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    43.659733504,
    0.000000001,
    "ERNIE 4.5 VL 28B A3B ordinary text resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    15.1565568,
    0.000000001,
    "ERNIE 4.5 VL 28B A3B resident-only vision footprint",
  );
  assertNear(
    result.single.batchWeight,
    6.713158144,
    0.000000001,
    "ERNIE 4.5 VL 28B A3B single-session decode traffic",
  );
  assertNear(
    result.single.batchWeight - weightAdapter.fixed_weight_gb,
    3.82205952,
    0.000000001,
    "ERNIE 4.5 VL 28B A3B six routed text experts traffic",
  );
  assertNear(
    result.alloc,
    5.7344,
    0.000000001,
    "ERNIE 4.5 VL 28B A3B BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.835008,
    0.000000001,
    "ERNIE 4.5 VL 28B A3B BF16 KV read traffic",
  );
  assert.equal(result.bMem, 10);
  assert.equal(result.best.batch, 1);
  assertNear(
    result.best.aggregate,
    31.93667453359222,
    0.000000001,
    "ERNIE 4.5 VL 28B A3B DGX aggregate",
  );
  assertNear(
    result.dennard,
    433.8939463206842,
    0.000000001,
    "ERNIE 4.5 VL 28B A3B Dennard",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 5);
  assertNear(
    m5Result.best.aggregate,
    109.98172864621658,
    0.000000001,
    "ERNIE 4.5 VL 28B A3B M5 aggregate",
  );
}

{
  const result = profiled("Qwen/Qwen2-VL-2B-Instruct", "nvidia-dgx-spark");
  assertNear(
    result.resident,
    4.4179712,
    0.000000001,
    "Qwen2 VL 2B Instruct resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    3.087428608,
    0.000000001,
    "Qwen2 VL 2B Instruct swept BF16 text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    1.330542592,
    0.000000001,
    "Qwen2 VL 2B Instruct visual resident-only footprint",
  );
  assertNear(
    result.alloc,
    2.8672,
    0.000000001,
    "Qwen2 VL 2B Instruct BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.917504,
    0.000000001,
    "Qwen2 VL 2B Instruct BF16 KV read traffic",
  );
}

{
  const result = profiled("Qwen/Qwen2-0.5B", "nvidia-dgx-spark");
  assertNear(
    result.resident,
    0.988065536,
    0.000000001,
    "Qwen2 0.5B resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    0.988065536,
    0.000000001,
    "Qwen2 0.5B swept BF16 decode traffic",
  );
  assertNear(
    result.alloc,
    1.2288,
    0.000000001,
    "Qwen2 0.5B BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.393216,
    0.000000001,
    "Qwen2 0.5B BF16 KV read traffic",
  );
}

{
  const result = profiled("Qwen/Qwen2-0.5B-Instruct", "nvidia-dgx-spark");
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    0.988065536,
    0.000000001,
    "Qwen2 0.5B Instruct resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    0.988065536,
    0.000000001,
    "Qwen2 0.5B Instruct swept BF16 decode traffic",
  );
  assertNear(
    result.alloc,
    1.2288,
    0.000000001,
    "Qwen2 0.5B Instruct BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.393216,
    0.000000001,
    "Qwen2 0.5B Instruct BF16 KV read traffic",
  );
  assert.equal(result.best.batch, 32);
  assertNear(
    result.best.aggregate,
    643.7266568915791,
    0.000000001,
    "Qwen2 0.5B Instruct DGX Spark aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    20.116458027861846,
    0.000000001,
    "Qwen2 0.5B Instruct DGX Spark per-session throughput",
  );
}

{
  const result = profiled("Qwen/Qwen2.5-0.5B", "nvidia-dgx-spark");
  assertNear(
    result.resident,
    0.988065536,
    0.000000001,
    "Qwen2.5 0.5B resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    0.988065536,
    0.000000001,
    "Qwen2.5 0.5B swept BF16 decode traffic",
  );
  assertNear(
    result.alloc,
    1.2288,
    0.000000001,
    "Qwen2.5 0.5B BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.393216,
    0.000000001,
    "Qwen2.5 0.5B BF16 KV read traffic",
  );
}

{
  const result = profiled("Qwen/Qwen2.5-0.5B-Instruct", "nvidia-dgx-spark");
  assertNear(
    result.resident,
    0.988065536,
    0.000000001,
    "Qwen2.5 0.5B Instruct resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    0.988065536,
    0.000000001,
    "Qwen2.5 0.5B Instruct swept BF16 decode traffic",
  );
  assertNear(
    result.alloc,
    1.2288,
    0.000000001,
    "Qwen2.5 0.5B Instruct BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.393216,
    0.000000001,
    "Qwen2.5 0.5B Instruct BF16 KV read traffic",
  );
}

{
  const result = profiled("Qwen/Qwen2-1.5B-Instruct", "nvidia-dgx-spark");
  assertNear(
    result.resident,
    3.087428608,
    0.000000001,
    "Qwen2 1.5B Instruct resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    3.087428608,
    0.000000001,
    "Qwen2 1.5B Instruct swept BF16 decode traffic",
  );
  assertNear(
    result.alloc,
    2.8672,
    0.000000001,
    "Qwen2 1.5B Instruct BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.917504,
    0.000000001,
    "Qwen2 1.5B Instruct BF16 KV read traffic",
  );
}

{
  const repo = "Qwen/Qwen2-1.5B";
  const catalogRow = model(repo);
  const item = profile(repo);
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  assert.equal(item.status, "audited");
  assert.equal(catalogRow.hf_downloads, 197198);
  assert.equal(catalogRow.tags.includes("region:us"), true);
  assertNear(
    weightAdapter.total_params_b,
    1.543714304,
    0.000000001,
    "Qwen2 1.5B total parameters",
  );
  assertNear(
    weightAdapter.embedding_params_b,
    0.233373696,
    0.000000001,
    "Qwen2 1.5B tied embedding parameters",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    3.087428608,
    0.000000001,
    "Qwen2 1.5B resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    3.087428608,
    0.000000001,
    "Qwen2 1.5B swept BF16 decode traffic",
  );
  assertNear(
    result.alloc,
    2.8672,
    0.000000001,
    "Qwen2 1.5B BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.917504,
    0.000000001,
    "Qwen2 1.5B BF16 KV read traffic",
  );
  assert.equal(result.bMem, 40);
  assert.equal(result.best.batch, 11);
  assertNear(
    result.best.aggregate,
    227.8456935621577,
    0.000000001,
    "Qwen2 1.5B DGX aggregate",
  );
}

{
  const result = profiled("Qwen/Qwen2.5-1.5B", "nvidia-dgx-spark");
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    3.087428608,
    0.000000001,
    "Qwen2.5 1.5B resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    3.087428608,
    0.000000001,
    "Qwen2.5 1.5B swept BF16 decode traffic",
  );
  assertNear(
    result.alloc,
    2.8672,
    0.000000001,
    "Qwen2.5 1.5B BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.917504,
    0.000000001,
    "Qwen2.5 1.5B BF16 KV read traffic",
  );
  assert.equal(result.bMem, 40);
  assert.equal(result.best.batch, 11);
  assertNear(
    result.best.aggregate,
    227.8456935621577,
    0.000000001,
    "Qwen2.5 1.5B DGX aggregate",
  );
}

{
  const result = calculate(
    "RedHatAI/Qwen2.5-1.5B-quantized.w8a8",
    "nvidia-dgx-spark",
  );
  assertNear(
    result.resident,
    2.245270528,
    0.000000001,
    "Legacy RedHatAI Qwen2.5 1.5B W8A8 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    1.778523136,
    0.000000001,
    "Legacy RedHatAI Qwen2.5 1.5B W8A8 swept text-decode traffic",
  );
  assertNear(
    result.alloc,
    2.8672,
    0.000000001,
    "Legacy RedHatAI Qwen2.5 1.5B W8A8 BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.917504,
    0.000000001,
    "Legacy RedHatAI Qwen2.5 1.5B W8A8 BF16 KV read traffic",
  );
  assert.equal(result.bMem, 41);
  assert.equal(result.best.batch, 12);
}

{
  const result = profiled(
    "RedHatAI/Qwen2.5-1.5B-quantized.w8a8",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    2.245270528,
    0.000000001,
    "RedHatAI Qwen2.5 1.5B W8A8 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    1.778523136,
    0.000000001,
    "RedHatAI Qwen2.5 1.5B W8A8 swept text-decode traffic",
  );
  assertNear(
    result.alloc,
    2.8672,
    0.000000001,
    "RedHatAI Qwen2.5 1.5B W8A8 BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.917504,
    0.000000001,
    "RedHatAI Qwen2.5 1.5B W8A8 BF16 KV read traffic",
  );
  assert.equal(result.bMem, 41);
  assert.equal(result.best.batch, 12);
  assertNear(
    result.best.aggregate,
    256.1662256996027,
    0.000000001,
    "RedHatAI Qwen2.5 1.5B W8A8 DGX aggregate",
  );
  assertNear(
    result.dennard,
    6304.105884569162,
    0.000000001,
    "RedHatAI Qwen2.5 1.5B W8A8 DGX Dennard bound",
  );
}

{
  const result = profiled(
    "RedHatAI/Qwen2.5-1.5B-quantized.w8a8",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(result.best.batch, 31);
  assertNear(
    result.best.aggregate,
    629.8238751277029,
    0.000000001,
    "RedHatAI Qwen2.5 1.5B W8A8 M5 Max aggregate",
  );
  assertNear(
    result.best.perSession,
    20.316899197667833,
    0.000000001,
    "RedHatAI Qwen2.5 1.5B W8A8 M5 Max per-session throughput",
  );
}

{
  const result = profiled("Qwen/Qwen2.5-1.5B-Instruct", "nvidia-dgx-spark");
  assertNear(
    result.resident,
    3.087428608,
    0.000000001,
    "Qwen2.5 1.5B Instruct resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    3.087428608,
    0.000000001,
    "Qwen2.5 1.5B Instruct swept BF16 decode traffic",
  );
  assertNear(
    result.alloc,
    2.8672,
    0.000000001,
    "Qwen2.5 1.5B Instruct BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.917504,
    0.000000001,
    "Qwen2.5 1.5B Instruct BF16 KV read traffic",
  );
}

{
  const item = profile("Qwen/Qwen2.5-1.5B-Instruct-GGUF");
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(
    "Qwen/Qwen2.5-1.5B-Instruct-GGUF",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "Qwen/Qwen2.5-1.5B-Instruct-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(item.architecture.max_context_tokens, 8192);
  assert.equal(
    item.serving.runtime_format,
    "llama.cpp-gguf-f16-f32-memory-bound",
  );
  assertNear(
    weightAdapter.resident_params_b,
    1.777088,
    0.000000001,
    "Qwen2.5 1.5B Instruct GGUF logical resident parameters",
  );
  assertNear(
    weightAdapter.swept_params_b,
    1.543714304,
    0.000000001,
    "Qwen2.5 1.5B Instruct GGUF logical swept parameters",
  );
  assertNear(
    result.resident,
    3.560416288,
    0.000000001,
    "Qwen2.5 1.5B Instruct GGUF selected FP16 resident file footprint",
  );
  assertNear(
    result.single.batchWeight,
    3.0877184,
    0.000000001,
    "Qwen2.5 1.5B Instruct GGUF swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    0.472697888,
    0.000000001,
    "Qwen2.5 1.5B Instruct GGUF resident input embedding plus header footprint",
  );
  assertNear(
    result.alloc,
    2.8672,
    0.000000001,
    "Qwen2.5 1.5B Instruct GGUF full-context FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.917504,
    0.000000001,
    "Qwen2.5 1.5B Instruct GGUF full-context FP16 KV read traffic",
  );
  assert.equal(result.bMem, 40);
  assert.equal(result.best.batch, 11);
  assertNear(
    result.single.aggregate,
    68.161008986667,
    0.000000001,
    "Qwen2.5 1.5B Instruct GGUF DGX single-session tok/s",
  );
  assertNear(
    result.best.aggregate,
    227.8406839608899,
    0.000000001,
    "Qwen2.5 1.5B Instruct GGUF DGX aggregate tok/s at b*",
  );
  assertNear(
    result.dennard,
    3590.6048846465806,
    0.000000001,
    "Qwen2.5 1.5B Instruct GGUF DGX Dennard bound",
  );
  assert.equal(m5Result.best.batch, 30);
  assertNear(
    m5Result.best.aggregate,
    601.7083342392714,
    0.000000001,
    "Qwen2.5 1.5B Instruct GGUF M5 Max aggregate tok/s at b*",
  );
}

{
  const modelRow = model("MaziyarPanahi/Qwen2.5-1.5B-Instruct-GGUF");
  const item = profile("MaziyarPanahi/Qwen2.5-1.5B-Instruct-GGUF");
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(
    "MaziyarPanahi/Qwen2.5-1.5B-Instruct-GGUF",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "MaziyarPanahi/Qwen2.5-1.5B-Instruct-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  const m1UltraResult = profiled(
    "MaziyarPanahi/Qwen2.5-1.5B-Instruct-GGUF",
    "apple-mac-studio-m1-ultra-128gb",
  );
  assert.equal(modelRow.name, "Qwen2.5-1.5B-Instruct-GGUF GGUF Q2_K");
  assert.equal(modelRow.hf_downloads, 149795);
  assert.equal(modelRow.license, "apache-2.0");
  assert.equal(modelRow.tags.includes("region:us"), true);
  assert.equal(item.architecture.max_context_tokens, 32768);
  assert.equal(item.serving.weight_format, "gguf_quantized");
  assert.equal(item.serving.runtime_format, "llama.cpp-gguf-q2-k-memory-bound");
  assertNear(
    weightAdapter.resident_params_b,
    1.543714304,
    0.000000001,
    "MaziyarPanahi Qwen2.5 1.5B Instruct GGUF logical resident parameters",
  );
  assertNear(
    weightAdapter.swept_params_b,
    1.543714304,
    0.000000001,
    "MaziyarPanahi Qwen2.5 1.5B Instruct GGUF logical swept parameters",
  );
  assertNear(
    result.resident,
    0.67630512,
    0.000000001,
    "MaziyarPanahi Qwen2.5 1.5B Instruct Q2_K resident file footprint",
  );
  assertNear(
    result.single.batchWeight,
    0.67035392,
    0.000000001,
    "MaziyarPanahi Qwen2.5 1.5B Instruct Q2_K swept text traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    0.0059512,
    0.000000001,
    "MaziyarPanahi Qwen2.5 1.5B Instruct Q2_K header overhead",
  );
  assertNear(
    result.alloc,
    2.8672,
    0.000000001,
    "MaziyarPanahi Qwen2.5 1.5B Instruct Q2_K FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.917504,
    0.000000001,
    "MaziyarPanahi Qwen2.5 1.5B Instruct Q2_K FP16 KV read traffic",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(result.bMem, 41);
  assert.equal(result.best.batch, 14);
  assertNear(
    result.single.aggregate,
    171.92974041405418,
    0.000000001,
    "MaziyarPanahi Qwen2.5 1.5B Instruct Q2_K DGX single-session tok/s",
  );
  assertNear(
    result.best.aggregate,
    282.78831516195703,
    0.000000001,
    "MaziyarPanahi Qwen2.5 1.5B Instruct Q2_K DGX aggregate tok/s at b*",
  );
  assertNear(
    result.dennard,
    16948.34120410883,
    0.000000001,
    "MaziyarPanahi Qwen2.5 1.5B Instruct Q2_K DGX Dennard bound",
  );
  assert.equal(m5Result.best.batch, 32);
  assertNear(
    m5Result.best.aggregate,
    654.2685546086634,
    0.000000001,
    "MaziyarPanahi Qwen2.5 1.5B Instruct Q2_K M5 Max aggregate tok/s at b*",
  );
  assert.equal(m1UltraResult.best.batch, 41);
  assertNear(
    m1UltraResult.best.aggregate,
    856.6648727686346,
    0.000000001,
    "MaziyarPanahi Qwen2.5 1.5B Instruct Q2_K M1 Ultra aggregate tok/s at b*",
  );
}

{
  const modelRow = model("nvidia/NVLM-D-72B");
  const item = profile("nvidia/NVLM-D-72B");
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled("nvidia/NVLM-D-72B", "nvidia-dgx-spark");
  const m5Result = profiled(
    "nvidia/NVLM-D-72B",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  const m1UltraResult = profiled(
    "nvidia/NVLM-D-72B",
    "apple-mac-studio-m1-ultra-128gb",
  );
  assert.equal(modelRow.hf_downloads, 149066);
  assert.equal(modelRow.tags.includes("region:us"), true);
  assert.equal(item.status, "audited");
  assert.equal(item.serving.weight_format, "mixed_bf16_f32");
  assert.equal(
    item.serving.runtime_format,
    "transformers-nvlm-d-qwen2-bf16-f32-text-decode-memory-bound",
  );
  assertNear(
    weightAdapter.resident_params_b,
    79.379593344,
    0.000000001,
    "NVLM-D 72B resident parameters",
  );
  assertNear(
    weightAdapter.swept_params_b,
    71.46049536,
    0.000000001,
    "NVLM-D 72B ordinary text-decode swept parameters",
  );
  assertNear(
    result.resident,
    176.9021222,
    0.000000001,
    "NVLM-D 72B loaded multimodal resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    156.34440192,
    0.000000001,
    "NVLM-D 72B ordinary text-decode language traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    20.55772028,
    0.000000001,
    "NVLM-D 72B resident-only vision/projector/input/header footprint",
  );
  assertNear(
    result.alloc,
    32.768,
    0.000000001,
    "NVLM-D 72B BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    10.48576,
    0.000000001,
    "NVLM-D 72B BF16 KV read traffic",
  );
  assert.equal(result.status_code, "resident_not_fit");
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    1.6363947433612849,
    0.000000001,
    "NVLM-D 72B DGX single-session memory-side tok/s",
  );
  assert.equal(m5Result.status_code, "resident_not_fit");
  assert.equal(m5Result.best, null);
  assertNear(
    m5Result.single.aggregate,
    3.680389642578128,
    0.000000001,
    "NVLM-D 72B M5 Max single-session memory-side tok/s",
  );
  assert.equal(m1UltraResult.status_code, "resident_not_fit");
  assert.equal(m1UltraResult.best, null);
  assertNear(
    m1UltraResult.single.aggregate,
    4.795295951241861,
    0.000000001,
    "NVLM-D 72B M1 Ultra single-session memory-side tok/s",
  );
}

{
  const repo = "Qwen/Qwen2.5-0.5B-Instruct-GGUF";
  const catalogRow = model(repo);
  const item = profile(repo);
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  assert.equal(item.status, "audited");
  assert.equal(item.architecture.max_context_tokens, 8192);
  assert.equal(
    item.serving.runtime_format,
    "llama.cpp-gguf-f16-f32-memory-bound",
  );
  assert.equal(catalogRow.hf_downloads, 148822);
  assertNear(
    catalogRow.adapter.resident_weight_gb,
    1.266425696,
    0.000000001,
    "Qwen2.5 0.5B Instruct GGUF catalog resident footprint",
  );
  assertNear(
    catalogRow.adapter.active_weight_gb,
    0.98820864,
    0.000000001,
    "Qwen2.5 0.5B Instruct GGUF catalog swept traffic",
  );
  assertNear(
    weightAdapter.resident_params_b,
    0.630167424,
    0.000000001,
    "Qwen2.5 0.5B Instruct GGUF logical resident parameters",
  );
  assertNear(
    weightAdapter.swept_params_b,
    0.494032768,
    0.000000001,
    "Qwen2.5 0.5B Instruct GGUF logical swept parameters",
  );
  assertNear(
    result.resident,
    1.266425696,
    0.000000001,
    "Qwen2.5 0.5B Instruct GGUF selected FP16 resident file footprint",
  );
  assertNear(
    result.single.batchWeight,
    0.98820864,
    0.000000001,
    "Qwen2.5 0.5B Instruct GGUF swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    0.278217056,
    0.000000001,
    "Qwen2.5 0.5B Instruct GGUF resident input embedding plus header footprint",
  );
  assertNear(
    result.alloc,
    1.2288,
    0.000000001,
    "Qwen2.5 0.5B Instruct GGUF full-context FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.393216,
    0.000000001,
    "Qwen2.5 0.5B Instruct GGUF full-context FP16 KV read traffic",
  );
  assert.equal(result.bMem, 96);
  assert.equal(result.best.batch, 32);
  assertNear(
    result.single.aggregate,
    197.6220722398581,
    0.000000001,
    "Qwen2.5 0.5B Instruct GGUF DGX single-session tok/s",
  );
  assertNear(
    result.best.aggregate,
    643.7198689584415,
    0.000000001,
    "Qwen2.5 0.5B Instruct GGUF DGX aggregate tok/s at b*",
  );
  assertNear(
    result.dennard,
    26693.55028665493,
    0.000000001,
    "Qwen2.5 0.5B Instruct GGUF DGX Dennard bound",
  );
  assert.equal(m5Result.best.batch, 75);
  assertNear(
    m5Result.best.aggregate,
    1510.8560846408861,
    0.000000001,
    "Qwen2.5 0.5B Instruct GGUF M5 Max aggregate tok/s at b*",
  );
}

{
  const item = profile("Qwen/Qwen2.5-Math-1.5B");
  const result = profiled("Qwen/Qwen2.5-Math-1.5B", "nvidia-dgx-spark");
  assert.equal(result.status_code, "ok");
  assert.equal(item.architecture.max_context_tokens, 4096);
  assertNear(
    result.resident,
    3.087428608,
    0.000000001,
    "Qwen2.5 Math 1.5B resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    3.087428608,
    0.000000001,
    "Qwen2.5 Math 1.5B swept BF16 decode traffic",
  );
  assertNear(
    result.alloc,
    2.8672,
    0.000000001,
    "Qwen2.5 Math 1.5B BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.917504,
    0.000000001,
    "Qwen2.5 Math 1.5B BF16 KV read traffic",
  );
  assert.equal(result.bMem, 40);
  assert.equal(result.best.batch, 11);
  assertNear(
    result.single.aggregate,
    68.165941033,
    0.000001,
    "Qwen2.5 Math 1.5B DGX Spark single-session bound",
  );
  assertNear(
    result.best.aggregate,
    227.845693562,
    0.000001,
    "Qwen2.5 Math 1.5B DGX Spark aggregate bound",
  );
  assertNear(
    result.dennard,
    3605.528622963,
    0.000001,
    "Qwen2.5 Math 1.5B DGX Spark Dennard bound",
  );
}

{
  const item = profile("Qwen/Qwen2.5-Math-1.5B-Instruct");
  const result = profiled(
    "Qwen/Qwen2.5-Math-1.5B-Instruct",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(item.architecture.max_context_tokens, 4096);
  assertNear(
    result.resident,
    3.087428608,
    0.000000001,
    "Qwen2.5 Math 1.5B Instruct resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    3.087428608,
    0.000000001,
    "Qwen2.5 Math 1.5B Instruct swept BF16 decode traffic",
  );
  assertNear(
    result.alloc,
    2.8672,
    0.000000001,
    "Qwen2.5 Math 1.5B Instruct BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.917504,
    0.000000001,
    "Qwen2.5 Math 1.5B Instruct BF16 KV read traffic",
  );
  assert.equal(result.bMem, 40);
  assert.equal(result.best.batch, 11);
  assertNear(
    result.single.aggregate,
    68.165941033,
    0.000001,
    "Qwen2.5 Math 1.5B Instruct DGX Spark single-session bound",
  );
  assertNear(
    result.best.aggregate,
    227.845693562,
    0.000001,
    "Qwen2.5 Math 1.5B Instruct DGX Spark aggregate bound",
  );
  assertNear(
    result.dennard,
    3605.528622963,
    0.000001,
    "Qwen2.5 Math 1.5B Instruct DGX Spark Dennard bound",
  );
}

{
  const item = profile("Qwen/Qwen2.5-Coder-1.5B");
  const result = profiled("Qwen/Qwen2.5-Coder-1.5B", "nvidia-dgx-spark");
  const m5Result = profiled(
    "Qwen/Qwen2.5-Coder-1.5B",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(item.status, "audited");
  assert.equal(result.status_code, "ok");
  assertNear(
    item.architecture.weight_adapter.total_params_b,
    1.543714304,
    0.000000001,
    "Qwen2.5 Coder 1.5B stored BF16 parameters",
  );
  assertNear(
    item.architecture.weight_adapter.embedding_params_b,
    0.233373696,
    0.000000001,
    "Qwen2.5 Coder 1.5B tied embedding parameters",
  );
  assertNear(
    result.resident,
    3.087428608,
    0.000000001,
    "Qwen2.5 Coder 1.5B resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    3.087428608,
    0.000000001,
    "Qwen2.5 Coder 1.5B swept BF16 decode traffic",
  );
  assertNear(
    result.alloc,
    2.8672,
    0.000000001,
    "Qwen2.5 Coder 1.5B BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.917504,
    0.000000001,
    "Qwen2.5 Coder 1.5B BF16 KV read traffic",
  );
  assert.equal(result.bMem, 40);
  assert.equal(result.best.batch, 11);
  assertNear(
    result.single.aggregate,
    68.16594103348268,
    0.000000001,
    "Qwen2.5 Coder 1.5B DGX single-session tok/s",
  );
  assertNear(
    result.best.aggregate,
    227.8456935621577,
    0.000000001,
    "Qwen2.5 Coder 1.5B DGX aggregate tok/s",
  );
  assertNear(
    result.best.perSession,
    20.713244869287063,
    0.000000001,
    "Qwen2.5 Coder 1.5B DGX per-session tok/s",
  );
  assertNear(
    result.dennard,
    3605.5286229633844,
    0.000000001,
    "Qwen2.5 Coder 1.5B DGX Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 30);
  assertNear(
    m5Result.best.aggregate,
    601.7140302779719,
    0.000000001,
    "Qwen2.5 Coder 1.5B M5 Max aggregate tok/s",
  );
  assertNear(
    m5Result.best.perSession,
    20.057134342599063,
    0.000000001,
    "Qwen2.5 Coder 1.5B M5 Max per-session tok/s",
  );
}

{
  const result = profiled(
    "Qwen/Qwen2.5-Coder-1.5B-Instruct",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    3.087428608,
    0.000000001,
    "Qwen2.5 Coder 1.5B Instruct resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    3.087428608,
    0.000000001,
    "Qwen2.5 Coder 1.5B Instruct swept BF16 decode traffic",
  );
  assertNear(
    result.alloc,
    2.8672,
    0.000000001,
    "Qwen2.5 Coder 1.5B Instruct BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.917504,
    0.000000001,
    "Qwen2.5 Coder 1.5B Instruct BF16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    68.165941033,
    0.000000001,
    "Qwen2.5 Coder 1.5B Instruct DGX single-session tok/s",
  );
  assert.equal(result.bMem, 40);
  assert.equal(result.best.batch, 11);
  assertNear(
    result.best.aggregate,
    227.845693562,
    0.000000001,
    "Qwen2.5 Coder 1.5B Instruct DGX aggregate tok/s",
  );
  assertNear(
    result.best.perSession,
    20.713244869,
    0.000000001,
    "Qwen2.5 Coder 1.5B Instruct DGX per-session tok/s",
  );
  assertNear(
    result.dennard,
    3605.528622963,
    0.000000001,
    "Qwen2.5 Coder 1.5B Instruct DGX Dennard bound",
  );
}

{
  const result = profiled(
    "Qwen/Qwen2.5-Coder-1.5B-Instruct",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.single.aggregate,
    153.310944302,
    0.000000001,
    "Qwen2.5 Coder 1.5B Instruct M5 Max single-session tok/s",
  );
  assert.equal(result.bMem, 40);
  assert.equal(result.best.batch, 30);
  assertNear(
    result.best.aggregate,
    601.714030278,
    0.000000001,
    "Qwen2.5 Coder 1.5B Instruct M5 Max aggregate tok/s",
  );
  assertNear(
    result.best.perSession,
    20.057134343,
    0.000000001,
    "Qwen2.5 Coder 1.5B Instruct M5 Max per-session tok/s",
  );
  assertNear(
    result.dennard,
    8109.137635529,
    0.000000001,
    "Qwen2.5 Coder 1.5B Instruct M5 Max Dennard bound",
  );
}

{
  const result = profiled("Qwen/Qwen2.5-3B-Instruct", "nvidia-dgx-spark");
  assertNear(
    result.resident,
    6.171877376,
    0.000000001,
    "Qwen2.5 3B Instruct resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    6.171877376,
    0.000000001,
    "Qwen2.5 3B Instruct swept BF16 decode traffic",
  );
  assertNear(
    result.alloc,
    3.6864,
    0.000000001,
    "Qwen2.5 3B Instruct BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.179648,
    0.000000001,
    "Qwen2.5 3B Instruct BF16 KV read traffic",
  );
}

{
  const result = profiled("Qwen/Qwen2.5-Coder-3B-Instruct", "nvidia-dgx-spark");
  const m5Result = profiled(
    "Qwen/Qwen2.5-Coder-3B-Instruct",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    6.171877376,
    0.000000001,
    "Qwen2.5 Coder 3B Instruct resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    6.171877376,
    0.000000001,
    "Qwen2.5 Coder 3B Instruct swept BF16 decode traffic",
  );
  assertNear(
    result.alloc,
    3.6864,
    0.000000001,
    "Qwen2.5 Coder 3B Instruct BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.179648,
    0.000000001,
    "Qwen2.5 Coder 3B Instruct BF16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    37.1351503310107,
    0.000000001,
    "Qwen2.5 Coder 3B Instruct DGX Spark single-session tok/s",
  );
  assert.equal(result.bMem, 30);
  assert.equal(result.best.batch, 6);
  assertNear(
    result.best.aggregate,
    123.62483059262287,
    0.000000001,
    "Qwen2.5 Coder 3B Instruct DGX Spark aggregate tok/s",
  );
  assertNear(
    result.best.perSession,
    20.604138432103813,
    0.000000001,
    "Qwen2.5 Coder 3B Instruct DGX Spark per-session tok/s",
  );
  assertNear(
    result.dennard,
    1365.816873827231,
    0.000000001,
    "Qwen2.5 Coder 3B Instruct DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.bMem, 30);
  assert.equal(m5Result.best.batch, 20);
  assertNear(
    m5Result.best.aggregate,
    412.56734733251443,
    0.000000001,
    "Qwen2.5 Coder 3B Instruct M5 Max aggregate tok/s",
  );
  assertNear(
    m5Result.best.perSession,
    20.62836736662572,
    0.000000001,
    "Qwen2.5 Coder 3B Instruct M5 Max per-session tok/s",
  );
}

{
  const result = profiled("Qwen/Qwen2.5-3B", "nvidia-dgx-spark");
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    6.171877376,
    0.000000001,
    "Qwen2.5 3B resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    6.171877376,
    0.000000001,
    "Qwen2.5 3B swept BF16 decode traffic",
  );
  assertNear(
    result.alloc,
    3.6864,
    0.000000001,
    "Qwen2.5 3B BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.179648,
    0.000000001,
    "Qwen2.5 3B BF16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    37.135150331,
    0.000000001,
    "Qwen2.5 3B DGX Spark single-session tok/s",
  );
  assert.equal(result.bMem, 30);
  assert.equal(result.best.batch, 6);
  assertNear(
    result.best.aggregate,
    123.624830593,
    0.000000001,
    "Qwen2.5 3B DGX Spark aggregate tok/s",
  );
  assertNear(
    result.best.perSession,
    20.604138432,
    0.000000001,
    "Qwen2.5 3B DGX Spark per-session tok/s",
  );
  assertNear(
    result.dennard,
    1365.816873827,
    0.000000001,
    "Qwen2.5 3B DGX Spark Dennard bound",
  );
}

{
  const result = profiled("Qwen/Qwen2.5-Omni-3B", "nvidia-dgx-spark");
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    11.972343936,
    0.000000001,
    "Qwen2.5 Omni 3B full checkpoint resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    6.171877376,
    0.000000001,
    "Qwen2.5 Omni 3B Thinker text-decode traffic",
  );
  assertNear(
    result.alloc,
    3.6864,
    0.000000001,
    "Qwen2.5 Omni 3B BF16 Thinker KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.179648,
    0.000000001,
    "Qwen2.5 Omni 3B BF16 Thinker KV read traffic",
  );
  assert.equal(result.bMem, 29);
  assert.equal(result.best.batch, 6);
  assertNear(
    result.best.aggregate,
    123.62483059262287,
    0.000000001,
    "Qwen2.5 Omni 3B DGX Spark aggregate throughput",
  );
}

{
  const result = profiled("Qwen/Qwen2.5-Omni-7B", "nvidia-dgx-spark");
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    22.362553472,
    0.000000001,
    "Qwen2.5 Omni 7B full checkpoint resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    14.141238272,
    0.000000001,
    "Qwen2.5 Omni 7B Thinker text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    8.2213152,
    0.000000001,
    "Qwen2.5 Omni 7B Talker/Token2Wav/encoder resident footprint",
  );
  assertNear(
    result.alloc,
    5.7344,
    0.000000001,
    "Qwen2.5 Omni 7B BF16 Thinker KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.835008,
    0.000000001,
    "Qwen2.5 Omni 7B BF16 Thinker KV read traffic",
  );
  assert.equal(result.bMem, 17);
  assertNear(
    result.single.aggregate,
    17.08786878670369,
    0.000000001,
    "Qwen2.5 Omni 7B DGX Spark single-session throughput",
  );
}

{
  const result = profiled("Qwen/Qwen2.5-Omni-7B-AWQ", "nvidia-dgx-spark");
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    12.70206784,
    0.000000001,
    "Qwen2.5 Omni 7B AWQ full checkpoint resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    4.48075264,
    0.000000001,
    "Qwen2.5 Omni 7B AWQ Thinker text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    8.2213152,
    0.000000001,
    "Qwen2.5 Omni 7B AWQ Talker/Token2Wav/encoder resident footprint",
  );
  assertNear(
    result.alloc,
    5.7344,
    0.000000001,
    "Qwen2.5 Omni 7B AWQ BF16 Thinker KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.835008,
    0.000000001,
    "Qwen2.5 Omni 7B AWQ BF16 Thinker KV read traffic",
  );
  assert.equal(result.bMem, 18);
  assert.equal(result.best.batch, 4);
  assertNear(
    result.best.aggregate,
    92.37965441860888,
    0.000000001,
    "Qwen2.5 Omni 7B AWQ DGX Spark aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    23.09491360465222,
    0.000000001,
    "Qwen2.5 Omni 7B AWQ DGX Spark per-session throughput",
  );
}

{
  const result = profiled("Qwen/Qwen2.5-VL-3B-Instruct", "nvidia-dgx-spark");
  assertNear(
    result.resident,
    7.509245952,
    0.000000001,
    "Qwen2.5 VL 3B Instruct resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    6.171877376,
    0.000000001,
    "Qwen2.5 VL 3B Instruct swept BF16 text-decode traffic",
  );
  assertNear(
    result.alloc,
    3.6864,
    0.000000001,
    "Qwen2.5 VL 3B Instruct BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.179648,
    0.000000001,
    "Qwen2.5 VL 3B Instruct BF16 KV read traffic",
  );
}

{
  const result = profiled(
    "Qwen/Qwen2.5-VL-3B-Instruct-AWQ",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "Qwen/Qwen2.5-VL-3B-Instruct-AWQ",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assertNear(
    result.resident,
    3.401637888,
    0.000000001,
    "Qwen2.5 VL 3B AWQ resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    2.064269312,
    0.000000001,
    "Qwen2.5 VL 3B AWQ swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    1.337368576,
    0.000000001,
    "Qwen2.5 VL 3B AWQ resident-only visual footprint",
  );
  assertNear(
    result.alloc,
    3.6864,
    0.000000001,
    "Qwen2.5 VL 3B AWQ BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.179648,
    0.000000001,
    "Qwen2.5 VL 3B AWQ BF16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    84.1575088828898,
    0.000000001,
    "Qwen2.5 VL 3B AWQ DGX single-session tok/s",
  );
  assert.equal(result.bMem, 31);
  assert.equal(result.best.batch, 9);
  assertNear(
    result.best.aggregate,
    193.75288782488988,
    0.000000001,
    "Qwen2.5 VL 3B AWQ DGX aggregate tok/s",
  );
  assertNear(
    result.dennard,
    4182.984768413783,
    0.000000001,
    "Qwen2.5 VL 3B AWQ DGX Dennard bound",
  );
  assertNear(
    m5Result.single.aggregate,
    189.27732767067525,
    0.000000001,
    "Qwen2.5 VL 3B AWQ M5 Max single-session tok/s",
  );
  assert.equal(m5Result.best.batch, 24);
  assertNear(
    m5Result.best.aggregate,
    485.1226851989193,
    0.000000001,
    "Qwen2.5 VL 3B AWQ M5 Max aggregate tok/s",
  );
  assertNear(
    m5Result.dennard,
    9407.885156798766,
    0.000000001,
    "Qwen2.5 VL 3B AWQ M5 Max Dennard bound",
  );
}

{
  const repo = "RedHatAI/Qwen2.5-VL-3B-Instruct-quantized.w4a16";
  const row = model(repo);
  const item = profile(repo);
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  const m1Result = profiled(repo, "apple-mac-studio-m1-ultra-128gb");

  assert.equal(row.hf_downloads, 115971);
  assert.ok(row.tags.includes("region:us"));
  assert.equal(
    row.adapter.weight_precision,
    "compressed-tensors W4A16 INT4/BF16",
  );
  assertNear(
    row.architecture.total_params_b,
    4.08746444,
    0.000000001,
    "RedHatAI Qwen2.5 VL 3B W4A16 catalog total params",
  );
  assertNear(
    row.architecture.active_params_b,
    3.107615224,
    0.000000001,
    "RedHatAI Qwen2.5 VL 3B W4A16 catalog swept params",
  );
  assert.equal(item.status, "audited");
  assert.equal(item.base_model_proof.config_compatible, true);
  assert.equal(
    item.serving.runtime_format,
    "vllm-compressed-tensors-w4a16-qwen2.5-vl-text-decode-memory-bound",
  );
  assert.equal(item.architecture.kv_adapter.kind, "full_context");
  assert.equal(item.architecture.kv_adapter.layers, 36);
  assert.equal(item.architecture.kv_adapter.kv_heads, 2);
  assert.equal(item.architecture.kv_adapter.head_dim, 128);
  assertNear(
    result.resident,
    4.01313376,
    0.000000001,
    "RedHatAI Qwen2.5 VL 3B W4A16 resident compressed-tensors payload",
  );
  assertNear(
    result.single.batchWeight,
    2.053435328,
    0.000000001,
    "RedHatAI Qwen2.5 VL 3B W4A16 swept text-decode traffic",
  );
  assertNear(
    item.architecture.weight_adapter.auxiliary_resident_weight_gb,
    1.959698432,
    0.000000001,
    "RedHatAI Qwen2.5 VL 3B W4A16 resident-only visual/input-embedding footprint",
  );
  assertNear(
    result.alloc,
    3.6864,
    0.000000001,
    "RedHatAI Qwen2.5 VL 3B W4A16 BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.179648,
    0.000000001,
    "RedHatAI Qwen2.5 VL 3B W4A16 BF16 KV read traffic",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(result.bMem, 31);
  assert.equal(result.best.batch, 9);
  assertNear(
    result.single.aggregate,
    84.4395186587656,
    0.000000001,
    "RedHatAI Qwen2.5 VL 3B W4A16 DGX single-session tok/s",
  );
  assertNear(
    result.best.aggregate,
    193.91856038982542,
    0.000000001,
    "RedHatAI Qwen2.5 VL 3B W4A16 DGX aggregate tok/s",
  );
  assertNear(
    result.best.perSession,
    21.5465067099806,
    0.000000001,
    "RedHatAI Qwen2.5 VL 3B W4A16 DGX per-session tok/s",
  );
  assertNear(
    result.dennard,
    4183.001062146388,
    0.000000001,
    "RedHatAI Qwen2.5 VL 3B W4A16 DGX Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 24);
  assertNear(
    m5Result.best.aggregate,
    485.2957730830903,
    0.000000001,
    "RedHatAI Qwen2.5 VL 3B W4A16 M5 Max aggregate tok/s",
  );
  assertNear(
    m5Result.best.perSession,
    20.22065721179543,
    0.000000001,
    "RedHatAI Qwen2.5 VL 3B W4A16 M5 Max per-session tok/s",
  );
  assert.equal(m1Result.status_code, "ok");
  assert.equal(m1Result.best.batch, 31);
  assertNear(
    m1Result.best.aggregate,
    642.1123702712829,
    0.000000001,
    "RedHatAI Qwen2.5 VL 3B W4A16 M1 Ultra aggregate tok/s",
  );
}

{
  const repo = "RedHatAI/Qwen2.5-VL-3B-Instruct-quantized.w8a8";
  const row = model(repo);
  const item = profile(repo);
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  const m1Result = profiled(repo, "apple-mac-studio-m1-ultra-128gb");

  assert.equal(row.hf_downloads, 121846);
  assert.ok(row.tags.includes("region:us"));
  assert.equal(
    row.adapter.weight_precision,
    "compressed-tensors W8A8 INT8/BF16",
  );
  assertNear(
    row.architecture.total_params_b,
    4.066820096,
    0.000000001,
    "RedHatAI Qwen2.5 VL 3B W8A8 catalog total params",
  );
  assertNear(
    row.architecture.active_params_b,
    3.08697088,
    0.000000001,
    "RedHatAI Qwen2.5 VL 3B W8A8 catalog swept params",
  );
  assert.equal(item.status, "audited");
  assert.equal(item.base_model_proof.config_compatible, true);
  assert.equal(
    item.serving.runtime_format,
    "vllm-compressed-tensors-w8a8-qwen2.5-vl-text-decode-memory-bound",
  );
  assert.equal(item.architecture.kv_adapter.kind, "full_context");
  assert.equal(item.architecture.kv_adapter.layers, 36);
  assert.equal(item.architecture.kv_adapter.kv_heads, 2);
  assert.equal(item.architecture.kv_adapter.head_dim, 128);
  assertNear(
    result.resident,
    5.359108096,
    0.000000001,
    "RedHatAI Qwen2.5 VL 3B W8A8 resident compressed-tensors payload",
  );
  assertNear(
    result.single.batchWeight,
    3.399409664,
    0.000000001,
    "RedHatAI Qwen2.5 VL 3B W8A8 swept text-decode traffic",
  );
  assertNear(
    item.architecture.weight_adapter.auxiliary_resident_weight_gb,
    1.959698432,
    0.000000001,
    "RedHatAI Qwen2.5 VL 3B W8A8 resident-only visual/input-embedding footprint",
  );
  assertNear(
    result.alloc,
    3.6864,
    0.000000001,
    "RedHatAI Qwen2.5 VL 3B W8A8 BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.179648,
    0.000000001,
    "RedHatAI Qwen2.5 VL 3B W8A8 BF16 KV read traffic",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(result.bMem, 31);
  assert.equal(result.best.batch, 8);
  assertNear(
    result.single.aggregate,
    59.619253574003466,
    0.000000001,
    "RedHatAI Qwen2.5 VL 3B W8A8 DGX single-session tok/s",
  );
  assertNear(
    result.best.aggregate,
    170.13859417588245,
    0.000000001,
    "RedHatAI Qwen2.5 VL 3B W8A8 DGX aggregate tok/s",
  );
  assertNear(
    result.best.perSession,
    21.267324271985306,
    0.000000001,
    "RedHatAI Qwen2.5 VL 3B W8A8 DGX per-session tok/s",
  );
  assertNear(
    result.dennard,
    2497.44677335443,
    0.000000001,
    "RedHatAI Qwen2.5 VL 3B W8A8 DGX Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 23);
  assertNear(
    m5Result.best.aggregate,
    462.5415124751574,
    0.000000001,
    "RedHatAI Qwen2.5 VL 3B W8A8 M5 Max aggregate tok/s",
  );
  assertNear(
    m5Result.best.perSession,
    20.110500542398146,
    0.000000001,
    "RedHatAI Qwen2.5 VL 3B W8A8 M5 Max per-session tok/s",
  );
  assert.equal(m1Result.status_code, "ok");
  assert.equal(m1Result.best.batch, 31);
  assertNear(
    m1Result.best.aggregate,
    620.4886710650021,
    0.000000001,
    "RedHatAI Qwen2.5 VL 3B W8A8 M1 Ultra aggregate tok/s",
  );
}

{
  const result = profiled("Qwen/Qwen2-7B-Instruct", "nvidia-dgx-spark");
  assertNear(
    result.resident,
    15.231233024,
    0.000000001,
    "Qwen2 7B Instruct resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    14.141238272,
    0.000000001,
    "Qwen2 7B Instruct swept BF16 decode traffic",
  );
  assertNear(
    result.alloc,
    5.7344,
    0.000000001,
    "Qwen2 7B Instruct BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.835008,
    0.000000001,
    "Qwen2 7B Instruct BF16 KV read traffic",
  );
}

{
  const result = profiled("Qwen/Qwen2-Audio-7B-Instruct", "nvidia-dgx-spark");
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    16.794189824,
    0.000000001,
    "Qwen2 Audio 7B Instruct full resident package footprint",
  );
  assertNear(
    result.single.batchWeight,
    14.231543808,
    0.000000001,
    "Qwen2 Audio 7B Instruct swept BF16 text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    2.562646016,
    0.000000001,
    "Qwen2 Audio 7B Instruct resident audio/projector/input footprint",
  );
  assertNear(
    result.alloc,
    52.4288,
    0.000000001,
    "Qwen2 Audio 7B Instruct full-context BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    16.777216,
    0.000000001,
    "Qwen2 Audio 7B Instruct full-context BF16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    8.803963838,
    0.000000001,
    "Qwen2 Audio 7B Instruct DGX single-session tok/s",
  );
  assert.equal(result.bMem, 1);
  assert.equal(result.best, null);
  assertNear(
    result.dennard,
    37.761119637,
    0.000000001,
    "Qwen2 Audio 7B Instruct DGX Dennard bound",
  );
}

{
  const result = profiled(
    "Qwen/Qwen2-Audio-7B-Instruct",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.single.aggregate,
    19.800856397,
    0.000000001,
    "Qwen2 Audio 7B Instruct M5 Max single-session tok/s",
  );
  assert.equal(result.bMem, 1);
  assert.equal(result.best, null);
  assertNear(
    result.dennard,
    84.927939404,
    0.000000001,
    "Qwen2 Audio 7B Instruct M5 Max Dennard bound",
  );
}

{
  const result = profiled("Qwen/Qwen2.5-7B", "nvidia-dgx-spark");
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    15.231233024,
    0.000000001,
    "Qwen2.5 7B base resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    14.141238272,
    0.000000001,
    "Qwen2.5 7B base swept BF16 decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    1.089994752,
    0.000000001,
    "Qwen2.5 7B base resident-only input embedding footprint",
  );
  assertNear(
    result.alloc,
    5.7344,
    0.000000001,
    "Qwen2.5 7B base BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.835008,
    0.000000001,
    "Qwen2.5 7B base BF16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    17.087868787,
    0.000000001,
    "Qwen2.5 7B base DGX single-session tok/s",
  );
  assert.equal(result.bMem, 18);
  assert.equal(result.best, null);
  assertNear(
    result.dennard,
    352.711042188,
    0.000000001,
    "Qwen2.5 7B base DGX Dennard bound",
  );
}

{
  const result = profiled("Qwen/Qwen2.5-7B-Instruct", "nvidia-dgx-spark");
  assertNear(
    result.resident,
    15.231233024,
    0.000000001,
    "Qwen2.5 7B Instruct resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    14.141238272,
    0.000000001,
    "Qwen2.5 7B Instruct swept BF16 decode traffic",
  );
  assertNear(
    result.alloc,
    5.7344,
    0.000000001,
    "Qwen2.5 7B Instruct BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.835008,
    0.000000001,
    "Qwen2.5 7B Instruct BF16 KV read traffic",
  );
}

{
  const repo = "Qwen/Qwen2.5-Math-7B-Instruct";
  const row = model(repo);
  const item = profile(repo);
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");

  assert.equal(row.hf_downloads, 148342);
  assert.equal(row.tags.includes("region:us"), true);
  assert.equal(row.architecture.active_params_b, 7.070619136);
  assert.equal(item.status, "audited");
  assert.equal(item.architecture.kv_adapter.kind, "full_context");
  assert.equal(item.architecture.kv_adapter.layers, 28);
  assert.equal(item.architecture.kv_adapter.kv_heads, 4);
  assertNear(
    weightAdapter.resident_params_b,
    7.615616512,
    0.000000001,
    "Qwen2.5 Math 7B Instruct resident parameters",
  );
  assertNear(
    weightAdapter.swept_params_b,
    7.070619136,
    0.000000001,
    "Qwen2.5 Math 7B Instruct swept parameters",
  );
  assertNear(
    result.resident,
    15.231233024,
    0.000000001,
    "Qwen2.5 Math 7B Instruct resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    14.141238272,
    0.000000001,
    "Qwen2.5 Math 7B Instruct swept BF16 decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    1.089994752,
    0.000000001,
    "Qwen2.5 Math 7B Instruct resident-only input embedding footprint",
  );
  assertNear(
    result.alloc,
    5.7344,
    0.000000001,
    "Qwen2.5 Math 7B Instruct BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.835008,
    0.000000001,
    "Qwen2.5 Math 7B Instruct BF16 KV read traffic",
  );
  assert.equal(result.status_code, "no_floor");
  assert.equal(result.bMem, 18);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    17.08786878670369,
    0.000000001,
    "Qwen2.5 Math 7B Instruct DGX single-session tok/s",
  );
  assertNear(
    result.dennard,
    352.7110421882862,
    0.000000001,
    "Qwen2.5 Math 7B Instruct DGX Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 9);
  assertNear(
    m5Result.best.aggregate,
    180.2565263389568,
    0.000000001,
    "Qwen2.5 Math 7B Instruct M5 Max aggregate tok/s at b*",
  );
  assertNear(
    m5Result.best.perSession,
    20.028502926550757,
    0.000000001,
    "Qwen2.5 Math 7B Instruct M5 Max per-session tok/s at b*",
  );
}

{
  const item = profile("Qwen/Qwen2.5-Coder-7B");
  const result = profiled("Qwen/Qwen2.5-Coder-7B", "nvidia-dgx-spark");
  assert.equal(result.status_code, "no_floor");
  assert.equal(item.architecture.max_context_tokens, 32768);
  assertNear(
    result.resident,
    15.231233024,
    0.000000001,
    "Qwen2.5 Coder 7B resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    14.141238272,
    0.000000001,
    "Qwen2.5 Coder 7B swept BF16 decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    1.089994752,
    0.000000001,
    "Qwen2.5 Coder 7B resident input embedding footprint",
  );
  assertNear(
    result.alloc,
    5.7344,
    0.000000001,
    "Qwen2.5 Coder 7B BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.835008,
    0.000000001,
    "Qwen2.5 Coder 7B BF16 KV read traffic",
  );
  assert.equal(result.bMem, 18);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    17.08786878670369,
    0.000000001,
    "Qwen2.5 Coder 7B DGX Spark single-session throughput",
  );
  assertNear(
    result.dennard,
    352.7110421882862,
    0.000000001,
    "Qwen2.5 Coder 7B DGX Spark Dennard bound",
  );
}

{
  const result = profiled("Qwen/Qwen2.5-Coder-7B-Instruct", "nvidia-dgx-spark");
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    15.231233024,
    0.000000001,
    "Qwen2.5 Coder 7B Instruct resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    14.141238272,
    0.000000001,
    "Qwen2.5 Coder 7B Instruct swept BF16 decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    1.089994752,
    0.000000001,
    "Qwen2.5 Coder 7B Instruct resident input embedding footprint",
  );
  assertNear(
    result.alloc,
    5.7344,
    0.000000001,
    "Qwen2.5 Coder 7B Instruct BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.835008,
    0.000000001,
    "Qwen2.5 Coder 7B Instruct BF16 KV read traffic",
  );
}

{
  const repo = "Qwen/Qwen2.5-Coder-7B-Instruct-GGUF";
  const row = model(repo);
  const item = profile(repo);
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");

  assert.equal(row.hf_downloads, 155704);
  assert.ok(row.tags.includes("region:us"));
  assert.equal(row.adapter.weight_precision, "GGUF Q5_K_M");
  assert.equal(row.architecture.max_context_tokens, 131072);
  assert.equal(item.status, "audited");
  assert.equal(
    item.serving.runtime_format,
    "llama.cpp-gguf-q5-k-m-qwen2.5-coder-memory-bound",
  );
  assert.equal(item.architecture.max_context_tokens, 131072);
  assert.equal(item.architecture.kv_adapter.kind, "full_context");
  assert.equal(item.architecture.kv_adapter.layers, 28);
  assert.equal(item.architecture.kv_adapter.kv_heads, 4);
  assert.equal(item.architecture.kv_adapter.head_dim, 128);
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    5.444831232,
    0.000000001,
    "Qwen2.5 Coder 7B Instruct GGUF Q5_K_M resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    5.064192,
    0.000000001,
    "Qwen2.5 Coder 7B Instruct GGUF Q5_K_M swept decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.380639232,
    0.000000001,
    "Qwen2.5 Coder 7B Instruct GGUF Q5_K_M resident input/header footprint",
  );
  assertNear(
    result.alloc,
    5.7344,
    0.000000001,
    "Qwen2.5 Coder 7B Instruct GGUF Q5_K_M FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.835008,
    0.000000001,
    "Qwen2.5 Coder 7B Instruct GGUF Q5_K_M FP16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    39.56980519480519,
    0.000000001,
    "Qwen2.5 Coder 7B Instruct GGUF Q5_K_M DGX single-session throughput",
  );
  assert.equal(result.bMem, 19);
  assert.equal(result.best.batch, 4);
  assertNear(
    result.best.aggregate,
    88.03452759318117,
    0.000000001,
    "Qwen2.5 Coder 7B Instruct GGUF Q5_K_M DGX aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    22.00863189829529,
    0.000000001,
    "Qwen2.5 Coder 7B Instruct GGUF Q5_K_M DGX per-session throughput",
  );
  assertNear(
    result.dennard,
    1076.9094551509895,
    0.000000001,
    "Qwen2.5 Coder 7B Instruct GGUF Q5_K_M DGX Dennard bound",
  );
  assertNear(
    m5Result.single.aggregate,
    88.99582560296845,
    0.000000001,
    "Qwen2.5 Coder 7B Instruct GGUF Q5_K_M M5 Max single-session throughput",
  );
  assert.equal(m5Result.best.batch, 13);
  assertNear(
    m5Result.best.aggregate,
    276.0094851548253,
    0.000000001,
    "Qwen2.5 Coder 7B Instruct GGUF Q5_K_M M5 Max aggregate throughput",
  );
  assertNear(
    m5Result.dennard,
    2422.0600932699913,
    0.000000001,
    "Qwen2.5 Coder 7B Instruct GGUF Q5_K_M M5 Max Dennard bound",
  );
}

{
  const item = profile("Qwen/Qwen2.5-Coder-7B-Instruct-GPTQ-Int4");
  const result = profiled(
    "Qwen/Qwen2.5-Coder-7B-Instruct-GPTQ-Int4",
    "nvidia-dgx-spark",
  );
  assert.equal(item.serving.weight_format, "int4");
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    5.575277568,
    0.000000001,
    "Qwen2.5 Coder 7B Instruct GPTQ Int4 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    4.485282816,
    0.000000001,
    "Qwen2.5 Coder 7B Instruct GPTQ Int4 swept decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    1.089994752,
    0.000000001,
    "Qwen2.5 Coder 7B Instruct GPTQ Int4 resident input embedding footprint",
  );
  assertNear(
    result.alloc,
    5.7344,
    0.000000001,
    "Qwen2.5 Coder 7B Instruct GPTQ Int4 FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.835008,
    0.000000001,
    "Qwen2.5 Coder 7B Instruct GPTQ Int4 FP16 KV read traffic",
  );
  assert.equal(result.bMem, 19);
  assert.equal(result.best.batch, 4);
  assertNear(
    result.single.aggregate,
    43.194214942,
    0.000001,
    "Qwen2.5 Coder 7B Instruct GPTQ Int4 DGX Spark single-session throughput",
  );
  assertNear(
    result.best.aggregate,
    92.344264571,
    0.000001,
    "Qwen2.5 Coder 7B Instruct GPTQ Int4 DGX Spark aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    23.086066143,
    0.000001,
    "Qwen2.5 Coder 7B Instruct GPTQ Int4 DGX Spark per-session throughput",
  );
  assertNear(
    result.dennard,
    1214.520077601,
    0.000001,
    "Qwen2.5 Coder 7B Instruct GPTQ Int4 DGX Spark Dennard bound",
  );
}

{
  const item = profile("Qwen/Qwen2.5-Coder-7B-Instruct-AWQ");
  const result = profiled(
    "Qwen/Qwen2.5-Coder-7B-Instruct-AWQ",
    "nvidia-dgx-spark",
  );
  assert.equal(item.status, "audited");
  assert.equal(item.serving.weight_format, "int4");
  assert.equal(
    item.serving.runtime_format,
    "transformers-awq-gemm-memory-bound",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    item.architecture.weight_adapter.resident_params_b,
    7.615616512,
    0.000000001,
    "Qwen2.5 Coder 7B Instruct AWQ logical resident parameters",
  );
  assertNear(
    item.architecture.weight_adapter.swept_params_b,
    7.070619136,
    0.000000001,
    "Qwen2.5 Coder 7B Instruct AWQ logical swept parameters",
  );
  assertNear(
    item.architecture.weight_adapter.auxiliary_resident_params_b,
    0.544997376,
    0.000000001,
    "Qwen2.5 Coder 7B Instruct AWQ resident input embedding parameters",
  );
  assertNear(
    result.resident,
    5.570747392,
    0.000000001,
    "Qwen2.5 Coder 7B Instruct AWQ resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    4.48075264,
    0.000000001,
    "Qwen2.5 Coder 7B Instruct AWQ swept decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    1.089994752,
    0.000000001,
    "Qwen2.5 Coder 7B Instruct AWQ resident input embedding footprint",
  );
  assertNear(
    result.alloc,
    5.7344,
    0.000000001,
    "Qwen2.5 Coder 7B Instruct AWQ FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.835008,
    0.000000001,
    "Qwen2.5 Coder 7B Instruct AWQ FP16 KV read traffic",
  );
  assert.equal(result.bMem, 19);
  assert.equal(result.best.batch, 4);
  assertNear(
    result.single.aggregate,
    43.225197337,
    0.000001,
    "Qwen2.5 Coder 7B Instruct AWQ DGX Spark single-session throughput",
  );
  assertNear(
    result.best.aggregate,
    92.379654419,
    0.000001,
    "Qwen2.5 Coder 7B Instruct AWQ DGX Spark aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    23.094913605,
    0.000001,
    "Qwen2.5 Coder 7B Instruct AWQ DGX Spark per-session throughput",
  );
  assertNear(
    result.dennard,
    1215.796126552,
    0.000001,
    "Qwen2.5 Coder 7B Instruct AWQ DGX Spark Dennard bound",
  );
}

{
  const result = profiled(
    "Qwen/Qwen2.5-Coder-32B-Instruct",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    65.527752704,
    0.000000001,
    "Qwen2.5 Coder 32B Instruct resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    63.970617344,
    0.000000001,
    "Qwen2.5 Coder 32B Instruct swept BF16 decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    1.55713536,
    0.000000001,
    "Qwen2.5 Coder 32B Instruct resident input embedding footprint",
  );
  assertNear(
    result.alloc,
    26.2144,
    0.000000001,
    "Qwen2.5 Coder 32B Instruct BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    8.388608,
    0.000000001,
    "Qwen2.5 Coder 32B Instruct BF16 KV read traffic",
  );
}

{
  const result = profiled(
    "nvidia/NVIDIA-Nemotron-3-Nano-4B-BF16",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    7.947113664,
    0.000000001,
    "Nemotron 3 Nano 4B BF16 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    7.12503008,
    0.000000001,
    "Nemotron 3 Nano 4B BF16 swept BF16 decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    0.822083584,
    0.000000001,
    "Nemotron 3 Nano 4B BF16 resident input embedding footprint",
  );
  assertNear(
    result.alloc,
    1.681321984,
    0.000000001,
    "Nemotron 3 Nano 4B BF16 hybrid attention KV plus Mamba state allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.567209984,
    0.000000001,
    "Nemotron 3 Nano 4B BF16 hybrid attention KV plus Mamba state read traffic",
  );
  assert.equal(result.best.batch, 11);
  assertNear(
    result.best.aggregate,
    224.70245605629876,
    0.000000001,
    "Nemotron 3 Nano 4B BF16 DGX Spark aggregate throughput",
  );
}

{
  const catalogRow = model("nvidia/Llama-3_3-Nemotron-Super-49B-v1");
  const modelProfile = profile("nvidia/Llama-3_3-Nemotron-Super-49B-v1");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "nvidia/Llama-3_3-Nemotron-Super-49B-v1",
    "nvidia-dgx-spark",
  );
  assert.equal(catalogRow.hf_downloads, 188263);
  assert.equal(catalogRow.architecture.kv_heads, 8);
  assertNear(
    catalogRow.adapter.kv_alloc_gb_per_1k_tokens,
    0.200704,
    0.000000001,
    "Llama 3.3 Nemotron Super 49B v1 catalog corrected 49-layer KV allocation per 1K",
  );
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    99.734290432,
    0.000000001,
    "Llama 3.3 Nemotron Super 49B v1 BF16 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    97.632944128,
    0.000000001,
    "Llama 3.3 Nemotron Super 49B v1 BF16 swept decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    2.101346304,
    0.000000001,
    "Llama 3.3 Nemotron Super 49B v1 resident input embedding footprint",
  );
  assert.equal(modelProfile.architecture.kv_adapter.layers, 49);
  assert.equal(modelProfile.architecture.kv_adapter.kv_heads, 8);
  assert.equal(modelProfile.architecture.kv_adapter.head_dim, 128);
  assertNear(
    result.alloc,
    20.0704,
    0.000000001,
    "Llama 3.3 Nemotron Super 49B v1 49-layer BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    6.422528,
    0.000000001,
    "Llama 3.3 Nemotron Super 49B v1 49-layer BF16 KV read traffic",
  );
  assert.equal(result.bMem, 1);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    2.6236006085694283,
    0.000000001,
    "Llama 3.3 Nemotron Super 49B v1 DGX Spark single-session throughput",
  );
  assertNear(
    result.dennard,
    2.8233976425449123,
    0.000000001,
    "Llama 3.3 Nemotron Super 49B v1 DGX Spark Dennard bound",
  );
}

{
  const result = profiled(
    "nvidia/Llama-3_3-Nemotron-Super-49B-v1_5",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    99.734290432,
    0.000000001,
    "Llama 3.3 Nemotron Super 49B v1.5 BF16 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    97.632944128,
    0.000000001,
    "Llama 3.3 Nemotron Super 49B v1.5 BF16 swept decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    2.101346304,
    0.000000001,
    "Llama 3.3 Nemotron Super 49B v1.5 resident input embedding footprint",
  );
  assertNear(
    result.alloc,
    20.0704,
    0.000000001,
    "Llama 3.3 Nemotron Super 49B v1.5 49-layer BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    6.422528,
    0.000000001,
    "Llama 3.3 Nemotron Super 49B v1.5 49-layer BF16 KV read traffic",
  );
  assert.equal(result.bMem, 1);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    2.6236006085694283,
    0.000000001,
    "Llama 3.3 Nemotron Super 49B v1.5 DGX Spark single-session throughput",
  );
  assertNear(
    result.dennard,
    2.8233976425449123,
    0.000000001,
    "Llama 3.3 Nemotron Super 49B v1.5 DGX Spark Dennard bound",
  );
}

{
  const result = profiled(
    "nvidia/Llama-3_3-Nemotron-Super-49B-v1_5",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "no_floor");
  assert.equal(result.bMem, 1);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    5.900698804621352,
    0.000000001,
    "Llama 3.3 Nemotron Super 49B v1.5 M5 Max single-session throughput",
  );
  assertNear(
    result.dennard,
    6.3500591667493635,
    0.000000001,
    "Llama 3.3 Nemotron Super 49B v1.5 M5 Max Dennard bound",
  );
}

{
  const modelProfile = profile("nvidia/Llama-3_3-Nemotron-Super-49B-v1_5-FP8");
  const result = profiled(
    "nvidia/Llama-3_3-Nemotron-Super-49B-v1_5-FP8",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "no_floor");
  assert.equal(modelProfile.serving.weight_format, "fp8");
  assert.equal(modelProfile.serving.kv_store_format, "fp8");
  assert.equal(modelProfile.serving.kv_read_format, "fp8");
  assertNear(
    result.resident,
    51.96956036,
    0.000000001,
    "Llama 3.3 Nemotron Super 49B v1.5 FP8 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    49.868214056,
    0.000000001,
    "Llama 3.3 Nemotron Super 49B v1.5 FP8 swept decode traffic",
  );
  assertNear(
    modelProfile.architecture.weight_adapter.auxiliary_resident_weight_gb,
    2.101346304,
    0.000000001,
    "Llama 3.3 Nemotron Super 49B v1.5 FP8 resident input embedding footprint",
  );
  assertNear(
    result.alloc,
    10.0352,
    0.000000001,
    "Llama 3.3 Nemotron Super 49B v1.5 FP8 49-layer FP8 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    3.211264,
    0.000000001,
    "Llama 3.3 Nemotron Super 49B v1.5 FP8 49-layer FP8 KV read traffic",
  );
  assert.equal(result.bMem, 6);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    5.143230679698453,
    0.000000001,
    "Llama 3.3 Nemotron Super 49B v1.5 FP8 DGX Spark single-session throughput",
  );
  assertNear(
    result.dennard,
    37.11214678920625,
    0.000000001,
    "Llama 3.3 Nemotron Super 49B v1.5 FP8 DGX Spark Dennard bound",
  );
}

{
  const result = profiled(
    "nvidia/Llama-3_3-Nemotron-Super-49B-v1_5-FP8",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "no_floor");
  assert.equal(result.bMem, 6);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    11.567559111116667,
    0.000000001,
    "Llama 3.3 Nemotron Super 49B v1.5 FP8 M5 Max single-session throughput",
  );
  assertNear(
    result.dennard,
    83.46834479330636,
    0.000000001,
    "Llama 3.3 Nemotron Super 49B v1.5 FP8 M5 Max Dennard bound",
  );
}

{
  const result = profiled(
    "nvidia/NVIDIA-Nemotron-Nano-9B-v2",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    17.776454656,
    0.000000001,
    "Nemotron Nano 9B v2 BF16 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    16.602049536,
    0.000000001,
    "Nemotron Nano 9B v2 BF16 swept decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    1.17440512,
    0.000000001,
    "Nemotron Nano 9B v2 BF16 resident input embedding footprint",
  );
  assertNear(
    result.alloc,
    1.782611968,
    0.000000001,
    "Nemotron Nano 9B v2 BF16 hybrid attention KV plus Mamba state allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.668499968,
    0.000000001,
    "Nemotron Nano 9B v2 BF16 hybrid attention KV plus Mamba state read traffic",
  );
  assertNear(
    result.single.aggregate,
    15.807256158049343,
    0.000000001,
    "Nemotron Nano 9B v2 BF16 DGX Spark single-session throughput",
  );
  assert.equal(result.bMem, 57);
  assert.equal(result.best, null);
  assertNear(
    result.dennard,
    942.9638918173164,
    0.000000001,
    "Nemotron Nano 9B v2 BF16 DGX Spark Dennard bound",
  );
}

{
  const catalogRow = model("nvidia/NVIDIA-Nemotron-Nano-12B-v2-VL-BF16");
  const item = profile("nvidia/NVIDIA-Nemotron-Nano-12B-v2-VL-BF16");
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(
    "nvidia/NVIDIA-Nemotron-Nano-12B-v2-VL-BF16",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "nvidia/NVIDIA-Nemotron-Nano-12B-v2-VL-BF16",
    "apple-macbook-pro-16-m5-max-128gb",
  );

  assert.equal(item.status, "audited");
  assert.equal(catalogRow.hf_downloads, 174551);
  assert.ok(catalogRow.tags.includes("region:us"));
  assert.equal(item.base_model_proof.relation, "derived_package");
  assert.equal(item.base_model_proof.config_compatible, false);
  assert.equal(item.architecture.kv_adapter.kind, "layered_kv");
  assert.equal(item.serving.weight_format, "mixed_bf16_f32");
  assertNear(
    weightAdapter.resident_params_b,
    13.181860358,
    0.000000001,
    "Nemotron Nano 12B v2 VL BF16 resident tensor elements",
  );
  assertNear(
    weightAdapter.swept_params_b,
    11.644155392,
    0.000000001,
    "Nemotron Nano 12B v2 VL BF16 swept tensor elements",
  );
  assertNear(
    weightAdapter.auxiliary_resident_params_b,
    1.537704966,
    0.000000001,
    "Nemotron Nano 12B v2 VL BF16 auxiliary tensor elements",
  );
  assertNear(
    result.resident,
    26.363720728,
    0.000000001,
    "Nemotron Nano 12B v2 VL BF16 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    23.288310784,
    0.000000001,
    "Nemotron Nano 12B v2 VL BF16 swept text-decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    3.075409944,
    0.000000001,
    "Nemotron Nano 12B v2 VL BF16 resident vision/projector/input-embedding footprint",
  );
  assertNear(
    result.alloc,
    2.607153152,
    0.000000001,
    "Nemotron Nano 12B v2 VL BF16 hybrid attention KV plus Mamba state allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.935985152,
    0.000000001,
    "Nemotron Nano 12B v2 VL BF16 hybrid attention KV plus Mamba state read traffic",
  );
  assert.equal(result.status_code, "no_floor");
  assert.equal(result.bMem, 35);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    11.269677381801285,
    0.000000001,
    "Nemotron Nano 12B v2 VL BF16 DGX Spark single-session throughput",
  );
  assertNear(
    result.dennard,
    421.01955071497434,
    0.000000001,
    "Nemotron Nano 12B v2 VL BF16 DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 7);
  assertNear(
    m5Result.single.aggregate,
    25.34645389167029,
    0.000000001,
    "Nemotron Nano 12B v2 VL BF16 M5 Max single-session throughput",
  );
  assertNear(
    m5Result.best.aggregate,
    144.03385411814153,
    0.000000001,
    "Nemotron Nano 12B v2 VL BF16 M5 Max aggregate throughput",
  );
  assertNear(
    m5Result.best.perSession,
    20.576264874020218,
    0.000000001,
    "Nemotron Nano 12B v2 VL BF16 M5 Max per-session throughput",
  );
  assertNear(
    m5Result.dennard,
    946.908440069576,
    0.000000001,
    "Nemotron Nano 12B v2 VL BF16 M5 Max Dennard bound",
  );
}

{
  const item = profile("nvidia/NVIDIA-Nemotron-Nano-9B-v2-FP8");
  const result = profiled(
    "nvidia/NVIDIA-Nemotron-Nano-9B-v2-FP8",
    "nvidia-dgx-spark",
  );
  assert.equal(item.status, "audited");
  assertNear(
    item.architecture.weight_adapter.resident_params_b,
    8.888227536,
    0.000000001,
    "Nemotron Nano 9B v2 FP8 resident tensor elements",
  );
  assertNear(
    item.architecture.weight_adapter.swept_params_b,
    8.301024976,
    0.000000001,
    "Nemotron Nano 9B v2 FP8 swept tensor elements",
  );
  assertNear(
    item.architecture.weight_adapter.auxiliary_resident_params_b,
    0.58720256,
    0.000000001,
    "Nemotron Nano 9B v2 FP8 resident input embedding elements",
  );
  assert.equal(
    item.serving.kv_store_format,
    "bf16-attention-bf16-conv-f32-ssm",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    10.285035328,
    0.000000001,
    "Nemotron Nano 9B v2 FP8 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    9.110630208,
    0.000000001,
    "Nemotron Nano 9B v2 FP8 swept decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    1.17440512,
    0.000000001,
    "Nemotron Nano 9B v2 FP8 resident input embedding footprint",
  );
  assertNear(
    result.alloc,
    1.782611968,
    0.000000001,
    "Nemotron Nano 9B v2 FP8 hybrid attention KV plus Mamba state allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.668499968,
    0.000000001,
    "Nemotron Nano 9B v2 FP8 hybrid attention KV plus Mamba state read traffic",
  );
  assertNear(
    result.single.aggregate,
    27.916593305,
    0.000000001,
    "Nemotron Nano 9B v2 FP8 DGX Spark single-session throughput",
  );
  assert.equal(result.bMem, 61);
  assert.equal(result.best.batch, 6);
  assertNear(
    result.best.aggregate,
    124.832051963,
    0.000000001,
    "Nemotron Nano 9B v2 FP8 DGX Spark aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    20.805341994,
    0.000000001,
    "Nemotron Nano 9B v2 FP8 DGX Spark per-session throughput",
  );
  assertNear(
    result.dennard,
    1844.264800061,
    0.000000001,
    "Nemotron Nano 9B v2 FP8 DGX Spark Dennard bound",
  );
}

{
  const result = profiled(
    "nvidia/NVIDIA-Nemotron-Nano-9B-v2-FP8",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.single.aggregate,
    62.78677029,
    0.000000001,
    "Nemotron Nano 9B v2 FP8 M5 Max single-session throughput",
  );
  assert.equal(result.bMem, 61);
  assert.equal(result.best.batch, 32);
  assertNear(
    result.best.aggregate,
    644.141194566,
    0.000000001,
    "Nemotron Nano 9B v2 FP8 M5 Max aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    20.12941233,
    0.000000001,
    "Nemotron Nano 9B v2 FP8 M5 Max per-session throughput",
  );
  assertNear(
    result.dennard,
    4147.906912958,
    0.000000001,
    "Nemotron Nano 9B v2 FP8 M5 Max Dennard bound",
  );
}

{
  const result = profiled(
    "nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-BF16",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    63.155892352,
    0.000000001,
    "Nemotron 3 Nano 30B BF16 DGX resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    6.455521408,
    0.000000001,
    "Nemotron 3 Nano 30B BF16 exact single-session decode traffic",
  );
  assertNear(
    result.alloc,
    0.663764992,
    0.000000001,
    "Nemotron 3 Nano 30B BF16 hybrid attention KV plus Mamba state allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.245972992,
    0.000000001,
    "Nemotron 3 Nano 30B BF16 hybrid attention KV plus Mamba state read traffic",
  );
  assertNear(
    result.single.aggregate,
    40.73718244097914,
    0.000000001,
    "Nemotron 3 Nano 30B BF16 DGX single-session throughput",
  );
  assert.equal(result.bMem, 85);
  assert.equal(result.best.batch, 3);
  assertNear(
    result.best.aggregate,
    66.47725986349127,
    0.000000001,
    "Nemotron 3 Nano 30B BF16 DGX aggregate throughput",
  );
  assertNear(
    result.dennard,
    3621.6162593181825,
    0.000000001,
    "Nemotron 3 Nano 30B BF16 DGX Dennard bound",
  );
}

{
  const modelProfile = profile("nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-NVFP4");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-NVFP4",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    19.339781632,
    0.000000001,
    "Nemotron 3 Nano 30B NVFP4 DGX resident footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    18.63513856,
    0.000000001,
    "Nemotron 3 Nano 30B NVFP4 ordinary text resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.704643072,
    0.000000001,
    "Nemotron 3 Nano 30B NVFP4 input embedding resident footprint",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    2.11176192,
    0.000000001,
    "Nemotron 3 Nano 30B NVFP4 fixed ordinary text-decode traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.12908888,
    0.000000001,
    "Nemotron 3 Nano 30B NVFP4 routed expert byte group",
  );
  assertNear(
    result.single.batchWeight,
    2.8862952,
    0.000000001,
    "Nemotron 3 Nano 30B NVFP4 exact single-session decode traffic",
  );
  assertNear(
    result.alloc,
    0.356564992,
    0.000000001,
    "Nemotron 3 Nano 30B NVFP4 FP8 KV plus Mamba state allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.147668992,
    0.000000001,
    "Nemotron 3 Nano 30B NVFP4 FP8 KV plus Mamba state read traffic",
  );
  assertNear(
    result.single.aggregate,
    89.98128610741362,
    0.000000001,
    "Nemotron 3 Nano 30B NVFP4 DGX single-session throughput",
  );
  assert.equal(result.bMem, 282);
  assert.equal(result.best.batch, 16);
  assertNear(
    result.best.aggregate,
    327.60530534734556,
    0.000000001,
    "Nemotron 3 Nano 30B NVFP4 DGX aggregate throughput",
  );
  assertNear(
    result.dennard,
    26701.832469856658,
    0.000000001,
    "Nemotron 3 Nano 30B NVFP4 DGX Dennard bound",
  );
}

{
  const modelProfile = profile("nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-FP8");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-FP8",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    32.679949312,
    0.000000001,
    "Nemotron 3 Nano 30B FP8 DGX resident footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    31.97530624,
    0.000000001,
    "Nemotron 3 Nano 30B FP8 ordinary text resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.704643072,
    0.000000001,
    "Nemotron 3 Nano 30B FP8 input embedding resident footprint",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    2.600451072,
    0.000000001,
    "Nemotron 3 Nano 30B FP8 fixed ordinary text-decode traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.229491056,
    0.000000001,
    "Nemotron 3 Nano 30B FP8 routed expert byte group",
  );
  assertNear(
    result.single.batchWeight,
    3.977397408,
    0.000000001,
    "Nemotron 3 Nano 30B FP8 exact single-session decode traffic",
  );
  assertNear(
    result.alloc,
    0.356564992,
    0.000000001,
    "Nemotron 3 Nano 30B FP8 FP8 KV plus Mamba state allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.147668992,
    0.000000001,
    "Nemotron 3 Nano 30B FP8 FP8 KV plus Mamba state read traffic",
  );
  assertNear(
    result.single.aggregate,
    66.18075287224468,
    0.000000001,
    "Nemotron 3 Nano 30B FP8 DGX single-session throughput",
  );
  assert.equal(result.bMem, 244);
  assert.equal(result.best.batch, 8);
  assertNear(
    result.best.aggregate,
    166.08369101307227,
    0.000000001,
    "Nemotron 3 Nano 30B FP8 DGX aggregate throughput",
  );
  assertNear(
    result.dennard,
    16808.886258937506,
    0.000000001,
    "Nemotron 3 Nano 30B FP8 DGX Dennard bound",
  );
}

{
  const modelProfile = profile(
    "nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-BF16",
  );
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-BF16",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    66.03127052,
    0.000000001,
    "Nemotron 3 Nano Omni BF16 DGX resident package footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    62.451243392,
    0.000000001,
    "Nemotron 3 Nano Omni BF16 ordinary text resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    3.580027128,
    0.000000001,
    "Nemotron 3 Nano Omni BF16 multimodal plus input-embedding resident footprint",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    3.701627264,
    0.000000001,
    "Nemotron 3 Nano Omni BF16 fixed ordinary text-decode traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.458981376,
    0.000000001,
    "Nemotron 3 Nano Omni BF16 routed expert byte group",
  );
  assertNear(
    result.single.batchWeight,
    6.45551552,
    0.000000001,
    "Nemotron 3 Nano Omni BF16 exact single-session decode traffic",
  );
  assertNear(
    result.alloc,
    0.639270912,
    0.000000001,
    "Nemotron 3 Nano Omni BF16 hybrid attention KV plus BF16 Mamba state allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.221478912,
    0.000000001,
    "Nemotron 3 Nano Omni BF16 hybrid attention KV plus BF16 Mamba state read traffic",
  );
  assertNear(
    result.single.aggregate,
    40.88665982580829,
    0.000000001,
    "Nemotron 3 Nano Omni BF16 DGX single-session throughput",
  );
  assert.equal(result.bMem, 84);
  assert.equal(result.best.batch, 3);
  assertNear(
    result.best.aggregate,
    66.8761725075152,
    0.000000001,
    "Nemotron 3 Nano Omni BF16 DGX aggregate throughput",
  );
  assertNear(
    result.dennard,
    3570.1705885532006,
    0.000000001,
    "Nemotron 3 Nano Omni BF16 DGX Dennard bound",
  );
}

{
  const result = profiled(
    "nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-BF16",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "resident_not_fit");
  assertNear(
    result.resident,
    247.22210816,
    0.000000001,
    "Nemotron 3 Super BF16 DGX resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    24.466774016,
    0.000000001,
    "Nemotron 3 Super BF16 DGX exact single-session decode traffic",
  );
  assertNear(
    result.alloc,
    0.58064896,
    0.000000001,
    "Nemotron 3 Super BF16 DGX FP8 KV plus Mamba state allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.30212096,
    0.000000001,
    "Nemotron 3 Super BF16 DGX FP8 KV plus Mamba state read traffic",
  );
  assertNear(
    result.single.aggregate,
    11.021888553,
    0.000000001,
    "Nemotron 3 Super BF16 DGX single-session throughput",
  );
  assert.equal(result.bMem, 0);
  assert.equal(result.best, null);
  assert.equal(result.dennard, 0);
}

{
  const result = profiled(
    "nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-FP8",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "resident_not_fit");
  assertNear(
    result.resident,
    128.334890312,
    0.000000001,
    "Nemotron 3 Super FP8 DGX resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    13.47771296,
    0.000000001,
    "Nemotron 3 Super FP8 DGX exact single-session decode traffic",
  );
  assertNear(
    result.alloc,
    0.58064896,
    0.000000001,
    "Nemotron 3 Super FP8 DGX FP8 KV plus Mamba state allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.30212096,
    0.000000001,
    "Nemotron 3 Super FP8 DGX FP8 KV plus Mamba state read traffic",
  );
  assertNear(
    result.single.aggregate,
    19.811559528578123,
    0.000000001,
    "Nemotron 3 Super FP8 DGX single-session throughput",
  );
  assert.equal(result.bMem, 0);
  assert.equal(result.best, null);
  assert.equal(result.dennard, 0);
}

{
  const result = profiled(
    "nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-FP8",
    "apple-mac-studio-m2-ultra-192gb",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.single.aggregate,
    58.05585209839742,
    0.000000001,
    "Nemotron 3 Super FP8 M2 Ultra 192GB single-session throughput",
  );
  assert.equal(result.bMem, 95);
  assert.equal(result.best?.batch, 6);
  assertNear(
    result.best?.aggregate ?? 0,
    131.27865741062897,
    0.000000001,
    "Nemotron 3 Super FP8 M2 Ultra 192GB aggregate throughput",
  );
  assertNear(
    result.best?.perSession ?? 0,
    21.879776235104828,
    0.000000001,
    "Nemotron 3 Super FP8 M2 Ultra 192GB per-session throughput",
  );
  assertNear(
    result.dennard,
    5690.405308853797,
    0.000000001,
    "Nemotron 3 Super FP8 M2 Ultra 192GB Dennard bound",
  );
}

{
  const result = profiled(
    "nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-NVFP4",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    80.297329824,
    0.000000001,
    "Nemotron 3 Super NVFP4 DGX resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    12.64573328,
    0.000000001,
    "Nemotron 3 Super NVFP4 DGX exact single-session decode traffic",
  );
  assertNear(
    result.alloc,
    0.49676288,
    0.000000001,
    "Nemotron 3 Super NVFP4 DGX FP8 KV plus Mamba state allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.21823488,
    0.000000001,
    "Nemotron 3 Super NVFP4 DGX FP8 KV plus Mamba state read traffic",
  );
  assertNear(
    result.single.aggregate,
    21.222067452629638,
    0.000000001,
    "Nemotron 3 Super NVFP4 DGX single-session throughput",
  );
  assert.equal(result.bMem, 79);
  assert.equal(result.best?.batch, 1);
  assertNear(
    result.best?.aggregate ?? 0,
    21.222067452629638,
    0.000000001,
    "Nemotron 3 Super NVFP4 DGX aggregate throughput",
  );
  assertNear(
    result.dennard,
    1725.3976776238326,
    0.000000001,
    "Nemotron 3 Super NVFP4 DGX Dennard bound",
  );
}

{
  const result = profiled(
    "nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-NVFP4",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.single.aggregate,
    47.73021764071281,
    0.000000001,
    "Nemotron 3 Super NVFP4 M5 Max single-session throughput",
  );
  assert.equal(result.bMem, 79);
  assert.equal(result.best?.batch, 8);
  assertNear(
    result.best?.aggregate ?? 0,
    161.2859479609885,
    0.000000001,
    "Nemotron 3 Super NVFP4 M5 Max aggregate throughput",
  );
  assertNear(
    result.best?.perSession ?? 0,
    20.160743495123562,
    0.000000001,
    "Nemotron 3 Super NVFP4 M5 Max per-session throughput",
  );
  assertNear(
    result.dennard,
    3880.5647401503047,
    0.000000001,
    "Nemotron 3 Super NVFP4 M5 Max Dennard bound",
  );
}

{
  const result = profiled(
    "nvidia/NVIDIA-Nemotron-3-Ultra-550B-A55B-NVFP4",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "resident_not_fit");
  assertNear(
    result.resident,
    352.28406128,
    0.000000001,
    "Nemotron 3 Ultra NVFP4 DGX resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    50.251769952,
    0.000000001,
    "Nemotron 3 Ultra NVFP4 DGX exact single-session decode traffic",
  );
  assertNear(
    result.alloc,
    0.82280448,
    0.000000001,
    "Nemotron 3 Ultra NVFP4 DGX FP8 KV plus Mamba state allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.40501248,
    0.000000001,
    "Nemotron 3 Ultra NVFP4 DGX FP8 KV plus Mamba state read traffic",
  );
  assertNear(
    result.single.aggregate,
    5.3892092409632655,
    0.000000001,
    "Nemotron 3 Ultra NVFP4 DGX single-session throughput",
  );
  assert.equal(result.bMem, 0);
  assert.equal(result.best, null);
  assert.equal(result.dennard, 0);
}

{
  const result = profiled(
    "nvidia/NVIDIA-Nemotron-3-Ultra-550B-A55B-NVFP4",
    "nvidia-4x-rtx-pro-6000-blackwell-workstation-2026-bom",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.single.aggregate,
    141.5012887883688,
    0.000000001,
    "Nemotron 3 Ultra NVFP4 4x RTX PRO single-session throughput",
  );
  assert.equal(result.bMem, 28);
  assert.equal(result.best?.batch, 28);
  assertNear(
    result.best?.batchWeight ?? 0,
    242.94445642710338,
    0.000000001,
    "Nemotron 3 Ultra NVFP4 4x RTX PRO expected distinct expert traffic",
  );
  assertNear(
    result.best?.aggregate ?? 0,
    789.2882129374798,
    0.000000001,
    "Nemotron 3 Ultra NVFP4 4x RTX PRO aggregate throughput",
  );
  assertNear(
    result.best?.perSession ?? 0,
    28.188864747767134,
    0.000000001,
    "Nemotron 3 Ultra NVFP4 4x RTX PRO per-session throughput",
  );
  assertNear(
    result.dennard,
    4111.405433821978,
    0.000000001,
    "Nemotron 3 Ultra NVFP4 4x RTX PRO Dennard bound",
  );
}

{
  const result = profiled(
    "nvidia/NVIDIA-Nemotron-3-Ultra-550B-A55B-BF16",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "resident_not_fit");
  assertNear(
    result.resident,
    1121.049257984,
    0.000000001,
    "Nemotron 3 Ultra BF16 DGX resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    109.970251776,
    0.000000001,
    "Nemotron 3 Ultra BF16 DGX exact single-session decode traffic",
  );
  assertNear(
    result.alloc,
    0.82280448,
    0.000000001,
    "Nemotron 3 Ultra BF16 DGX FP8 KV plus Mamba state allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.40501248,
    0.000000001,
    "Nemotron 3 Ultra BF16 DGX FP8 KV plus Mamba state read traffic",
  );
  assertNear(
    result.single.aggregate,
    2.47338026178415,
    0.000000001,
    "Nemotron 3 Ultra BF16 DGX single-session throughput",
  );
  assert.equal(result.bMem, 0);
  assert.equal(result.best, null);
  assert.equal(result.dennard, 0);
}

{
  const result = profiled(
    "nvidia/Llama-3.1-Nemotron-Nano-VL-8B-V1",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    17.443536908,
    0.000000001,
    "Llama Nemotron Nano VL resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    15.011946496,
    0.000000001,
    "Llama Nemotron Nano VL swept BF16 text decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    2.431590412,
    0.000000001,
    "Llama Nemotron Nano VL resident-only vision/projector/input-embedding footprint",
  );
  assertNear(
    result.alloc,
    13.1072,
    0.000000001,
    "Llama Nemotron Nano VL default BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    4.194304,
    0.000000001,
    "Llama Nemotron Nano VL default BF16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    14.21412264,
    0.000000001,
    "Llama Nemotron Nano VL DGX single-session throughput",
  );
  assert.equal(result.bMem, 7);
  assert.equal(result.best, null);
  assertNear(
    result.dennard,
    142.291431195,
    0.000000001,
    "Llama Nemotron Nano VL DGX Dennard bound",
  );
}

{
  const result = profiled("Qwen/Qwen2.5-7B-Instruct-AWQ", "nvidia-dgx-spark");
  assertNear(
    result.resident,
    5.570747392,
    0.000000001,
    "Qwen2.5 7B Instruct AWQ resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    4.48075264,
    0.000000001,
    "Qwen2.5 7B Instruct AWQ swept decode traffic",
  );
  assertNear(
    result.alloc,
    5.7344,
    0.000000001,
    "Qwen2.5 7B Instruct AWQ FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.835008,
    0.000000001,
    "Qwen2.5 7B Instruct AWQ FP16 KV read traffic",
  );
}

{
  const result = profiled("Qwen/Qwen2.5-1.5B-Instruct-AWQ", "nvidia-dgx-spark");
  assertNear(
    result.resident,
    1.614472192,
    0.000000001,
    "Qwen2.5 1.5B Instruct AWQ resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    1.1477248,
    0.000000001,
    "Qwen2.5 1.5B Instruct AWQ swept stored decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    0.466747392,
    0.000000001,
    "Qwen2.5 1.5B Instruct AWQ resident input embedding footprint",
  );
  assertNear(
    result.alloc,
    2.8672,
    0.000000001,
    "Qwen2.5 1.5B Instruct AWQ FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.917504,
    0.000000001,
    "Qwen2.5 1.5B Instruct AWQ FP16 KV read traffic",
  );
}

{
  const result = profiled("Qwen/Qwen2.5-3B-Instruct-AWQ", "nvidia-dgx-spark");
  const m5Result = profiled(
    "Qwen/Qwen2.5-3B-Instruct-AWQ",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assertNear(
    result.resident,
    2.686599168,
    0.000000001,
    "Qwen2.5 3B Instruct AWQ resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    2.064269312,
    0.000000001,
    "Qwen2.5 3B Instruct AWQ swept stored decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    0.622329856,
    0.000000001,
    "Qwen2.5 3B Instruct AWQ resident input embedding footprint",
  );
  assertNear(
    result.alloc,
    3.6864,
    0.000000001,
    "Qwen2.5 3B Instruct AWQ FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.179648,
    0.000000001,
    "Qwen2.5 3B Instruct AWQ FP16 KV read traffic",
  );
  assert.equal(result.bMem, 31);
  assert.equal(result.best?.batch, 9);
  assertNear(
    result.single.aggregate,
    84.1575088828898,
    0.000000001,
    "Qwen2.5 3B Instruct AWQ DGX Spark single-session throughput",
  );
  assertNear(
    result.best?.aggregate ?? 0,
    193.75288782488988,
    0.000000001,
    "Qwen2.5 3B Instruct AWQ DGX Spark aggregate throughput at b*",
  );
  assertNear(
    result.dennard,
    4208.636896114454,
    0.000000001,
    "Qwen2.5 3B Instruct AWQ DGX Spark Dennard bound",
  );
  assert.equal(m5Result.best?.batch, 24);
  assertNear(
    m5Result.best?.aggregate ?? 0,
    485.1226851989193,
    0.000000001,
    "Qwen2.5 3B Instruct AWQ M5 Max aggregate throughput at b*",
  );
}

{
  const result = profiled("Qwen/Qwen2.5-14B-Instruct", "nvidia-dgx-spark");
  assertNear(
    result.resident,
    29.540067328,
    0.000000001,
    "Qwen2.5 14B Instruct resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    27.982931968,
    0.000000001,
    "Qwen2.5 14B Instruct swept BF16 decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    1.55713536,
    0.000000001,
    "Qwen2.5 14B Instruct resident input embedding footprint",
  );
  assertNear(
    result.alloc,
    19.6608,
    0.000000001,
    "Qwen2.5 14B Instruct BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    6.291456,
    0.000000001,
    "Qwen2.5 14B Instruct BF16 KV read traffic",
  );
}

{
  const result = profiled("Qwen/Qwen2.5-14B-Instruct-AWQ", "nvidia-dgx-spark");
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    9.980028928,
    0.000000001,
    "Qwen2.5 14B Instruct AWQ resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    8.422893568,
    0.000000001,
    "Qwen2.5 14B Instruct AWQ swept stored decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    1.55713536,
    0.000000001,
    "Qwen2.5 14B Instruct AWQ resident input embedding footprint",
  );
  assertNear(
    result.alloc,
    19.6608,
    0.000000001,
    "Qwen2.5 14B Instruct AWQ FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    6.291456,
    0.000000001,
    "Qwen2.5 14B Instruct AWQ FP16 KV read traffic",
  );
  assert.equal(result.bMem, 5);
  assert.equal(result.best, null);
}

{
  const modelProfile = profile("Qwen/Qwen2.5-14B-Instruct-GPTQ-Int4");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "Qwen/Qwen2.5-14B-Instruct-GPTQ-Int4",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "no_floor");
  assertNear(
    weightAdapter.resident_params_b,
    14.770033664,
    0.000000001,
    "Qwen2.5 14B GPTQ Int4 logical resident parameters",
  );
  assertNear(
    weightAdapter.swept_params_b,
    13.991465984,
    0.000000001,
    "Qwen2.5 14B GPTQ Int4 logical swept parameters",
  );
  assertNear(
    result.resident,
    9.988581376,
    0.000000001,
    "Qwen2.5 14B GPTQ Int4 stored resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    8.431446016,
    0.000000001,
    "Qwen2.5 14B GPTQ Int4 stored swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    1.55713536,
    0.000000001,
    "Qwen2.5 14B GPTQ Int4 resident input embedding footprint",
  );
  assertNear(
    result.alloc,
    19.6608,
    0.000000001,
    "Qwen2.5 14B GPTQ Int4 FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    6.291456,
    0.000000001,
    "Qwen2.5 14B GPTQ Int4 FP16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    18.542540030716726,
    0.000000001,
    "Qwen2.5 14B GPTQ Int4 DGX Spark single-session throughput",
  );
  assert.equal(result.bMem, 5);
  assert.equal(result.best, null);
  assertNear(
    result.dennard,
    181.17453821547426,
    0.000000001,
    "Qwen2.5 14B GPTQ Int4 DGX Spark Dennard bound",
  );
}

{
  const result = profiled(
    "Qwen/Qwen2.5-14B-Instruct-GPTQ-Int4",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.single.aggregate,
    41.70373472109916,
    0.000000001,
    "Qwen2.5 14B GPTQ Int4 M5 Max single-session throughput",
  );
  assert.equal(result.bMem, 5);
  assert.equal(result.best.batch, 3);
  assertNear(
    result.best.aggregate,
    67.45816106857936,
    0.000000001,
    "Qwen2.5 14B GPTQ Int4 M5 Max aggregate throughput at b*",
  );
  assertNear(
    result.best.perSession,
    22.486053689526454,
    0.000000001,
    "Qwen2.5 14B GPTQ Int4 M5 Max per-session throughput at b*",
  );
  assertNear(
    result.dennard,
    407.47680023553545,
    0.000000001,
    "Qwen2.5 14B GPTQ Int4 M5 Max Dennard bound",
  );
}

{
  const result = profiled("Qwen/Qwen2.5-72B-Instruct-AWQ", "nvidia-dgx-spark");
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    41.595518976,
    0.000000001,
    "Qwen2.5 72B Instruct AWQ resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    39.1041024,
    0.000000001,
    "Qwen2.5 72B Instruct AWQ swept stored decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    2.491416576,
    0.000000001,
    "Qwen2.5 72B Instruct AWQ resident input embedding footprint",
  );
  assertNear(
    result.alloc,
    32.768,
    0.000000001,
    "Qwen2.5 72B Instruct AWQ FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    10.48576,
    0.000000001,
    "Qwen2.5 72B Instruct AWQ FP16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    5.505157441,
    0.000000001,
    "Qwen2.5 72B Instruct AWQ DGX single-session tok/s",
  );
  assert.equal(result.bMem, 2);
  assert.equal(result.best, null);
  assertNear(
    result.dennard,
    16.704415158,
    0.000000001,
    "Qwen2.5 72B Instruct AWQ DGX Dennard bound",
  );
}

{
  const result = profiled("Qwen/Qwen2.5-72B-Instruct", "nvidia-dgx-spark");
  assert.equal(result.status_code, "resident_not_fit");
  assert.equal(result.bMem, 0);
  assert.equal(result.best, null);
  assertNear(
    result.resident,
    145.412407296,
    0.000000001,
    "Qwen2.5 72B Instruct BF16 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    142.92099072,
    0.000000001,
    "Qwen2.5 72B Instruct BF16 swept decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    2.491416576,
    0.000000001,
    "Qwen2.5 72B Instruct BF16 resident input embedding footprint",
  );
  assertNear(
    result.alloc,
    32.768,
    0.000000001,
    "Qwen2.5 72B Instruct BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    10.48576,
    0.000000001,
    "Qwen2.5 72B Instruct BF16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    1.7795827023172088,
    0.000000001,
    "Qwen2.5 72B Instruct BF16 DGX single-session bound despite non-fit resident payload",
  );
  assert.equal(result.dennard, 0);
}

{
  const result = profiled("Qwen/Qwen2.5-32B-Instruct", "nvidia-dgx-spark");
  assertNear(
    result.resident,
    65.527752704,
    0.000000001,
    "Qwen2.5 32B Instruct resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    63.970617344,
    0.000000001,
    "Qwen2.5 32B Instruct swept BF16 decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    1.55713536,
    0.000000001,
    "Qwen2.5 32B Instruct resident input embedding footprint",
  );
  assertNear(
    result.alloc,
    26.2144,
    0.000000001,
    "Qwen2.5 32B Instruct BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    8.388608,
    0.000000001,
    "Qwen2.5 32B Instruct BF16 KV read traffic",
  );
}

{
  const repo = "CalamitousFelicitousness/Qwen2.5-32B-Instruct-fp8-dynamic";
  const item = profile(repo);
  const catalog = model(repo);
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");

  assert.equal(item.status, "audited");
  assert.equal(
    item.serving.runtime_format,
    "vllm-fp8-dynamic-qwen2.5-memory-bound",
  );
  assert.equal(catalog.hf_downloads, 153510);
  assert.ok(catalog.tags.includes("region:us"));
  assert.equal(
    catalog.architecture.detail,
    "qwen2 (Qwen2ForCausalLM, FP8 dynamic)",
  );
  assert.equal(
    catalog.adapter.weight_precision,
    "FP8 F8_E4M3 + BF16/F32 side tensors",
  );
  assertNear(
    catalog.adapter.resident_weight_gb,
    34.322132736,
    0.000000001,
    "Calamitous Qwen2.5 32B FP8 catalog resident tensor payload",
  );
  assertNear(
    catalog.adapter.active_weight_gb,
    32.764997376,
    0.000000001,
    "Calamitous Qwen2.5 32B FP8 catalog swept text-decode traffic",
  );
  assertNear(
    result.resident,
    34.322132736,
    0.000000001,
    "Calamitous Qwen2.5 32B FP8 resident tensor payload",
  );
  assertNear(
    result.single.batchWeight,
    32.764997376,
    0.000000001,
    "Calamitous Qwen2.5 32B FP8 swept text-decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.55713536,
    0.000000001,
    "Calamitous Qwen2.5 32B FP8 resident input embedding",
  );
  assertNear(
    result.alloc,
    26.2144,
    0.000000001,
    "Calamitous Qwen2.5 32B FP8 BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    8.388608,
    0.000000001,
    "Calamitous Qwen2.5 32B FP8 BF16 KV read traffic",
  );
  assert.equal(result.status_code, "no_floor");
  assert.equal(result.bMem, 3);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    6.6336836713511484,
    0.000000001,
    "Calamitous Qwen2.5 32B FP8 DGX single-session throughput",
  );
  assertNear(
    result.dennard,
    27.23210637488365,
    0.000000001,
    "Calamitous Qwen2.5 32B FP8 DGX Dennard bound",
  );
  assert.equal(m5Result.status_code, "no_floor");
  assert.equal(m5Result.bMem, 3);
  assert.equal(m5Result.best, null);
  assertNear(
    m5Result.single.aggregate,
    14.919713458643242,
    0.000000001,
    "Calamitous Qwen2.5 32B FP8 M5 Max single-session throughput",
  );
  assertNear(
    m5Result.dennard,
    61.247301517137586,
    0.000000001,
    "Calamitous Qwen2.5 32B FP8 M5 Max Dennard bound",
  );
}

{
  const item = profile("sugoitoolkit/Sugoi-32B-Ultra-GGUF");
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(
    "sugoitoolkit/Sugoi-32B-Ultra-GGUF",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "sugoitoolkit/Sugoi-32B-Ultra-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );

  assert.equal(item.status, "audited");
  assert.equal(item.serving.runtime_format, "llama.cpp-gguf-f16-memory-bound");
  assert.equal(item.architecture.kv_adapter.kind, "full_context");
  assertNear(
    result.resident,
    65.53596928,
    0.000000001,
    "Sugoi 32B Ultra F16 GGUF resident file footprint",
  );
  assertNear(
    result.single.batchWeight,
    63.972855808,
    0.000000001,
    "Sugoi 32B Ultra F16 GGUF swept text-decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.563113472,
    0.000000001,
    "Sugoi 32B Ultra F16 GGUF resident input embedding plus header overhead",
  );
  assertNear(
    result.alloc,
    26.2144,
    0.000000001,
    "Sugoi 32B Ultra F16 GGUF FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    8.388608,
    0.000000001,
    "Sugoi 32B Ultra F16 GGUF FP16 KV read traffic",
  );
  assert.equal(result.status_code, "no_floor");
  assert.equal(result.bMem, 2);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    3.772726332960365,
    0.000000001,
    "Sugoi 32B Ultra F16 GGUF DGX single-session throughput",
  );
  assertNear(
    result.dennard,
    8.86618452430719,
    0.000000001,
    "Sugoi 32B Ultra F16 GGUF DGX Dennard bound",
  );
  assert.equal(m5Result.status_code, "no_floor");
  assert.equal(m5Result.bMem, 2);
  assert.equal(m5Result.best, null);
  assertNear(
    m5Result.single.aggregate,
    8.485179371566534,
    0.000000001,
    "Sugoi 32B Ultra F16 GGUF M5 Max single-session throughput",
  );
  assertNear(
    m5Result.dennard,
    19.940795963093827,
    0.000000001,
    "Sugoi 32B Ultra F16 GGUF M5 Max Dennard bound",
  );
}

{
  const result = profiled("Qwen/Qwen2.5-VL-32B-Instruct", "nvidia-dgx-spark");
  assertNear(
    result.resident,
    68.28312064,
    0.000000001,
    "Qwen2.5 VL 32B Instruct resident BF16/F32 footprint",
  );
  assertNear(
    result.single.batchWeight,
    63.970617344,
    0.000000001,
    "Qwen2.5 VL 32B Instruct swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    4.312503296,
    0.000000001,
    "Qwen2.5 VL 32B Instruct resident visual/input-embedding footprint",
  );
  assertNear(
    result.alloc,
    26.2144,
    0.000000001,
    "Qwen2.5 VL 32B Instruct BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    8.388608,
    0.000000001,
    "Qwen2.5 VL 32B Instruct BF16 KV read traffic",
  );
  assert.equal(result.status_code, "no_floor");
  assert.equal(result.bMem, 1);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    3.772843043884757,
    0.000000001,
    "Qwen2.5 VL 32B Instruct DGX single-session throughput",
  );
  assertNear(
    result.dennard,
    8.419271110228358,
    0.000000001,
    "Qwen2.5 VL 32B Instruct DGX Dennard bound",
  );
}

{
  const result = profiled("Qwen/Qwen2.5-VL-72B-Instruct", "nvidia-dgx-spark");
  assert.equal(result.status_code, "resident_not_fit");
  assertNear(
    result.resident,
    146.821554688,
    0.000000001,
    "Qwen2.5 VL 72B Instruct resident BF16 footprint",
  );
  assertNear(
    result.single.batchWeight,
    142.92099072,
    0.000000001,
    "Qwen2.5 VL 72B Instruct swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    3.900563968,
    0.000000001,
    "Qwen2.5 VL 72B Instruct resident visual/input-embedding footprint",
  );
  assertNear(
    result.alloc,
    32.768,
    0.000000001,
    "Qwen2.5 VL 72B Instruct BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    10.48576,
    0.000000001,
    "Qwen2.5 VL 72B Instruct BF16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    1.7795827023172088,
    0.000000001,
    "Qwen2.5 VL 72B Instruct DGX single-session throughput",
  );
  assert.equal(result.bMem, 0);
  assert.equal(result.best, null);
  assert.equal(result.dennard, 0);
}

{
  const modelProfile = profile("Qwen/Qwen2.5-VL-72B-Instruct-AWQ");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  assert.equal(modelProfile.status, "audited");
  assert.equal(modelProfile.base_model_proof.config_compatible, false);
  assertNear(
    weightAdapter.resident_weight_gb,
    43.004666368,
    0.000000001,
    "Qwen2.5 VL 72B AWQ resident stored bytes",
  );
  assertNear(
    weightAdapter.swept_weight_gb,
    39.1041024,
    0.000000001,
    "Qwen2.5 VL 72B AWQ swept text-decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    3.900563968,
    0.000000001,
    "Qwen2.5 VL 72B AWQ resident visual/input-embedding footprint",
  );

  const result = profiled(
    "Qwen/Qwen2.5-VL-72B-Instruct-AWQ",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    43.004666368,
    0.000000001,
    "Qwen2.5 VL 72B AWQ DGX resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    39.1041024,
    0.000000001,
    "Qwen2.5 VL 72B AWQ DGX swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    3.900563968,
    0.000000001,
    "Qwen2.5 VL 72B AWQ DGX resident-only visual/input-embedding footprint",
  );
  assertNear(
    result.alloc,
    32.768,
    0.000000001,
    "Qwen2.5 VL 72B AWQ BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    10.48576,
    0.000000001,
    "Qwen2.5 VL 72B AWQ BF16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    5.50515744121121,
    0.000000001,
    "Qwen2.5 VL 72B AWQ DGX single-session throughput",
  );
  assert.equal(result.bMem, 2);
  assert.equal(result.best, null);
  assertNear(
    result.dennard,
    16.404190186945065,
    0.000000001,
    "Qwen2.5 VL 72B AWQ DGX Dennard bound",
  );
}

{
  const result = profiled(
    "Qwen/Qwen2.5-VL-72B-Instruct-AWQ",
    "nvidia-4x-rtx-pro-6000-blackwell-workstation-2026-bom",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(result.bMem, 10);
  assert.equal(result.best?.batch, 10);
  assertNear(
    result.best?.aggregate ?? 0,
    497.91019976157213,
    0.000000001,
    "Qwen2.5 VL 72B AWQ 4x RTX PRO aggregate throughput",
  );
  assertNear(
    result.best?.perSession ?? 0,
    49.791019976157216,
    0.000000001,
    "Qwen2.5 VL 72B AWQ 4x RTX PRO per-session throughput",
  );
  assertNear(
    result.dennard,
    1862.7899570966754,
    0.000000001,
    "Qwen2.5 VL 72B AWQ 4x RTX PRO Dennard bound",
  );
}

{
  const result = profiled(
    "Qwen/Qwen2.5-VL-72B-Instruct",
    "nvidia-4x-rtx-pro-6000-blackwell-workstation-2026-bom",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(result.bMem, 6);
  assert.equal(result.best?.batch, 6);
  assertNear(
    result.best?.aggregate ?? 0,
    208.94349809622625,
    0.000000001,
    "Qwen2.5 VL 72B Instruct 4x RTX PRO aggregate throughput",
  );
  assertNear(
    result.best?.perSession ?? 0,
    34.82391634937104,
    0.000000001,
    "Qwen2.5 VL 72B Instruct 4x RTX PRO per-session throughput",
  );
  assertNear(
    result.dennard,
    350.77272176356763,
    0.000000001,
    "Qwen2.5 VL 72B Instruct 4x RTX PRO Dennard bound",
  );
}

{
  const result = profiled(
    "deepseek-ai/DeepSeek-R1-Distill-Qwen-32B",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    65.527752704,
    0.000000001,
    "DeepSeek R1 Distill Qwen 32B resident BF16 footprint",
  );
  assertNear(
    result.single.batchWeight,
    63.970617344,
    0.000000001,
    "DeepSeek R1 Distill Qwen 32B swept BF16 decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    1.55713536,
    0.000000001,
    "DeepSeek R1 Distill Qwen 32B resident input embedding footprint",
  );
  assertNear(
    result.alloc,
    26.2144,
    0.000000001,
    "DeepSeek R1 Distill Qwen 32B BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    8.388608,
    0.000000001,
    "DeepSeek R1 Distill Qwen 32B BF16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    3.772843044,
    0.000000001,
    "DeepSeek R1 Distill Qwen 32B DGX single-session tok/s",
  );
  assert.equal(result.bMem, 2);
  assert.equal(result.best, null);
  assertNear(
    result.dennard,
    8.867832391,
    0.000000001,
    "DeepSeek R1 Distill Qwen 32B DGX Dennard bound",
  );
}

{
  const result = profiled(
    "deepseek-ai/DeepSeek-R1-Distill-Qwen-32B",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.single.aggregate,
    8.485441864,
    0.000000001,
    "DeepSeek R1 Distill Qwen 32B M5 Max single-session tok/s",
  );
  assert.equal(result.bMem, 2);
  assert.equal(result.best, null);
  assertNear(
    result.dennard,
    19.944502155,
    0.000000001,
    "DeepSeek R1 Distill Qwen 32B M5 Max Dennard bound",
  );
}

{
  const result = profiled(
    "casperhansen/deepseek-r1-distill-qwen-32b-awq",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    19.328804864,
    0.000000001,
    "Casper Hansen DeepSeek R1 Distill Qwen 32B AWQ resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    17.771669504,
    0.000000001,
    "Casper Hansen DeepSeek R1 Distill Qwen 32B AWQ swept traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    1.55713536,
    0.000000001,
    "Casper Hansen DeepSeek R1 Distill Qwen 32B AWQ input embedding footprint",
  );
  assertNear(
    result.alloc,
    26.2144,
    0.000000001,
    "Casper Hansen DeepSeek R1 Distill Qwen 32B AWQ BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    8.388608,
    0.000000001,
    "Casper Hansen DeepSeek R1 Distill Qwen 32B AWQ BF16 KV read traffic",
  );
  assert.equal(result.bMem, 3);
  assertNear(
    result.single.aggregate,
    10.435669115446398,
    0.000000001,
    "Casper Hansen DeepSeek R1 Distill Qwen 32B AWQ DGX single-session throughput",
  );
  assert.equal(result.best, null);
  assertNear(
    result.dennard,
    58.992896662981124,
    0.000000001,
    "Casper Hansen DeepSeek R1 Distill Qwen 32B AWQ DGX Dennard bound",
  );
}

{
  const result = profiled(
    "casperhansen/deepseek-r1-distill-qwen-32b-awq",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(result.bMem, 3);
  assert.equal(result.best?.batch, 1);
  assertNear(
    result.single.aggregate,
    23.470699036205453,
    0.000000001,
    "Casper Hansen DeepSeek R1 Distill Qwen 32B AWQ M5 Max single-session throughput",
  );
  assertNear(
    result.best?.aggregate ?? 0,
    23.470699036205453,
    0.000000001,
    "Casper Hansen DeepSeek R1 Distill Qwen 32B AWQ M5 Max aggregate throughput",
  );
  assertNear(
    result.dennard,
    132.6799946925656,
    0.000000001,
    "Casper Hansen DeepSeek R1 Distill Qwen 32B AWQ M5 Max Dennard bound",
  );
}

{
  const result = profiled(
    "Qwen/Qwen2.5-Coder-32B-Instruct-AWQ",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    19.328804864,
    0.000000001,
    "Qwen2.5 Coder 32B AWQ stored resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    17.771669504,
    0.000000001,
    "Qwen2.5 Coder 32B AWQ stored swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    1.55713536,
    0.000000001,
    "Qwen2.5 Coder 32B AWQ resident input embedding footprint",
  );
  assertNear(
    result.alloc,
    26.2144,
    0.000000001,
    "Qwen2.5 Coder 32B AWQ FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    8.388608,
    0.000000001,
    "Qwen2.5 Coder 32B AWQ FP16 KV read traffic",
  );
  assert.equal(result.bMem, 3);
  assertNear(
    result.single.aggregate,
    10.435669115446398,
    0.000000001,
    "Qwen2.5 Coder 32B AWQ single-session throughput",
  );
}

{
  const repo = "Qwen/Qwen2.5-Coder-32B-Instruct-GPTQ-Int4";
  const catalogRow = model(repo);
  const item = profile(repo);
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  assert.equal(item.status, "audited");
  assert.equal(item.base_model_proof.config_compatible, true);
  assert.equal(catalogRow.hf_downloads, 148914);
  assert.equal(result.status_code, "no_floor");
  assertNear(
    catalogRow.adapter.resident_weight_gb,
    19.343747072,
    0.000000001,
    "Qwen2.5 Coder 32B GPTQ catalog resident footprint",
  );
  assertNear(
    catalogRow.adapter.active_weight_gb,
    17.786611712,
    0.000000001,
    "Qwen2.5 Coder 32B GPTQ catalog swept traffic",
  );
  assertNear(
    weightAdapter.resident_params_b,
    32.763876352,
    0.000000001,
    "Qwen2.5 Coder 32B GPTQ logical resident parameters",
  );
  assertNear(
    weightAdapter.swept_params_b,
    31.985308672,
    0.000000001,
    "Qwen2.5 Coder 32B GPTQ logical swept parameters",
  );
  assertNear(
    result.resident,
    19.343747072,
    0.000000001,
    "Qwen2.5 Coder 32B GPTQ stored resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    17.786611712,
    0.000000001,
    "Qwen2.5 Coder 32B GPTQ stored swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    1.55713536,
    0.000000001,
    "Qwen2.5 Coder 32B GPTQ resident input embedding footprint",
  );
  assertNear(
    result.alloc,
    26.2144,
    0.000000001,
    "Qwen2.5 Coder 32B GPTQ FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    8.388608,
    0.000000001,
    "Qwen2.5 Coder 32B GPTQ FP16 KV read traffic",
  );
  assert.equal(result.bMem, 3);
  assertNear(
    result.single.aggregate,
    10.429711880311112,
    0.000000001,
    "Qwen2.5 Coder 32B GPTQ DGX Spark single-session throughput",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best?.batch, 1);
  assertNear(
    m5Result.best?.aggregate ?? 0,
    23.45730071249459,
    0.000000001,
    "Qwen2.5 Coder 32B GPTQ M5 Max aggregate throughput",
  );
}

{
  const result = profiled("Qwen/Qwen2.5-32B-Instruct-AWQ", "nvidia-dgx-spark");
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    19.328804864,
    0.000000001,
    "Qwen2.5 32B AWQ stored resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    17.771669504,
    0.000000001,
    "Qwen2.5 32B AWQ stored swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    1.55713536,
    0.000000001,
    "Qwen2.5 32B AWQ resident input embedding footprint",
  );
  assertNear(
    result.alloc,
    26.2144,
    0.000000001,
    "Qwen2.5 32B AWQ FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    8.388608,
    0.000000001,
    "Qwen2.5 32B AWQ FP16 KV read traffic",
  );
  assert.equal(result.bMem, 3);
  assertNear(
    result.single.aggregate,
    10.435669115446398,
    0.000000001,
    "Qwen2.5 32B AWQ DGX single-session throughput",
  );
  assert.equal(result.best, null);
  assertNear(
    result.dennard,
    58.992896663,
    0.000000001,
    "Qwen2.5 32B AWQ DGX Dennard bound",
  );
}

{
  const result = profiled(
    "Qwen/Qwen2.5-32B-Instruct-AWQ",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.single.aggregate,
    23.470699036,
    0.000000001,
    "Qwen2.5 32B AWQ M5 Max single-session throughput",
  );
  assert.equal(result.bMem, 3);
  assert.equal(result.best.batch, 1);
  assertNear(
    result.best.aggregate,
    23.470699036,
    0.000000001,
    "Qwen2.5 32B AWQ M5 Max aggregate throughput at b*",
  );
  assertNear(
    result.dennard,
    132.679994693,
    0.000000001,
    "Qwen2.5 32B AWQ M5 Max Dennard bound",
  );
}

{
  const result = profiled(
    "Qwen/Qwen2.5-32B-Instruct-GPTQ-Int4",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    19.343747072,
    0.000000001,
    "Qwen2.5 32B GPTQ Int4 stored resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    17.786611712,
    0.000000001,
    "Qwen2.5 32B GPTQ Int4 stored swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    1.55713536,
    0.000000001,
    "Qwen2.5 32B GPTQ Int4 resident input embedding footprint",
  );
  assertNear(
    result.alloc,
    26.2144,
    0.000000001,
    "Qwen2.5 32B GPTQ Int4 FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    8.388608,
    0.000000001,
    "Qwen2.5 32B GPTQ Int4 FP16 KV read traffic",
  );
  assert.equal(result.bMem, 3);
  assertNear(
    result.single.aggregate,
    10.429711880311112,
    0.000000001,
    "Qwen2.5 32B GPTQ Int4 DGX single-session throughput",
  );
  assert.equal(result.best, null);
  assertNear(
    result.dennard,
    58.93458909157554,
    0.000000001,
    "Qwen2.5 32B GPTQ Int4 DGX Dennard bound",
  );
}

{
  const result = profiled(
    "Qwen/Qwen2.5-32B-Instruct-GPTQ-Int4",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.single.aggregate,
    23.45730071249459,
    0.000000001,
    "Qwen2.5 32B GPTQ Int4 M5 Max single-session throughput",
  );
  assert.equal(result.bMem, 3);
  assert.equal(result.best.batch, 1);
  assertNear(
    result.best.aggregate,
    23.45730071249459,
    0.000000001,
    "Qwen2.5 32B GPTQ Int4 M5 Max aggregate throughput at b*",
  );
  assertNear(
    result.dennard,
    132.54885605211496,
    0.000000001,
    "Qwen2.5 32B GPTQ Int4 M5 Max Dennard bound",
  );
}

{
  const repo = "Qwen/Qwen2.5-32B-Instruct-GPTQ-Int8";
  const catalogRow = model(repo);
  const item = profile(repo);
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  assert.equal(item.status, "audited");
  assert.equal(item.base_model_proof.config_compatible, true);
  assert.equal(catalogRow.hf_downloads, 118191);
  assert.ok(catalogRow.tags.includes("region:us"));
  assert.equal(result.status_code, "no_floor");
  assert.equal(m5Result.status_code, "no_floor");
  assert.equal(item.serving.weight_format, "int8");
  assertNear(
    catalogRow.adapter.resident_weight_gb,
    35.068454912,
    0.000000001,
    "Qwen2.5 32B GPTQ Int8 catalog resident footprint",
  );
  assertNear(
    catalogRow.adapter.active_weight_gb,
    33.511319552,
    0.000000001,
    "Qwen2.5 32B GPTQ Int8 catalog swept traffic",
  );
  assertNear(
    weightAdapter.resident_params_b,
    32.763876352,
    0.000000001,
    "Qwen2.5 32B GPTQ Int8 logical resident parameters",
  );
  assertNear(
    weightAdapter.swept_params_b,
    31.985308672,
    0.000000001,
    "Qwen2.5 32B GPTQ Int8 logical swept parameters",
  );
  assertNear(
    result.resident,
    35.068454912,
    0.000000001,
    "Qwen2.5 32B GPTQ Int8 stored resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    33.511319552,
    0.000000001,
    "Qwen2.5 32B GPTQ Int8 stored swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    1.55713536,
    0.000000001,
    "Qwen2.5 32B GPTQ Int8 resident input embedding footprint",
  );
  assertNear(
    result.alloc,
    26.2144,
    0.000000001,
    "Qwen2.5 32B GPTQ Int8 FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    8.388608,
    0.000000001,
    "Qwen2.5 32B GPTQ Int8 FP16 KV read traffic",
  );
  assert.equal(result.bMem, 3);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    6.515524392284276,
    0.000000001,
    "Qwen2.5 32B GPTQ Int8 DGX single-session throughput",
  );
  assertNear(
    result.dennard,
    26.39369664944565,
    0.000000001,
    "Qwen2.5 32B GPTQ Int8 DGX Dennard bound",
  );
  assert.equal(m5Result.bMem, 3);
  assert.equal(m5Result.best, null);
  assertNear(
    m5Result.single.aggregate,
    14.65396328521079,
    0.000000001,
    "Qwen2.5 32B GPTQ Int8 M5 Max single-session throughput",
  );
  assertNear(
    m5Result.dennard,
    59.361647409375934,
    0.000000001,
    "Qwen2.5 32B GPTQ Int8 M5 Max Dennard bound",
  );
}

{
  const result = profiled(
    "Qwen/Qwen2.5-Coder-14B-Instruct-AWQ",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    9.980028928,
    0.000000001,
    "Qwen2.5 Coder 14B AWQ stored resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    8.422893568,
    0.000000001,
    "Qwen2.5 Coder 14B AWQ stored swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    1.55713536,
    0.000000001,
    "Qwen2.5 Coder 14B AWQ resident input embedding footprint",
  );
  assertNear(
    result.alloc,
    19.6608,
    0.000000001,
    "Qwen2.5 Coder 14B AWQ FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    6.291456,
    0.000000001,
    "Qwen2.5 Coder 14B AWQ FP16 KV read traffic",
  );
  assert.equal(result.bMem, 5);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    18.553317544779972,
    0.000000001,
    "Qwen2.5 Coder 14B AWQ single-session throughput",
  );
  assertNear(
    result.dennard,
    181.37259851429485,
    0.000000001,
    "Qwen2.5 Coder 14B AWQ DGX Spark Dennard bound",
  );
}

{
  const modelProfile = profile(
    "lmstudio-community/Qwen2.5-Coder-14B-Instruct-MLX-4bit",
  );
  const modelRow = model(
    "lmstudio-community/Qwen2.5-Coder-14B-Instruct-MLX-4bit",
  );
  const result = profiled(
    "lmstudio-community/Qwen2.5-Coder-14B-Instruct-MLX-4bit",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "lmstudio-community/Qwen2.5-Coder-14B-Instruct-MLX-4bit",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(modelProfile.status, "audited");
  assert.equal(modelRow.hf_downloads, 150668);
  assert.ok(modelRow.tags.includes("region:us"));
  assert.equal(modelRow.architecture.active_params_b, 13.991465984);
  assert.equal(modelRow.adapter.weight_precision, "MLX 4-bit affine");
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    8.309352448,
    0.000000001,
    "LM Studio Qwen2.5 Coder 14B MLX 4-bit resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    7.871408128,
    0.000000001,
    "LM Studio Qwen2.5 Coder 14B MLX 4-bit swept decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    0.43794432,
    0.000000001,
    "LM Studio Qwen2.5 Coder 14B MLX 4-bit resident input embedding footprint",
  );
  assertNear(
    result.alloc,
    19.6608,
    0.000000001,
    "LM Studio Qwen2.5 Coder 14B MLX 4-bit BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    6.291456,
    0.000000001,
    "LM Studio Qwen2.5 Coder 14B MLX 4-bit BF16 KV read traffic",
  );
  assert.equal(result.bMem, 5);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    19.27576212923477,
    0.000000001,
    "LM Studio Qwen2.5 Coder 14B MLX 4-bit DGX single-session tok/s",
  );
  assertNear(
    result.dennard,
    197.02704309293063,
    0.000000001,
    "LM Studio Qwen2.5 Coder 14B MLX 4-bit DGX Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 3);
  assertNear(
    m5Result.best.aggregate,
    68.87068788673591,
    0.000000001,
    "LM Studio Qwen2.5 Coder 14B MLX 4-bit M5 Max aggregate tok/s at b*",
  );
}

{
  const repo = "lmstudio-community/Qwen2.5-Coder-14B-Instruct-MLX-8bit";
  const modelProfile = profile(repo);
  const modelRow = model(repo);
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  const m1UltraResult = profiled(repo, "apple-mac-studio-m1-ultra-128gb");
  assert.equal(modelProfile.status, "audited");
  assert.equal(modelRow.hf_downloads, 118924);
  assert.ok(modelRow.tags.includes("region:us"));
  assert.equal(modelRow.architecture.active_params_b, 13.991465984);
  assert.equal(modelRow.adapter.weight_precision, "MLX 8-bit affine");
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    15.693948928,
    0.000000001,
    "LM Studio Qwen2.5 Coder 14B MLX 8-bit resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    14.866720768,
    0.000000001,
    "LM Studio Qwen2.5 Coder 14B MLX 8-bit swept decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    0.82722816,
    0.000000001,
    "LM Studio Qwen2.5 Coder 14B MLX 8-bit resident input embedding footprint",
  );
  assertNear(
    result.alloc,
    19.6608,
    0.000000001,
    "LM Studio Qwen2.5 Coder 14B MLX 8-bit BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    6.291456,
    0.000000001,
    "LM Studio Qwen2.5 Coder 14B MLX 8-bit BF16 KV read traffic",
  );
  assert.equal(result.bMem, 5);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    12.902813082311043,
    0.000000001,
    "LM Studio Qwen2.5 Coder 14B MLX 8-bit DGX single-session tok/s",
  );
  assertNear(
    result.dennard,
    97.4217173403159,
    0.000000001,
    "LM Studio Qwen2.5 Coder 14B MLX 8-bit DGX Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 2);
  assertNear(
    m5Result.best.aggregate,
    44.736481918678614,
    0.000000001,
    "LM Studio Qwen2.5 Coder 14B MLX 8-bit M5 Max aggregate tok/s at b*",
  );
  assert.equal(m1UltraResult.status_code, "ok");
  assert.equal(m1UltraResult.best.batch, 3);
  assertNear(
    m1UltraResult.best.aggregate,
    71.12989199910338,
    0.000000001,
    "LM Studio Qwen2.5 Coder 14B MLX 8-bit M1 Ultra aggregate tok/s at b*",
  );
}

{
  const result = profiled(
    "Qwen/Qwen2.5-Coder-14B-Instruct",
    "nvidia-dgx-spark",
  );
  assertNear(
    result.resident,
    29.540067328,
    0.000000001,
    "Qwen2.5 Coder 14B Instruct resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    27.982931968,
    0.000000001,
    "Qwen2.5 Coder 14B Instruct swept BF16 decode traffic",
  );
  assertNear(
    result.alloc,
    19.6608,
    0.000000001,
    "Qwen2.5 Coder 14B Instruct BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    6.291456,
    0.000000001,
    "Qwen2.5 Coder 14B Instruct BF16 KV read traffic",
  );
}

{
  const result = profiled("deepseek-ai/DeepSeek-R1", "nvidia-dgx-spark");
  assertNear(
    result.resident,
    688.57483936,
    0.000001,
    "DeepSeek R1 resident footprint",
  );
  assertNear(result.alloc, 7.0272, 0.000001, "DeepSeek R1 MLA allocation");
}

{
  const result = profiled("deepseek-ai/DeepSeek-R1-0528", "nvidia-dgx-spark");
  assertNear(
    result.resident,
    688.57483936,
    0.000001,
    "DeepSeek R1 0528 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    39.521833312,
    0.000001,
    "DeepSeek R1 0528 expected-distinct MoE decode traffic",
  );
  assertNear(result.alloc, 7.0272, 0.000001, "DeepSeek R1 0528 MLA allocation");
  assertNear(
    result.single.readTraffic,
    2.248704,
    0.000001,
    "DeepSeek R1 0528 MLA read traffic",
  );
}

{
  const modelProfile = profile("nvidia/DeepSeek-R1-0528-NVFP4-v2");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "nvidia/DeepSeek-R1-0528-NVFP4-v2",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "resident_not_fit");
  assertNear(
    result.resident,
    413.306995616,
    0.000000001,
    "NVIDIA DeepSeek R1 0528 NVFP4 v2 resident footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    384.526784416,
    0.000000001,
    "NVIDIA DeepSeek R1 0528 NVFP4 v2 ordinary text resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    28.7802112,
    0.000000001,
    "NVIDIA DeepSeek R1 0528 NVFP4 v2 resident-only embedding plus NTP layer",
  );
  assertNear(
    result.single.batchWeight,
    28.197245728,
    0.000000001,
    "NVIDIA DeepSeek R1 0528 NVFP4 v2 single-session MoE decode traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    1.436812656,
    0.000000001,
    "NVIDIA DeepSeek R1 0528 NVFP4 v2 per-expert routed traffic",
  );
  assertNear(
    result.alloc,
    249.856,
    0.000000001,
    "NVIDIA DeepSeek R1 0528 NVFP4 v2 expanded FP8 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    79.95392,
    0.000000001,
    "NVIDIA DeepSeek R1 0528 NVFP4 v2 expanded FP8 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    2.524244636,
    0.000000001,
    "NVIDIA DeepSeek R1 0528 NVFP4 v2 DGX Spark single-session tok/s",
  );
}

{
  const result = profiled("deepseek-ai/DeepSeek-V3-0324", "nvidia-dgx-spark");
  assert.equal(result.status_code, "resident_not_fit");
  assertNear(
    result.resident,
    688.57483936,
    0.000001,
    "DeepSeek V3 0324 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    39.521833312,
    0.000001,
    "DeepSeek V3 0324 expected-distinct MoE decode traffic",
  );
  assertNear(
    result.single.batchWeight - 19.082195296,
    20.439638016,
    0.000001,
    "DeepSeek V3 0324 eight routed expert indexes traffic",
  );
  assertNear(result.alloc, 7.0272, 0.000001, "DeepSeek V3 0324 MLA allocation");
  assertNear(
    result.single.readTraffic,
    2.248704,
    0.000001,
    "DeepSeek V3 0324 MLA read traffic",
  );
}

{
  const result = profiled("deepseek-ai/DeepSeek-V3", "nvidia-dgx-spark");
  assert.equal(result.status_code, "resident_not_fit");
  assertNear(
    result.resident,
    688.57483936,
    0.000001,
    "DeepSeek V3 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    39.521833312,
    0.000001,
    "DeepSeek V3 expected-distinct MoE decode traffic",
  );
  assertNear(
    result.single.batchWeight - 19.082195296,
    20.439638016,
    0.000001,
    "DeepSeek V3 eight routed expert indexes traffic",
  );
  assertNear(result.alloc, 7.0272, 0.000001, "DeepSeek V3 MLA allocation");
  assertNear(
    result.single.readTraffic,
    2.248704,
    0.000001,
    "DeepSeek V3 MLA read traffic",
  );
}

{
  const modelProfile = profile("deepseek-ai/DeepSeek-V3.1");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled("deepseek-ai/DeepSeek-V3.1", "nvidia-dgx-spark");
  assert.equal(result.status_code, "resident_not_fit");
  assert.equal(modelProfile.serving.weight_format, "fp8");
  assert.equal(modelProfile.serving.kv_store_format, "mla_bf16");
  assertNear(
    result.resident,
    688.57483936,
    0.000001,
    "DeepSeek V3.1 resident footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    673.150611808,
    0.000001,
    "DeepSeek V3.1 main resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    15.424227552,
    0.000001,
    "DeepSeek V3.1 next-token-prediction resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    39.521833312,
    0.000001,
    "DeepSeek V3.1 expected-distinct MoE decode traffic",
  );
  assertNear(
    result.single.batchWeight - 19.082195296,
    20.439638016,
    0.000001,
    "DeepSeek V3.1 eight routed expert indexes traffic",
  );
  assertNear(result.alloc, 7.0272, 0.000001, "DeepSeek V3.1 MLA allocation");
  assertNear(
    result.single.readTraffic,
    2.248704,
    0.000001,
    "DeepSeek V3.1 MLA read traffic",
  );
  assertNear(
    result.single.aggregate,
    6.535707165,
    0.000001,
    "DeepSeek V3.1 DGX Spark single-session tok/s",
  );
}

{
  const result = profiled("deepseek-ai/DeepSeek-V3.2", "nvidia-dgx-spark");
  assert.equal(result.status_code, "resident_not_fit");
  assertNear(
    result.resident,
    689.4711072,
    0.000001,
    "DeepSeek V3.2 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    40.403603136,
    0.000001,
    "DeepSeek V3.2 expected-distinct MoE decode traffic",
  );
  assertNear(
    result.alloc,
    4.8068,
    0.000001,
    "DeepSeek V3.2 conservative DSA/MLA allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.538176,
    0.000001,
    "DeepSeek V3.2 conservative DSA/MLA read traffic",
  );
}

{
  const repo = "deepseek-ai/DeepSeek-V3.2-Exp";
  const catalogRow = model(repo);
  const modelProfile = profile(repo);
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  assert.equal(result.status_code, "resident_not_fit");
  assert.equal(modelProfile.status, "audited");
  assert.equal(catalogRow.hf_downloads, 229989);
  assertNear(
    catalogRow.adapter.resident_weight_gb,
    689.4711072,
    0.000001,
    "DeepSeek V3.2 Exp catalog resident footprint",
  );
  assertNear(
    catalogRow.adapter.active_weight_gb,
    40.403603136,
    0.000001,
    "DeepSeek V3.2 Exp catalog expected-distinct traffic",
  );
  assertNear(
    result.resident,
    689.4711072,
    0.000001,
    "DeepSeek V3.2 Exp resident footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    674.032381632,
    0.000001,
    "DeepSeek V3.2 Exp main resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    15.438725568,
    0.000001,
    "DeepSeek V3.2 Exp resident-only NTP footprint",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    19.96396512,
    0.000001,
    "DeepSeek V3.2 Exp fixed ordinary decode traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    2.554954752,
    0.000001,
    "DeepSeek V3.2 Exp routed expert byte group",
  );
  assertNear(
    result.single.batchWeight,
    40.403603136,
    0.000001,
    "DeepSeek V3.2 Exp expected-distinct MoE decode traffic",
  );
  assertNear(
    result.alloc,
    4.8068,
    0.000001,
    "DeepSeek V3.2 Exp conservative DSA/MLA allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.538176,
    0.000001,
    "DeepSeek V3.2 Exp conservative DSA/MLA read traffic",
  );
}

{
  const modelProfile = profile("QuantTrio/DeepSeek-V3.2-AWQ");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled("QuantTrio/DeepSeek-V3.2-AWQ", "nvidia-dgx-spark");
  assert.equal(result.status_code, "resident_not_fit");
  assertNear(
    result.resident,
    361.909457408,
    0.000001,
    "QuantTrio DeepSeek V3.2 AWQ resident footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    352.008032512,
    0.000001,
    "QuantTrio DeepSeek V3.2 AWQ main resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    9.901424896,
    0.000001,
    "QuantTrio DeepSeek V3.2 AWQ resident-only NTP footprint",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    12.281991424,
    0.000001,
    "QuantTrio DeepSeek V3.2 AWQ fixed ordinary decode traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    1.327054848,
    0.000001,
    "QuantTrio DeepSeek V3.2 AWQ routed expert byte group",
  );
  assertNear(
    result.single.batchWeight,
    22.898430208,
    0.000001,
    "QuantTrio DeepSeek V3.2 AWQ expected-distinct MoE decode traffic",
  );
  assertNear(
    result.alloc,
    4.8068,
    0.000001,
    "QuantTrio DeepSeek V3.2 AWQ conservative DSA/MLA allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.538176,
    0.000001,
    "QuantTrio DeepSeek V3.2 AWQ conservative DSA/MLA read traffic",
  );
}

{
  const result = profiled("openai/gpt-oss-20b", "nvidia-dgx-spark");
  assertNear(
    result.resident,
    13.761264768,
    0.000000001,
    "gpt-oss-20b resident footprint",
  );
  assertNear(
    result.alloc,
    2.460745728,
    0.000000001,
    "gpt-oss-20b hybrid KV allocation",
  );
  assertNear(
    result.single.batchWeight,
    3.708083328,
    0.000000001,
    "gpt-oss-20b single-session decode traffic",
  );
}

{
  const repo = "openai/gpt-oss-safeguard-20b";
  const modelProfile = profile(repo);
  const modelRow = model(repo);
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const dgxResult = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");

  assert.equal(modelProfile.status, "audited");
  assert.equal(modelRow.hf_downloads, 151082);
  assert.ok(modelRow.tags.includes("region:us"));
  assert.equal(modelRow.architecture.total_params_b, 21.511953984);
  assert.equal(modelRow.architecture.active_params_b, 3.6);
  assert.equal(modelRow.adapter.active_weight_gb, 3.708083328);
  assert.equal(dgxResult.status_code, "ok");
  assertNear(
    dgxResult.resident,
    13.761264768,
    0.000000001,
    "gpt-oss-safeguard-20b resident footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    12.602997888,
    0.000000001,
    "gpt-oss-safeguard-20b main resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.15826688,
    0.000000001,
    "gpt-oss-safeguard-20b resident-only embedding footprint",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    2.437381248,
    0.000000001,
    "gpt-oss-safeguard-20b fixed ordinary decode traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.31767552,
    0.000000001,
    "gpt-oss-safeguard-20b routed expert byte group",
  );
  assertNear(
    dgxResult.alloc,
    2.460745728,
    0.000000001,
    "gpt-oss-safeguard-20b hybrid KV allocation",
  );
  assertNear(
    dgxResult.single.readTraffic,
    0.789577728,
    0.000000001,
    "gpt-oss-safeguard-20b hybrid KV read traffic",
  );
  assertNear(
    dgxResult.single.batchWeight,
    3.708083328,
    0.000000001,
    "gpt-oss-safeguard-20b single-session decode traffic",
  );
  assertNear(
    dgxResult.single.aggregate,
    60.698215494876095,
    0.000000001,
    "gpt-oss-safeguard-20b DGX single-session throughput",
  );
  assert.equal(dgxResult.bMem, 43);
  assert.equal(dgxResult.best.batch, 6);
  assertNear(
    dgxResult.best.aggregate,
    128.18723816475244,
    0.000000001,
    "gpt-oss-safeguard-20b DGX aggregate throughput at b*",
  );
  assertNear(
    dgxResult.best.perSession,
    21.36453969412541,
    0.000000001,
    "gpt-oss-safeguard-20b DGX per-session throughput at b*",
  );
  assertNear(
    dgxResult.dennard,
    3178.5519505718958,
    0.000000001,
    "gpt-oss-safeguard-20b DGX Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 23);
  assertNear(
    m5Result.best.aggregate,
    466.19627557389947,
    0.000000001,
    "gpt-oss-safeguard-20b M5 Max aggregate throughput at b*",
  );
  assertNear(
    m5Result.best.perSession,
    20.269403285821717,
    0.000000001,
    "gpt-oss-safeguard-20b M5 Max per-session throughput at b*",
  );
}

{
  const modelProfile = profile("mlx-community/gpt-oss-20b-MXFP4-Q8");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "mlx-community/gpt-oss-20b-MXFP4-Q8",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    12.076119168,
    0.000000001,
    "MLX gpt-oss-20b MXFP4 Q8 resident footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    11.460789888,
    0.000000001,
    "MLX gpt-oss-20b MXFP4 Q8 main resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.61532928,
    0.000000001,
    "MLX gpt-oss-20b MXFP4 Q8 resident-only embedding footprint",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    1.295173248,
    0.000000001,
    "MLX gpt-oss-20b MXFP4 Q8 fixed ordinary decode traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.31767552,
    0.000000001,
    "MLX gpt-oss-20b MXFP4 Q8 routed expert byte group",
  );
  assertNear(
    result.alloc,
    2.460745728,
    0.000000001,
    "MLX gpt-oss-20b MXFP4 Q8 hybrid KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.789577728,
    0.000000001,
    "MLX gpt-oss-20b MXFP4 Q8 hybrid KV read traffic",
  );
  assertNear(
    result.single.batchWeight,
    2.565875328,
    0.000000001,
    "MLX gpt-oss-20b MXFP4 Q8 single-session decode traffic",
  );
  assert.equal(result.bMem, 43);
  assert.equal(result.best.batch, 7);
  assertNear(
    result.best.aggregate,
    147.047078026,
    0.000000001,
    "MLX gpt-oss-20b MXFP4 Q8 DGX aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    21.006725432,
    0.000000001,
    "MLX gpt-oss-20b MXFP4 Q8 DGX per-session throughput",
  );

  const m5Result = profiled(
    "mlx-community/gpt-oss-20b-MXFP4-Q8",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 24);
  assertNear(
    m5Result.best.aggregate,
    491.228696977,
    0.000000001,
    "MLX gpt-oss-20b MXFP4 Q8 M5 aggregate throughput",
  );
  assertNear(
    m5Result.best.perSession,
    20.467862374,
    0.000000001,
    "MLX gpt-oss-20b MXFP4 Q8 M5 per-session throughput",
  );
}

{
  const modelProfile = profile("unsloth/gpt-oss-20b-GGUF");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled("unsloth/gpt-oss-20b-GGUF", "nvidia-dgx-spark");
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    13.792639168,
    0.000000001,
    "Unsloth gpt-oss-20b F16 GGUF resident footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    12.621363456,
    0.000000001,
    "Unsloth gpt-oss-20b F16 GGUF main resident tensor footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.171275712,
    0.000000001,
    "Unsloth gpt-oss-20b F16 GGUF resident-only embedding plus overhead",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    2.442475776,
    0.000000001,
    "Unsloth gpt-oss-20b F16 GGUF fixed ordinary decode traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.31809024,
    0.000000001,
    "Unsloth gpt-oss-20b F16 GGUF routed expert byte group",
  );
  assertNear(
    result.alloc,
    2.460745728,
    0.000000001,
    "Unsloth gpt-oss-20b F16 GGUF hybrid KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.789577728,
    0.000000001,
    "Unsloth gpt-oss-20b F16 GGUF hybrid KV read traffic",
  );
  assertNear(
    result.single.batchWeight,
    3.714836736,
    0.000000001,
    "Unsloth gpt-oss-20b F16 GGUF single-session decode traffic",
  );
  assert.equal(result.bMem, 43);
  assert.equal(result.best.batch, 6);
  assertNear(
    result.best.aggregate,
    128.062869359,
    0.000000001,
    "Unsloth gpt-oss-20b F16 GGUF DGX aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    21.34381156,
    0.000000001,
    "Unsloth gpt-oss-20b F16 GGUF DGX per-session throughput",
  );

  const m5Result = profiled(
    "unsloth/gpt-oss-20b-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 23);
  assertNear(
    m5Result.best.aggregate,
    465.923257258,
    0.000000001,
    "Unsloth gpt-oss-20b F16 GGUF M5 aggregate throughput",
  );
  assertNear(
    m5Result.best.perSession,
    20.257532924,
    0.000000001,
    "Unsloth gpt-oss-20b F16 GGUF M5 per-session throughput",
  );
}

{
  const result = profiled("openai/gpt-oss-120b", "nvidia-dgx-spark");
  assertNear(
    result.resident,
    65.248815744,
    0.000000001,
    "gpt-oss-120b resident footprint",
  );
  assertNear(
    result.alloc,
    3.691118592,
    0.000000001,
    "gpt-oss-120b hybrid KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.184366592,
    0.000000001,
    "gpt-oss-120b hybrid KV read traffic",
  );
  assertNear(
    result.single.batchWeight,
    5.002902144,
    0.000000001,
    "gpt-oss-120b single-session decode traffic",
  );
}

{
  const modelProfile = profile("unsloth/gpt-oss-120b-GGUF");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled("unsloth/gpt-oss-120b-GGUF", "nvidia-dgx-spark");
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    65.369017728,
    0.000000001,
    "Unsloth gpt-oss-120b F16 GGUF resident footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    64.197727488,
    0.000000001,
    "Unsloth gpt-oss-120b F16 GGUF main resident tensor footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.17129024,
    0.000000001,
    "Unsloth gpt-oss-120b F16 GGUF resident-only embedding plus overhead",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    3.124401408,
    0.000000001,
    "Unsloth gpt-oss-120b F16 GGUF fixed ordinary decode traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.47713536,
    0.000000001,
    "Unsloth gpt-oss-120b F16 GGUF routed expert byte group",
  );
  assertNear(
    result.alloc,
    3.691118592,
    0.000000001,
    "Unsloth gpt-oss-120b F16 GGUF hybrid KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.184366592,
    0.000000001,
    "Unsloth gpt-oss-120b F16 GGUF hybrid KV read traffic",
  );
  assertNear(
    result.single.batchWeight,
    5.032942848,
    0.000000001,
    "Unsloth gpt-oss-120b F16 GGUF single-session decode traffic",
  );
  assert.equal(result.bMem, 14);
  assert.equal(result.best.batch, 3);
  assertNear(
    result.best.aggregate,
    66.988037187,
    0.000000001,
    "Unsloth gpt-oss-120b F16 GGUF DGX aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    22.329345729,
    0.000000001,
    "Unsloth gpt-oss-120b F16 GGUF DGX per-session throughput",
  );

  const m5Result = profiled(
    "unsloth/gpt-oss-120b-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 9);
  assertNear(
    m5Result.best.aggregate,
    190.795742117,
    0.000000001,
    "Unsloth gpt-oss-120b F16 GGUF M5 aggregate throughput",
  );
  assertNear(
    m5Result.best.perSession,
    21.199526902,
    0.000000001,
    "Unsloth gpt-oss-120b F16 GGUF M5 per-session throughput",
  );
}

{
  const modelRow = model("ggml-org/gpt-oss-120b-GGUF");
  const modelProfile = profile("ggml-org/gpt-oss-120b-GGUF");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled("ggml-org/gpt-oss-120b-GGUF", "nvidia-dgx-spark");

  assert.equal(modelRow.name, "gpt-oss-120b GGUF MXFP4_MOE");
  assert.equal(modelRow.hf_downloads, 116699);
  assert.ok(modelRow.tags.includes("region:us"));
  assertNear(
    modelRow.architecture.total_params_b,
    116.829156672,
    0.000000001,
    "ggml-org gpt-oss-120b GGUF logical tensor count",
  );
  assertNear(
    modelRow.adapter.resident_weight_gb,
    63.387346464,
    0.000000001,
    "ggml-org gpt-oss-120b GGUF catalog resident split footprint",
  );
  assertNear(
    modelRow.adapter.active_weight_gb,
    3.594210048,
    0.000000001,
    "ggml-org gpt-oss-120b GGUF catalog single-session active traffic",
  );
  assert.equal(
    modelProfile.serving.runtime_format,
    "llama.cpp-gguf-mxfp4-moe-q8-0-memory-bound",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    63.387346464,
    0.000000001,
    "ggml-org gpt-oss-120b GGUF resident split footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    62.758994688,
    0.000000001,
    "ggml-org gpt-oss-120b GGUF main resident tensor footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.628351776,
    0.000000001,
    "ggml-org gpt-oss-120b GGUF resident-only embedding plus overhead",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    1.685668608,
    0.000000001,
    "ggml-org gpt-oss-120b GGUF fixed ordinary decode traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.47713536,
    0.000000001,
    "ggml-org gpt-oss-120b GGUF routed expert byte group",
  );
  assertNear(
    result.alloc,
    3.691118592,
    0.000000001,
    "ggml-org gpt-oss-120b GGUF hybrid KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.184366592,
    0.000000001,
    "ggml-org gpt-oss-120b GGUF hybrid KV read traffic",
  );
  assertNear(
    result.single.batchWeight,
    3.594210048,
    0.000000001,
    "ggml-org gpt-oss-120b GGUF single-session decode traffic",
  );
  assert.equal(result.bMem, 15);
  assert.equal(result.best.batch, 3);
  assertNear(
    result.best.aggregate,
    75.9223962513906,
    0.000000001,
    "ggml-org gpt-oss-120b GGUF DGX aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    25.3074654171302,
    0.000000001,
    "ggml-org gpt-oss-120b GGUF DGX per-session throughput",
  );
  assertNear(
    result.dennard,
    1164.9699035576941,
    0.000000001,
    "ggml-org gpt-oss-120b GGUF DGX Dennard bound",
  );

  const m5Result = profiled(
    "ggml-org/gpt-oss-120b-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 10);
  assertNear(
    m5Result.best.aggregate,
    203.69750508216933,
    0.000000001,
    "ggml-org gpt-oss-120b GGUF M5 aggregate throughput",
  );
  assertNear(
    m5Result.best.perSession,
    20.36975050821693,
    0.000000001,
    "ggml-org gpt-oss-120b GGUF M5 per-session throughput",
  );
}

{
  const modelProfile = profile("sakamakismile/Qwen3.6-27B-Text-NVFP4-MTP");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "sakamakismile/Qwen3.6-27B-Text-NVFP4-MTP",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "no_floor");
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    3.392195584,
    0.000000001,
    "SakamakiSmile Qwen3.6 27B Text NVFP4 MTP resident-only embedding plus MTP footprint",
  );
  assertNear(
    result.resident,
    19.6374752,
    0.000000001,
    "SakamakiSmile Qwen3.6 27B Text NVFP4 MTP resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    16.245279616,
    0.000000001,
    "SakamakiSmile Qwen3.6 27B Text NVFP4 MTP single-session text traffic",
  );
  assertNear(
    result.alloc,
    3.431727104,
    0.000000001,
    "SakamakiSmile Qwen3.6 27B Text NVFP4 MTP FP8 KV plus DeltaNet allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.203503104,
    0.000000001,
    "SakamakiSmile Qwen3.6 27B Text NVFP4 MTP FP8 KV plus DeltaNet read traffic",
  );
  assertNear(
    result.single.aggregate,
    15.645790562059334,
    0.000000001,
    "SakamakiSmile Qwen3.6 27B Text NVFP4 MTP DGX Spark single-session tok/s",
  );
  assert.equal(result.bMem, 29);
}

{
  const result = profiled(
    "sakamakismile/Qwen3.6-27B-Text-NVFP4-MTP",
    "nvidia-single-rtx-pro-6000-blackwell-workstation",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.single.aggregate,
    102.70057394582537,
    0.000000001,
    "SakamakiSmile Qwen3.6 27B Text NVFP4 MTP single RTX PRO single-session tok/s",
  );
  assert.equal(result.bMem, 19);
  assert.equal(result.best?.batch, 19);
  assertNear(
    result.best?.aggregate ?? 0,
    870.5292623846182,
    0.000000001,
    "SakamakiSmile Qwen3.6 27B Text NVFP4 MTP single RTX PRO aggregate tok/s",
  );
  assertNear(
    result.best?.perSession ?? 0,
    45.81732959919043,
    0.000000001,
    "SakamakiSmile Qwen3.6 27B Text NVFP4 MTP single RTX PRO per-session tok/s",
  );
  assertNear(
    result.dennard,
    2197.4356377060953,
    0.000000001,
    "SakamakiSmile Qwen3.6 27B Text NVFP4 MTP single RTX PRO Dennard bound",
  );
}

{
  const result = profiled("Qwen/Qwen3.6-35B-A3B-FP8", "nvidia-dgx-spark");
  assertNear(
    result.resident,
    37.454789472,
    0.000000001,
    "Qwen3.6 FP8 resident footprint",
  );
  assertNear(
    result.alloc,
    2.11288064,
    0.000000001,
    "Qwen3.6 FP8 full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.batchWeight,
    3.481428736,
    0.000000001,
    "Qwen3.6 FP8 single-session decode traffic",
  );
  assertNear(
    result.single.readTraffic,
    0.72024064,
    0.000000001,
    "Qwen3.6 FP8 full-attention KV plus DeltaNet state read traffic",
  );
}

{
  const modelProfile = profile("lmstudio-community/Qwen3.6-35B-A3B-MLX-4bit");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "lmstudio-community/Qwen3.6-35B-A3B-MLX-4bit",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    weightAdapter.fixed_weight_gb,
    1.103329536,
    0.000000001,
    "LM Studio Qwen3.6 35B A3B MLX 4-bit fixed text traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.07077888,
    0.000000001,
    "LM Studio Qwen3.6 35B A3B MLX 4-bit per-expert text traffic",
  );
  assertNear(
    result.resident,
    20.401929952,
    0.000000001,
    "LM Studio Qwen3.6 35B A3B MLX 4-bit resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    1.669560576,
    0.000000001,
    "LM Studio Qwen3.6 35B A3B MLX 4-bit single-session decode traffic",
  );
  assertNear(
    result.alloc,
    2.11288064,
    0.000000001,
    "LM Studio Qwen3.6 35B A3B MLX 4-bit full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.72024064,
    0.000000001,
    "LM Studio Qwen3.6 35B A3B MLX 4-bit full-attention KV plus DeltaNet state read traffic",
  );
  assert.equal(result.bMem, 47);
  assert.equal(result.best.batch, 10);
  assertNear(
    result.best.aggregate,
    206.276815585454,
    0.000000001,
    "LM Studio Qwen3.6 35B A3B MLX 4-bit DGX Spark aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    20.627681558545397,
    0.000000001,
    "LM Studio Qwen3.6 35B A3B MLX 4-bit DGX Spark per-session throughput",
  );
  assertNear(
    result.dennard,
    7707.906276927898,
    0.000000001,
    "LM Studio Qwen3.6 35B A3B MLX 4-bit DGX Spark Dennard bound",
  );
}

{
  const modelProfile = profile("lmstudio-community/Qwen3.6-35B-A3B-MLX-6bit");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "lmstudio-community/Qwen3.6-35B-A3B-MLX-6bit",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    weightAdapter.fixed_weight_gb,
    3.595991296,
    0.000000001,
    "LM Studio Qwen3.6 35B A3B MLX 6-bit fixed text traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.09437184,
    0.000000001,
    "LM Studio Qwen3.6 35B A3B MLX 6-bit per-expert text traffic",
  );
  assertNear(
    result.resident,
    29.061529312,
    0.000000001,
    "LM Studio Qwen3.6 35B A3B MLX 6-bit resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.306346976,
    0.000000001,
    "LM Studio Qwen3.6 35B A3B MLX 6-bit resident-only embedding and vision footprint",
  );
  assertNear(
    result.single.batchWeight,
    4.350966016,
    0.000000001,
    "LM Studio Qwen3.6 35B A3B MLX 6-bit single-session decode traffic",
  );
  assertNear(
    result.alloc,
    2.11288064,
    0.000000001,
    "LM Studio Qwen3.6 35B A3B MLX 6-bit full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.72024064,
    0.000000001,
    "LM Studio Qwen3.6 35B A3B MLX 6-bit full-attention KV plus DeltaNet state read traffic",
  );
  assert.equal(result.bMem, 43);
  assert.equal(result.best.batch, 7);
  assertNear(
    result.best.aggregate,
    142.06002629128946,
    0.000000001,
    "LM Studio Qwen3.6 35B A3B MLX 6-bit DGX Spark aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    20.294289470184207,
    0.000000001,
    "LM Studio Qwen3.6 35B A3B MLX 6-bit DGX Spark per-session throughput",
  );
  assertNear(
    result.dennard,
    2700.5339319149016,
    0.000000001,
    "LM Studio Qwen3.6 35B A3B MLX 6-bit DGX Spark Dennard bound",
  );
}

{
  const modelProfile = profile("lmstudio-community/Qwen3.6-35B-A3B-MLX-8bit");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "lmstudio-community/Qwen3.6-35B-A3B-MLX-8bit",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    weightAdapter.fixed_weight_gb,
    2.062121216,
    0.000000001,
    "LM Studio Qwen3.6 35B A3B MLX 8-bit fixed text traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.13369344,
    0.000000001,
    "LM Studio Qwen3.6 35B A3B MLX 8-bit per-expert text traffic",
  );
  assertNear(
    result.resident,
    37.721128672,
    0.000000001,
    "LM Studio Qwen3.6 35B A3B MLX 8-bit resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.433486816,
    0.000000001,
    "LM Studio Qwen3.6 35B A3B MLX 8-bit resident-only embedding and vision footprint",
  );
  assertNear(
    result.single.batchWeight,
    3.131668736,
    0.000000001,
    "LM Studio Qwen3.6 35B A3B MLX 8-bit single-session decode traffic",
  );
  assertNear(
    result.alloc,
    2.11288064,
    0.000000001,
    "LM Studio Qwen3.6 35B A3B MLX 8-bit full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.72024064,
    0.000000001,
    "LM Studio Qwen3.6 35B A3B MLX 8-bit full-attention KV plus DeltaNet state read traffic",
  );
  assert.equal(result.bMem, 38);
  assert.equal(result.best.batch, 6);
  assertNear(
    result.best.aggregate,
    132.95556135455388,
    0.000000001,
    "LM Studio Qwen3.6 35B A3B MLX 8-bit DGX Spark aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    22.15926022575898,
    0.000000001,
    "LM Studio Qwen3.6 35B A3B MLX 8-bit DGX Spark per-session throughput",
  );
  assertNear(
    result.dennard,
    3394.6905558568737,
    0.000000001,
    "LM Studio Qwen3.6 35B A3B MLX 8-bit DGX Spark Dennard bound",
  );
}

{
  const result = profiled("Qwen/Qwen3.5-35B-A3B-FP8", "nvidia-dgx-spark");
  assertNear(
    result.resident,
    37.454799072,
    0.000000001,
    "Qwen3.5 FP8 resident footprint",
  );
  assertNear(
    result.alloc,
    2.11288064,
    0.000000001,
    "Qwen3.5 FP8 full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.batchWeight,
    3.481438336,
    0.000000001,
    "Qwen3.5 FP8 single-session decode traffic",
  );
  assertNear(
    result.single.readTraffic,
    0.72024064,
    0.000000001,
    "Qwen3.5 FP8 full-attention KV plus DeltaNet state read traffic",
  );
}

{
  const result = profiled("Qwen/Qwen3.5-35B-A3B-GPTQ-Int4", "nvidia-dgx-spark");
  assertNear(
    result.resident,
    24.403162208,
    0.000000001,
    "Qwen3.5 GPTQ Int4 resident footprint",
  );
  assertNear(
    result.alloc,
    2.11288064,
    0.000000001,
    "Qwen3.5 GPTQ Int4 full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.batchWeight,
    4.408478336,
    0.000000001,
    "Qwen3.5 GPTQ Int4 single-session decode traffic",
  );
  assertNear(
    result.single.readTraffic,
    0.72024064,
    0.000000001,
    "Qwen3.5 GPTQ Int4 full-attention KV plus DeltaNet state read traffic",
  );
}

{
  const modelProfile = profile("cyankiwi/Qwen3.5-35B-A3B-AWQ-4bit");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "cyankiwi/Qwen3.5-35B-A3B-AWQ-4bit",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    weightAdapter.fixed_weight_gb,
    3.879593216,
    0.000000001,
    "cyankiwi Qwen3.5 35B A3B AWQ fixed text traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.0707808,
    0.000000001,
    "cyankiwi Qwen3.5 35B A3B AWQ per-expert text traffic",
  );
  assertNear(
    result.resident,
    24.441405152,
    0.000000001,
    "cyankiwi Qwen3.5 35B A3B AWQ resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    2.441927136,
    0.000000001,
    "cyankiwi Qwen3.5 35B A3B AWQ resident-only input, vision, and MTP footprint",
  );
  assertNear(
    result.single.batchWeight,
    4.445839616,
    0.000000001,
    "cyankiwi Qwen3.5 35B A3B AWQ single-session decode traffic",
  );
  assertNear(
    result.alloc,
    2.11288064,
    0.000000001,
    "cyankiwi Qwen3.5 35B A3B AWQ full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.72024064,
    0.000000001,
    "cyankiwi Qwen3.5 35B A3B AWQ full-attention KV plus DeltaNet state read traffic",
  );
  assert.equal(result.bMem, 45);
  assert.equal(result.best.batch, 7);
  assertNear(
    result.best.aggregate,
    152.4876331282079,
    0.000000001,
    "cyankiwi Qwen3.5 35B A3B AWQ DGX Spark aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    21.783947589743985,
    0.000000001,
    "cyankiwi Qwen3.5 35B A3B AWQ DGX Spark per-session throughput",
  );
  assertNear(
    result.dennard,
    2777.1775561760096,
    0.000000001,
    "cyankiwi Qwen3.5 35B A3B AWQ DGX Spark Dennard bound",
  );

  const m5Result = profiled(
    "cyankiwi/Qwen3.5-35B-A3B-AWQ-4bit",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.bMem, 45);
  assert.equal(m5Result.best.batch, 23);
  assertNear(
    m5Result.best.aggregate,
    473.3398780702132,
    0.000000001,
    "cyankiwi Qwen3.5 35B A3B AWQ M5 Max aggregate throughput",
  );
  assertNear(
    m5Result.best.perSession,
    20.579994698704922,
    0.000000001,
    "cyankiwi Qwen3.5 35B A3B AWQ M5 Max per-session throughput",
  );
  assertNear(
    m5Result.dennard,
    6246.106298505751,
    0.000000001,
    "cyankiwi Qwen3.5 35B A3B AWQ M5 Max Dennard bound",
  );
}

{
  const repo = "cyankiwi/Nex-N2-mini-AWQ-INT4";
  const catalogRow = model(repo);
  const modelProfile = profile(repo);
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  assert.equal(catalogRow.hf_downloads, 108667);
  assert.equal(catalogRow.tags.includes("region:us"), true);
  assert.equal(catalogRow.architecture.detail, "qwen35moe / qwen3_5_moe_text");
  assert.equal(catalogRow.architecture.active_params_b, 3);
  assert.equal(catalogRow.architecture.shared_experts_per_token, 1);
  assert.equal(
    catalogRow.adapter.weight_precision,
    "compressed-tensors AWQ INT4",
  );
  assert.equal(
    modelProfile.serving.runtime_format,
    "compressed-tensors-awq-int4-nex-n2-mini-qwen3.5-moe-text-decode-memory-bound",
  );
  assert.equal(
    result.status_code,
    "ok",
    "Nex-N2-mini AWQ INT4 should fit DGX Spark and meet the 20 tok/s floor",
  );
  assertNear(
    result.resident,
    24.413055712,
    0.000000001,
    "Nex-N2-mini AWQ INT4 resident tensor payload",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    22.502794496,
    0.000000001,
    "Nex-N2-mini AWQ INT4 ordinary text resident package",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.910261216,
    0.000000001,
    "Nex-N2-mini AWQ INT4 resident-only visual/input package",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    3.879593216,
    0.000000001,
    "Nex-N2-mini AWQ INT4 fixed ordinary text traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.07274688,
    0.000000001,
    "Nex-N2-mini AWQ INT4 per-expert text traffic",
  );
  assertNear(
    result.single.batchWeight,
    4.461568256,
    0.000000001,
    "Nex-N2-mini AWQ INT4 single-session decode traffic",
  );
  assertNear(
    result.alloc,
    2.11288064,
    0.000000001,
    "Nex-N2-mini AWQ INT4 full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.72024064,
    0.000000001,
    "Nex-N2-mini AWQ INT4 full-attention KV plus DeltaNet state read traffic",
  );
  assert.equal(result.bMem, 45);
  assert.equal(result.best.batch, 7);
  assertNear(
    result.best.aggregate,
    151.27690653102982,
    0.000000001,
    "Nex-N2-mini AWQ INT4 DGX Spark aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    21.610986647289973,
    0.000000001,
    "Nex-N2-mini AWQ INT4 DGX Spark per-session throughput",
  );
  assertNear(
    result.dennard,
    2768.208004715283,
    0.000000001,
    "Nex-N2-mini AWQ INT4 DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.bMem, 45);
  assert.equal(m5Result.best.batch, 23);
  assertNear(
    m5Result.best.aggregate,
    469.23778089020794,
    0.000000001,
    "Nex-N2-mini AWQ INT4 M5 Max aggregate throughput",
  );
  assertNear(
    m5Result.best.perSession,
    20.401642647400344,
    0.000000001,
    "Nex-N2-mini AWQ INT4 M5 Max per-session throughput",
  );
  assertNear(
    m5Result.dennard,
    6225.93302159408,
    0.000000001,
    "Nex-N2-mini AWQ INT4 M5 Max Dennard bound",
  );
}

{
  const result = profiled("Qwen/Qwen3.5-122B-A10B", "nvidia-dgx-spark");
  assert.equal(result.status_code, "resident_not_fit");
  assertNear(
    result.resident,
    250.17300784,
    0.000000001,
    "Qwen3.5 122B A10B BF16 resident footprint",
  );
  assertNear(
    result.alloc,
    2.612133888,
    0.000000001,
    "Qwen3.5 122B A10B BF16 full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.batchWeight,
    18.016912896,
    0.000000001,
    "Qwen3.5 122B A10B BF16 exact single-session decode traffic",
  );
  assertNear(
    result.single.readTraffic,
    0.940965888,
    0.000000001,
    "Qwen3.5 122B A10B BF16 full-attention KV plus DeltaNet state read traffic",
  );
  assert.equal(result.bMem, 0);
  assert.equal(result.best, null);
}

{
  const result = profiled("Qwen/Qwen3.5-122B-A10B-FP8", "nvidia-dgx-spark");
  assert.equal(result.status_code, "resident_not_fit");
  assertNear(
    result.resident,
    127.152313312,
    0.000000001,
    "Qwen3.5 122B A10B FP8 resident footprint",
  );
  assertNear(
    result.alloc,
    2.612133888,
    0.000000001,
    "Qwen3.5 122B A10B FP8 full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.batchWeight,
    9.82643712,
    0.000000001,
    "Qwen3.5 122B A10B FP8 exact single-session decode traffic",
  );
  assertNear(
    result.single.readTraffic,
    0.940965888,
    0.000000001,
    "Qwen3.5 122B A10B FP8 full-attention KV plus DeltaNet state read traffic",
  );
  assert.equal(result.bMem, 0);
  assert.equal(result.best, null);
}

{
  const repo = "txn545/Qwen3.5-122B-A10B-NVFP4";
  const catalogRow = model(repo);
  const modelProfile = profile(repo);
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  assert.equal(catalogRow.hf_downloads, 129110);
  assert.equal(catalogRow.architecture.shared_experts_per_token, 1);
  assert.equal(modelProfile.serving.weight_format, "nvfp4");
  assert.equal(modelProfile.serving.kv_store_format, "fp8");
  assertNear(
    result.resident,
    82.823706304,
    0.000000001,
    "txn545 Qwen3.5 122B A10B NVFP4 resident footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    75.348088032,
    0.000000001,
    "txn545 Qwen3.5 122B A10B NVFP4 main resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    7.475618272,
    0.000000001,
    "txn545 Qwen3.5 122B A10B NVFP4 resident-only visual, MTP, and input embedding footprint",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    10.117977312,
    0.000000001,
    "txn545 Qwen3.5 122B A10B NVFP4 fixed text traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.25480512,
    0.000000001,
    "txn545 Qwen3.5 122B A10B NVFP4 per-expert text traffic",
  );
  assertNear(
    result.alloc,
    1.383333888,
    0.000000001,
    "txn545 Qwen3.5 122B A10B NVFP4 FP8 full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.batchWeight,
    12.156418272,
    0.000000001,
    "txn545 Qwen3.5 122B A10B NVFP4 single-session decode traffic",
  );
  assertNear(
    result.single.readTraffic,
    0.547749888,
    0.000000001,
    "txn545 Qwen3.5 122B A10B NVFP4 FP8 full-attention KV plus DeltaNet state read traffic",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(result.bMem, 26);
  assert.equal(result.best.batch, 1);
  assertNear(
    result.single.aggregate,
    21.48901026511601,
    0.000000001,
    "txn545 Qwen3.5 122B A10B NVFP4 DGX Spark single-session throughput",
  );
  assertNear(
    result.dennard,
    603.5261422921471,
    0.000000001,
    "txn545 Qwen3.5 122B A10B NVFP4 DGX Spark Dennard bound",
  );

  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.bMem, 26);
  assert.equal(m5Result.best.batch, 8);
  assertNear(
    m5Result.best.aggregate,
    168.61705604072958,
    0.000000001,
    "txn545 Qwen3.5 122B A10B NVFP4 M5 Max aggregate throughput",
  );
  assertNear(
    m5Result.best.perSession,
    21.077132005091197,
    0.000000001,
    "txn545 Qwen3.5 122B A10B NVFP4 M5 Max per-session throughput",
  );
  assertNear(
    m5Result.dennard,
    1357.3811405398474,
    0.000000001,
    "txn545 Qwen3.5 122B A10B NVFP4 M5 Max Dennard bound",
  );
}

{
  const repo = "RedHatAI/Qwen3.5-122B-A10B-NVFP4";
  const catalogRow = model(repo);
  const modelProfile = profile(repo);
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  assert.equal(catalogRow.hf_downloads, 246347);
  assert.equal(catalogRow.license, "unknown");
  assert.equal(catalogRow.hf_pipeline_tag, "unknown");
  assert.equal(catalogRow.architecture.shared_experts_per_token, 1);
  assert.equal(modelProfile.serving.weight_format, "nvfp4");
  assert.equal(modelProfile.serving.kv_store_format, "bf16");
  assertNear(
    result.resident,
    76.419752928,
    0.000000001,
    "RedHatAI Qwen3.5 122B A10B NVFP4 resident footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    73.99149312,
    0.000000001,
    "RedHatAI Qwen3.5 122B A10B NVFP4 main resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    2.428259808,
    0.000000001,
    "RedHatAI Qwen3.5 122B A10B NVFP4 resident-only visual and input embedding footprint",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    8.7613824,
    0.000000001,
    "RedHatAI Qwen3.5 122B A10B NVFP4 fixed text traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.25480512,
    0.000000001,
    "RedHatAI Qwen3.5 122B A10B NVFP4 per-expert text traffic",
  );
  assertNear(
    result.alloc,
    2.612133888,
    0.000000001,
    "RedHatAI Qwen3.5 122B A10B NVFP4 BF16 full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.batchWeight,
    10.79982336,
    0.000000001,
    "RedHatAI Qwen3.5 122B A10B NVFP4 single-session decode traffic",
  );
  assertNear(
    result.single.readTraffic,
    0.940965888,
    0.000000001,
    "RedHatAI Qwen3.5 122B A10B NVFP4 BF16 full-attention KV plus DeltaNet state read traffic",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(result.bMem, 16);
  assert.equal(result.best.batch, 1);
  assertNear(
    result.single.aggregate,
    23.25226986307624,
    0.000000001,
    "RedHatAI Qwen3.5 122B A10B NVFP4 DGX Spark single-session throughput",
  );
  assertNear(
    result.dennard,
    421.73558706741494,
    0.000000001,
    "RedHatAI Qwen3.5 122B A10B NVFP4 DGX Spark Dennard bound",
  );

  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.bMem, 16);
  assert.equal(m5Result.best.batch, 7);
  assertNear(
    m5Result.best.aggregate,
    151.6207697155682,
    0.000000001,
    "RedHatAI Qwen3.5 122B A10B NVFP4 M5 Max aggregate throughput",
  );
  assertNear(
    m5Result.best.perSession,
    21.660109959366885,
    0.000000001,
    "RedHatAI Qwen3.5 122B A10B NVFP4 M5 Max per-session throughput",
  );
  assertNear(
    m5Result.dennard,
    948.5188661516219,
    0.000000001,
    "RedHatAI Qwen3.5 122B A10B NVFP4 M5 Max Dennard bound",
  );
}

{
  const modelProfile = profile("Qwen/Qwen3.5-122B-A10B-GPTQ-Int4");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "Qwen/Qwen3.5-122B-A10B-GPTQ-Int4",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(modelProfile.serving.weight_format, "int4");
  assertNear(
    result.resident,
    78.844078048,
    0.000000001,
    "Qwen3.5 122B A10B GPTQ Int4 resident footprint",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    10.769155584,
    0.000000001,
    "Qwen3.5 122B A10B GPTQ Int4 fixed text traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.236716032,
    0.000000001,
    "Qwen3.5 122B A10B GPTQ Int4 per-expert text traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    7.475618272,
    0.000000001,
    "Qwen3.5 122B A10B GPTQ Int4 resident-only visual, MTP, and input embedding footprint",
  );
  assertNear(
    result.alloc,
    2.612133888,
    0.000000001,
    "Qwen3.5 122B A10B GPTQ Int4 full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.batchWeight,
    12.66288384,
    0.000000001,
    "Qwen3.5 122B A10B GPTQ Int4 single-session decode traffic",
  );
  assertNear(
    result.single.readTraffic,
    0.940965888,
    0.000000001,
    "Qwen3.5 122B A10B GPTQ Int4 full-attention KV plus DeltaNet state read traffic",
  );
  assert.equal(result.bMem, 15);
  assert.equal(result.best.batch, 1);
  assertNear(
    result.single.aggregate,
    20.067848841207077,
    0.000000001,
    "Qwen3.5 122B A10B GPTQ Int4 DGX Spark single-session throughput",
  );
  assertNear(
    result.dennard,
    339.67761348357817,
    0.000000001,
    "Qwen3.5 122B A10B GPTQ Int4 DGX Spark Dennard bound",
  );

  const m5Result = profiled(
    "Qwen/Qwen3.5-122B-A10B-GPTQ-Int4",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.bMem, 15);
  assert.equal(m5Result.best.batch, 7);
  assertNear(
    m5Result.best.aggregate,
    146.03154381922846,
    0.000000001,
    "Qwen3.5 122B A10B GPTQ Int4 M5 Max aggregate throughput",
  );
  assertNear(
    m5Result.best.perSession,
    20.861649117032638,
    0.000000001,
    "Qwen3.5 122B A10B GPTQ Int4 M5 Max per-session throughput",
  );
  assertNear(
    m5Result.dennard,
    763.9635702524432,
    0.000000001,
    "Qwen3.5 122B A10B GPTQ Int4 M5 Max Dennard bound",
  );
}

{
  const modelProfile = profile("cyankiwi/Qwen3.5-122B-A10B-AWQ-4bit");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "cyankiwi/Qwen3.5-122B-A10B-AWQ-4bit",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "no_floor");
  assertNear(
    weightAdapter.fixed_weight_gb,
    10.76914176,
    0.000000001,
    "cyankiwi Qwen3.5 122B A10B AWQ fixed text traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.254806272,
    0.000000001,
    "cyankiwi Qwen3.5 122B A10B AWQ per-expert text traffic",
  );
  assertNear(
    result.resident,
    80.00229424,
    0.000000001,
    "cyankiwi Qwen3.5 122B A10B AWQ resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    4.002746848,
    0.000000001,
    "cyankiwi Qwen3.5 122B A10B AWQ resident-only input, vision, and MTP footprint",
  );
  assertNear(
    result.single.batchWeight,
    12.807591936,
    0.000000001,
    "cyankiwi Qwen3.5 122B A10B AWQ single-session decode traffic",
  );
  assertNear(
    result.alloc,
    2.612133888,
    0.000000001,
    "cyankiwi Qwen3.5 122B A10B AWQ full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.940965888,
    0.000000001,
    "cyankiwi Qwen3.5 122B A10B AWQ full-attention KV plus DeltaNet state read traffic",
  );
  assertNear(
    result.single.aggregate,
    19.856628127456464,
    0.000000001,
    "cyankiwi Qwen3.5 122B A10B AWQ DGX Spark single-session throughput",
  );
  assert.equal(result.bMem, 15);
  assert.equal(result.best, null);
  assertNear(
    result.dennard,
    326.3884732434616,
    0.000000001,
    "cyankiwi Qwen3.5 122B A10B AWQ DGX Spark Dennard bound",
  );

  const m5Result = profiled(
    "cyankiwi/Qwen3.5-122B-A10B-AWQ-4bit",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.bMem, 15);
  assert.equal(m5Result.best.batch, 7);
  assertNear(
    m5Result.best.aggregate,
    141.59183363862115,
    0.000000001,
    "cyankiwi Qwen3.5 122B A10B AWQ M5 Max aggregate throughput",
  );
  assertNear(
    m5Result.best.perSession,
    20.227404805517306,
    0.000000001,
    "cyankiwi Qwen3.5 122B A10B AWQ M5 Max per-session throughput",
  );
  assertNear(
    m5Result.dennard,
    734.0751742545253,
    0.000000001,
    "cyankiwi Qwen3.5 122B A10B AWQ M5 Max Dennard bound",
  );
}

{
  const modelProfile = profile("Qwen/Qwen3.5-397B-A17B");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled("Qwen/Qwen3.5-397B-A17B", "nvidia-dgx-spark");
  assert.equal(result.status_code, "resident_not_fit");
  assertNear(
    result.resident,
    806.795875168,
    0.000000001,
    "Qwen3.5 397B A17B BF16 resident footprint",
  );
  assertNear(
    result.alloc,
    3.26516736,
    0.000000001,
    "Qwen3.5 397B A17B BF16 full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.batchWeight,
    32.663861632,
    0.000000001,
    "Qwen3.5 397B A17B BF16 exact single-session decode traffic",
  );
  assertNear(
    result.single.readTraffic,
    1.17620736,
    0.000000001,
    "Qwen3.5 397B A17B BF16 full-attention KV plus DeltaNet state read traffic",
  );
  assertNear(
    result.single.aggregate,
    8.067359439,
    0.000000001,
    "Qwen3.5 397B A17B BF16 single-session throughput",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    16.137394656,
    0.000000001,
    "Qwen3.5 397B A17B BF16 resident-only vision/MTP/input embedding footprint",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    17.564367232,
    0.000000001,
    "Qwen3.5 397B A17B BF16 fixed ordinary decode traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    1.50994944,
    0.000000001,
    "Qwen3.5 397B A17B BF16 per-expert routed traffic",
  );
  assert.equal(result.bMem, 0);
  assert.equal(result.best, null);
}

{
  const modelProfile = profile("Qwen/Qwen3.5-397B-A17B-FP8");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled("Qwen/Qwen3.5-397B-A17B-FP8", "nvidia-dgx-spark");
  assert.equal(result.status_code, "resident_not_fit");
  assertNear(
    result.resident,
    406.12518128,
    0.000000001,
    "Qwen3.5 397B A17B FP8 resident footprint",
  );
  assertNear(
    result.alloc,
    3.26516736,
    0.000000001,
    "Qwen3.5 397B A17B FP8 full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.batchWeight,
    17.503303552,
    0.000000001,
    "Qwen3.5 397B A17B FP8 exact single-session decode traffic",
  );
  assertNear(
    result.single.readTraffic,
    1.17620736,
    0.000000001,
    "Qwen3.5 397B A17B FP8 full-attention KV plus DeltaNet state read traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    9.578303968,
    0.000000001,
    "Qwen3.5 397B A17B FP8 resident-only vision/MTP/input embedding footprint",
  );
  assert.equal(result.bMem, 0);
  assert.equal(result.best, null);
}

{
  const modelProfile = profile("nvidia/Qwen3.5-397B-A17B-NVFP4");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled("nvidia/Qwen3.5-397B-A17B-NVFP4", "nvidia-dgx-spark");
  assert.equal(result.status_code, "resident_not_fit");
  assertNear(
    result.resident,
    251.135201368,
    0.000000001,
    "NVIDIA Qwen3.5 397B A17B NVFP4 resident footprint",
  );
  assertNear(
    result.alloc,
    1.72916736,
    0.000000001,
    "NVIDIA Qwen3.5 397B A17B NVFP4 FP8 full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.batchWeight,
    9.177853624,
    0.000000001,
    "NVIDIA Qwen3.5 397B A17B NVFP4 exact single-session decode traffic",
  );
  assertNear(
    result.single.readTraffic,
    0.68468736,
    0.000000001,
    "NVIDIA Qwen3.5 397B A17B NVFP4 FP8 full-attention KV plus DeltaNet state read traffic",
  );
  assertNear(
    result.single.aggregate,
    27.680493338,
    0.000000001,
    "NVIDIA Qwen3.5 397B A17B NVFP4 single-session throughput",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    16.137394656,
    0.000000001,
    "NVIDIA Qwen3.5 397B A17B NVFP4 resident-only vision/MTP/input embedding footprint",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    4.679448184,
    0.000000001,
    "NVIDIA Qwen3.5 397B A17B NVFP4 fixed ordinary decode traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.449840544,
    0.000000001,
    "NVIDIA Qwen3.5 397B A17B NVFP4 per-expert routed traffic",
  );
  assert.equal(result.bMem, 0);
  assert.equal(result.best, null);
}

{
  const result = profiled("RedHatAI/Qwen3.6-35B-A3B-NVFP4", "nvidia-dgx-spark");
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    25.025991648,
    0.000000001,
    "RedHatAI Qwen3.6 NVFP4 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    3.873048576,
    0.000000001,
    "RedHatAI Qwen3.6 NVFP4 single-session decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    21.152943072,
    0.000000001,
    "RedHatAI Qwen3.6 NVFP4 resident-only and inactive expert footprint",
  );
  assertNear(
    result.alloc,
    2.11288064,
    0.000000001,
    "RedHatAI Qwen3.6 NVFP4 BF16 KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.72024064,
    0.000000001,
    "RedHatAI Qwen3.6 NVFP4 BF16 KV plus DeltaNet state read traffic",
  );
}

{
  const result = profiled("Qwen/Qwen3.5-0.8B", "nvidia-dgx-spark");
  assertNear(
    result.resident,
    1.746882752,
    0.000000001,
    "Qwen3.5 0.8B resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    1.504791232,
    0.000000001,
    "Qwen3.5 0.8B swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    0.24209152,
    0.000000001,
    "Qwen3.5 0.8B resident visual/MTP footprint",
  );
  assertNear(
    result.alloc,
    1.248559104,
    0.000000001,
    "Qwen3.5 0.8B full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.412975104,
    0.000000001,
    "Qwen3.5 0.8B full-attention KV plus DeltaNet state read traffic",
  );
}

{
  const result = profiled("Qwen/Qwen3.5-0.8B-Base", "nvidia-dgx-spark");
  assert.equal(result.status.residentFit.code, "fits");
  assert.equal(result.status.floorFit.code, "meets_floor");
  assertNear(
    result.resident,
    1.746882752,
    0.000000001,
    "Qwen3.5 0.8B Base resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    1.504791232,
    0.000000001,
    "Qwen3.5 0.8B Base swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    0.24209152,
    0.000000001,
    "Qwen3.5 0.8B Base resident visual/MTP footprint",
  );
  assertNear(
    result.alloc,
    1.248559104,
    0.000000001,
    "Qwen3.5 0.8B Base full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.412975104,
    0.000000001,
    "Qwen3.5 0.8B Base full-attention KV plus DeltaNet state read traffic",
  );
  assert.equal(result.bMem, 94);
  assert.equal(result.best.batch, 29);
  assertNear(
    result.single.aggregate,
    142.3531088617461,
    0.000000001,
    "Qwen3.5 0.8B Base DGX Spark single-session throughput",
  );
  assertNear(
    result.best.aggregate,
    587.2679573376225,
    0.000000001,
    "Qwen3.5 0.8B Base DGX Spark aggregate",
  );
  assertNear(
    result.dennard,
    17182.63984539862,
    0.000000001,
    "Qwen3.5 0.8B Base DGX Spark Dennard bound",
  );

  const m5 = profiled(
    "Qwen/Qwen3.5-0.8B-Base",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(m5.status.floorFit.code, "meets_floor");
  assert.equal(m5.best.batch, 70);
  assertNear(
    m5.best.aggregate,
    1413.2092014071357,
    0.000000001,
    "Qwen3.5 0.8B Base M5 Max aggregate",
  );
  assertNear(
    m5.dennard,
    38645.20463397345,
    0.000000001,
    "Qwen3.5 0.8B Base M5 Max Dennard bound",
  );
}

{
  const result = profiled("unsloth/Qwen3.5-0.8B-GGUF", "nvidia-dgx-spark");
  assert.equal(result.status.residentFit.code, "fits");
  assert.equal(result.status.floorFit.code, "meets_floor");
  assertNear(
    result.resident,
    1.516744736,
    0.000000001,
    "Unsloth Qwen3.5 0.8B GGUF resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    1.50578304,
    0.000000001,
    "Unsloth Qwen3.5 0.8B GGUF swept tensor traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    0.010961696,
    0.000000001,
    "Unsloth Qwen3.5 0.8B GGUF resident GGUF overhead",
  );
  assertNear(
    result.alloc,
    1.248559104,
    0.000000001,
    "Unsloth Qwen3.5 0.8B GGUF full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.412975104,
    0.000000001,
    "Unsloth Qwen3.5 0.8B GGUF full-attention KV plus DeltaNet state read traffic",
  );
  assertNear(
    result.single.aggregate,
    142.279526398,
    0.000000001,
    "Unsloth Qwen3.5 0.8B GGUF DGX Spark single-session throughput",
  );
  assert.equal(result.bMem, 94);
  assert.equal(result.best.batch, 29);
  assertNear(
    result.best.aggregate,
    587.224754963,
    0.000000001,
    "Unsloth Qwen3.5 0.8B GGUF DGX Spark aggregate",
  );
  assertNear(
    result.dennard,
    17204.740152701,
    0.000000001,
    "Unsloth Qwen3.5 0.8B GGUF DGX Spark Dennard bound",
  );

  const m5 = profiled(
    "unsloth/Qwen3.5-0.8B-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(m5.status.floorFit.code, "meets_floor");
  assertNear(
    m5.single.aggregate,
    319.998641788,
    0.000000001,
    "Unsloth Qwen3.5 0.8B GGUF M5 Max single-session throughput",
  );
  assert.equal(m5.best.batch, 70);
  assertNear(
    m5.best.aggregate,
    1413.16311637,
    0.000000001,
    "Unsloth Qwen3.5 0.8B GGUF M5 Max aggregate",
  );
  assertNear(
    m5.dennard,
    38694.910087026,
    0.000000001,
    "Unsloth Qwen3.5 0.8B GGUF M5 Max Dennard bound",
  );
}

{
  const result = profiled("Qwen/Qwen3.5-2B", "nvidia-dgx-spark");
  assertNear(
    result.resident,
    4.548144832,
    0.000000001,
    "Qwen3.5 2B resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    3.76365536,
    0.000000001,
    "Qwen3.5 2B swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    0.784489472,
    0.000000001,
    "Qwen3.5 2B resident visual/MTP footprint",
  );
  assertNear(
    result.alloc,
    1.248559104,
    0.000000001,
    "Qwen3.5 2B full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.412975104,
    0.000000001,
    "Qwen3.5 2B full-attention KV plus DeltaNet state read traffic",
  );
  assert.equal(result.best.batch, 23);
  assertNear(result.best.aggregate, 473, 1, "Qwen3.5 2B aggregate");
  assertNear(result.dennard, 6707, 100, "Qwen3.5 2B Dennard");
}

{
  const result = profiled("Qwen/Qwen3.5-2B-Base", "nvidia-dgx-spark");
  assertNear(
    result.resident,
    4.548144832,
    0.000000001,
    "Qwen3.5 2B Base resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    3.76365536,
    0.000000001,
    "Qwen3.5 2B Base swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    0.784489472,
    0.000000001,
    "Qwen3.5 2B Base resident visual/MTP footprint",
  );
  assertNear(
    result.alloc,
    1.248559104,
    0.000000001,
    "Qwen3.5 2B Base full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.412975104,
    0.000000001,
    "Qwen3.5 2B Base full-attention KV plus DeltaNet state read traffic",
  );
  assert.equal(result.bMem, 92);
  assert.equal(result.best.batch, 23);
  assertNear(
    result.best.aggregate,
    473.45504604494266,
    0.000000001,
    "Qwen3.5 2B Base aggregate",
  );
  assertNear(
    result.dennard,
    6707.251777357739,
    0.000000001,
    "Qwen3.5 2B Base Dennard",
  );
}

{
  const repo = "unsloth/Qwen3.5-2B-GGUF";
  const modelRow = model(repo);
  const modelProfile = profile(repo);
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  assert.equal(modelRow.hf_downloads, 140054);
  assert.equal(modelRow.tags.includes("region:us"), true);
  assert.equal(
    modelRow.architecture.detail,
    "qwen3_5_text (selected BF16 GGUF)",
  );
  assert.equal(modelProfile.base_model_proof.config_compatible, true);
  assertNear(
    modelProfile.architecture.weight_adapter.auxiliary_resident_weight_gb,
    0.010961696,
    0.000000001,
    "Unsloth Qwen3.5 2B GGUF metadata/header overhead",
  );
  assertNear(
    modelRow.adapter.active_weight_gb,
    3.76474752,
    0.000000001,
    "Unsloth Qwen3.5 2B GGUF catalog swept text traffic",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    3.775709216,
    0.000000001,
    "Unsloth Qwen3.5 2B GGUF selected BF16 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    3.76474752,
    0.000000001,
    "Unsloth Qwen3.5 2B GGUF swept text-decode traffic",
  );
  assertNear(
    result.alloc,
    1.248559104,
    0.000000001,
    "Unsloth Qwen3.5 2B GGUF full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.412975104,
    0.000000001,
    "Unsloth Qwen3.5 2B GGUF full-attention KV plus DeltaNet state read traffic",
  );
  assert.equal(result.bMem, 93);
  assert.equal(result.best.batch, 23);
  assertNear(
    result.best.aggregate,
    473.41605925131904,
    0.000000001,
    "Unsloth Qwen3.5 2B GGUF DGX Spark aggregate",
  );
  assertNear(
    result.best.perSession,
    20.583306923970394,
    0.000000001,
    "Unsloth Qwen3.5 2B GGUF DGX Spark per-session",
  );
  assertNear(
    result.dennard,
    6750.168130512359,
    0.000000001,
    "Unsloth Qwen3.5 2B GGUF DGX Spark Dennard",
  );
  assert.equal(m5Result.best.batch, 65);
  assertNear(
    m5Result.best.aggregate,
    1303.9019678369575,
    0.000000001,
    "Unsloth Qwen3.5 2B GGUF M5 Max aggregate",
  );
}

{
  const result = profiled("cyankiwi/Qwen3.5-2B-AWQ-4bit", "nvidia-dgx-spark");
  assertNear(
    result.resident,
    2.501190736,
    0.000000001,
    "cyankiwi Qwen3.5 2B AWQ resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    1.792067552,
    0.000000001,
    "cyankiwi Qwen3.5 2B AWQ swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    0.709123184,
    0.000000001,
    "cyankiwi Qwen3.5 2B AWQ resident visual/MTP footprint",
  );
  assertNear(
    result.alloc,
    1.248559104,
    0.000000001,
    "cyankiwi Qwen3.5 2B AWQ full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.412975104,
    0.000000001,
    "cyankiwi Qwen3.5 2B AWQ full-attention KV plus DeltaNet state read traffic",
  );
  assert.equal(result.status.residentFit.code, "fits");
  assert.equal(result.status.floorFit.code, "meets_floor");
  assert.equal(result.best.batch, 28);
  assertNear(
    result.best.aggregate,
    572,
    1,
    "cyankiwi Qwen3.5 2B AWQ aggregate",
  );
  assertNear(result.dennard, 14336, 100, "cyankiwi Qwen3.5 2B AWQ Dennard");
}

{
  const result = profiled("Qwen/Qwen3.5-27B", "nvidia-dgx-spark");
  assertNear(
    result.resident,
    55.5628728,
    0.000000001,
    "Qwen3.5 27B resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    51.249217024,
    0.000000001,
    "Qwen3.5 27B swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    4.313655776,
    0.000000001,
    "Qwen3.5 27B resident visual/MTP/input-embedding footprint",
  );
  assertNear(
    result.alloc,
    6.708527104,
    0.000000001,
    "Qwen3.5 27B full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    2.252079104,
    0.000000001,
    "Qwen3.5 27B full-attention KV plus DeltaNet state read traffic",
  );
}

{
  const repo = "unsloth/Qwen3.5-27B-GGUF";
  const item = profile(repo);
  const modelRow = model(repo);
  const weightAdapter = item.architecture.weight_adapter;
  assert.equal(item.status, "audited");
  assert.equal(item.architecture.max_context_tokens, 262144);
  assert.equal(modelRow.hf_downloads, 131531);
  assert.ok(modelRow.tags.includes("region:us"));
  assert.equal(modelRow.architecture.total_params_b, 26.895998464);
  assert.equal(modelRow.architecture.active_params_b, 25.624600064);
  assert.equal(modelRow.adapter.weight_precision, "GGUF IQ4_NL");
  assertNear(
    weightAdapter.resident_weight_gb,
    15.687894944,
    0.000000001,
    "Unsloth Qwen3.5 27B IQ4_NL resident linked artifact size",
  );
  assertNear(
    weightAdapter.swept_weight_gb,
    14.961739776,
    0.000000001,
    "Unsloth Qwen3.5 27B IQ4_NL swept tensor spans",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.726155168,
    0.000000001,
    "Unsloth Qwen3.5 27B IQ4_NL resident-only token embedding plus GGUF overhead",
  );
  const [attentionKv, deltaState] = item.architecture.kv_adapter.components;
  assert.equal(attentionKv.kind, "full_context");
  assert.equal(attentionKv.layers, 16);
  assert.equal(attentionKv.kv_heads, 4);
  assert.equal(attentionKv.head_dim, 256);
  assert.equal(deltaState.kind, "recurrent_state");
  assertNear(
    deltaState.alloc_gb_per_session,
    0.154927104,
    0.000000001,
    "Unsloth Qwen3.5 27B fixed DeltaNet state allocation",
  );
  const dgxResult = profiled(repo, "nvidia-dgx-spark");
  assert.equal(dgxResult.status_code, "no_floor");
  assertNear(
    dgxResult.resident,
    15.687894944,
    0.000000001,
    "Unsloth Qwen3.5 27B DGX resident footprint",
  );
  assertNear(
    dgxResult.alloc,
    6.708527104,
    0.000000001,
    "Unsloth Qwen3.5 27B DGX FP16 KV plus DeltaNet allocation",
  );
  assertNear(
    dgxResult.single.readTraffic,
    2.252079104,
    0.000000001,
    "Unsloth Qwen3.5 27B DGX FP16 KV plus DeltaNet read traffic",
  );
  assertNear(
    dgxResult.single.aggregate,
    15.859351251638127,
    0.000000001,
    "Unsloth Qwen3.5 27B DGX single-session throughput",
  );
  assert.equal(dgxResult.bMem, 15);
  assert.equal(dgxResult.best, null);
  assertNear(
    dgxResult.dennard,
    283.7187782602703,
    0.000000001,
    "Unsloth Qwen3.5 27B DGX Dennard bound",
  );
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 6);
  assertNear(
    m5Result.single.aggregate,
    35.669017100753884,
    0.000000001,
    "Unsloth Qwen3.5 27B M5 Max single-session throughput",
  );
  assertNear(
    m5Result.best.aggregate,
    129.38021566628368,
    0.000000001,
    "Unsloth Qwen3.5 27B M5 Max aggregate throughput at b*",
  );
  assertNear(
    m5Result.best.perSession,
    21.563369277713946,
    0.000000001,
    "Unsloth Qwen3.5 27B M5 Max per-session throughput at b*",
  );
  const m1UltraResult = profiled(repo, "apple-mac-studio-m1-ultra-128gb");
  assert.equal(m1UltraResult.status_code, "ok");
  assert.equal(m1UltraResult.best.batch, 11);
  assertNear(
    m1UltraResult.best.aggregate,
    221.46939450815177,
    0.000000001,
    "Unsloth Qwen3.5 27B M1 Ultra aggregate throughput at b*",
  );
  assertNear(
    m1UltraResult.best.perSession,
    20.13358131892289,
    0.000000001,
    "Unsloth Qwen3.5 27B M1 Ultra per-session throughput at b*",
  );
}

{
  const result = profiled("Qwen/Qwen3.5-27B-FP8", "nvidia-dgx-spark");
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    30.86668016,
    0.000000001,
    "Qwen3.5 27B FP8 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    26.925223424,
    0.000000001,
    "Qwen3.5 27B FP8 swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    3.941456736,
    0.000000001,
    "Qwen3.5 27B FP8 resident visual/MTP/input-embedding footprint",
  );
  assertNear(
    result.alloc,
    6.708527104,
    0.000000001,
    "Qwen3.5 27B FP8 full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    2.252079104,
    0.000000001,
    "Qwen3.5 27B FP8 full-attention KV plus DeltaNet state read traffic",
  );
  assert.equal(result.bMem, 13);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    9.356588044,
    0.000000001,
    "Qwen3.5 27B FP8 single-session tok/s",
  );
}

{
  const modelProfile = profile("Qwen/Qwen3.5-27B-GPTQ-Int4");
  const result = profiled("Qwen/Qwen3.5-27B-GPTQ-Int4", "nvidia-dgx-spark");
  const m5Result = profiled(
    "Qwen/Qwen3.5-27B-GPTQ-Int4",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(modelProfile.serving.weight_format, "int4");
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    30.235043808,
    0.000000001,
    "Qwen3.5 27B GPTQ Int4 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    25.921388032,
    0.000000001,
    "Qwen3.5 27B GPTQ Int4 swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    4.313655776,
    0.000000001,
    "Qwen3.5 27B GPTQ Int4 resident-only embedding/vision/MTP footprint",
  );
  assertNear(
    result.alloc,
    6.708527104,
    0.000000001,
    "Qwen3.5 27B GPTQ Int4 BF16 full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    2.252079104,
    0.000000001,
    "Qwen3.5 27B GPTQ Int4 BF16 full-attention KV plus DeltaNet state read traffic",
  );
  assert.equal(result.bMem, 13);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    9.689968178,
    0.000000001,
    "Qwen3.5 27B GPTQ Int4 DGX single-session tok/s",
  );
  assertNear(
    result.dennard,
    140.923700333,
    0.000000001,
    "Qwen3.5 27B GPTQ Int4 DGX Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 2);
  assertNear(
    m5Result.best.aggregate,
    40.360820158,
    0.000000001,
    "Qwen3.5 27B GPTQ Int4 M5 Max aggregate",
  );
  assertNear(
    m5Result.best.perSession,
    20.180410079,
    0.000000001,
    "Qwen3.5 27B GPTQ Int4 M5 Max per-session",
  );
}

{
  const result = profiled("cyankiwi/Qwen3.5-27B-AWQ-4bit", "nvidia-dgx-spark");
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    20.057751376,
    0.000000001,
    "cyankiwi Qwen3.5 27B AWQ resident compressed-tensors footprint",
  );
  assertNear(
    result.single.batchWeight,
    16.279196928,
    0.000000001,
    "cyankiwi Qwen3.5 27B AWQ swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    3.778554448,
    0.000000001,
    "cyankiwi Qwen3.5 27B AWQ resident-only embedding/vision/MTP footprint",
  );
  assertNear(
    result.alloc,
    6.708527104,
    0.000000001,
    "cyankiwi Qwen3.5 27B AWQ BF16 full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    2.252079104,
    0.000000001,
    "cyankiwi Qwen3.5 27B AWQ BF16 full-attention KV plus DeltaNet state read traffic",
  );
  assert.equal(result.bMem, 14);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    14.731851143,
    0.000000001,
    "cyankiwi Qwen3.5 27B AWQ DGX single-session tok/s",
  );
  assertNear(
    result.dennard,
    249.834038318,
    0.000000001,
    "cyankiwi Qwen3.5 27B AWQ DGX Dennard bound",
  );
}

{
  const modelProfile = profile("QuantTrio/Qwen3.5-27B-AWQ");
  const result = profiled("QuantTrio/Qwen3.5-27B-AWQ", "nvidia-dgx-spark");
  const m5Result = profiled(
    "QuantTrio/Qwen3.5-27B-AWQ",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(modelProfile.serving.weight_format, "int4");
  assert.equal(modelProfile.serving.kv_store_format, "fp16");
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    21.85285424,
    0.000000001,
    "QuantTrio Qwen3.5 27B AWQ resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    17.539198464,
    0.000000001,
    "QuantTrio Qwen3.5 27B AWQ swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    4.313655776,
    0.000000001,
    "QuantTrio Qwen3.5 27B AWQ resident-only embedding/vision/MTP footprint",
  );
  assertNear(
    result.alloc,
    6.708527104,
    0.000000001,
    "QuantTrio Qwen3.5 27B AWQ FP16 full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    2.252079104,
    0.000000001,
    "QuantTrio Qwen3.5 27B AWQ FP16 full-attention KV plus DeltaNet state read traffic",
  );
  assert.equal(result.bMem, 14);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    13.793955396,
    0.000000001,
    "QuantTrio Qwen3.5 27B AWQ DGX single-session tok/s",
  );
  assertNear(
    result.dennard,
    227.721166711,
    0.000000001,
    "QuantTrio Qwen3.5 27B AWQ DGX Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 5);
  assertNear(
    m5Result.best.aggregate,
    106.598725027,
    0.000000001,
    "QuantTrio Qwen3.5 27B AWQ M5 Max aggregate",
  );
  assertNear(
    m5Result.best.perSession,
    21.319745005,
    0.000000001,
    "QuantTrio Qwen3.5 27B AWQ M5 Max per-session",
  );
}

{
  const repo =
    "QuantTrio/Qwen3.5-27B-Claude-4.6-Opus-Reasoning-Distilled-v2-AWQ";
  const modelProfile = profile(repo);
  const modelRow = model(repo);
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");

  assert.equal(modelProfile.status, "audited");
  assert.equal(
    modelProfile.base_model_proof.base_model,
    "Jackrong/Qwen3.5-27B-Claude-4.6-Opus-Reasoning-Distilled-v2",
  );
  assert.equal(modelProfile.serving.weight_format, "int4");
  assert.equal(modelProfile.serving.kv_store_format, "fp16");
  assert.equal(modelRow.hf_downloads, 216646);
  assert.ok(modelRow.tags.includes("region:us"));
  assert.equal(modelRow.architecture.active_params_b, 25.624600064);
  assert.equal(modelRow.adapter.weight_precision, "AWQ 4-bit");
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    21.85285424,
    0.000000001,
    "QuantTrio Qwen3.5 27B Claude v2 AWQ resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    17.539198464,
    0.000000001,
    "QuantTrio Qwen3.5 27B Claude v2 AWQ swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    4.313655776,
    0.000000001,
    "QuantTrio Qwen3.5 27B Claude v2 AWQ resident-only embedding/vision/MTP footprint",
  );
  assertNear(
    result.alloc,
    6.708527104,
    0.000000001,
    "QuantTrio Qwen3.5 27B Claude v2 AWQ FP16 full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    2.252079104,
    0.000000001,
    "QuantTrio Qwen3.5 27B Claude v2 AWQ FP16 full-attention KV plus DeltaNet state read traffic",
  );
  assert.equal(result.bMem, 14);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    13.793955396,
    0.000000001,
    "QuantTrio Qwen3.5 27B Claude v2 AWQ DGX single-session tok/s",
  );
  assertNear(
    result.dennard,
    227.721166711,
    0.000000001,
    "QuantTrio Qwen3.5 27B Claude v2 AWQ DGX Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 5);
  assertNear(
    m5Result.best.aggregate,
    106.598725027,
    0.000000001,
    "QuantTrio Qwen3.5 27B Claude v2 AWQ M5 Max aggregate",
  );
  assertNear(
    m5Result.best.perSession,
    21.319745005,
    0.000000001,
    "QuantTrio Qwen3.5 27B Claude v2 AWQ M5 Max per-session",
  );
}

{
  const result = profiled(
    "deepseek-ai/deepseek-coder-7b-instruct-v1.5",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    13.820731392,
    0.000000001,
    "DeepSeek Coder 7B v1.5 resident BF16 footprint",
  );
  assertNear(
    result.single.batchWeight,
    12.981870592,
    0.000000001,
    "DeepSeek Coder 7B v1.5 swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    0.8388608,
    0.000000001,
    "DeepSeek Coder 7B v1.5 resident-only input embedding footprint",
  );
  assertNear(
    result.alloc,
    49.152,
    0.000000001,
    "DeepSeek Coder 7B v1.5 full-context BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    15.72864,
    0.000000001,
    "DeepSeek Coder 7B v1.5 full-context BF16 KV read traffic",
  );
  assert.equal(result.bMem, 2);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    9.508712815,
    0.000000001,
    "DeepSeek Coder 7B v1.5 DGX single-session tok/s",
  );
  assertNear(
    result.dennard,
    45.428030311,
    0.000000001,
    "DeepSeek Coder 7B v1.5 DGX Dennard bound",
  );
}

{
  const result = profiled(
    "deepseek-ai/deepseek-coder-6.7b-instruct",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    13.481025536,
    0.000000001,
    "DeepSeek Coder 6.7B resident BF16 footprint",
  );
  assertNear(
    result.single.batchWeight,
    13.216784384,
    0.000000001,
    "DeepSeek Coder 6.7B swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    0.264241152,
    0.000000001,
    "DeepSeek Coder 6.7B resident-only input embedding footprint",
  );
  assertNear(
    result.alloc,
    52.4288,
    0.000000001,
    "DeepSeek Coder 6.7B full-context BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    16.777216,
    0.000000001,
    "DeepSeek Coder 6.7B full-context BF16 KV read traffic",
  );
  assert.equal(result.bMem, 2);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    9.101820248,
    0.000000001,
    "DeepSeek Coder 6.7B DGX single-session tok/s",
  );
  assertNear(
    result.dennard,
    41.965644845,
    0.000000001,
    "DeepSeek Coder 6.7B DGX Dennard bound",
  );
}

{
  const result = profiled(
    "deepseek-ai/deepseek-coder-6.7b-instruct",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(result.bMem, 2);
  assert.equal(result.best.batch, 1);
  assertNear(
    result.best.aggregate,
    20.470760557,
    0.000000001,
    "DeepSeek Coder 6.7B M5 Max aggregate tok/s",
  );
  assertNear(
    result.best.perSession,
    20.470760557,
    0.000000001,
    "DeepSeek Coder 6.7B M5 Max per-session tok/s",
  );
}

{
  const result = profiled(
    "speakleash/Bielik-11B-v3.0-Instruct-awq",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    6.192805344,
    0.000000001,
    "Bielik 11B AWQ resident compressed-tensors footprint",
  );
  assertNear(
    result.single.batchWeight,
    5.929612768,
    0.000000001,
    "Bielik 11B AWQ swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    0.263192576,
    0.000000001,
    "Bielik 11B AWQ resident-only input embedding footprint",
  );
  assertNear(
    result.alloc,
    20.48,
    0.000000001,
    "Bielik 11B AWQ full-context BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    6.5536,
    0.000000001,
    "Bielik 11B AWQ full-context BF16 KV read traffic",
  );
  assert.equal(result.bMem, 5);
  assert.equal(result.best.batch, 1);
  assertNear(
    result.single.aggregate,
    21.869370095,
    0.000000001,
    "Bielik 11B AWQ DGX single-session tok/s",
  );
  assertNear(
    result.best.aggregate,
    21.869370095,
    0.000000001,
    "Bielik 11B AWQ DGX aggregate tok/s at b*",
  );
  assertNear(
    result.dennard,
    255.844496986,
    0.000000001,
    "Bielik 11B AWQ DGX Dennard bound",
  );
}

{
  const result = profiled("Qwen/Qwen3.6-27B", "nvidia-dgx-spark");
  assertNear(
    result.resident,
    55.562855904,
    0.000000001,
    "Qwen3.6 27B resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    51.249200128,
    0.000000001,
    "Qwen3.6 27B swept text-decode traffic",
  );
  assertNear(
    result.alloc,
    6.708527104,
    0.000000001,
    "Qwen3.6 27B full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    2.252079104,
    0.000000001,
    "Qwen3.6 27B full-attention KV plus DeltaNet state read traffic",
  );
}

{
  const result = profiled("Qwen/Qwen3.6-27B-FP8", "nvidia-dgx-spark");
  assertNear(
    result.resident,
    30.866663264,
    0.000000001,
    "Qwen3.6 27B FP8 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    26.925206528,
    0.000000001,
    "Qwen3.6 27B FP8 swept text-decode traffic",
  );
  assertNear(
    result.alloc,
    6.708527104,
    0.000000001,
    "Qwen3.6 27B FP8 full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    2.252079104,
    0.000000001,
    "Qwen3.6 27B FP8 full-attention KV plus DeltaNet state read traffic",
  );
}

{
  const result = profiled(
    "groxaxo/Qwen3.6-27B-GPTQ-Pro-4bit",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    18.709748192,
    0.000000001,
    "groxaxo Qwen3.6 27B GPTQ resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    15.2454912,
    0.000000001,
    "groxaxo Qwen3.6 27B GPTQ swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    3.464256992,
    0.000000001,
    "groxaxo Qwen3.6 27B GPTQ resident-only visual/input-embedding footprint",
  );
  assertNear(
    result.alloc,
    6.708527104,
    0.000000001,
    "groxaxo Qwen3.6 27B GPTQ full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    2.252079104,
    0.000000001,
    "groxaxo Qwen3.6 27B GPTQ full-attention KV plus DeltaNet state read traffic",
  );
  assert.equal(result.bMem, 15);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    15.602166201,
    0.000000001,
    "groxaxo Qwen3.6 27B GPTQ DGX single-session tok/s",
  );
  assertNear(
    result.dennard,
    270.371989934,
    0.000000001,
    "groxaxo Qwen3.6 27B GPTQ DGX Dennard bound",
  );
}

{
  const result = profiled(
    "groxaxo/Qwen3.6-27B-GPTQ-Pro-4bit",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(result.bMem, 15);
  assert.equal(result.best.batch, 6);
  assertNear(
    result.single.aggregate,
    35.090586255,
    0.000000001,
    "groxaxo Qwen3.6 27B GPTQ M5 Max single-session tok/s",
  );
  assertNear(
    result.best.aggregate,
    128.103636486,
    0.000000001,
    "groxaxo Qwen3.6 27B GPTQ M5 Max aggregate tok/s",
  );
  assertNear(
    result.best.perSession,
    21.350606081,
    0.000000001,
    "groxaxo Qwen3.6 27B GPTQ M5 Max per-session tok/s",
  );
  assertNear(
    result.dennard,
    608.089383955,
    0.000000001,
    "groxaxo Qwen3.6 27B GPTQ M5 Max Dennard bound",
  );
}

{
  const result = profiled("unsloth/Qwen3.6-27B-GGUF", "nvidia-dgx-spark");
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    16.071772384,
    0.000000001,
    "Unsloth Qwen3.6 27B GGUF IQ4_NL resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    15.345616896,
    0.000000001,
    "Unsloth Qwen3.6 27B GGUF IQ4_NL swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    0.726155488,
    0.000000001,
    "Unsloth Qwen3.6 27B GGUF IQ4_NL resident-only input-embedding and GGUF overhead footprint",
  );
  assertNear(
    result.alloc,
    6.708527104,
    0.000000001,
    "Unsloth Qwen3.6 27B GGUF IQ4_NL full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    2.252079104,
    0.000000001,
    "Unsloth Qwen3.6 27B GGUF IQ4_NL full-attention KV plus DeltaNet state read traffic",
  );
  assert.equal(result.bMem, 15);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    15.513394480732025,
    0.000000001,
    "Unsloth Qwen3.6 27B GGUF IQ4_NL DGX single-session tok/s",
  );
  assertNear(
    result.dennard,
    275.6034421434826,
    0.000000001,
    "Unsloth Qwen3.6 27B GGUF IQ4_NL DGX Dennard bound",
  );
}

{
  const modelProfile = profile("lmstudio-community/Qwen3.6-27B-GGUF");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "lmstudio-community/Qwen3.6-27B-GGUF",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    16.547398784,
    0.000000001,
    "LM Studio Qwen3.6 27B GGUF Q4_K_M resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    15.821244416,
    0.000000001,
    "LM Studio Qwen3.6 27B GGUF Q4_K_M swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    0.726154368,
    0.000000001,
    "LM Studio Qwen3.6 27B GGUF Q4_K_M resident-only input-embedding and GGUF overhead footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.726154368,
    0.000000001,
    "LM Studio Qwen3.6 27B GGUF Q4_K_M auxiliary resident bytes",
  );
  assertNear(
    result.alloc,
    6.708527104,
    0.000000001,
    "LM Studio Qwen3.6 27B GGUF Q4_K_M full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    2.252079104,
    0.000000001,
    "LM Studio Qwen3.6 27B GGUF Q4_K_M full-attention KV plus DeltaNet state read traffic",
  );
  assert.equal(result.bMem, 15);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    15.105135460995719,
    0.000000001,
    "LM Studio Qwen3.6 27B GGUF Q4_K_M DGX single-session tok/s",
  );
  assertNear(
    result.dennard,
    266.0947116547451,
    0.000000001,
    "LM Studio Qwen3.6 27B GGUF Q4_K_M DGX Dennard bound",
  );
}

{
  const result = profiled(
    "lmstudio-community/Qwen3.6-27B-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(result.bMem, 15);
  assert.equal(result.best.batch, 6);
  assertNear(
    result.single.aggregate,
    33.97272224560942,
    0.000000001,
    "LM Studio Qwen3.6 27B GGUF Q4_K_M M5 Max single-session tok/s",
  );
  assertNear(
    result.best.aggregate,
    125.58925770634231,
    0.000000001,
    "LM Studio Qwen3.6 27B GGUF Q4_K_M M5 Max aggregate tok/s",
  );
  assertNear(
    result.best.perSession,
    20.93154295105705,
    0.000000001,
    "LM Studio Qwen3.6 27B GGUF Q4_K_M M5 Max per-session tok/s",
  );
  assertNear(
    result.dennard,
    598.4694247473021,
    0.000000001,
    "LM Studio Qwen3.6 27B GGUF Q4_K_M M5 Max Dennard bound",
  );
}

{
  const repo = "batiai/Qwen3.6-27B-GGUF";
  const modelProfile = profile(repo);
  const modelRow = model(repo);
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  assert.equal(modelProfile.status, "audited");
  assert.equal(modelRow.hf_downloads, 154057);
  assert.ok(modelRow.tags.includes("region:us"));
  assert.equal(
    modelRow.architecture.detail,
    "qwen3_5_text (API-selected IQ3_XXS GGUF)",
  );
  assert.equal(modelRow.adapter.weight_precision, "GGUF IQ3_XXS");
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    11.1863704,
    0.000000001,
    "BatiAI Qwen3.6 27B GGUF IQ3_XXS selected linked-file resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    10.629072896,
    0.000000001,
    "BatiAI Qwen3.6 27B GGUF IQ3_XXS swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    0.557297504,
    0.000000001,
    "BatiAI Qwen3.6 27B GGUF IQ3_XXS resident-only token embedding and GGUF overhead footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.557297504,
    0.000000001,
    "BatiAI Qwen3.6 27B GGUF IQ3_XXS auxiliary resident bytes",
  );
  assertNear(
    result.alloc,
    6.708527104,
    0.000000001,
    "BatiAI Qwen3.6 27B GGUF IQ3_XXS full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    2.252079104,
    0.000000001,
    "BatiAI Qwen3.6 27B GGUF IQ3_XXS full-attention KV plus DeltaNet state read traffic",
  );
  assert.equal(result.bMem, 16);
  assert.equal(result.best?.batch, 1);
  assertNear(
    result.single.aggregate,
    21.193756583262118,
    0.000000001,
    "BatiAI Qwen3.6 27B GGUF IQ3_XXS DGX single-session tok/s",
  );
  assertNear(
    result.best?.aggregate ?? 0,
    21.193756583262118,
    0.000000001,
    "BatiAI Qwen3.6 27B GGUF IQ3_XXS DGX aggregate tok/s",
  );
  assertNear(
    result.best?.perSession ?? 0,
    21.193756583262118,
    0.000000001,
    "BatiAI Qwen3.6 27B GGUF IQ3_XXS DGX per-session tok/s",
  );
  assertNear(
    result.dennard,
    416.6039464534867,
    0.000000001,
    "BatiAI Qwen3.6 27B GGUF IQ3_XXS DGX Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.bMem, 16);
  assert.equal(m5Result.best?.batch, 8);
  assertNear(
    m5Result.single.aggregate,
    47.66654411034044,
    0.000000001,
    "BatiAI Qwen3.6 27B GGUF IQ3_XXS M5 Max single-session tok/s",
  );
  assertNear(
    m5Result.best?.aggregate ?? 0,
    171.47421839213834,
    0.000000001,
    "BatiAI Qwen3.6 27B GGUF IQ3_XXS M5 Max aggregate tok/s",
  );
  assertNear(
    m5Result.best?.perSession ?? 0,
    21.434277299017293,
    0.000000001,
    "BatiAI Qwen3.6 27B GGUF IQ3_XXS M5 Max per-session tok/s",
  );
  assertNear(
    m5Result.dennard,
    936.9773740748749,
    0.000000001,
    "BatiAI Qwen3.6 27B GGUF IQ3_XXS M5 Max Dennard bound",
  );
}

{
  const modelProfile = profile(
    "DavidAU/Qwen3.6-27B-Heretic-Uncensored-FINETUNE-NEO-CODE-Di-IMatrix-MAX-GGUF",
  );
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "DavidAU/Qwen3.6-27B-Heretic-Uncensored-FINETUNE-NEO-CODE-Di-IMatrix-MAX-GGUF",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    29.86634176,
    0.000000001,
    "DavidAU Qwen3.6 27B GGUF Q8_0 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    28.504487936,
    0.000000001,
    "DavidAU Qwen3.6 27B GGUF Q8_0 swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    1.361853824,
    0.000000001,
    "DavidAU Qwen3.6 27B GGUF Q8_0 resident-only input-embedding and GGUF overhead footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.361853824,
    0.000000001,
    "DavidAU Qwen3.6 27B GGUF Q8_0 auxiliary resident bytes",
  );
  assertNear(
    result.alloc,
    6.708527104,
    0.000000001,
    "DavidAU Qwen3.6 27B GGUF Q8_0 full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    2.252079104,
    0.000000001,
    "DavidAU Qwen3.6 27B GGUF Q8_0 full-attention KV plus DeltaNet state read traffic",
  );
  assert.equal(result.bMem, 13);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    8.876153169011154,
    0.000000001,
    "DavidAU Qwen3.6 27B GGUF Q8_0 DGX single-session tok/s",
  );
  assertNear(
    result.dennard,
    128.67945792872968,
    0.000000001,
    "DavidAU Qwen3.6 27B GGUF Q8_0 DGX Dennard bound",
  );
}

{
  const result = profiled(
    "DavidAU/Qwen3.6-40B-Claude-4.6-Opus-Deckard-Heretic-Uncensored-Thinking-NEO-CODE-Di-IMatrix-MAX-GGUF",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    42.847202336,
    0.000000001,
    "DavidAU Qwen3.6 40B GGUF Q8_0 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    41.485323264,
    0.000000001,
    "DavidAU Qwen3.6 40B GGUF Q8_0 swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    1.361879072,
    0.000000001,
    "DavidAU Qwen3.6 40B GGUF Q8_0 resident-only input-embedding and GGUF overhead footprint",
  );
  assertNear(
    result.alloc,
    10.062790656,
    0.000000001,
    "DavidAU Qwen3.6 40B GGUF Q8_0 full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    3.378118656,
    0.000000001,
    "DavidAU Qwen3.6 40B GGUF Q8_0 full-attention KV plus DeltaNet state read traffic",
  );
  assert.equal(result.bMem, 7);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    6.085132756572949,
    0.000000001,
    "DavidAU Qwen3.6 40B GGUF Q8_0 DGX single-session tok/s",
  );
  assertNear(
    result.dennard,
    50.454674580685314,
    0.000000001,
    "DavidAU Qwen3.6 40B GGUF Q8_0 DGX Dennard bound",
  );
}

{
  const result = profiled(
    "lmstudio-community/Qwen3.6-27B-MLX-4bit",
    "nvidia-dgx-spark",
  );
  assertNear(
    result.resident,
    16.05426224,
    0.000000001,
    "LM Studio Qwen3.6 27B MLX 4bit resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    14.417640448,
    0.000000001,
    "LM Studio Qwen3.6 27B MLX 4bit swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    1.636621792,
    0.000000001,
    "LM Studio Qwen3.6 27B MLX 4bit resident-only visual/input-embedding footprint",
  );
  assertNear(
    result.alloc,
    6.708527104,
    0.000000001,
    "LM Studio Qwen3.6 27B MLX 4bit full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    2.252079104,
    0.000000001,
    "LM Studio Qwen3.6 27B MLX 4bit full-attention KV plus DeltaNet state read traffic",
  );
  assertNear(
    result.single.aggregate,
    16.377000174,
    0.000000001,
    "LM Studio Qwen3.6 27B MLX 4bit DGX single-session tok/s",
  );
  assertNear(
    result.dennard,
    293.39179457,
    0.000000001,
    "LM Studio Qwen3.6 27B MLX 4bit DGX Dennard bound",
  );
}

{
  const result = profiled(
    "lmstudio-community/Qwen3.6-27B-MLX-6bit",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    22.77760048,
    0.000000001,
    "LM Studio Qwen3.6 27B MLX 6bit resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    20.823129088,
    0.000000001,
    "LM Studio Qwen3.6 27B MLX 6bit swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    1.954471392,
    0.000000001,
    "LM Studio Qwen3.6 27B MLX 6bit resident-only visual/input-embedding footprint",
  );
  assertNear(
    result.alloc,
    6.708527104,
    0.000000001,
    "LM Studio Qwen3.6 27B MLX 6bit full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    2.252079104,
    0.000000001,
    "LM Studio Qwen3.6 27B MLX 6bit full-attention KV plus DeltaNet state read traffic",
  );
  assertNear(
    result.single.aggregate,
    11.830879173,
    0.000000001,
    "LM Studio Qwen3.6 27B MLX 6bit DGX single-session tok/s",
  );
  assertNear(
    result.dennard,
    190.000967499,
    0.000000001,
    "LM Studio Qwen3.6 27B MLX 6bit DGX Dennard bound",
  );
}

{
  const result = profiled(
    "lmstudio-community/Qwen3.6-27B-MLX-5bit",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    19.41593136,
    0.000000001,
    "LM Studio Qwen3.6 27B MLX 5bit resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    17.620384768,
    0.000000001,
    "LM Studio Qwen3.6 27B MLX 5bit swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    1.795546592,
    0.000000001,
    "LM Studio Qwen3.6 27B MLX 5bit resident-only visual/input-embedding footprint",
  );
  assertNear(
    result.alloc,
    6.708527104,
    0.000000001,
    "LM Studio Qwen3.6 27B MLX 5bit full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    2.252079104,
    0.000000001,
    "LM Studio Qwen3.6 27B MLX 5bit full-attention KV plus DeltaNet state read traffic",
  );
  assertNear(
    result.single.aggregate,
    13.737602029,
    0.000000001,
    "LM Studio Qwen3.6 27B MLX 5bit DGX single-session tok/s",
  );
  assertNear(
    result.dennard,
    232.300037297,
    0.000000001,
    "LM Studio Qwen3.6 27B MLX 5bit DGX Dennard bound",
  );
}

{
  const result = profiled(
    "lmstudio-community/Qwen3.6-27B-MLX-8bit",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    29.50093872,
    0.000000001,
    "LM Studio Qwen3.6 27B MLX 8bit resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    27.228617728,
    0.000000001,
    "LM Studio Qwen3.6 27B MLX 8bit swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    2.272320992,
    0.000000001,
    "LM Studio Qwen3.6 27B MLX 8bit resident-only visual/input-embedding footprint",
  );
  assertNear(
    result.alloc,
    6.708527104,
    0.000000001,
    "LM Studio Qwen3.6 27B MLX 8bit full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    2.252079104,
    0.000000001,
    "LM Studio Qwen3.6 27B MLX 8bit full-attention KV plus DeltaNet state read traffic",
  );
  assertNear(
    result.single.aggregate,
    9.260296714,
    0.000000001,
    "LM Studio Qwen3.6 27B MLX 8bit DGX single-session tok/s",
  );
  assertNear(
    result.dennard,
    135.255192843,
    0.000000001,
    "LM Studio Qwen3.6 27B MLX 8bit DGX Dennard bound",
  );
}

{
  const repo = "TheBloke/TinyLlama-1.1B-Chat-v0.3-AWQ";
  const row = model(repo);
  const item = profile(repo);
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  const m1Result = profiled(repo, "apple-mac-studio-m1-ultra-128gb");

  assert.equal(row.hf_downloads, 132292);
  assert.ok(row.tags.includes("region:us"));
  assert.equal(row.adapter.weight_precision, "AWQ 4-bit group 128 GEMM");
  assertNear(
    row.architecture.total_params_b,
    1.100060672,
    0.000000001,
    "TheBloke TinyLlama 1.1B AWQ catalog total params",
  );
  assertNear(
    row.architecture.active_params_b,
    1.034518528,
    0.000000001,
    "TheBloke TinyLlama 1.1B AWQ catalog swept params",
  );
  assert.equal(item.status, "audited");
  assert.equal(item.base_model_proof.config_compatible, true);
  assert.equal(item.serving.runtime_format, "vllm-awq-gemm-memory-bound");
  assert.equal(item.architecture.kv_adapter.kind, "full_context");
  assert.equal(item.architecture.kv_adapter.layers, 22);
  assert.equal(item.architecture.kv_adapter.kv_heads, 4);
  assert.equal(item.architecture.kv_adapter.head_dim, 64);
  assertNear(
    result.resident,
    0.765718528,
    0.000000001,
    "TheBloke TinyLlama 1.1B AWQ resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    0.63463424,
    0.000000001,
    "TheBloke TinyLlama 1.1B AWQ swept text-decode traffic",
  );
  assertNear(
    item.architecture.weight_adapter.auxiliary_resident_weight_gb,
    0.131084288,
    0.000000001,
    "TheBloke TinyLlama 1.1B AWQ resident-only input-embedding footprint",
  );
  assertNear(
    result.alloc,
    2.2528,
    0.000000001,
    "TheBloke TinyLlama 1.1B AWQ full-context KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.720896,
    0.000000001,
    "TheBloke TinyLlama 1.1B AWQ full-context KV read traffic",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(result.bMem, 52);
  assert.equal(result.best.batch, 18);
  assertNear(
    result.single.aggregate,
    201.3972037982716,
    0.000000001,
    "TheBloke TinyLlama 1.1B AWQ DGX single-session tok/s",
  );
  assertNear(
    result.best.aggregate,
    361.03782531433006,
    0.000000001,
    "TheBloke TinyLlama 1.1B AWQ DGX aggregate tok/s",
  );
  assertNear(
    result.best.perSession,
    20.057656961907227,
    0.000000001,
    "TheBloke TinyLlama 1.1B AWQ DGX per-session tok/s",
  );
  assertNear(
    result.dennard,
    22767.620766598066,
    0.000000001,
    "TheBloke TinyLlama 1.1B AWQ DGX Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 41);
  assertNear(
    m5Result.best.aggregate,
    833.8144244492562,
    0.000000001,
    "TheBloke TinyLlama 1.1B AWQ M5 Max aggregate tok/s",
  );
  assertNear(
    m5Result.best.perSession,
    20.336937181689176,
    0.000000001,
    "TheBloke TinyLlama 1.1B AWQ M5 Max per-session tok/s",
  );
  assert.equal(m1Result.status_code, "ok");
  assert.equal(m1Result.best.batch, 52);
  assertNear(
    m1Result.best.aggregate,
    1091.2555576806126,
    0.000000001,
    "TheBloke TinyLlama 1.1B AWQ M1 Ultra aggregate tok/s",
  );
}

{
  const result = profiled(
    "TheBloke/TinyLlama-1.1B-Chat-v0.3-GPTQ",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    0.768083968,
    0.000000001,
    "TheBloke TinyLlama 1.1B GPTQ resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    0.63699968,
    0.000000001,
    "TheBloke TinyLlama 1.1B GPTQ swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    0.131084288,
    0.000000001,
    "TheBloke TinyLlama 1.1B GPTQ resident-only input-embedding footprint",
  );
  assertNear(
    result.alloc,
    2.2528,
    0.000000001,
    "TheBloke TinyLlama 1.1B GPTQ full-context KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.720896,
    0.000000001,
    "TheBloke TinyLlama 1.1B GPTQ full-context KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    201.046371986,
    0.000000001,
    "TheBloke TinyLlama 1.1B GPTQ DGX single-session tok/s",
  );
  assertNear(
    result.dennard,
    22682.625290829,
    0.000000001,
    "TheBloke TinyLlama 1.1B GPTQ DGX Dennard bound",
  );
}

{
  const repo = "TheBloke/TinyLlama-1.1B-Chat-v1.0-GPTQ";
  const catalogRow = model(repo);
  const item = profile(repo);
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  assert.equal(item.status, "audited");
  assert.equal(item.base_model_proof.config_compatible, true);
  assert.equal(item.architecture.max_context_tokens, 2048);
  assert.equal(
    item.serving.runtime_format,
    "gptq-4bit-group128-actorder-text-decode-memory-bound",
  );
  assert.equal(catalogRow.hf_downloads, 132526);
  assertNear(
    catalogRow.architecture.total_params_b,
    1.100442624,
    0.000000001,
    "TheBloke TinyLlama 1.1B Chat v1.0 GPTQ catalog total params",
  );
  assertNear(
    catalogRow.architecture.active_params_b,
    1.034906624,
    0.000000001,
    "TheBloke TinyLlama 1.1B Chat v1.0 GPTQ catalog swept params",
  );
  assertNear(
    catalogRow.adapter.resident_weight_gb,
    0.768059392,
    0.000000001,
    "TheBloke TinyLlama 1.1B Chat v1.0 GPTQ catalog resident footprint",
  );
  assertNear(
    catalogRow.adapter.active_weight_gb,
    0.636987392,
    0.000000001,
    "TheBloke TinyLlama 1.1B Chat v1.0 GPTQ catalog swept traffic",
  );
  assertNear(
    weightAdapter.resident_params_b,
    1.100442624,
    0.000000001,
    "TheBloke TinyLlama 1.1B Chat v1.0 GPTQ reconstructed resident params",
  );
  assertNear(
    weightAdapter.swept_params_b,
    1.034906624,
    0.000000001,
    "TheBloke TinyLlama 1.1B Chat v1.0 GPTQ swept params",
  );
  assertNear(
    result.resident,
    0.768059392,
    0.000000001,
    "TheBloke TinyLlama 1.1B Chat v1.0 GPTQ resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    0.636987392,
    0.000000001,
    "TheBloke TinyLlama 1.1B Chat v1.0 GPTQ swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    0.131072,
    0.000000001,
    "TheBloke TinyLlama 1.1B Chat v1.0 GPTQ resident-only input embedding",
  );
  assertNear(
    result.alloc,
    2.2528,
    0.000000001,
    "TheBloke TinyLlama 1.1B Chat v1.0 GPTQ full-context KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.720896,
    0.000000001,
    "TheBloke TinyLlama 1.1B Chat v1.0 GPTQ full-context KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    201.048191331,
    0.000000001,
    "TheBloke TinyLlama 1.1B Chat v1.0 GPTQ DGX single-session tok/s",
  );
  assert.equal(result.bMem, 52);
  assert.equal(result.best?.batch, 18);
  assertNear(
    result.best?.aggregate ?? 0,
    360.975416611,
    0.000000001,
    "TheBloke TinyLlama 1.1B Chat v1.0 GPTQ DGX aggregate throughput",
  );
  assertNear(
    result.best?.perSession ?? 0,
    20.054189812,
    0.000000001,
    "TheBloke TinyLlama 1.1B Chat v1.0 GPTQ DGX per-session throughput",
  );
  assertNear(
    result.dennard,
    22683.067532363,
    0.000000001,
    "TheBloke TinyLlama 1.1B Chat v1.0 GPTQ DGX Dennard bound",
  );
  assert.equal(m5Result.best?.batch, 41);
  assertNear(
    m5Result.best?.aggregate ?? 0,
    833.749441007,
    0.000000001,
    "TheBloke TinyLlama 1.1B Chat v1.0 GPTQ M5 aggregate throughput",
  );
  assertNear(
    m5Result.best?.perSession ?? 0,
    20.33535222,
    0.000000001,
    "TheBloke TinyLlama 1.1B Chat v1.0 GPTQ M5 per-session throughput",
  );
}

{
  const repo = "mlx-community/Devstral-Small-2-24B-Instruct-2512-4bit";
  const catalogRow = model(repo);
  const item = profile(repo);
  const weightAdapter = item.architecture.weight_adapter;
  const dgx = profiled(repo, "nvidia-dgx-spark");
  const m5 = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  assert.equal(item.status, "audited");
  assert.equal(item.base_model_proof.config_compatible, true);
  assert.equal(item.architecture.max_context_tokens, 393216);
  assert.equal(
    item.serving.runtime_format,
    "mlx-vlm-4bit-affine-mistral3-multimodal-text-decode-memory-bound",
  );
  assert.equal(catalogRow.hf_pipeline_tag, "image-text-to-text");
  assert.equal(catalogRow.hf_downloads, 129826);
  assert.equal(
    catalogRow.architecture.detail,
    "mistral3 / ministral3 text (MLX 4-bit affine)",
  );
  assertNear(
    catalogRow.architecture.total_params_b,
    24.01136128,
    0.000000001,
    "MLX Devstral Small 2 catalog resident logical params",
  );
  assertNear(
    catalogRow.architecture.active_params_b,
    22.90131456,
    0.000000001,
    "MLX Devstral Small 2 catalog swept logical params",
  );
  assertNear(
    catalogRow.adapter.resident_weight_gb,
    15.10267904,
    0.000000001,
    "MLX Devstral Small 2 catalog resident footprint",
  );
  assertNear(
    catalogRow.adapter.active_weight_gb,
    13.84727552,
    0.000000001,
    "MLX Devstral Small 2 catalog swept traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.25540352,
    0.000000001,
    "MLX Devstral Small 2 resident-only input embedding and vision/projector",
  );
  assert.equal(dgx.status_code, "no_floor");
  assertNear(
    dgx.resident,
    15.10267904,
    0.000000001,
    "MLX Devstral Small 2 resident footprint",
  );
  assertNear(
    dgx.single.batchWeight,
    13.84727552,
    0.000000001,
    "MLX Devstral Small 2 swept text-decode traffic",
  );
  assertNear(
    dgx.alloc,
    16.384,
    0.000000001,
    "MLX Devstral Small 2 full-context KV allocation",
  );
  assertNear(
    dgx.single.readTraffic,
    5.24288,
    0.000000001,
    "MLX Devstral Small 2 full-context KV read traffic",
  );
  assertNear(
    dgx.single.aggregate,
    14.300564483,
    0.000000001,
    "MLX Devstral Small 2 DGX single-session tok/s",
  );
  assert.equal(dgx.bMem, 6);
  assert.equal(dgx.best, null);
  assertNear(
    dgx.dennard,
    126.224241863,
    0.000000001,
    "MLX Devstral Small 2 DGX Dennard bound",
  );
  assert.equal(m5.status_code, "ok");
  assert.equal(m5.best?.batch, 3);
  assertNear(
    m5.best?.aggregate ?? 0,
    62.280405107,
    0.000000001,
    "MLX Devstral Small 2 M5 aggregate throughput",
  );
  assertNear(
    m5.best?.perSession ?? 0,
    20.760135036,
    0.000000001,
    "MLX Devstral Small 2 M5 per-session throughput",
  );
}

{
  const repo = "TheBloke/TinyLlama-1.1B-Chat-v1.0-GGUF";
  const catalogRow = model(repo);
  const item = profile(repo);
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  assert.equal(item.status, "audited");
  assert.equal(item.base_model_proof.config_compatible, true);
  assert.equal(item.architecture.max_context_tokens, 2048);
  assert.equal(
    item.serving.runtime_format,
    "llama.cpp-gguf-q4-k-m-memory-bound",
  );
  assert.equal(catalogRow.hf_downloads, 194341);
  assertNear(
    catalogRow.adapter.resident_weight_gb,
    0.668788096,
    0.000000001,
    "TheBloke TinyLlama 1.1B Chat v1.0 GGUF catalog resident footprint",
  );
  assertNear(
    catalogRow.adapter.active_weight_gb,
    0.630214656,
    0.000000001,
    "TheBloke TinyLlama 1.1B Chat v1.0 GGUF catalog swept traffic",
  );
  assertNear(
    weightAdapter.resident_params_b,
    1.100048384,
    0.000000001,
    "TheBloke TinyLlama 1.1B Chat v1.0 GGUF logical resident parameters",
  );
  assertNear(
    weightAdapter.swept_params_b,
    1.034512384,
    0.000000001,
    "TheBloke TinyLlama 1.1B Chat v1.0 GGUF logical swept parameters",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    0.668788096,
    0.000000001,
    "TheBloke TinyLlama 1.1B Chat v1.0 GGUF Q4_K_M resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    0.630214656,
    0.000000001,
    "TheBloke TinyLlama 1.1B Chat v1.0 GGUF Q4_K_M swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    0.03857344,
    0.000000001,
    "TheBloke TinyLlama 1.1B Chat v1.0 GGUF resident-only input embedding plus header footprint",
  );
  assertNear(
    result.alloc,
    2.2528,
    0.000000001,
    "TheBloke TinyLlama 1.1B Chat v1.0 GGUF full-context FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.720896,
    0.000000001,
    "TheBloke TinyLlama 1.1B Chat v1.0 GGUF full-context FP16 KV read traffic",
  );
  assert.equal(result.bMem, 52);
  assert.equal(result.best.batch, 18);
  assertNear(
    result.single.aggregate,
    202.05598911359635,
    0.000000001,
    "TheBloke TinyLlama 1.1B Chat v1.0 GGUF DGX single-session tok/s",
  );
  assertNear(
    result.best.aggregate,
    361.15509687190405,
    0.000000001,
    "TheBloke TinyLlama 1.1B Chat v1.0 GGUF DGX aggregate tok/s at b*",
  );
  assertNear(
    result.dennard,
    22945.92459723394,
    0.000000001,
    "TheBloke TinyLlama 1.1B Chat v1.0 GGUF DGX Dennard bound",
  );
  assert.equal(m5Result.best.batch, 41);
  assertNear(
    m5Result.best.aggregate,
    833.9365008037465,
    0.000000001,
    "TheBloke TinyLlama 1.1B Chat v1.0 GGUF M5 Max aggregate tok/s at b*",
  );
}

{
  const result = profiled("cyankiwi/Qwen3.6-27B-AWQ-INT4", "nvidia-dgx-spark");
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    20.443676496,
    0.000000001,
    "Cyankiwi Qwen3.6 27B AWQ INT4 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    16.659305728,
    0.000000001,
    "Cyankiwi Qwen3.6 27B AWQ INT4 swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    3.784370768,
    0.000000001,
    "Cyankiwi Qwen3.6 27B AWQ INT4 resident-only visual/MTP/input-embedding footprint",
  );
  assertNear(
    result.alloc,
    6.708527104,
    0.000000001,
    "Cyankiwi Qwen3.6 27B AWQ INT4 full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    2.252079104,
    0.000000001,
    "Cyankiwi Qwen3.6 27B AWQ INT4 full-attention KV plus DeltaNet state read traffic",
  );
  assertNear(
    result.single.aggregate,
    14.435748753,
    0.000000001,
    "Cyankiwi Qwen3.6 27B AWQ INT4 DGX single-session tok/s",
  );
  assertNear(
    result.dennard,
    243.19095612,
    0.000000001,
    "Cyankiwi Qwen3.6 27B AWQ INT4 DGX Dennard bound",
  );
}

{
  const result = profiled(
    "cyankiwi/Qwen3.6-27B-AWQ-BF16-INT4",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    28.315858512,
    0.000000001,
    "Cyankiwi Qwen3.6 27B AWQ BF16 INT4 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    24.531487744,
    0.000000001,
    "Cyankiwi Qwen3.6 27B AWQ BF16 INT4 swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    3.784370768,
    0.000000001,
    "Cyankiwi Qwen3.6 27B AWQ BF16 INT4 resident-only visual/MTP/input-embedding footprint",
  );
  assertNear(
    result.alloc,
    6.708527104,
    0.000000001,
    "Cyankiwi Qwen3.6 27B AWQ BF16 INT4 full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    2.252079104,
    0.000000001,
    "Cyankiwi Qwen3.6 27B AWQ BF16 INT4 full-attention KV plus DeltaNet state read traffic",
  );
  assertNear(
    result.single.aggregate,
    10.192817168,
    0.000000001,
    "Cyankiwi Qwen3.6 27B AWQ BF16 INT4 DGX single-session tok/s",
  );
  assert.equal(result.bMem, 13);
  assertNear(
    result.dennard,
    152.091801341,
    0.000000001,
    "Cyankiwi Qwen3.6 27B AWQ BF16 INT4 DGX Dennard bound",
  );
}

{
  const result = profiled(
    "cyankiwi/Qwen3.6-27B-AWQ-BF16-INT4",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.single.aggregate,
    22.924504547,
    0.000000001,
    "Cyankiwi Qwen3.6 27B AWQ BF16 INT4 M5 Max single-session tok/s",
  );
  assert.equal(result.bMem, 13);
  assert.equal(result.best.batch, 2);
  assertNear(
    result.best.aggregate,
    42.292842461,
    0.000000001,
    "Cyankiwi Qwen3.6 27B AWQ BF16 INT4 M5 Max aggregate tok/s",
  );
  assertNear(
    result.dennard,
    342.067274812,
    0.000000001,
    "Cyankiwi Qwen3.6 27B AWQ BF16 INT4 M5 Max Dennard bound",
  );
}

{
  const result = profiled("QuantTrio/Qwen3.6-27B-AWQ", "nvidia-dgx-spark");
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    21.852837344,
    0.000000001,
    "QuantTrio Qwen3.6 27B AWQ resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    17.539181568,
    0.000000001,
    "QuantTrio Qwen3.6 27B AWQ swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    4.313655776,
    0.000000001,
    "QuantTrio Qwen3.6 27B AWQ resident-only visual/MTP/input-embedding footprint",
  );
  assertNear(
    result.alloc,
    6.708527104,
    0.000000001,
    "QuantTrio Qwen3.6 27B AWQ full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    2.252079104,
    0.000000001,
    "QuantTrio Qwen3.6 27B AWQ full-attention KV plus DeltaNet state read traffic",
  );
  assert.equal(result.bMem, 14);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    13.793967172,
    0.000000001,
    "QuantTrio Qwen3.6 27B AWQ DGX single-session tok/s",
  );
  assertNear(
    result.dennard,
    227.721425284,
    0.000000001,
    "QuantTrio Qwen3.6 27B AWQ DGX Dennard bound",
  );
}

{
  const result = profiled("unsloth/Qwen3.6-27B-NVFP4", "nvidia-dgx-spark");
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    26.380988256,
    0.000000001,
    "Unsloth Qwen3.6 27B NVFP4 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    22.06733248,
    0.000000001,
    "Unsloth Qwen3.6 27B NVFP4 swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    4.313655776,
    0.000000001,
    "Unsloth Qwen3.6 27B NVFP4 resident-only visual/MTP/input-embedding footprint",
  );
  assertNear(
    result.alloc,
    6.708527104,
    0.000000001,
    "Unsloth Qwen3.6 27B NVFP4 full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    2.252079104,
    0.000000001,
    "Unsloth Qwen3.6 27B NVFP4 full-attention KV plus DeltaNet state read traffic",
  );
  assert.equal(result.bMem, 13);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    11.225600548,
    0.000000001,
    "Unsloth Qwen3.6 27B NVFP4 DGX single-session tok/s",
  );
  assertNear(
    result.dennard,
    172.643281493,
    0.000000001,
    "Unsloth Qwen3.6 27B NVFP4 DGX Dennard bound",
  );
}

{
  const catalogRow = model("sakamakismile/Qwen3.6-27B-NVFP4");
  const modelProfile = profile("sakamakismile/Qwen3.6-27B-NVFP4");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  assert.equal(catalogRow.hf_downloads, 169313);
  assert.equal(catalogRow.license, "apache-2.0");
  assert.equal(catalogRow.hf_pipeline_tag, "image-text-to-text");
  assert.ok(catalogRow.tags.includes("region:us"));
  assert.equal(modelProfile.base_model_proof.config_compatible, true);
  assert.equal(modelProfile.serving.kv_store_bytes_per_scalar, 1);
  assertNear(
    weightAdapter.resident_weight_gb,
    19.709536608,
    0.000000001,
    "SakamakiSmile Qwen3.6 27B NVFP4 resident footprint",
  );
  assertNear(
    weightAdapter.swept_weight_gb,
    16.245279616,
    0.000000001,
    "SakamakiSmile Qwen3.6 27B NVFP4 swept text-decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    3.464256992,
    0.000000001,
    "SakamakiSmile Qwen3.6 27B NVFP4 resident-only visual/input-embedding footprint",
  );

  const result = profiled(
    "sakamakismile/Qwen3.6-27B-NVFP4",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    19.709536608,
    0.000000001,
    "SakamakiSmile Qwen3.6 27B NVFP4 DGX resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    16.245279616,
    0.000000001,
    "SakamakiSmile Qwen3.6 27B NVFP4 DGX swept text-decode traffic",
  );
  assertNear(
    result.alloc,
    3.431727104,
    0.000000001,
    "SakamakiSmile Qwen3.6 27B NVFP4 FP8 attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.203503104,
    0.000000001,
    "SakamakiSmile Qwen3.6 27B NVFP4 FP8 attention KV plus DeltaNet state read traffic",
  );
  assert.equal(result.bMem, 29);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    15.645790562,
    0.000000001,
    "SakamakiSmile Qwen3.6 27B NVFP4 DGX single-session tok/s",
  );
  assertNear(
    result.dennard,
    491.114039291,
    0.000000001,
    "SakamakiSmile Qwen3.6 27B NVFP4 DGX Dennard bound",
  );

  const m5Result = profiled(
    "sakamakismile/Qwen3.6-27B-NVFP4",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 12);
  assertNear(
    m5Result.single.aggregate,
    35.18870111759865,
    0.000000001,
    "SakamakiSmile Qwen3.6 27B NVFP4 M5 single",
  );
  assertNear(
    m5Result.best.aggregate,
    240.0991925313474,
    0.000000001,
    "SakamakiSmile Qwen3.6 27B NVFP4 M5 aggregate",
  );
  assertNear(
    m5Result.best.perSession,
    20.00826604427895,
    0.000000001,
    "SakamakiSmile Qwen3.6 27B NVFP4 M5 per-session",
  );

  const m1UltraResult = profiled(
    "sakamakismile/Qwen3.6-27B-NVFP4",
    "apple-mac-studio-m1-ultra-128gb",
  );
  assert.equal(m1UltraResult.status_code, "ok");
  assert.equal(m1UltraResult.best.batch, 19);
  assertNear(
    m1UltraResult.best.aggregate,
    388.6291349931331,
    0.000000001,
    "SakamakiSmile Qwen3.6 27B NVFP4 M1 Ultra aggregate",
  );
  assertNear(
    m1UltraResult.best.perSession,
    20.454164999638586,
    0.000000001,
    "SakamakiSmile Qwen3.6 27B NVFP4 M1 Ultra per-session",
  );
}

{
  const repo = "ocicek/Qwen3.6-27B-NVFP4";
  const catalogRow = model(repo);
  const modelProfile = profile(repo);
  const weightAdapter = modelProfile.architecture.weight_adapter;
  assert.equal(catalogRow.hf_downloads, 117099);
  assert.equal(catalogRow.license, "other");
  assert.equal(catalogRow.hf_pipeline_tag, "text-generation");
  assert.ok(catalogRow.tags.includes("region:us"));
  assert.equal(catalogRow.architecture.total_params_b, 27.781427952);
  assert.equal(catalogRow.architecture.active_params_b, 25.624600064);
  assert.equal(modelProfile.base_model_proof.config_compatible, true);
  assert.equal(modelProfile.serving.kv_store_bytes_per_scalar, 2);
  assertNear(
    weightAdapter.resident_weight_gb,
    20.558935392,
    0.000000001,
    "ocicek Qwen3.6 27B NVFP4 resident footprint",
  );
  assertNear(
    weightAdapter.swept_weight_gb,
    16.245279616,
    0.000000001,
    "ocicek Qwen3.6 27B NVFP4 swept text-decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    4.313655776,
    0.000000001,
    "ocicek Qwen3.6 27B NVFP4 resident-only visual/MTP/input-embedding footprint",
  );

  const result = profiled(repo, "nvidia-dgx-spark");
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    20.558935392,
    0.000000001,
    "ocicek Qwen3.6 27B NVFP4 DGX resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    16.245279616,
    0.000000001,
    "ocicek Qwen3.6 27B NVFP4 DGX swept text-decode traffic",
  );
  assertNear(
    result.alloc,
    6.708527104,
    0.000000001,
    "ocicek Qwen3.6 27B NVFP4 BF16 full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    2.252079104,
    0.000000001,
    "ocicek Qwen3.6 27B NVFP4 BF16 full-attention KV plus DeltaNet state read traffic",
  );
  assert.equal(result.bMem, 14);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    14.75886390767903,
    0.000000001,
    "ocicek Qwen3.6 27B NVFP4 DGX single-session tok/s",
  );
  assertNear(
    result.dennard,
    249.10018069734483,
    0.000000001,
    "ocicek Qwen3.6 27B NVFP4 DGX Dennard bound",
  );

  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 6);
  assertNear(
    m5Result.single.aggregate,
    33.193928349138915,
    0.000000001,
    "ocicek Qwen3.6 27B NVFP4 M5 single",
  );
  assertNear(
    m5Result.best.aggregate,
    123.7996647962101,
    0.000000001,
    "ocicek Qwen3.6 27B NVFP4 M5 aggregate",
  );
  assertNear(
    m5Result.best.perSession,
    20.633277466035015,
    0.000000001,
    "ocicek Qwen3.6 27B NVFP4 M5 per-session",
  );

  const m1UltraResult = profiled(repo, "apple-mac-studio-m1-ultra-128gb");
  assert.equal(m1UltraResult.status_code, "ok");
  assert.equal(m1UltraResult.best.batch, 10);
  assertNear(
    m1UltraResult.best.aggregate,
    206.3660274209866,
    0.000000001,
    "ocicek Qwen3.6 27B NVFP4 M1 Ultra aggregate",
  );
  assertNear(
    m1UltraResult.best.perSession,
    20.63660274209866,
    0.000000001,
    "ocicek Qwen3.6 27B NVFP4 M1 Ultra per-session",
  );
}

{
  const modelProfile = profile("deepseek-ai/DeepSeek-Coder-V2-Lite-Instruct");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "deepseek-ai/DeepSeek-Coder-V2-Lite-Instruct",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    31.412968448,
    0.000000001,
    "DeepSeek Coder V2 Lite resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    4.902870016,
    0.000000001,
    "DeepSeek Coder V2 Lite single-token active traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.4194304,
    0.000000001,
    "DeepSeek Coder V2 Lite resident-only input embedding footprint",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    2.203835392,
    0.000000001,
    "DeepSeek Coder V2 Lite fixed ordinary-decode traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.449839104,
    0.000000001,
    "DeepSeek Coder V2 Lite per-expert routed traffic",
  );
  assertNear(
    result.alloc,
    27.648,
    0.000000001,
    "DeepSeek Coder V2 Lite expanded K/V allocation",
  );
  assertNear(
    result.single.readTraffic,
    8.84736,
    0.000000001,
    "DeepSeek Coder V2 Lite expanded K/V read traffic",
  );
  assert.equal(result.bMem, 3);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    19.854213325,
    0.000000001,
    "DeepSeek Coder V2 Lite DGX single-session tok/s",
  );
  assertNear(
    result.dennard,
    178.409795743,
    0.000000001,
    "DeepSeek Coder V2 Lite DGX Dennard bound",
  );
}

{
  const repo = "RedHatAI/DeepSeek-Coder-V2-Lite-Instruct-FP8";
  const catalogRow = model(repo);
  const modelProfile = profile(repo);
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  assert.equal(result.status_code, "ok");
  assert.equal(modelProfile.serving.weight_format, "fp8");
  assert.equal(
    modelProfile.serving.kv_store_format,
    "expanded_bf16_key_value_cache",
  );
  assert.equal(catalogRow.hf_downloads, 245921);
  assertNear(
    catalogRow.adapter.resident_weight_gb,
    16.129490408,
    0.000000001,
    "RedHatAI DeepSeek Coder V2 Lite FP8 catalog resident footprint",
  );
  assertNear(
    catalogRow.adapter.active_weight_gb,
    2.6646898,
    0.000000001,
    "RedHatAI DeepSeek Coder V2 Lite FP8 catalog active traffic",
  );
  assertNear(
    result.resident,
    16.129490408,
    0.000000001,
    "RedHatAI DeepSeek Coder V2 Lite FP8 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    2.6646898,
    0.000000001,
    "RedHatAI DeepSeek Coder V2 Lite FP8 single-token active traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.4194304,
    0.000000001,
    "RedHatAI DeepSeek Coder V2 Lite FP8 resident-only input embedding footprint",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    1.315168744,
    0.000000001,
    "RedHatAI DeepSeek Coder V2 Lite FP8 fixed ordinary-decode traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.224920176,
    0.000000001,
    "RedHatAI DeepSeek Coder V2 Lite FP8 per-expert routed traffic",
  );
  assertNear(
    result.alloc,
    27.648,
    0.000000001,
    "RedHatAI DeepSeek Coder V2 Lite FP8 expanded K/V allocation",
  );
  assertNear(
    result.single.readTraffic,
    8.84736,
    0.000000001,
    "RedHatAI DeepSeek Coder V2 Lite FP8 expanded K/V read traffic",
  );
  assert.equal(result.bMem, 3);
  assert.equal(result.best.batch, 1);
  assertNear(
    result.single.aggregate,
    23.714282403,
    0.000000001,
    "RedHatAI DeepSeek Coder V2 Lite FP8 DGX single-session tok/s",
  );
  assertNear(
    result.dennard,
    384.897002588,
    0.000000001,
    "RedHatAI DeepSeek Coder V2 Lite FP8 DGX Dennard bound",
  );
}

{
  const modelProfile = profile("deepseek-ai/DeepSeek-V2-Lite-Chat");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "deepseek-ai/DeepSeek-V2-Lite-Chat",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    31.412968448,
    0.000000001,
    "DeepSeek V2 Lite Chat resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    4.902870016,
    0.000000001,
    "DeepSeek V2 Lite Chat single-token active traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.4194304,
    0.000000001,
    "DeepSeek V2 Lite Chat resident-only input embedding footprint",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    2.203835392,
    0.000000001,
    "DeepSeek V2 Lite Chat fixed ordinary-decode traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.449839104,
    0.000000001,
    "DeepSeek V2 Lite Chat per-expert routed traffic",
  );
  assertNear(
    result.alloc,
    27.648,
    0.000000001,
    "DeepSeek V2 Lite Chat expanded K/V allocation",
  );
  assertNear(
    result.single.readTraffic,
    8.84736,
    0.000000001,
    "DeepSeek V2 Lite Chat expanded K/V read traffic",
  );
  assert.equal(result.bMem, 3);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    19.854213325,
    0.000000001,
    "DeepSeek V2 Lite Chat DGX single-session tok/s",
  );
  assertNear(
    result.dennard,
    178.409795743,
    0.000000001,
    "DeepSeek V2 Lite Chat DGX Dennard bound",
  );
}

{
  const modelProfile = profile("deepseek-ai/DeepSeek-V2-Lite");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled("deepseek-ai/DeepSeek-V2-Lite", "nvidia-dgx-spark");
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    31.412968448,
    0.000000001,
    "DeepSeek V2 Lite resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    4.902870016,
    0.000000001,
    "DeepSeek V2 Lite single-token active traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.4194304,
    0.000000001,
    "DeepSeek V2 Lite resident-only input embedding footprint",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    2.203835392,
    0.000000001,
    "DeepSeek V2 Lite fixed ordinary-decode traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.449839104,
    0.000000001,
    "DeepSeek V2 Lite per-expert routed traffic",
  );
  assertNear(
    result.alloc,
    27.648,
    0.000000001,
    "DeepSeek V2 Lite expanded K/V allocation",
  );
  assertNear(
    result.single.readTraffic,
    8.84736,
    0.000000001,
    "DeepSeek V2 Lite expanded K/V read traffic",
  );
  assert.equal(result.bMem, 3);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    19.854213325,
    0.000000001,
    "DeepSeek V2 Lite DGX single-session tok/s",
  );
  assertNear(
    result.dennard,
    178.409795743,
    0.000000001,
    "DeepSeek V2 Lite DGX Dennard bound",
  );
}

{
  const modelProfile = profile("deepseek-ai/deepseek-vl2-tiny");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled("deepseek-ai/deepseek-vl2-tiny", "nvidia-dgx-spark");
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    6.74100288,
    0.000000001,
    "DeepSeek VL2 Tiny resident footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    5.53851136,
    0.000000001,
    "DeepSeek VL2 Tiny ordinary text resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.20249152,
    0.000000001,
    "DeepSeek VL2 Tiny resident-only vision/projector/image/input-embedding footprint",
  );
  assertNear(
    result.single.batchWeight,
    1.14825472,
    0.000000001,
    "DeepSeek VL2 Tiny single-token active traffic",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    0.69409024,
    0.000000001,
    "DeepSeek VL2 Tiny fixed ordinary-decode traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.07569408,
    0.000000001,
    "DeepSeek VL2 Tiny per-expert routed traffic",
  );
  assertNear(
    result.alloc,
    6.144,
    0.000000001,
    "DeepSeek VL2 Tiny BF16 MHA K/V allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.96608,
    0.000000001,
    "DeepSeek VL2 Tiny BF16 MHA K/V read traffic",
  );
  assert.equal(result.bMem, 18);
  assert.equal(result.best.batch, 5);
  assertNear(
    result.best.aggregate,
    110.013091595,
    0.000000001,
    "DeepSeek VL2 Tiny DGX aggregate tok/s",
  );
  assertNear(
    result.dennard,
    4382.742068382,
    0.000000001,
    "DeepSeek VL2 Tiny DGX Dennard bound",
  );
}

{
  const modelProfile = profile(
    "nm-testing/SmolLM-1.7B-Instruct-quantized.w4a16",
  );
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "nm-testing/SmolLM-1.7B-Instruct-quantized.w4a16",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    1.711680128,
    0.000000001,
    "SmolLM 1.7B W4A16 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    1.309026944,
    0.000000001,
    "SmolLM 1.7B W4A16 swept text-decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.402653184,
    0.000000001,
    "SmolLM 1.7B W4A16 resident-only input embedding footprint",
  );
  assertNear(
    result.alloc,
    19.6608,
    0.000000001,
    "SmolLM 1.7B W4A16 BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    6.291456,
    0.000000001,
    "SmolLM 1.7B W4A16 BF16 KV read traffic",
  );
  assert.equal(result.bMem, 6);
  assert.equal(result.best.batch, 1);
  assertNear(
    result.best.aggregate,
    35.91877016387657,
    0.000000001,
    "SmolLM 1.7B W4A16 DGX Spark aggregate throughput",
  );
  assertNear(
    result.dennard,
    1254.742877584941,
    0.000000001,
    "SmolLM 1.7B W4A16 DGX Dennard bound",
  );
}

{
  const result = profiled("Qwen/Qwen3.6-35B-A3B", "nvidia-dgx-spark");
  assertNear(
    result.resident,
    71.903645408,
    0.000000001,
    "Qwen3.6 35B A3B resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    5.892859136,
    0.000000001,
    "Qwen3.6 35B A3B single-session decode traffic",
  );
  assertNear(
    result.alloc,
    2.11288064,
    0.000000001,
    "Qwen3.6 35B A3B full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.72024064,
    0.000000001,
    "Qwen3.6 35B A3B full-attention KV plus DeltaNet state read traffic",
  );
}

{
  const modelProfile = profile("QuantTrio/Qwen3.6-35B-A3B-AWQ");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled("QuantTrio/Qwen3.6-35B-A3B-AWQ", "nvidia-dgx-spark");
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    25.44858288,
    0.000000001,
    "QuantTrio Qwen3.6 35B A3B AWQ resident footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    21.849040128,
    0.000000001,
    "QuantTrio Qwen3.6 35B A3B AWQ ordinary text main package",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    3.599542752,
    0.000000001,
    "QuantTrio Qwen3.6 35B A3B AWQ resident-only visual/MTP/input package",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    3.921536256,
    0.000000001,
    "QuantTrio Qwen3.6 35B A3B AWQ fixed text traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.070029312,
    0.000000001,
    "QuantTrio Qwen3.6 35B A3B AWQ routed expert group traffic",
  );
  assertNear(
    result.single.batchWeight,
    4.481770752,
    0.000000001,
    "QuantTrio Qwen3.6 35B A3B AWQ single-session decode traffic",
  );
  assertNear(
    result.alloc,
    2.11288064,
    0.000000001,
    "QuantTrio Qwen3.6 35B A3B AWQ full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.72024064,
    0.000000001,
    "QuantTrio Qwen3.6 35B A3B AWQ full-attention KV plus DeltaNet state read traffic",
  );
  assert.equal(result.bMem, 44);
  assert.equal(result.best.batch, 7);
  assertNear(
    result.best.aggregate,
    152.4437709472079,
    0.000000001,
    "QuantTrio Qwen3.6 35B A3B AWQ DGX aggregate tok/s at b*",
  );
  assertNear(
    result.best.perSession,
    21.77768156388684,
    0.000000001,
    "QuantTrio Qwen3.6 35B A3B AWQ DGX per-session tok/s at b*",
  );
  assertNear(
    result.dennard,
    2725.8759476324717,
    0.000000001,
    "QuantTrio Qwen3.6 35B A3B AWQ DGX Dennard bound",
  );
}

{
  const modelProfile = profile("palmfuture/Qwen3.6-35B-A3B-GPTQ-Int4");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "palmfuture/Qwen3.6-35B-A3B-GPTQ-Int4",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    24.403152608,
    0.000000001,
    "palmfuture Qwen3.6 35B A3B GPTQ resident footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    20.803609856,
    0.000000001,
    "palmfuture Qwen3.6 35B A3B GPTQ ordinary text main package",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    3.599542752,
    0.000000001,
    "palmfuture Qwen3.6 35B A3B GPTQ resident-only visual/MTP/input package",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    3.879593216,
    0.000000001,
    "palmfuture Qwen3.6 35B A3B GPTQ fixed text traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.06610944,
    0.000000001,
    "palmfuture Qwen3.6 35B A3B GPTQ routed expert group traffic",
  );
  assertNear(
    result.single.batchWeight,
    4.408468736,
    0.000000001,
    "palmfuture Qwen3.6 35B A3B GPTQ single-session decode traffic",
  );
  assertNear(
    result.alloc,
    1.08888064,
    0.000000001,
    "palmfuture Qwen3.6 35B A3B GPTQ FP8 KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.39256064,
    0.000000001,
    "palmfuture Qwen3.6 35B A3B GPTQ FP8 KV plus DeltaNet state read traffic",
  );
  assert.equal(result.bMem, 87);
  assert.equal(result.best.batch, 11);
  assertNear(
    result.best.aggregate,
    227.73282100426647,
    0.000000001,
    "palmfuture Qwen3.6 35B A3B GPTQ DGX aggregate tok/s at b*",
  );
  assertNear(
    result.best.perSession,
    20.702983727660587,
    0.000000001,
    "palmfuture Qwen3.6 35B A3B GPTQ DGX per-session tok/s at b*",
  );
  assertNear(
    result.dennard,
    5436.735137096732,
    0.000000001,
    "palmfuture Qwen3.6 35B A3B GPTQ DGX Dennard bound",
  );
}

{
  const modelProfile = profile("unsloth/Qwen3.6-35B-A3B-GGUF");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled("unsloth/Qwen3.6-35B-A3B-GGUF", "nvidia-dgx-spark");
  assert.equal(
    result.status_code,
    "ok",
    "Qwen3.6 35B A3B MXFP4_MOE GGUF should fit DGX Spark and meet the 20 tok/s floor",
  );
  assertNear(
    result.resident,
    21.706144736,
    0.000000001,
    "Qwen3.6 35B A3B MXFP4_MOE GGUF resident file footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    21.154810368,
    0.000000001,
    "Qwen3.6 35B A3B MXFP4_MOE GGUF main resident routed/fixed footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.551334368,
    0.000000001,
    "Qwen3.6 35B A3B MXFP4_MOE GGUF resident-only token embedding plus header footprint",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    2.137836032,
    0.000000001,
    "Qwen3.6 35B A3B MXFP4_MOE GGUF fixed ordinary text-decode traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.074285056,
    0.000000001,
    "Qwen3.6 35B A3B MXFP4_MOE GGUF routed expert byte group",
  );
  assertNear(
    result.single.batchWeight,
    2.73211648,
    0.000000001,
    "Qwen3.6 35B A3B MXFP4_MOE GGUF single-session decode traffic",
  );
  assertNear(
    result.alloc,
    2.11288064,
    0.000000001,
    "Qwen3.6 35B A3B MXFP4_MOE GGUF hybrid KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.72024064,
    0.000000001,
    "Qwen3.6 35B A3B MXFP4_MOE GGUF hybrid KV plus DeltaNet state read traffic",
  );
  assertNear(
    result.single.aggregate,
    79.07640794704344,
    0.000000001,
    "Qwen3.6 35B A3B MXFP4_MOE GGUF DGX single-session tok/s",
  );
  assert.equal(result.bMem, 46);
  assert.equal(result.best.batch, 9);
  assertNear(
    result.best.aggregate,
    184.09328113719152,
    0.000000001,
    "Qwen3.6 35B A3B MXFP4_MOE GGUF DGX aggregate tok/s at b*",
  );
  assertNear(
    result.dennard,
    4648.521474227382,
    0.000000001,
    "Qwen3.6 35B A3B MXFP4_MOE GGUF DGX Dennard bound",
  );
}

{
  const repo = "unsloth/Qwen3.5-35B-A3B-GGUF";
  const modelProfile = profile(repo);
  const modelRow = model(repo);
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const dgxResult = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");

  assert.equal(modelProfile.status, "audited");
  assert.equal(modelRow.hf_downloads, 150052);
  assert.ok(modelRow.tags.includes("region:us"));
  assert.equal(modelRow.architecture.detail, "qwen35moe / qwen3_5_moe_text");
  assert.equal(modelRow.architecture.total_params_b, 34.660610688);
  assert.equal(modelRow.architecture.shared_experts_per_token, 1);
  assert.equal(modelRow.adapter.weight_precision, "GGUF MXFP4_MOE");
  assert.equal(modelRow.adapter.active_weight_gb, 2.717223424);
  assert.equal(
    dgxResult.status_code,
    "ok",
    "Qwen3.5 35B A3B MXFP4_MOE GGUF should fit DGX Spark and meet the 20 tok/s floor",
  );
  assertNear(
    dgxResult.resident,
    21.587638912,
    0.000000001,
    "Qwen3.5 35B A3B MXFP4_MOE GGUF resident file footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    21.036304896,
    0.000000001,
    "Qwen3.5 35B A3B MXFP4_MOE GGUF main resident routed/fixed footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.551334016,
    0.000000001,
    "Qwen3.5 35B A3B MXFP4_MOE GGUF resident-only token embedding plus header footprint",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    2.126285312,
    0.000000001,
    "Qwen3.5 35B A3B MXFP4_MOE GGUF fixed ordinary text-decode traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.073867264,
    0.000000001,
    "Qwen3.5 35B A3B MXFP4_MOE GGUF routed expert byte group",
  );
  assertNear(
    dgxResult.single.batchWeight,
    2.717223424,
    0.000000001,
    "Qwen3.5 35B A3B MXFP4_MOE GGUF single-session decode traffic",
  );
  assertNear(
    dgxResult.alloc,
    2.11288064,
    0.000000001,
    "Qwen3.5 35B A3B MXFP4_MOE GGUF hybrid KV plus DeltaNet state allocation",
  );
  assertNear(
    dgxResult.single.readTraffic,
    0.72024064,
    0.000000001,
    "Qwen3.5 35B A3B MXFP4_MOE GGUF hybrid KV plus DeltaNet state read traffic",
  );
  assertNear(
    dgxResult.single.aggregate,
    79.41901207319793,
    0.000000001,
    "Qwen3.5 35B A3B MXFP4_MOE GGUF DGX single-session tok/s",
  );
  assert.equal(dgxResult.bMem, 46);
  assert.equal(dgxResult.best.batch, 9);
  assertNear(
    dgxResult.best.aggregate,
    184.6207758655113,
    0.000000001,
    "Qwen3.5 35B A3B MXFP4_MOE GGUF DGX aggregate tok/s at b*",
  );
  assertNear(
    dgxResult.best.perSession,
    20.513419540612365,
    0.000000001,
    "Qwen3.5 35B A3B MXFP4_MOE GGUF DGX per-session tok/s at b*",
  );
  assertNear(
    dgxResult.dennard,
    4679.63504763545,
    0.000000001,
    "Qwen3.5 35B A3B MXFP4_MOE GGUF DGX Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 25);
  assertNear(
    m5Result.best.aggregate,
    503.41152776141604,
    0.000000001,
    "Qwen3.5 35B A3B MXFP4_MOE GGUF M5 Max aggregate tok/s at b*",
  );
  assertNear(
    m5Result.best.perSession,
    20.13646111045664,
    0.000000001,
    "Qwen3.5 35B A3B MXFP4_MOE GGUF M5 Max per-session tok/s at b*",
  );
}

{
  const repo = "Hcompany/Holo-3.1-35B-A3B-GGUF";
  const modelProfile = profile(repo);
  const modelRow = model(repo);
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const dgxResult = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");

  assert.equal(modelProfile.status, "audited");
  assert.equal(modelRow.hf_downloads, 191258);
  assert.ok(modelRow.tags.includes("region:us"));
  assert.equal(modelRow.architecture.detail, "qwen35moe / qwen3_5_moe_text");
  assert.equal(modelRow.architecture.shared_experts_per_token, 1);
  assert.equal(modelRow.adapter.weight_precision, "GGUF BF16/F32");
  assert.equal(modelRow.adapter.active_weight_gb, 5.937285632);
  assert.equal(
    dgxResult.status_code,
    "ok",
    "Holo 3.1 35B A3B BF16 GGUF should fit DGX Spark and meet the 20 tok/s floor",
  );
  assertNear(
    dgxResult.resident,
    69.376637024,
    0.000000001,
    "Holo 3.1 35B A3B BF16 GGUF resident file footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    68.348529152,
    0.000000001,
    "Holo 3.1 35B A3B BF16 GGUF ordinary resident routed/fixed footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.028107872,
    0.000000001,
    "Holo 3.1 35B A3B BF16 GGUF resident-only token embedding plus header footprint",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    3.924019712,
    0.000000001,
    "Holo 3.1 35B A3B BF16 GGUF fixed ordinary text-decode traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.25165824,
    0.000000001,
    "Holo 3.1 35B A3B BF16 GGUF routed expert byte group",
  );
  assertNear(
    dgxResult.single.batchWeight,
    5.937285632,
    0.000000001,
    "Holo 3.1 35B A3B BF16 GGUF single-session decode traffic",
  );
  assertNear(
    dgxResult.alloc,
    2.11288064,
    0.000000001,
    "Holo 3.1 35B A3B BF16 GGUF hybrid KV plus DeltaNet state allocation",
  );
  assertNear(
    dgxResult.single.readTraffic,
    0.72024064,
    0.000000001,
    "Holo 3.1 35B A3B BF16 GGUF hybrid KV plus DeltaNet state read traffic",
  );
  assertNear(
    dgxResult.single.aggregate,
    41.00622195787258,
    0.000000001,
    "Holo 3.1 35B A3B BF16 GGUF DGX single-session tok/s",
  );
  assert.equal(dgxResult.bMem, 23);
  assert.equal(dgxResult.best.batch, 3);
  assertNear(
    dgxResult.best.aggregate,
    68.60582530209696,
    0.000000001,
    "Holo 3.1 35B A3B BF16 GGUF DGX aggregate tok/s at b*",
  );
  assertNear(
    dgxResult.best.perSession,
    22.86860843403232,
    0.000000001,
    "Holo 3.1 35B A3B BF16 GGUF DGX per-session tok/s at b*",
  );
  assertNear(
    dgxResult.dennard,
    1101.6679963092402,
    0.000000001,
    "Holo 3.1 35B A3B BF16 GGUF DGX Dennard bound",
  );
  assert.equal(m5Result.best.batch, 10);
  assertNear(
    m5Result.best.aggregate,
    214.29995859368927,
    0.000000001,
    "Holo 3.1 35B A3B BF16 GGUF M5 Max aggregate tok/s at b*",
  );
}

{
  const repo = "llmfan46/Qwen3.6-35B-A3B-uncensored-heretic-GGUF";
  const modelProfile = profile(repo);
  const modelRow = model(repo);
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const dgxResult = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");

  assert.equal(modelProfile.status, "audited");
  assert.equal(modelRow.hf_downloads, 145539);
  assert.ok(modelRow.tags.includes("region:us"));
  assert.equal(modelRow.architecture.detail, "qwen35moe / qwen3_5_moe_text");
  assert.equal(modelRow.architecture.total_params_b, 34.660610688);
  assert.equal(modelRow.architecture.shared_experts_per_token, 1);
  assert.equal(modelRow.adapter.weight_precision, "GGUF BF16/F32");
  assert.equal(modelRow.adapter.active_weight_gb, 5.937285632);
  assert.equal(
    dgxResult.status_code,
    "ok",
    "llmfan46 Qwen3.6 35B A3B Heretic BF16 GGUF should fit DGX Spark and meet the 20 tok/s floor",
  );
  assertNear(
    dgxResult.resident,
    69.376641152,
    0.000000001,
    "llmfan46 Qwen3.6 35B A3B Heretic BF16 GGUF resident file footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    68.348529152,
    0.000000001,
    "llmfan46 Qwen3.6 35B A3B Heretic BF16 GGUF ordinary resident routed/fixed footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.028112,
    0.000000001,
    "llmfan46 Qwen3.6 35B A3B Heretic BF16 GGUF resident-only token embedding plus header footprint",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    3.924019712,
    0.000000001,
    "llmfan46 Qwen3.6 35B A3B Heretic BF16 GGUF fixed ordinary text-decode traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.25165824,
    0.000000001,
    "llmfan46 Qwen3.6 35B A3B Heretic BF16 GGUF routed expert byte group",
  );
  assertNear(
    dgxResult.single.batchWeight,
    5.937285632,
    0.000000001,
    "llmfan46 Qwen3.6 35B A3B Heretic BF16 GGUF single-session decode traffic",
  );
  assertNear(
    dgxResult.alloc,
    2.11288064,
    0.000000001,
    "llmfan46 Qwen3.6 35B A3B Heretic BF16 GGUF hybrid KV plus DeltaNet state allocation",
  );
  assertNear(
    dgxResult.single.readTraffic,
    0.72024064,
    0.000000001,
    "llmfan46 Qwen3.6 35B A3B Heretic BF16 GGUF hybrid KV plus DeltaNet state read traffic",
  );
  assertNear(
    dgxResult.single.aggregate,
    41.00622195787258,
    0.000000001,
    "llmfan46 Qwen3.6 35B A3B Heretic BF16 GGUF DGX single-session tok/s",
  );
  assert.equal(dgxResult.bMem, 23);
  assert.equal(dgxResult.best.batch, 3);
  assertNear(
    dgxResult.best.aggregate,
    68.60582530209696,
    0.000000001,
    "llmfan46 Qwen3.6 35B A3B Heretic BF16 GGUF DGX aggregate tok/s at b*",
  );
  assertNear(
    dgxResult.best.perSession,
    22.86860843403232,
    0.000000001,
    "llmfan46 Qwen3.6 35B A3B Heretic BF16 GGUF DGX per-session tok/s at b*",
  );
  assertNear(
    dgxResult.dennard,
    1101.6679064755108,
    0.000000001,
    "llmfan46 Qwen3.6 35B A3B Heretic BF16 GGUF DGX Dennard bound",
  );
  assert.equal(m5Result.best.batch, 10);
  assertNear(
    m5Result.best.aggregate,
    214.29995859368927,
    0.000000001,
    "llmfan46 Qwen3.6 35B A3B Heretic BF16 GGUF M5 Max aggregate tok/s at b*",
  );
  assertNear(
    m5Result.best.perSession,
    21.429995859368926,
    0.000000001,
    "llmfan46 Qwen3.6 35B A3B Heretic BF16 GGUF M5 Max per-session tok/s at b*",
  );
}

{
  const repo = "unsloth/Qwen-AgentWorld-35B-A3B-GGUF";
  const modelProfile = profile(repo);
  const modelRow = model(repo);
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const dgxResult = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");

  assert.equal(modelProfile.status, "audited");
  assert.equal(modelRow.name, "Qwen-AgentWorld-35B-A3B-GGUF GGUF MXFP4_MOE");
  assert.equal(modelRow.hf_downloads, 349969);
  assert.ok(modelRow.tags.includes("region:us"));
  assert.equal(modelRow.architecture.shared_experts_per_token, 1);
  assert.equal(modelRow.adapter.weight_precision, "GGUF MXFP4_MOE");
  assert.equal(modelRow.adapter.active_weight_gb, 2.731002368);
  assert.equal(
    dgxResult.status_code,
    "ok",
    "Qwen AgentWorld 35B A3B MXFP4_MOE GGUF should fit DGX Spark and meet the 20 tok/s floor",
  );
  assertNear(
    dgxResult.resident,
    21.67049344,
    0.000000001,
    "Qwen AgentWorld 35B A3B MXFP4_MOE GGUF resident file footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    21.119158784,
    0.000000001,
    "Qwen AgentWorld 35B A3B MXFP4_MOE GGUF main resident routed/fixed footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.551334656,
    0.000000001,
    "Qwen AgentWorld 35B A3B MXFP4_MOE GGUF resident-only token embedding plus header footprint",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    2.137836032,
    0.000000001,
    "Qwen AgentWorld 35B A3B MXFP4_MOE GGUF fixed ordinary text-decode traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.074145792,
    0.000000001,
    "Qwen AgentWorld 35B A3B MXFP4_MOE GGUF routed expert byte group",
  );
  assertNear(
    dgxResult.single.batchWeight,
    2.731002368,
    0.000000001,
    "Qwen AgentWorld 35B A3B MXFP4_MOE GGUF single-session decode traffic",
  );
  assertNear(
    dgxResult.alloc,
    2.11288064,
    0.000000001,
    "Qwen AgentWorld 35B A3B MXFP4_MOE GGUF hybrid KV plus DeltaNet state allocation",
  );
  assertNear(
    dgxResult.single.readTraffic,
    0.72024064,
    0.000000001,
    "Qwen AgentWorld 35B A3B MXFP4_MOE GGUF hybrid KV plus DeltaNet state read traffic",
  );
  assertNear(
    dgxResult.single.aggregate,
    79.101934974496,
    0.000000001,
    "Qwen AgentWorld 35B A3B MXFP4_MOE GGUF DGX single-session tok/s",
  );
  assert.equal(dgxResult.bMem, 46);
  assert.equal(dgxResult.best.batch, 9);
  assertNear(
    dgxResult.best.aggregate,
    184.21558370302606,
    0.000000001,
    "Qwen AgentWorld 35B A3B MXFP4_MOE GGUF DGX aggregate tok/s at b*",
  );
  assertNear(
    dgxResult.best.perSession,
    20.468398189225116,
    0.000000001,
    "Qwen AgentWorld 35B A3B MXFP4_MOE GGUF DGX per-session tok/s at b*",
  );
  assert.equal(m5Result.best.batch, 25);
  assertNear(
    m5Result.best.aggregate,
    502.57730296975626,
    0.000000001,
    "Qwen AgentWorld 35B A3B MXFP4_MOE GGUF M5 Max aggregate tok/s at b*",
  );
}

{
  const modelProfile = profile("lmstudio-community/Qwen3.6-35B-A3B-GGUF");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "lmstudio-community/Qwen3.6-35B-A3B-GGUF",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "lmstudio-community/Qwen3.6-35B-A3B-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(
    result.status_code,
    "ok",
    "LM Studio Qwen3.6 35B A3B Q4_K_M GGUF should fit DGX Spark and meet the 20 tok/s floor",
  );
  assertNear(
    result.resident,
    21.166757728,
    0.000000001,
    "LM Studio Qwen3.6 35B A3B Q4_K_M GGUF resident file footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    20.869704192,
    0.000000001,
    "LM Studio Qwen3.6 35B A3B Q4_K_M ordinary resident routed/fixed footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.297053536,
    0.000000001,
    "LM Studio Qwen3.6 35B A3B Q4_K_M resident-only token embedding plus header footprint",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    1.366190592,
    0.000000001,
    "LM Studio Qwen3.6 35B A3B Q4_K_M fixed ordinary text-decode traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.0761856,
    0.000000001,
    "LM Studio Qwen3.6 35B A3B Q4_K_M routed expert byte group",
  );
  assertNear(
    result.single.batchWeight,
    1.975675392,
    0.000000001,
    "LM Studio Qwen3.6 35B A3B Q4_K_M single-session decode traffic",
  );
  assertNear(
    result.alloc,
    2.11288064,
    0.000000001,
    "LM Studio Qwen3.6 35B A3B Q4_K_M hybrid KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.72024064,
    0.000000001,
    "LM Studio Qwen3.6 35B A3B Q4_K_M hybrid KV plus DeltaNet state read traffic",
  );
  assertNear(
    result.single.aggregate,
    101.26428151305271,
    0.000000001,
    "LM Studio Qwen3.6 35B A3B Q4_K_M DGX single-session tok/s",
  );
  assert.equal(result.bMem, 46);
  assert.equal(result.best.batch, 9);
  assertNear(
    result.best.aggregate,
    193.5289635546981,
    0.000000001,
    "LM Studio Qwen3.6 35B A3B Q4_K_M DGX aggregate tok/s at b*",
  );
  assertNear(
    result.dennard,
    6463.609872076501,
    0.000000001,
    "LM Studio Qwen3.6 35B A3B Q4_K_M DGX Dennard bound",
  );
  assert.equal(m5Result.best.batch, 25);
  assertNear(
    m5Result.best.aggregate,
    510.69640647798946,
    0.000000001,
    "LM Studio Qwen3.6 35B A3B Q4_K_M M5 Max aggregate",
  );
  assertNear(
    m5Result.best.perSession,
    20.42785625911958,
    0.000000001,
    "LM Studio Qwen3.6 35B A3B Q4_K_M M5 Max per-session",
  );
}

{
  const repo = "bartowski/Qwen_Qwen3.6-35B-A3B-GGUF";
  const catalogRow = model(repo);
  const modelProfile = profile(repo);
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  assert.equal(catalogRow.hf_downloads, 120082);
  assert.equal(catalogRow.architecture.detail, "qwen35moe / qwen3_5_moe_text");
  assert.equal(catalogRow.architecture.shared_experts_per_token, 1);
  assert.equal(catalogRow.adapter.weight_precision, "GGUF IQ1_M");
  assert.equal(
    modelProfile.serving.runtime_format,
    "llama.cpp-gguf-iq1-m-mtp-memory-bound",
  );
  assert.equal(
    result.status_code,
    "ok",
    "Bartowski Qwen3.6 35B A3B IQ1_M GGUF should fit DGX Spark and meet the 20 tok/s floor",
  );
  assertNear(
    result.resident,
    9.421649536,
    0.000000001,
    "Bartowski Qwen3.6 35B A3B IQ1_M GGUF resident file footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    8.345831936,
    0.000000001,
    "Bartowski Qwen3.6 35B A3B IQ1_M ordinary resident routed/fixed footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.0758176,
    0.000000001,
    "Bartowski Qwen3.6 35B A3B IQ1_M resident-only token embedding plus MTP/header footprint",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    1.205029376,
    0.000000001,
    "Bartowski Qwen3.6 35B A3B IQ1_M fixed ordinary text-decode traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.02789376,
    0.000000001,
    "Bartowski Qwen3.6 35B A3B IQ1_M routed expert byte group",
  );
  assertNear(
    result.single.batchWeight,
    1.428179456,
    0.000000001,
    "Bartowski Qwen3.6 35B A3B IQ1_M single-session decode traffic",
  );
  assertNear(
    result.alloc,
    2.11288064,
    0.000000001,
    "Bartowski Qwen3.6 35B A3B IQ1_M hybrid KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.72024064,
    0.000000001,
    "Bartowski Qwen3.6 35B A3B IQ1_M hybrid KV plus DeltaNet state read traffic",
  );
  assertNear(
    result.single.aggregate,
    127.07012027502466,
    0.000000001,
    "Bartowski Qwen3.6 35B A3B IQ1_M DGX single-session tok/s",
  );
  assert.equal(result.bMem, 52);
  assert.equal(result.best.batch, 13);
  assertNear(
    result.best.aggregate,
    273.3595895677669,
    0.000000001,
    "Bartowski Qwen3.6 35B A3B IQ1_M DGX aggregate tok/s at b*",
  );
  assertNear(
    result.dennard,
    10004.030539611478,
    0.000000001,
    "Bartowski Qwen3.6 35B A3B IQ1_M DGX Dennard bound",
  );
  assert.equal(m5Result.best.batch, 34);
  assertNear(
    m5Result.best.aggregate,
    686.5364323678818,
    0.000000001,
    "Bartowski Qwen3.6 35B A3B IQ1_M M5 Max aggregate",
  );
  assertNear(
    m5Result.best.perSession,
    20.192248010820055,
    0.000000001,
    "Bartowski Qwen3.6 35B A3B IQ1_M M5 Max per-session",
  );
}

{
  const repo = "deepreinforce-ai/Ornith-1.0-35B-GGUF";
  const catalogRow = model(repo);
  const modelProfile = profile(repo);
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  assert.equal(catalogRow.hf_downloads, 436780);
  assert.equal(catalogRow.architecture.detail, "qwen35moe / qwen3_5_moe_text");
  assert.equal(catalogRow.architecture.shared_experts_per_token, 1);
  assert.equal(modelProfile.serving.weight_format, "bf16");
  assert.equal(modelProfile.serving.kv_store_format, "fp16");
  assert.equal(
    result.status_code,
    "ok",
    "Ornith 1.0 35B BF16 GGUF should fit DGX Spark and meet the 20 tok/s floor",
  );
  assertNear(
    result.resident,
    69.3766368,
    0.000000001,
    "Ornith 1.0 35B BF16 GGUF resident file footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    68.348529152,
    0.000000001,
    "Ornith 1.0 35B BF16 GGUF ordinary resident routed/fixed footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.028107648,
    0.000000001,
    "Ornith 1.0 35B BF16 GGUF resident-only token embedding plus header footprint",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    3.924019712,
    0.000000001,
    "Ornith 1.0 35B BF16 GGUF fixed ordinary text-decode traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.25165824,
    0.000000001,
    "Ornith 1.0 35B BF16 GGUF routed expert byte group",
  );
  assertNear(
    result.single.batchWeight,
    5.937285632,
    0.000000001,
    "Ornith 1.0 35B BF16 GGUF single-session decode traffic",
  );
  assertNear(
    result.alloc,
    2.11288064,
    0.000000001,
    "Ornith 1.0 35B BF16 GGUF hybrid KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.72024064,
    0.000000001,
    "Ornith 1.0 35B BF16 GGUF hybrid KV plus DeltaNet state read traffic",
  );
  assertNear(
    result.single.aggregate,
    41.00622195787258,
    0.000000001,
    "Ornith 1.0 35B BF16 GGUF DGX single-session tok/s",
  );
  assert.equal(result.bMem, 23);
  assert.equal(result.best.batch, 3);
  assertNear(
    result.best.aggregate,
    68.60582530209696,
    0.000000001,
    "Ornith 1.0 35B BF16 GGUF DGX aggregate tok/s at b*",
  );
  assertNear(
    result.dennard,
    1101.6680011839387,
    0.000000001,
    "Ornith 1.0 35B BF16 GGUF DGX Dennard bound",
  );
  assert.equal(m5Result.best.batch, 10);
  assertNear(
    m5Result.best.aggregate,
    214.29995859368927,
    0.000000001,
    "Ornith 1.0 35B BF16 GGUF M5 Max aggregate",
  );
  assertNear(
    m5Result.best.perSession,
    21.429995859368926,
    0.000000001,
    "Ornith 1.0 35B BF16 GGUF M5 Max per-session",
  );
}

{
  const modelProfile = profile("unsloth/Qwen3.6-35B-A3B-MTP-GGUF");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "unsloth/Qwen3.6-35B-A3B-MTP-GGUF",
    "nvidia-dgx-spark",
  );
  assert.equal(
    result.status_code,
    "ok",
    "Qwen3.6 35B A3B MTP UD-Q4_K_XL GGUF should fit DGX Spark and clear the single-session floor",
  );
  assertNear(
    result.resident,
    22.853663008,
    0.000000001,
    "Qwen3.6 35B A3B MTP UD-Q4_K_XL GGUF resident file footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    21.773470208,
    0.000000001,
    "Qwen3.6 35B A3B MTP UD-Q4_K_XL ordinary resident routed/fixed footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.0801928,
    0.000000001,
    "Qwen3.6 35B A3B MTP UD-Q4_K_XL resident-only token embedding plus MTP/header footprint",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    2.137836032,
    0.000000001,
    "Qwen3.6 35B A3B MTP UD-Q4_K_XL fixed ordinary text-decode traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.076701696,
    0.000000001,
    "Qwen3.6 35B A3B MTP UD-Q4_K_XL routed expert byte group",
  );
  assertNear(
    result.single.batchWeight,
    2.7514496,
    0.000000001,
    "Qwen3.6 35B A3B MTP UD-Q4_K_XL single-session decode traffic",
  );
  assertNear(
    result.alloc,
    2.11288064,
    0.000000001,
    "Qwen3.6 35B A3B MTP UD-Q4_K_XL hybrid KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.72024064,
    0.000000001,
    "Qwen3.6 35B A3B MTP UD-Q4_K_XL hybrid KV plus DeltaNet state read traffic",
  );
  assertNear(
    result.single.aggregate,
    78.63604789809818,
    0.000000001,
    "Qwen3.6 35B A3B MTP UD-Q4_K_XL DGX single-session tok/s",
  );
  assert.equal(result.bMem, 45);
  assert.equal(result.best.batch, 9);
  assertNear(
    result.best.aggregate,
    181.9965370788121,
    0.000000001,
    "Qwen3.6 35B A3B MTP UD-Q4_K_XL DGX aggregate tok/s at b*",
  );
  assertNear(
    result.dennard,
    4561.971323762485,
    0.000000001,
    "Qwen3.6 35B A3B MTP UD-Q4_K_XL DGX Dennard bound",
  );
}

{
  const modelProfile = profile("unsloth/Qwen3.6-27B-MTP-GGUF");
  const result = profiled("unsloth/Qwen3.6-27B-MTP-GGUF", "nvidia-dgx-spark");
  assert.equal(
    result.status_code,
    "no_floor",
    "Qwen3.6 27B MTP UD-Q4_K_XL GGUF should fit DGX Spark but miss the 20 tok/s floor",
  );
  assertNear(
    result.resident,
    17.9090976,
    0.000000001,
    "Qwen3.6 27B MTP UD-Q4_K_XL GGUF resident file footprint",
  );
  assertNear(
    result.single.batchWeight,
    16.916391936,
    0.000000001,
    "Qwen3.6 27B MTP UD-Q4_K_XL GGUF ordinary swept text-decode traffic",
  );
  assertNear(
    modelProfile.architecture.weight_adapter.auxiliary_resident_weight_gb,
    0.992705664,
    0.000000001,
    "Qwen3.6 27B MTP UD-Q4_K_XL resident-only token embedding plus MTP/header footprint",
  );
  assertNear(
    result.alloc,
    6.708527104,
    0.000000001,
    "Qwen3.6 27B MTP UD-Q4_K_XL Qwen3.6 hybrid KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    2.252079104,
    0.000000001,
    "Qwen3.6 27B MTP UD-Q4_K_XL Qwen3.6 hybrid KV plus DeltaNet state read traffic",
  );
  assertNear(
    result.single.aggregate,
    14.242137489,
    0.000000001,
    "Qwen3.6 27B MTP UD-Q4_K_XL DGX single-session tok/s",
  );
  assert.equal(result.bMem, 15);
  assert.equal(result.best, null);
  assertNear(
    result.dennard,
    245.592314594,
    0.000000001,
    "Qwen3.6 27B MTP UD-Q4_K_XL DGX Dennard bound",
  );
}

{
  const modelProfile = profile("Jackrong/Qwopus3.6-27B-Coder-MTP-GGUF");
  const result = profiled(
    "Jackrong/Qwopus3.6-27B-Coder-MTP-GGUF",
    "nvidia-dgx-spark",
  );
  assert.equal(
    result.status_code,
    "no_floor",
    "Jackrong Qwopus3.6 27B Coder MTP Q5_K_M should fit DGX Spark but miss the 20 tok/s floor",
  );
  assertNear(
    result.resident,
    19.535698496,
    0.000000001,
    "Jackrong Qwopus3.6 27B Coder MTP Q5_K_M resident file footprint",
  );
  assertNear(
    result.single.batchWeight,
    18.346018816,
    0.000000001,
    "Jackrong Qwopus3.6 27B Coder MTP Q5_K_M ordinary swept text-decode traffic",
  );
  assertNear(
    modelProfile.architecture.weight_adapter.auxiliary_resident_weight_gb,
    1.18967968,
    0.000000001,
    "Jackrong Qwopus3.6 27B Coder MTP Q5_K_M resident-only token embedding plus MTP/header footprint",
  );
  assertNear(
    result.alloc,
    6.708527104,
    0.000000001,
    "Jackrong Qwopus3.6 27B Coder MTP Q5_K_M hybrid KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    2.252079104,
    0.000000001,
    "Jackrong Qwopus3.6 27B Coder MTP Q5_K_M hybrid KV plus DeltaNet state read traffic",
  );
  assertNear(
    result.single.aggregate,
    13.25365094681519,
    0.000000001,
    "Jackrong Qwopus3.6 27B Coder MTP Q5_K_M DGX single-session tok/s",
  );
  assert.equal(result.bMem, 14);
  assert.equal(result.best, null);
  assertNear(
    result.dennard,
    222.8462871897437,
    0.000000001,
    "Jackrong Qwopus3.6 27B Coder MTP Q5_K_M DGX Dennard bound",
  );

  const m5Result = profiled(
    "Jackrong/Qwopus3.6-27B-Coder-MTP-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 5);
  assertNear(
    m5Result.single.aggregate,
    29.808577587342587,
    0.000000001,
    "Jackrong Qwopus3.6 27B Coder MTP Q5_K_M M5 single-session tok/s",
  );
  assertNear(
    m5Result.best.aggregate,
    103.69374572546683,
    0.000000001,
    "Jackrong Qwopus3.6 27B Coder MTP Q5_K_M M5 aggregate tok/s at b*",
  );
  assertNear(
    m5Result.best.perSession,
    20.738749145093365,
    0.000000001,
    "Jackrong Qwopus3.6 27B Coder MTP Q5_K_M M5 per-session tok/s at b*",
  );
  assertNear(
    m5Result.dennard,
    501.2000744853576,
    0.000000001,
    "Jackrong Qwopus3.6 27B Coder MTP Q5_K_M M5 Dennard bound",
  );
}

{
  const modelProfile = profile("Jackrong/Qwopus3.6-27B-Coder-Compat-MTP-GGUF");
  const modelRow = model("Jackrong/Qwopus3.6-27B-Coder-Compat-MTP-GGUF");
  const result = profiled(
    "Jackrong/Qwopus3.6-27B-Coder-Compat-MTP-GGUF",
    "nvidia-dgx-spark",
  );
  assert.equal(modelProfile.status, "audited");
  assert.equal(
    modelProfile.serving.runtime_format,
    "llama.cpp-gguf-q4-k-m-coder-compat-mtp-memory-bound",
  );
  assert.equal(
    modelRow.name,
    "Qwopus3.6-27B-Coder-Compat-MTP-GGUF GGUF Q4_K_M",
  );
  assert.equal(modelRow.hf_downloads, 322097);
  assert.equal(modelRow.tags.includes("region:us"), true);
  assert.equal(
    modelRow.architecture.detail,
    "qwen35 GGUF (Qwen3_5ForConditionalGeneration + MTP)",
  );
  assert.equal(modelRow.architecture.total_params_b, 27.320697856);
  assert.equal(modelRow.architecture.active_params_b, 25.624600064);
  assert.equal(modelRow.adapter.weight_precision, "GGUF Q4_K_M");
  assert.equal(
    result.status_code,
    "no_floor",
    "Jackrong Qwopus3.6 27B Coder Compat MTP Q4_K_M should fit DGX Spark but miss the 20 tok/s floor",
  );
  assertNear(
    result.resident,
    16.810710112,
    0.000000001,
    "Jackrong Qwopus3.6 27B Coder Compat MTP Q4_K_M resident file footprint",
  );
  assertNear(
    result.single.batchWeight,
    15.821244416,
    0.000000001,
    "Jackrong Qwopus3.6 27B Coder Compat MTP Q4_K_M ordinary swept text-decode traffic",
  );
  assertNear(
    modelProfile.architecture.weight_adapter.auxiliary_resident_weight_gb,
    0.989465696,
    0.000000001,
    "Jackrong Qwopus3.6 27B Coder Compat MTP Q4_K_M resident-only token embedding plus MTP/header footprint",
  );
  assertNear(
    result.alloc,
    6.708527104,
    0.000000001,
    "Jackrong Qwopus3.6 27B Coder Compat MTP Q4_K_M hybrid KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    2.252079104,
    0.000000001,
    "Jackrong Qwopus3.6 27B Coder Compat MTP Q4_K_M hybrid KV plus DeltaNet state read traffic",
  );
  assertNear(
    result.single.aggregate,
    15.105135460995719,
    0.000000001,
    "Jackrong Qwopus3.6 27B Coder Compat MTP Q4_K_M DGX single-session tok/s",
  );
  assert.equal(result.bMem, 15);
  assert.equal(result.best, null);
  assertNear(
    result.dennard,
    265.4174377043947,
    0.000000001,
    "Jackrong Qwopus3.6 27B Coder Compat MTP Q4_K_M DGX Dennard bound",
  );

  const m5Result = profiled(
    "Jackrong/Qwopus3.6-27B-Coder-Compat-MTP-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 6);
  assertNear(
    m5Result.single.aggregate,
    33.97272224560942,
    0.000000001,
    "Jackrong Qwopus3.6 27B Coder Compat MTP Q4_K_M M5 single-session tok/s",
  );
  assertNear(
    m5Result.best.aggregate,
    125.58925770634231,
    0.000000001,
    "Jackrong Qwopus3.6 27B Coder Compat MTP Q4_K_M M5 aggregate tok/s at b*",
  );
  assertNear(
    m5Result.best.perSession,
    20.93154295105705,
    0.000000001,
    "Jackrong Qwopus3.6 27B Coder Compat MTP Q4_K_M M5 per-session tok/s at b*",
  );
  assertNear(
    m5Result.dennard,
    596.946178573254,
    0.000000001,
    "Jackrong Qwopus3.6 27B Coder Compat MTP Q4_K_M M5 Dennard bound",
  );

  const m1UltraResult = profiled(
    "Jackrong/Qwopus3.6-27B-Coder-Compat-MTP-GGUF",
    "apple-mac-studio-m1-ultra-128gb",
  );
  assert.equal(m1UltraResult.status_code, "ok");
  assert.equal(m1UltraResult.best.batch, 10);
  assertNear(
    m1UltraResult.best.aggregate,
    208.6482865308631,
    0.000000001,
    "Jackrong Qwopus3.6 27B Coder Compat MTP Q4_K_M M1 Ultra aggregate tok/s at b*",
  );
}

{
  const repo = "RecViking/Mistral-Medium-3.5-128B-NVFP4";
  const modelProfile = profile(repo);
  const modelRow = model(repo);
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  assert.equal(modelProfile.status, "audited");
  assert.equal(modelProfile.architecture.max_context_tokens, 262144);
  assert.equal(modelRow.hf_downloads, 106484);
  assert.equal(modelRow.tags.includes("region:us"), true);
  assert.equal(modelRow.architecture.detail, "mistral3 / ministral3 text");
  assert.equal(modelRow.architecture.total_params_b, 127.704210176);
  assert.equal(modelRow.architecture.active_params_b, 123.415375872);
  assert.equal(modelRow.adapter.weight_precision, "NVFP4");
  assert.equal(modelProfile.serving.kv_store_format, "turboquant_4bit_nc");
  assert.equal(modelProfile.serving.kv_store_bytes_per_scalar, 0.5);
  assertNear(
    weightAdapter.resident_weight_gb,
    80.3172048,
    0.000000001,
    "RecViking Mistral Medium 3.5 NVFP4 resident tensor payload",
  );
  assertNear(
    result.single.batchWeight,
    71.739536192,
    0.000000001,
    "RecViking Mistral Medium 3.5 NVFP4 ordinary swept text-decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    8.577668608,
    0.000000001,
    "RecViking Mistral Medium 3.5 NVFP4 resident-only embedding/vision/projector payload",
  );
  assert.equal(modelProfile.architecture.kv_adapter.kind, "full_context");
  assert.equal(modelProfile.architecture.kv_adapter.layers, 88);
  assert.equal(modelProfile.architecture.kv_adapter.kv_heads, 8);
  assert.equal(modelProfile.architecture.kv_adapter.head_dim, 128);
  assert.equal(modelProfile.architecture.kv_adapter.kv_scalar_multiplier, 2);
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    80.3172048,
    0.000000001,
    "RecViking Mistral Medium 3.5 DGX resident footprint",
  );
  assertNear(
    result.alloc,
    9.0112,
    0.000000001,
    "RecViking Mistral Medium 3.5 DGX TurboQuant 4-bit KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    2.883584,
    0.000000001,
    "RecViking Mistral Medium 3.5 DGX TurboQuant 4-bit KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    3.658383612177973,
    0.000000001,
    "RecViking Mistral Medium 3.5 DGX single-session tok/s",
  );
  assert.equal(result.bMem, 4);
  assert.equal(result.best, null);
  assertNear(
    result.dennard,
    16.75805877740116,
    0.000000001,
    "RecViking Mistral Medium 3.5 DGX Dennard bound",
  );

  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  assert.equal(m5Result.status_code, "no_floor");
  assert.equal(m5Result.best, null);
  assertNear(
    m5Result.single.aggregate,
    8.22801295925742,
    0.000000001,
    "RecViking Mistral Medium 3.5 M5 Max single-session tok/s",
  );
  assertNear(
    m5Result.dennard,
    37.690286041481,
    0.000000001,
    "RecViking Mistral Medium 3.5 M5 Max Dennard bound",
  );
}

{
  const modelProfile = profile("Jackrong/Qwopus3.6-27B-v2-MTP-GGUF");
  const result = profiled(
    "Jackrong/Qwopus3.6-27B-v2-MTP-GGUF",
    "nvidia-dgx-spark",
  );
  assert.equal(
    modelProfile.serving.runtime_format,
    "llama.cpp-gguf-q5-k-m-v2-mtp-memory-bound",
  );
  assert.equal(
    result.status_code,
    "no_floor",
    "Jackrong Qwopus3.6 27B v2 MTP Q5_K_M should fit DGX Spark but miss the 20 tok/s floor",
  );
  assertNear(
    result.resident,
    19.535699136,
    0.000000001,
    "Jackrong Qwopus3.6 27B v2 MTP Q5_K_M resident file footprint",
  );
  assertNear(
    result.single.batchWeight,
    18.346018816,
    0.000000001,
    "Jackrong Qwopus3.6 27B v2 MTP Q5_K_M ordinary swept text-decode traffic",
  );
  assertNear(
    modelProfile.architecture.weight_adapter.auxiliary_resident_weight_gb,
    1.18968032,
    0.000000001,
    "Jackrong Qwopus3.6 27B v2 MTP Q5_K_M resident-only token embedding plus MTP/header footprint",
  );
  assertNear(
    result.alloc,
    6.708527104,
    0.000000001,
    "Jackrong Qwopus3.6 27B v2 MTP Q5_K_M hybrid KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    2.252079104,
    0.000000001,
    "Jackrong Qwopus3.6 27B v2 MTP Q5_K_M hybrid KV plus DeltaNet state read traffic",
  );
  assertNear(
    result.single.aggregate,
    13.25365094681519,
    0.000000001,
    "Jackrong Qwopus3.6 27B v2 MTP Q5_K_M DGX single-session tok/s",
  );
  assert.equal(result.bMem, 14);
  assert.equal(result.best, null);
  assertNear(
    result.dennard,
    222.84628577011875,
    0.000000001,
    "Jackrong Qwopus3.6 27B v2 MTP Q5_K_M DGX Dennard bound",
  );

  const m5Result = profiled(
    "Jackrong/Qwopus3.6-27B-v2-MTP-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 5);
  assertNear(
    m5Result.single.aggregate,
    29.808577587342587,
    0.000000001,
    "Jackrong Qwopus3.6 27B v2 MTP Q5_K_M M5 single-session tok/s",
  );
  assertNear(
    m5Result.best.aggregate,
    103.69374572546683,
    0.000000001,
    "Jackrong Qwopus3.6 27B v2 MTP Q5_K_M M5 aggregate tok/s at b*",
  );
  assertNear(
    m5Result.best.perSession,
    20.738749145093365,
    0.000000001,
    "Jackrong Qwopus3.6 27B v2 MTP Q5_K_M M5 per-session tok/s at b*",
  );
  assertNear(
    m5Result.dennard,
    501.20007129250155,
    0.000000001,
    "Jackrong Qwopus3.6 27B v2 MTP Q5_K_M M5 Dennard bound",
  );
}

{
  const modelProfile = profile("Jackrong/Qwopus3.5-9B-Coder-MTP-GGUF");
  const result = profiled(
    "Jackrong/Qwopus3.5-9B-Coder-MTP-GGUF",
    "nvidia-dgx-spark",
  );
  assert.equal(
    modelProfile.serving.runtime_format,
    "llama.cpp-gguf-q5-k-m-coder-mtp-memory-bound",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    6.642546592,
    0.000000001,
    "Jackrong Qwopus3.5 9B Coder MTP Q5_K_M resident file footprint",
  );
  assertNear(
    result.single.batchWeight,
    5.757732864,
    0.000000001,
    "Jackrong Qwopus3.5 9B Coder MTP Q5_K_M ordinary swept text-decode traffic",
  );
  assertNear(
    modelProfile.architecture.weight_adapter.auxiliary_resident_weight_gb,
    0.884813728,
    0.000000001,
    "Jackrong Qwopus3.5 9B Coder MTP Q5_K_M resident-only token embedding plus MTP/header footprint",
  );
  assertNear(
    result.alloc,
    3.328704512,
    0.000000001,
    "Jackrong Qwopus3.5 9B Coder MTP Q5_K_M hybrid KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.100480512,
    0.000000001,
    "Jackrong Qwopus3.5 9B Coder MTP Q5_K_M hybrid KV plus DeltaNet state read traffic",
  );
  assertNear(
    result.single.aggregate,
    39.806285548850205,
    0.000000001,
    "Jackrong Qwopus3.5 9B Coder MTP Q5_K_M DGX single-session tok/s",
  );
  assert.equal(result.bMem, 34);
  assert.equal(result.best.batch, 7);
  assertNear(
    result.best.aggregate,
    141.9646614510313,
    0.000000001,
    "Jackrong Qwopus3.5 9B Coder MTP Q5_K_M DGX aggregate tok/s at b*",
  );
  assertNear(
    result.best.perSession,
    20.2806659215759,
    0.000000001,
    "Jackrong Qwopus3.5 9B Coder MTP Q5_K_M DGX per-session tok/s at b*",
  );
  assertNear(
    result.dennard,
    1614.678162450568,
    0.000000001,
    "Jackrong Qwopus3.5 9B Coder MTP Q5_K_M DGX Dennard bound",
  );

  const m5Result = profiled(
    "Jackrong/Qwopus3.5-9B-Coder-MTP-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 22);
  assertNear(
    m5Result.single.aggregate,
    89.52768984246896,
    0.000000001,
    "Jackrong Qwopus3.5 9B Coder MTP Q5_K_M M5 single-session tok/s",
  );
  assertNear(
    m5Result.best.aggregate,
    450.7428896311553,
    0.000000001,
    "Jackrong Qwopus3.5 9B Coder MTP Q5_K_M M5 aggregate tok/s at b*",
  );
  assertNear(
    m5Result.best.perSession,
    20.488313165052514,
    0.000000001,
    "Jackrong Qwopus3.5 9B Coder MTP Q5_K_M M5 per-session tok/s at b*",
  );
  assertNear(
    m5Result.dennard,
    3631.547222507871,
    0.000000001,
    "Jackrong Qwopus3.5 9B Coder MTP Q5_K_M M5 Dennard bound",
  );
}

{
  const result = profiled("Qwen/Qwen3.5-9B", "nvidia-dgx-spark");
  assertNear(
    result.resident,
    19.306216416,
    0.000000001,
    "Qwen3.5 9B resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    15.873376768,
    0.000000001,
    "Qwen3.5 9B swept text-decode traffic",
  );
  assertNear(
    result.alloc,
    3.328704512,
    0.000000001,
    "Qwen3.5 9B full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.100480512,
    0.000000001,
    "Qwen3.5 9B full-attention KV plus DeltaNet state read traffic",
  );
}

{
  const catalog = model("RedHatAI/Qwen3.5-9B-FP8-dynamic");
  const modelProfile = profile("RedHatAI/Qwen3.5-9B-FP8-dynamic");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "RedHatAI/Qwen3.5-9B-FP8-dynamic",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "RedHatAI/Qwen3.5-9B-FP8-dynamic",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  const m1Result = profiled(
    "RedHatAI/Qwen3.5-9B-FP8-dynamic",
    "apple-mac-studio-m1-ultra-128gb",
  );
  assert.equal(catalog.hf_downloads, 178278);
  assert.equal(catalog.adapter.kind, "hybrid");
  assertNear(
    catalog.adapter.kv_alloc_gb_per_1k_tokens,
    0.032768,
    0.000000001,
    "RedHatAI Qwen3.5 9B FP8 catalog full-attention KV allocation per 1K",
  );
  assertNear(
    catalog.adapter.kv_alloc_fixed_gb,
    0.051904512,
    0.000000001,
    "RedHatAI Qwen3.5 9B FP8 catalog DeltaNet fixed state allocation",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(modelProfile.serving.weight_format, "fp8");
  assert.equal(
    modelProfile.serving.runtime_format,
    "vllm-compressed-tensors-fp8-dynamic-qwen3.5-text-decode-memory-bound",
  );
  assertNear(
    weightAdapter.resident_params_b,
    9.653104368,
    0.000000001,
    "RedHatAI Qwen3.5 9B FP8 logical resident parameters",
  );
  assertNear(
    weightAdapter.swept_params_b,
    7.936684544,
    0.000000001,
    "RedHatAI Qwen3.5 9B FP8 ordinary swept parameters",
  );
  assertNear(
    weightAdapter.auxiliary_resident_params_b,
    1.716419824,
    0.000000001,
    "RedHatAI Qwen3.5 9B FP8 auxiliary resident parameters",
  );
  assertNear(
    result.resident,
    14.006672864,
    0.000000001,
    "RedHatAI Qwen3.5 9B FP8 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    10.573833216,
    0.000000001,
    "RedHatAI Qwen3.5 9B FP8 swept text-decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    3.432839648,
    0.000000001,
    "RedHatAI Qwen3.5 9B FP8 resident-only embedding/vision/MTP footprint",
  );
  assertNear(
    result.alloc,
    3.328704512,
    0.000000001,
    "RedHatAI Qwen3.5 9B FP8 full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.100480512,
    0.000000001,
    "RedHatAI Qwen3.5 9B FP8 full-attention KV plus DeltaNet state read traffic",
  );
  assertNear(
    result.single.aggregate,
    23.384672226619124,
    0.000000001,
    "RedHatAI Qwen3.5 9B FP8 DGX Spark single-session tok/s",
  );
  assert.equal(result.bMem, 31);
  assert.equal(result.best.batch, 2);
  assertNear(
    result.best.aggregate,
    42.7404144240839,
    0.000000001,
    "RedHatAI Qwen3.5 9B FP8 DGX Spark aggregate tok/s at b*",
  );
  assertNear(
    result.best.perSession,
    21.37020721204195,
    0.000000001,
    "RedHatAI Qwen3.5 9B FP8 DGX Spark per-session tok/s at b*",
  );
  assertNear(
    result.dennard,
    822.1167020244179,
    0.000000001,
    "RedHatAI Qwen3.5 9B FP8 DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 18);
  assertNear(
    m5Result.best.aggregate,
    363.7622444030317,
    0.000000001,
    "RedHatAI Qwen3.5 9B FP8 M5 aggregate tok/s at b*",
  );
  assert.equal(m1Result.status_code, "ok");
  assert.equal(m1Result.best.batch, 26);
  assertNear(
    m1Result.best.aggregate,
    530.797393961837,
    0.000000001,
    "RedHatAI Qwen3.5 9B FP8 M1 Ultra aggregate tok/s at b*",
  );
}

{
  const catalog = model("Hyper-AI/Qwen3.5-9B-fp8");
  const modelProfile = profile("Hyper-AI/Qwen3.5-9B-fp8");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled("Hyper-AI/Qwen3.5-9B-fp8", "nvidia-dgx-spark");
  const m5Result = profiled(
    "Hyper-AI/Qwen3.5-9B-fp8",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  const m1Result = profiled(
    "Hyper-AI/Qwen3.5-9B-fp8",
    "apple-mac-studio-m1-ultra-128gb",
  );
  assert.equal(catalog.hf_downloads, 104742);
  assert.equal(catalog.adapter.kind, "hybrid");
  assertNear(
    catalog.adapter.kv_alloc_gb_per_1k_tokens,
    0.032768,
    0.000000001,
    "Hyper-AI Qwen3.5 9B FP8 catalog full-attention KV allocation per 1K",
  );
  assertNear(
    catalog.adapter.kv_alloc_fixed_gb,
    0.051904512,
    0.000000001,
    "Hyper-AI Qwen3.5 9B FP8 catalog DeltaNet fixed state allocation",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(modelProfile.serving.weight_format, "fp8");
  assert.equal(
    modelProfile.serving.runtime_format,
    "vllm-lightvl-compressed-tensors-fp8-qwen3.5-text-decode-memory-bound",
  );
  assertNear(
    weightAdapter.resident_params_b,
    9.653104368,
    0.000000001,
    "Hyper-AI Qwen3.5 9B FP8 logical resident parameters",
  );
  assertNear(
    weightAdapter.swept_params_b,
    7.936684544,
    0.000000001,
    "Hyper-AI Qwen3.5 9B FP8 ordinary swept parameters",
  );
  assertNear(
    weightAdapter.auxiliary_resident_params_b,
    1.716419824,
    0.000000001,
    "Hyper-AI Qwen3.5 9B FP8 auxiliary resident parameters",
  );
  assertNear(
    result.resident,
    12.147390432,
    0.000000001,
    "Hyper-AI Qwen3.5 9B FP8 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    8.957726208,
    0.000000001,
    "Hyper-AI Qwen3.5 9B FP8 swept text-decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    3.189664224,
    0.000000001,
    "Hyper-AI Qwen3.5 9B FP8 resident-only embedding/vision/MTP footprint",
  );
  assertNear(
    result.alloc,
    3.328704512,
    0.000000001,
    "Hyper-AI Qwen3.5 9B FP8 full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.100480512,
    0.000000001,
    "Hyper-AI Qwen3.5 9B FP8 full-attention KV plus DeltaNet state read traffic",
  );
  assertNear(
    result.single.aggregate,
    27.14201523191601,
    0.000000001,
    "Hyper-AI Qwen3.5 9B FP8 DGX Spark single-session tok/s",
  );
  assert.equal(result.bMem, 32);
  assert.equal(result.best.batch, 4);
  assertNear(
    result.best.aggregate,
    81.73867897379468,
    0.000000001,
    "Hyper-AI Qwen3.5 9B FP8 DGX Spark aggregate tok/s at b*",
  );
  assertNear(
    result.best.perSession,
    20.43466974344867,
    0.000000001,
    "Hyper-AI Qwen3.5 9B FP8 DGX Spark per-session tok/s at b*",
  );
  assertNear(
    result.dennard,
    987.4617361126113,
    0.000000001,
    "Hyper-AI Qwen3.5 9B FP8 DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 19);
  assertNear(
    m5Result.best.aggregate,
    390.60020328214034,
    0.000000001,
    "Hyper-AI Qwen3.5 9B FP8 M5 aggregate tok/s at b*",
  );
  assert.equal(m1Result.status_code, "ok");
  assert.equal(m1Result.best.batch, 28);
  assertNear(
    m1Result.best.aggregate,
    563.2219032376532,
    0.000000001,
    "Hyper-AI Qwen3.5 9B FP8 M1 Ultra aggregate tok/s at b*",
  );
}

{
  const modelProfile = profile("Qwen/Qwen3.5-9B-Base");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled("Qwen/Qwen3.5-9B-Base", "nvidia-dgx-spark");
  const m5Result = profiled(
    "Qwen/Qwen3.5-9B-Base",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "no_floor");
  assertNear(
    weightAdapter.resident_params_b,
    9.653104368,
    0.000000001,
    "Qwen3.5 9B Base logical resident parameters",
  );
  assertNear(
    weightAdapter.swept_params_b,
    7.936684544,
    0.000000001,
    "Qwen3.5 9B Base ordinary swept parameters",
  );
  assertNear(
    weightAdapter.auxiliary_resident_params_b,
    1.716419824,
    0.000000001,
    "Qwen3.5 9B Base auxiliary resident parameters",
  );
  assertNear(
    result.resident,
    19.306216416,
    0.000000001,
    "Qwen3.5 9B Base resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    15.873376768,
    0.000000001,
    "Qwen3.5 9B Base swept text-decode traffic",
  );
  assertNear(
    result.alloc,
    3.328704512,
    0.000000001,
    "Qwen3.5 9B Base full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.100480512,
    0.000000001,
    "Qwen3.5 9B Base full-attention KV plus DeltaNet state read traffic",
  );
  assertNear(
    result.single.aggregate,
    16.083556936800164,
    0.000000001,
    "Qwen3.5 9B Base DGX Spark single-session tok/s",
  );
  assert.equal(result.bMem, 30);
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 13);
  assertNear(
    m5Result.single.aggregate,
    36.173274575806964,
    0.000000001,
    "Qwen3.5 9B Base M5 single-session tok/s",
  );
  assertNear(
    m5Result.best.aggregate,
    264.48308807101967,
    0.000000001,
    "Qwen3.5 9B Base M5 aggregate tok/s at b*",
  );
  assertNear(
    m5Result.best.perSession,
    20.344852928539975,
    0.000000001,
    "Qwen3.5 9B Base M5 per-session tok/s at b*",
  );
  assertNear(
    m5Result.dennard,
    1170.1093820472672,
    0.000000001,
    "Qwen3.5 9B Base M5 Dennard bound",
  );
}

{
  const modelProfile = profile("Jackrong/Qwen3.5-9B-DeepSeek-V4-Flash-GGUF");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "Jackrong/Qwen3.5-9B-DeepSeek-V4-Flash-GGUF",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "Jackrong/Qwen3.5-9B-DeepSeek-V4-Flash-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    weightAdapter.resident_params_b,
    8.953803264,
    0.000000001,
    "Jackrong Qwen3.5 9B DeepSeek V4 Flash GGUF logical resident parameters",
  );
  assertNear(
    weightAdapter.swept_params_b,
    7.936684544,
    0.000000001,
    "Jackrong Qwen3.5 9B DeepSeek V4 Flash GGUF logical swept parameters",
  );
  assertNear(
    result.resident,
    4.623521024,
    0.000000001,
    "Jackrong Qwen3.5 9B DeepSeek V4 Flash Q3_K_M resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    4.1755136,
    0.000000001,
    "Jackrong Qwen3.5 9B DeepSeek V4 Flash Q3_K_M swept text-decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.448007424,
    0.000000001,
    "Jackrong Qwen3.5 9B DeepSeek V4 Flash Q3_K_M resident-only token/header bytes",
  );
  assertNear(
    result.alloc,
    3.328704512,
    0.000000001,
    "Jackrong Qwen3.5 9B DeepSeek V4 Flash full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.100480512,
    0.000000001,
    "Jackrong Qwen3.5 9B DeepSeek V4 Flash full-attention KV plus DeltaNet state read traffic",
  );
  assert.equal(result.bMem, 34);
  assert.equal(result.best.batch, 8);
  assertNear(
    result.single.aggregate,
    51.74380300748903,
    0.000000001,
    "Jackrong Qwen3.5 9B DeepSeek V4 Flash DGX single-session tok/s",
  );
  assertNear(
    result.best.aggregate,
    168.26718633951114,
    0.000000001,
    "Jackrong Qwen3.5 9B DeepSeek V4 Flash DGX aggregate tok/s at b*",
  );
  assertNear(
    result.best.perSession,
    21.033398292438893,
    0.000000001,
    "Jackrong Qwen3.5 9B DeepSeek V4 Flash DGX per-session tok/s at b*",
  );
  assertNear(
    result.dennard,
    2266.181975341868,
    0.000000001,
    "Jackrong Qwen3.5 9B DeepSeek V4 Flash DGX Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 24);
  assertNear(
    m5Result.best.aggregate,
    481.77257960636445,
    0.000000001,
    "Jackrong Qwen3.5 9B DeepSeek V4 Flash M5 Max aggregate",
  );
  assertNear(
    m5Result.best.perSession,
    20.07385748359852,
    0.000000001,
    "Jackrong Qwen3.5 9B DeepSeek V4 Flash M5 Max per-session",
  );
}

{
  const modelProfile = profile("AxionML/Qwen3.5-9B-NVFP4");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled("AxionML/Qwen3.5-9B-NVFP4", "nvidia-dgx-spark");
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    9.360860576,
    0.000000001,
    "AxionML Qwen3.5 9B NVFP4 resident ModelOpt safetensors footprint",
  );
  assertNear(
    result.single.batchWeight,
    5.928020928,
    0.000000001,
    "AxionML Qwen3.5 9B NVFP4 swept text-decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    3.432839648,
    0.000000001,
    "AxionML Qwen3.5 9B NVFP4 resident-only embedding/vision/MTP footprint",
  );
  assertNear(
    result.alloc,
    3.328704512,
    0.000000001,
    "AxionML Qwen3.5 9B NVFP4 BF16 full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.100480512,
    0.000000001,
    "AxionML Qwen3.5 9B NVFP4 BF16 full-attention KV plus DeltaNet state read traffic",
  );
  assertNear(
    result.single.aggregate,
    38.841850191,
    0.000000001,
    "AxionML Qwen3.5 9B NVFP4 DGX single-session tok/s",
  );
  assert.equal(result.bMem, 33);
  assert.equal(result.best.batch, 7);
  assertNear(
    result.best.aggregate,
    140.19118882,
    0.000000001,
    "AxionML Qwen3.5 9B NVFP4 DGX aggregate tok/s at b*",
  );
  assertNear(
    result.best.perSession,
    20.027312689,
    0.000000001,
    "AxionML Qwen3.5 9B NVFP4 DGX per-session tok/s at b*",
  );
  assertNear(
    result.dennard,
    1530.687244784,
    0.000000001,
    "AxionML Qwen3.5 9B NVFP4 DGX Dennard bound",
  );
}

{
  const modelProfile = profile("apolo13x/Qwen3.5-9B-NVFP4");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled("apolo13x/Qwen3.5-9B-NVFP4", "nvidia-dgx-spark");
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    12.36044208,
    0.000000001,
    "Apolo13x Qwen3.5 9B NVFP4 resident llm-compressor safetensors footprint",
  );
  assertNear(
    result.single.batchWeight,
    8.927602432,
    0.000000001,
    "Apolo13x Qwen3.5 9B NVFP4 swept text-decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    3.432839648,
    0.000000001,
    "Apolo13x Qwen3.5 9B NVFP4 resident-only embedding/vision/MTP footprint",
  );
  assertNear(
    result.alloc,
    3.328704512,
    0.000000001,
    "Apolo13x Qwen3.5 9B NVFP4 BF16 full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.100480512,
    0.000000001,
    "Apolo13x Qwen3.5 9B NVFP4 BF16 full-attention KV plus DeltaNet state read traffic",
  );
  assertNear(
    result.single.aggregate,
    27.223548262,
    0.000000001,
    "Apolo13x Qwen3.5 9B NVFP4 DGX single-session tok/s",
  );
  assert.equal(result.bMem, 32);
  assert.equal(result.best.batch, 4);
  assertNear(
    result.best.aggregate,
    81.923402567,
    0.000000001,
    "Apolo13x Qwen3.5 9B NVFP4 DGX aggregate tok/s at b*",
  );
  assertNear(
    result.best.perSession,
    20.480850642,
    0.000000001,
    "Apolo13x Qwen3.5 9B NVFP4 DGX per-session tok/s at b*",
  );
  assertNear(
    result.dennard,
    988.836448101,
    0.000000001,
    "Apolo13x Qwen3.5 9B NVFP4 DGX Dennard bound",
  );
}

{
  const modelProfile = profile(
    "lmstudio-community/DeepSeek-R1-0528-Qwen3-8B-MLX-4bit",
  );
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "lmstudio-community/DeepSeek-R1-0528-Qwen3-8B-MLX-4bit",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    4.607731712,
    0.000000001,
    "LM Studio DeepSeek R1 Qwen3 8B MLX 4bit resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    4.257671168,
    0.000000001,
    "LM Studio DeepSeek R1 Qwen3 8B MLX 4bit swept text-decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.350060544,
    0.000000001,
    "LM Studio DeepSeek R1 Qwen3 8B MLX 4bit resident-only input-embedding footprint",
  );
  assertNear(
    result.alloc,
    14.7456,
    0.000000001,
    "LM Studio DeepSeek R1 Qwen3 8B MLX 4bit BF16 full-context KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    4.718592,
    0.000000001,
    "LM Studio DeepSeek R1 Qwen3 8B MLX 4bit BF16 full-context KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    30.413546806,
    0.000000001,
    "LM Studio DeepSeek R1 Qwen3 8B MLX 4bit DGX single-session tok/s",
  );
  assert.equal(result.bMem, 7);
  assert.equal(result.best.batch, 1);
  assertNear(
    result.best.aggregate,
    30.413546806,
    0.000000001,
    "LM Studio DeepSeek R1 Qwen3 8B MLX 4bit DGX aggregate tok/s at b*",
  );
  assertNear(
    result.best.perSession,
    30.413546806,
    0.000000001,
    "LM Studio DeepSeek R1 Qwen3 8B MLX 4bit DGX per-session tok/s at b*",
  );
  assertNear(
    result.dennard,
    501.770115701,
    0.000000001,
    "LM Studio DeepSeek R1 Qwen3 8B MLX 4bit DGX Dennard bound",
  );
}

{
  const modelProfile = profile(
    "lmstudio-community/DeepSeek-R1-0528-Qwen3-8B-MLX-8bit",
  );
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "lmstudio-community/DeepSeek-R1-0528-Qwen3-8B-MLX-8bit",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "lmstudio-community/DeepSeek-R1-0528-Qwen3-8B-MLX-8bit",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    8.70294528,
    0.000000001,
    "LM Studio DeepSeek R1 Qwen3 8B MLX 8bit resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    8.041719808,
    0.000000001,
    "LM Studio DeepSeek R1 Qwen3 8B MLX 8bit swept text-decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.661225472,
    0.000000001,
    "LM Studio DeepSeek R1 Qwen3 8B MLX 8bit resident-only input-embedding footprint",
  );
  assertNear(
    result.alloc,
    14.7456,
    0.000000001,
    "LM Studio DeepSeek R1 Qwen3 8B MLX 8bit BF16 full-context KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    4.718592,
    0.000000001,
    "LM Studio DeepSeek R1 Qwen3 8B MLX 8bit BF16 full-context KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    21.394461523177224,
    0.000000001,
    "LM Studio DeepSeek R1 Qwen3 8B MLX 8bit DGX single-session tok/s",
  );
  assert.equal(result.bMem, 7);
  assert.equal(result.best.batch, 1);
  assertNear(
    result.best.aggregate,
    21.394461523177224,
    0.000000001,
    "LM Studio DeepSeek R1 Qwen3 8B MLX 8bit DGX aggregate tok/s at b*",
  );
  assertNear(
    result.best.perSession,
    21.394461523177224,
    0.000000001,
    "LM Studio DeepSeek R1 Qwen3 8B MLX 8bit DGX per-session tok/s at b*",
  );
  assertNear(
    result.dennard,
    256.2329241066242,
    0.000000001,
    "LM Studio DeepSeek R1 Qwen3 8B MLX 8bit DGX Dennard bound",
  );
  assert.equal(m5Result.best.batch, 4);
  assertNear(
    m5Result.best.aggregate,
    91.24654435367192,
    0.000000001,
    "LM Studio DeepSeek R1 Qwen3 8B MLX 8bit M5 aggregate tok/s at b*",
  );
  assertNear(
    m5Result.best.perSession,
    22.81163608841798,
    0.000000001,
    "LM Studio DeepSeek R1 Qwen3 8B MLX 8bit M5 per-session tok/s at b*",
  );
}

{
  const modelProfile = profile("lmstudio-community/Qwen3.5-9B-MLX-4bit");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "lmstudio-community/Qwen3.5-9B-MLX-4bit",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    5.95006256,
    0.000000001,
    "LM Studio Qwen3.5 9B MLX 4bit resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    4.46591232,
    0.000000001,
    "LM Studio Qwen3.5 9B MLX 4bit swept text-decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.48415024,
    0.000000001,
    "LM Studio Qwen3.5 9B MLX 4bit resident-only visual/input-embedding footprint",
  );
  assertNear(
    result.alloc,
    3.328704512,
    0.000000001,
    "LM Studio Qwen3.5 9B MLX 4bit BF16 full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.100480512,
    0.000000001,
    "LM Studio Qwen3.5 9B MLX 4bit BF16 full-attention KV plus DeltaNet state read traffic",
  );
  assertNear(
    result.single.aggregate,
    49.044328749,
    0.000000001,
    "LM Studio Qwen3.5 9B MLX 4bit DGX single-session tok/s",
  );
  assert.equal(result.bMem, 34);
  assert.equal(result.best.batch, 8);
  assertNear(
    result.best.aggregate,
    164.584784493,
    0.000000001,
    "LM Studio Qwen3.5 9B MLX 4bit DGX aggregate tok/s at b*",
  );
  assertNear(
    result.best.perSession,
    20.573098062,
    0.000000001,
    "LM Studio Qwen3.5 9B MLX 4bit DGX per-session tok/s at b*",
  );
  assertNear(
    result.dennard,
    2094.460920533,
    0.000000001,
    "LM Studio Qwen3.5 9B MLX 4bit DGX Dennard bound",
  );
}

{
  const modelProfile = profile("lmstudio-community/Qwen3.5-9B-MLX-8bit");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "lmstudio-community/Qwen3.5-9B-MLX-8bit",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    10.426433504,
    0.000000001,
    "LM Studio Qwen3.5 9B MLX 8bit resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    8.433723904,
    0.000000001,
    "LM Studio Qwen3.5 9B MLX 8bit swept text-decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.9927096,
    0.000000001,
    "LM Studio Qwen3.5 9B MLX 8bit resident-only visual/input-embedding footprint",
  );
  assertNear(
    result.alloc,
    3.328704512,
    0.000000001,
    "LM Studio Qwen3.5 9B MLX 8bit BF16 full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.100480512,
    0.000000001,
    "LM Studio Qwen3.5 9B MLX 8bit BF16 full-attention KV plus DeltaNet state read traffic",
  );
  assertNear(
    result.single.aggregate,
    28.633747305,
    0.000000001,
    "LM Studio Qwen3.5 9B MLX 8bit DGX single-session tok/s",
  );
  assert.equal(result.bMem, 32);
  assert.equal(result.best.batch, 4);
  assertNear(
    result.best.aggregate,
    85.075578127,
    0.000000001,
    "LM Studio Qwen3.5 9B MLX 8bit DGX aggregate tok/s at b*",
  );
  assertNear(
    result.best.perSession,
    21.268894532,
    0.000000001,
    "LM Studio Qwen3.5 9B MLX 8bit DGX per-session tok/s at b*",
  );
  assertNear(
    result.dennard,
    1065.549968734,
    0.000000001,
    "LM Studio Qwen3.5 9B MLX 8bit DGX Dennard bound",
  );
}

{
  const result = profiled("cyankiwi/Qwen3.5-9B-AWQ-4bit", "nvidia-dgx-spark");
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    9.068440272,
    0.000000001,
    "cyankiwi Qwen3.5 9B AWQ resident compressed-tensors footprint",
  );
  assertNear(
    result.single.batchWeight,
    5.937066112,
    0.000000001,
    "cyankiwi Qwen3.5 9B AWQ swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    3.13137416,
    0.000000001,
    "cyankiwi Qwen3.5 9B AWQ resident-only embedding/vision/MTP footprint",
  );
  assertNear(
    result.alloc,
    3.328704512,
    0.000000001,
    "cyankiwi Qwen3.5 9B AWQ BF16 full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.100480512,
    0.000000001,
    "cyankiwi Qwen3.5 9B AWQ BF16 full-attention KV plus DeltaNet state read traffic",
  );
  assertNear(
    result.single.aggregate,
    38.791927725,
    0.000000001,
    "cyankiwi Qwen3.5 9B AWQ DGX single-session tok/s",
  );
  assert.equal(result.bMem, 33);
  assert.equal(result.best.batch, 7);
  assertNear(
    result.best.aggregate,
    140.098225832,
    0.000000001,
    "cyankiwi Qwen3.5 9B AWQ DGX aggregate tok/s at b*",
  );
  assertNear(
    result.best.perSession,
    20.014032262,
    0.000000001,
    "cyankiwi Qwen3.5 9B AWQ DGX per-session tok/s at b*",
  );
  assertNear(
    result.dennard,
    1532.394683808,
    0.000000001,
    "cyankiwi Qwen3.5 9B AWQ DGX Dennard bound",
  );
}

{
  const result = profiled("QuantTrio/Qwen3.5-9B-AWQ", "nvidia-dgx-spark");
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    12.37637424,
    0.000000001,
    "QuantTrio Qwen3.5 9B AWQ resident safetensors footprint",
  );
  assertNear(
    result.single.batchWeight,
    8.943534592,
    0.000000001,
    "QuantTrio Qwen3.5 9B AWQ swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    3.432839648,
    0.000000001,
    "QuantTrio Qwen3.5 9B AWQ resident-only embedding/vision/MTP footprint",
  );
  assertNear(
    result.alloc,
    3.328704512,
    0.000000001,
    "QuantTrio Qwen3.5 9B AWQ FP16 full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.100480512,
    0.000000001,
    "QuantTrio Qwen3.5 9B AWQ FP16 full-attention KV plus DeltaNet state read traffic",
  );
  assertNear(
    result.single.aggregate,
    27.180365339,
    0.000000001,
    "QuantTrio Qwen3.5 9B AWQ DGX single-session tok/s",
  );
  assert.equal(result.bMem, 32);
  assert.equal(result.best.batch, 4);
  assertNear(
    result.best.aggregate,
    81.825600237,
    0.000000001,
    "QuantTrio Qwen3.5 9B AWQ DGX aggregate tok/s at b*",
  );
  assertNear(
    result.best.perSession,
    20.456400059,
    0.000000001,
    "QuantTrio Qwen3.5 9B AWQ DGX per-session tok/s at b*",
  );
  assertNear(
    result.dennard,
    986.928817653,
    0.000000001,
    "QuantTrio Qwen3.5 9B AWQ DGX Dennard bound",
  );
}

{
  const result = profiled(
    "cyankiwi/Qwen3.5-9B-AWQ-4bit",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.single.aggregate,
    87.246313638,
    0.000000001,
    "cyankiwi Qwen3.5 9B AWQ M5 Max single-session tok/s",
  );
  assert.equal(result.best.batch, 22);
  assertNear(
    result.best.aggregate,
    448.061645147,
    0.000000001,
    "cyankiwi Qwen3.5 9B AWQ M5 Max aggregate tok/s at b*",
  );
  assertNear(
    result.dennard,
    3446.484746734,
    0.000000001,
    "cyankiwi Qwen3.5 9B AWQ M5 Max Dennard bound",
  );
}

{
  const modelProfile = profile(
    "hugging-quants/Llama-3.2-1B-Instruct-Q8_0-GGUF",
  );
  const result = profiled(
    "hugging-quants/Llama-3.2-1B-Instruct-Q8_0-GGUF",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    1.3210792,
    0.000000001,
    "Llama 3.2 1B Q8_0 GGUF resident file footprint",
  );
  assertNear(
    result.single.batchWeight,
    1.313251456,
    0.000000001,
    "Llama 3.2 1B Q8_0 GGUF swept text-decode traffic",
  );
  assertNear(
    modelProfile.architecture.weight_adapter.auxiliary_resident_weight_gb,
    0.007827744,
    0.000000001,
    "Llama 3.2 1B Q8_0 GGUF resident-only header footprint",
  );
  assertNear(
    result.alloc,
    3.2768,
    0.000000001,
    "Llama 3.2 1B Q8_0 GGUF full-context FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.048576,
    0.000000001,
    "Llama 3.2 1B Q8_0 GGUF full-context FP16 KV read traffic",
  );
  assert.equal(result.bMem, 36);
  assert.equal(result.best.batch, 11);
  assertNear(
    result.single.aggregate,
    115.58846066695908,
    0.000000001,
    "Llama 3.2 1B Q8_0 GGUF DGX single-session tok/s",
  );
  assertNear(
    result.best.aggregate,
    233.74038201993775,
    0.000000001,
    "Llama 3.2 1B Q8_0 GGUF DGX aggregate tok/s at b*",
  );
  assertNear(
    result.dennard,
    7529.019284667595,
    0.000000001,
    "Llama 3.2 1B Q8_0 GGUF DGX Dennard bound",
  );
}

{
  const modelProfile = profile("bartowski/Llama-3.2-1B-Instruct-GGUF");
  const result = profiled(
    "bartowski/Llama-3.2-1B-Instruct-GGUF",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "bartowski/Llama-3.2-1B-Instruct-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    2.47959536,
    0.000000001,
    "bartowski Llama 3.2 1B F16 GGUF resident file footprint",
  );
  assertNear(
    result.single.batchWeight,
    2.471764096,
    0.000000001,
    "bartowski Llama 3.2 1B F16 GGUF swept text-decode traffic",
  );
  assertNear(
    modelProfile.architecture.weight_adapter.auxiliary_resident_weight_gb,
    0.007831264,
    0.000000001,
    "bartowski Llama 3.2 1B F16 GGUF resident-only header footprint",
  );
  assertNear(
    result.alloc,
    3.2768,
    0.000000001,
    "bartowski Llama 3.2 1B F16 GGUF full-context FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.048576,
    0.000000001,
    "bartowski Llama 3.2 1B F16 GGUF full-context FP16 KV read traffic",
  );
  assert.equal(result.bMem, 35);
  assert.equal(result.best.batch, 10);
  assertNear(
    result.single.aggregate,
    77.54932550698648,
    0.000000001,
    "bartowski Llama 3.2 1B F16 GGUF DGX single-session tok/s",
  );
  assertNear(
    result.best.aggregate,
    210.68839847596763,
    0.000000001,
    "bartowski Llama 3.2 1B F16 GGUF DGX aggregate tok/s at b*",
  );
  assertNear(
    result.dennard,
    3961.128859515596,
    0.000000001,
    "bartowski Llama 3.2 1B F16 GGUF DGX Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 26);
  assertNear(
    m5Result.best.aggregate,
    536.8804283629007,
    0.000000001,
    "bartowski Llama 3.2 1B F16 GGUF M5 Max aggregate tok/s at b*",
  );
}

{
  const modelProfile = profile("MaziyarPanahi/Llama-3.2-1B-Instruct-GGUF");
  const modelRow = model("MaziyarPanahi/Llama-3.2-1B-Instruct-GGUF");
  const result = profiled(
    "MaziyarPanahi/Llama-3.2-1B-Instruct-GGUF",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "MaziyarPanahi/Llama-3.2-1B-Instruct-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(modelProfile.status, "audited");
  assert.equal(modelRow.hf_downloads, 119953);
  assert.equal(modelRow.license, "llama3.2");
  assert.ok(modelRow.tags.includes("region:us"));
  assert.equal(modelRow.architecture.detail, "llama");
  assert.equal(modelRow.architecture.max_context_tokens, 131072);
  assert.equal(modelRow.adapter.weight_precision, "GGUF F16");
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    2.479595392,
    0.000000001,
    "MaziyarPanahi Llama 3.2 1B F16 GGUF resident file footprint",
  );
  assertNear(
    result.single.batchWeight,
    2.471764096,
    0.000000001,
    "MaziyarPanahi Llama 3.2 1B F16 GGUF swept text-decode traffic",
  );
  assertNear(
    modelProfile.architecture.weight_adapter.auxiliary_resident_weight_gb,
    0.007831296,
    0.000000001,
    "MaziyarPanahi Llama 3.2 1B F16 GGUF resident-only header footprint",
  );
  assertNear(
    result.alloc,
    3.2768,
    0.000000001,
    "MaziyarPanahi Llama 3.2 1B F16 GGUF full-context FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.048576,
    0.000000001,
    "MaziyarPanahi Llama 3.2 1B F16 GGUF full-context FP16 KV read traffic",
  );
  assert.equal(result.bMem, 35);
  assert.equal(result.best.batch, 10);
  assertNear(
    result.single.aggregate,
    77.54932550698648,
    0.000000001,
    "MaziyarPanahi Llama 3.2 1B F16 GGUF DGX single-session tok/s",
  );
  assertNear(
    result.best.aggregate,
    210.68839847596763,
    0.000000001,
    "MaziyarPanahi Llama 3.2 1B F16 GGUF DGX aggregate tok/s at b*",
  );
  assertNear(
    result.dennard,
    3961.128858437008,
    0.000000001,
    "MaziyarPanahi Llama 3.2 1B F16 GGUF DGX Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 26);
  assertNear(
    m5Result.best.aggregate,
    536.8804283629007,
    0.000000001,
    "MaziyarPanahi Llama 3.2 1B F16 GGUF M5 Max aggregate tok/s at b*",
  );
}

{
  const modelProfile = profile("bartowski/Llama-3.2-3B-Instruct-GGUF");
  const result = profiled(
    "bartowski/Llama-3.2-3B-Instruct-GGUF",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "bartowski/Llama-3.2-3B-Instruct-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    6.43368784,
    0.000000001,
    "bartowski Llama 3.2 3B F16 GGUF resident file footprint",
  );
  assertNear(
    result.single.batchWeight,
    6.425850112,
    0.000000001,
    "bartowski Llama 3.2 3B F16 GGUF swept text-decode traffic",
  );
  assertNear(
    modelProfile.architecture.weight_adapter.auxiliary_resident_weight_gb,
    0.007837728,
    0.000000001,
    "bartowski Llama 3.2 3B F16 GGUF resident-only header footprint",
  );
  assertNear(
    result.alloc,
    11.4688,
    0.000000001,
    "bartowski Llama 3.2 3B F16 GGUF full-context FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    3.670016,
    0.000000001,
    "bartowski Llama 3.2 3B F16 GGUF full-context FP16 KV read traffic",
  );
  assert.equal(result.bMem, 9);
  assert.equal(result.best.batch, 1);
  assertNear(
    result.single.aggregate,
    27.040770645275373,
    0.000000001,
    "bartowski Llama 3.2 3B F16 GGUF DGX single-session tok/s",
  );
  assertNear(
    result.best.aggregate,
    27.040770645275373,
    0.000000001,
    "bartowski Llama 3.2 3B F16 GGUF DGX aggregate tok/s at b*",
  );
  assertNear(
    result.dennard,
    420.6913668661886,
    0.000000001,
    "bartowski Llama 3.2 3B F16 GGUF DGX Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 6);
  assertNear(
    m5Result.best.aggregate,
    129.50878784256344,
    0.000000001,
    "bartowski Llama 3.2 3B F16 GGUF M5 Max aggregate tok/s at b*",
  );
  assertNear(
    m5Result.best.perSession,
    21.584797973760573,
    0.000000001,
    "bartowski Llama 3.2 3B F16 GGUF M5 Max per-session tok/s at b*",
  );
}

{
  const result = profiled(
    "empero-ai/Qwythos-9B-Claude-Mythos-5-1M-GGUF",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    5.629109152,
    0.000000001,
    "Qwythos 9B Q4_K_M GGUF resident file footprint",
  );
  assertNear(
    result.single.batchWeight,
    5.046011904,
    0.000000001,
    "Qwythos 9B Q4_K_M GGUF swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    0.583097248,
    0.000000001,
    "Qwythos 9B Q4_K_M GGUF resident-only token embedding plus header footprint",
  );
  assertNear(
    result.alloc,
    3.328704512,
    0.000000001,
    "Qwythos 9B Q4_K_M GGUF Qwen3.5 hybrid KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.100480512,
    0.000000001,
    "Qwythos 9B Q4_K_M GGUF Qwen3.5 hybrid KV plus DeltaNet state read traffic",
  );
  assertNear(
    result.single.aggregate,
    44.415575831,
    0.000000001,
    "Qwythos 9B Q4_K_M GGUF DGX single-session tok/s",
  );
  assert.equal(result.best.batch, 7);
  assertNear(
    result.best.aggregate,
    149.889694738,
    0.000000001,
    "Qwythos 9B Q4_K_M GGUF DGX aggregate tok/s at b*",
  );
  assertNear(
    result.dennard,
    1858.8940423,
    0.000000001,
    "Qwythos 9B Q4_K_M GGUF DGX Dennard bound",
  );
}

{
  const result = profiled(
    "lmstudio-community/Qwen3.5-9B-GGUF",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    5.627044256,
    0.000000001,
    "LM Studio Qwen3.5 9B Q4_K_M GGUF resident file footprint",
  );
  assertNear(
    result.single.batchWeight,
    5.04394752,
    0.000000001,
    "LM Studio Qwen3.5 9B Q4_K_M GGUF swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    0.583096736,
    0.000000001,
    "LM Studio Qwen3.5 9B Q4_K_M GGUF resident-only token embedding plus header footprint",
  );
  assertNear(
    result.alloc,
    3.328704512,
    0.000000001,
    "LM Studio Qwen3.5 9B Q4_K_M GGUF Qwen3.5 hybrid KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.100480512,
    0.000000001,
    "LM Studio Qwen3.5 9B Q4_K_M GGUF Qwen3.5 hybrid KV plus DeltaNet state read traffic",
  );
  assertNear(
    result.single.aggregate,
    44.430498425,
    0.000000001,
    "LM Studio Qwen3.5 9B Q4_K_M GGUF DGX single-session tok/s",
  );
  assert.equal(result.bMem, 34);
  assert.equal(result.best.batch, 7);
  assertNear(
    result.best.aggregate,
    149.913968868,
    0.000000001,
    "LM Studio Qwen3.5 9B Q4_K_M GGUF DGX aggregate tok/s at b*",
  );
  assertNear(
    result.best.perSession,
    21.416281267,
    0.000000001,
    "LM Studio Qwen3.5 9B Q4_K_M GGUF DGX per-session tok/s at b*",
  );
  assertNear(
    result.dennard,
    1859.688424329,
    0.000000001,
    "LM Studio Qwen3.5 9B Q4_K_M GGUF DGX Dennard bound",
  );

  const m5Result = profiled(
    "lmstudio-community/Qwen3.5-9B-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 23);
  assertNear(
    m5Result.best.aggregate,
    465.22814454,
    0.000000001,
    "LM Studio Qwen3.5 9B Q4_K_M GGUF M5 Max aggregate tok/s at b*",
  );
  assertNear(
    m5Result.best.perSession,
    20.227310632,
    0.000000001,
    "LM Studio Qwen3.5 9B Q4_K_M GGUF M5 Max per-session tok/s at b*",
  );
}

{
  const result = profiled(
    "rippertnt/HyperCLOVAX-SEED-Text-Instruct-1.5B-Q4_K_M-GGUF",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    1.133974368,
    0.000000001,
    "HyperCLOVAX SEED Q4_K_M GGUF resident file footprint",
  );
  assertNear(
    result.single.batchWeight,
    1.002512384,
    0.000000001,
    "HyperCLOVAX SEED Q4_K_M GGUF swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    0.131461984,
    0.000000001,
    "HyperCLOVAX SEED Q4_K_M GGUF resident-only token embedding plus header footprint",
  );
  assertNear(
    result.alloc,
    9.8304,
    0.000000001,
    "HyperCLOVAX SEED Q4_K_M GGUF full-context FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    3.145728,
    0.000000001,
    "HyperCLOVAX SEED Q4_K_M GGUF full-context FP16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    65.811036663,
    0.000000001,
    "HyperCLOVAX SEED Q4_K_M GGUF DGX single-session tok/s",
  );
  assert.equal(result.bMem, 12);
  assert.equal(result.best.batch, 4);
  assertNear(
    result.best.aggregate,
    80.380264108,
    0.000000001,
    "HyperCLOVAX SEED Q4_K_M GGUF DGX aggregate tok/s at b*",
  );
  assertNear(
    result.dennard,
    3292.755267855,
    0.000000001,
    "HyperCLOVAX SEED Q4_K_M GGUF DGX Dennard bound",
  );
}

{
  const result = profiled(
    "lmg-anon/vntl-llama3-8b-v2-gguf",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    5.732991008,
    0.000000001,
    "VNTL Llama 3 8B Q5_K_M GGUF resident file footprint",
  );
  assertNear(
    result.single.batchWeight,
    5.363982336,
    0.000000001,
    "VNTL Llama 3 8B Q5_K_M GGUF swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    0.369008672,
    0.000000001,
    "VNTL Llama 3 8B Q5_K_M GGUF resident-only token embedding plus header footprint",
  );
  assertNear(
    result.alloc,
    13.1072,
    0.000000001,
    "VNTL Llama 3 8B Q5_K_M GGUF full-context FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    4.194304,
    0.000000001,
    "VNTL Llama 3 8B Q5_K_M GGUF full-context FP16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    28.561605125,
    0.000000001,
    "VNTL Llama 3 8B Q5_K_M GGUF DGX single-session tok/s",
  );
  assert.equal(result.bMem, 8);
  assert.equal(result.best.batch, 1);
  assertNear(
    result.best.aggregate,
    28.561605125,
    0.000000001,
    "VNTL Llama 3 8B Q5_K_M GGUF DGX aggregate tok/s at b*",
  );
  assertNear(
    result.dennard,
    443.696743611,
    0.000000001,
    "VNTL Llama 3 8B Q5_K_M GGUF DGX Dennard bound",
  );
}

{
  const result = profiled("unsloth/Qwen3.5-9B-GGUF", "nvidia-dgx-spark");
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    17.920697312,
    0.000000001,
    "Unsloth Qwen3.5 9B BF16 GGUF resident file footprint",
  );
  assertNear(
    result.single.batchWeight,
    15.87549184,
    0.000000001,
    "Unsloth Qwen3.5 9B BF16 GGUF swept text-decode traffic",
  );
  assertNear(
    result.alloc,
    3.328704512,
    0.000000001,
    "Unsloth Qwen3.5 9B BF16 GGUF FP16 KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.100480512,
    0.000000001,
    "Unsloth Qwen3.5 9B BF16 GGUF FP16 KV plus DeltaNet state read traffic",
  );
  assertNear(
    result.single.aggregate,
    16.081553,
    0.000001,
    "Unsloth Qwen3.5 9B BF16 GGUF DGX single",
  );
  assert.equal(result.best, null);
  assertNear(
    result.dennard,
    527.348734,
    0.000001,
    "Unsloth Qwen3.5 9B BF16 GGUF DGX Dennard",
  );
}

{
  const result = profiled(
    "unsloth/Qwen3.5-9B-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.single.aggregate,
    36.168768,
    0.000001,
    "Unsloth Qwen3.5 9B BF16 GGUF M5 Max single",
  );
  assert.equal(result.best.batch, 13);
  assertNear(
    result.best.aggregate,
    264.464554,
    0.000001,
    "Unsloth Qwen3.5 9B BF16 GGUF M5 Max aggregate",
  );
  assertNear(
    result.dennard,
    1186.051732,
    0.000001,
    "Unsloth Qwen3.5 9B BF16 GGUF M5 Max Dennard",
  );
}

{
  const repo = "unsloth/Qwen3.5-9B-MTP-GGUF";
  const catalog = model(repo);
  const modelProfile = profile(repo);
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  const m1Result = profiled(repo, "apple-mac-studio-m1-ultra-128gb");
  assert.equal(catalog.hf_downloads, 124435);
  assert.ok(catalog.tags.includes("region:us"));
  assert.equal(
    catalog.architecture.detail,
    "qwen35 GGUF selected BF16 MTP artifact",
  );
  assert.equal(catalog.architecture.total_params_b, 9.197093888);
  assert.equal(catalog.architecture.active_params_b, 7.936684544);
  assert.equal(catalog.adapter.weight_precision, "BF16/F32 GGUF MTP");
  assertNear(
    catalog.adapter.kv_alloc_gb_per_1k_tokens,
    0.032768,
    0.000000001,
    "Unsloth Qwen3.5 9B MTP catalog full-attention KV allocation per 1K",
  );
  assertNear(
    catalog.adapter.kv_alloc_fixed_gb,
    0.051904512,
    0.000000001,
    "Unsloth Qwen3.5 9B MTP catalog DeltaNet fixed state allocation",
  );
  assert.equal(modelProfile.serving.weight_format, "mixed_bf16_f32");
  assert.equal(
    modelProfile.serving.runtime_format,
    "llama.cpp-gguf-bf16-f32-mtp-memory-bound",
  );
  assert.equal(result.status_code, "no_floor");
  assertNear(
    weightAdapter.resident_params_b,
    9.197093888,
    0.000000001,
    "Unsloth Qwen3.5 9B MTP GGUF logical resident parameters",
  );
  assertNear(
    weightAdapter.swept_params_b,
    7.936684544,
    0.000000001,
    "Unsloth Qwen3.5 9B MTP GGUF ordinary swept parameters",
  );
  assertNear(
    weightAdapter.auxiliary_resident_params_b,
    1.260409344,
    0.000000001,
    "Unsloth Qwen3.5 9B MTP GGUF auxiliary resident parameters",
  );
  assertNear(
    result.resident,
    18.407321728,
    0.000000001,
    "Unsloth Qwen3.5 9B MTP GGUF resident file footprint",
  );
  assertNear(
    result.single.batchWeight,
    15.87549184,
    0.000000001,
    "Unsloth Qwen3.5 9B MTP GGUF ordinary swept text-decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    2.531829888,
    0.000000001,
    "Unsloth Qwen3.5 9B MTP GGUF resident-only token embedding plus MTP/header footprint",
  );
  assertNear(
    result.alloc,
    3.328704512,
    0.000000001,
    "Unsloth Qwen3.5 9B MTP GGUF hybrid KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.100480512,
    0.000000001,
    "Unsloth Qwen3.5 9B MTP GGUF hybrid KV plus DeltaNet state read traffic",
  );
  assertNear(
    result.single.aggregate,
    16.08155305270846,
    0.000000001,
    "Unsloth Qwen3.5 9B MTP GGUF DGX single-session tok/s",
  );
  assert.equal(result.bMem, 30);
  assert.equal(result.best, null);
  assertNear(
    result.dennard,
    524.8347988792368,
    0.000000001,
    "Unsloth Qwen3.5 9B MTP GGUF DGX Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 13);
  assertNear(
    m5Result.best.aggregate,
    264.4645536590895,
    0.000000001,
    "Unsloth Qwen3.5 9B MTP GGUF M5 aggregate tok/s at b*",
  );
  assertNear(
    m5Result.best.perSession,
    20.343427204545346,
    0.000000001,
    "Unsloth Qwen3.5 9B MTP GGUF M5 per-session tok/s at b*",
  );
  assertNear(
    m5Result.dennard,
    1180.3976795305912,
    0.000000001,
    "Unsloth Qwen3.5 9B MTP GGUF M5 Dennard bound",
  );
  assert.equal(m1Result.status_code, "ok");
  assert.equal(m1Result.best.batch, 21);
  assertNear(
    m1Result.best.aggregate,
    430.92853519258244,
    0.000000001,
    "Unsloth Qwen3.5 9B MTP GGUF M1 Ultra aggregate tok/s at b*",
  );
  assertNear(
    m1Result.best.perSession,
    20.52040643774202,
    0.000000001,
    "Unsloth Qwen3.5 9B MTP GGUF M1 Ultra per-session tok/s at b*",
  );
}

{
  const result = calculate("unsloth/Qwen3.5-4B-GGUF", "nvidia-dgx-spark");
  assertNear(
    result.resident,
    8.424393632,
    0.000000001,
    "Legacy Unsloth Qwen3.5 4B BF16 GGUF resident file footprint",
  );
  assertNear(
    result.single.batchWeight,
    8.413425664,
    0.000000001,
    "Legacy Unsloth Qwen3.5 4B BF16 GGUF swept text-decode traffic",
  );
  assertNear(
    result.alloc,
    3.328704512,
    0.000000001,
    "Legacy Unsloth Qwen3.5 4B BF16 GGUF FP16 KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.100480512,
    0.000000001,
    "Legacy Unsloth Qwen3.5 4B BF16 GGUF FP16 KV plus DeltaNet state read traffic",
  );
  assert.equal(result.bMem, 33);
  assert.equal(result.best.batch, 4);
}

{
  const result = profiled("unsloth/Qwen3.5-4B-GGUF", "nvidia-dgx-spark");
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    8.424393632,
    0.000000001,
    "Unsloth Qwen3.5 4B BF16 GGUF resident file footprint",
  );
  assertNear(
    result.single.batchWeight,
    8.413425664,
    0.000000001,
    "Unsloth Qwen3.5 4B BF16 GGUF swept text-decode traffic",
  );
  assertNear(
    result.alloc,
    3.328704512,
    0.000000001,
    "Unsloth Qwen3.5 4B BF16 GGUF FP16 KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.100480512,
    0.000000001,
    "Unsloth Qwen3.5 4B BF16 GGUF FP16 KV plus DeltaNet state read traffic",
  );
  assert.equal(result.bMem, 33);
  assert.equal(result.best.batch, 4);
  assertNear(
    result.single.aggregate,
    28.694838371296544,
    0.000000001,
    "Unsloth Qwen3.5 4B BF16 GGUF DGX single",
  );
  assertNear(
    result.best.aggregate,
    85.21032940662826,
    0.000000001,
    "Unsloth Qwen3.5 4B BF16 GGUF DGX aggregate",
  );
  assertNear(
    result.best.perSession,
    21.302582351657065,
    0.000000001,
    "Unsloth Qwen3.5 4B BF16 GGUF DGX per-session",
  );
  assertNear(
    result.dennard,
    1087.6365563898619,
    0.000000001,
    "Unsloth Qwen3.5 4B BF16 GGUF DGX Dennard",
  );
}

{
  const result = profiled(
    "unsloth/Qwen3.5-4B-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.single.aggregate,
    64.53710901090139,
    0.000000001,
    "Unsloth Qwen3.5 4B BF16 GGUF M5 Max single",
  );
  assert.equal(result.best.batch, 20);
  assertNear(
    result.best.aggregate,
    403.64150503419785,
    0.000000001,
    "Unsloth Qwen3.5 4B BF16 GGUF M5 Max aggregate",
  );
  assertNear(
    result.best.perSession,
    20.182075251709893,
    0.000000001,
    "Unsloth Qwen3.5 4B BF16 GGUF M5 Max per-session",
  );
  assertNear(
    result.dennard,
    2446.1862477046716,
    0.000000001,
    "Unsloth Qwen3.5 4B BF16 GGUF M5 Max Dennard",
  );
}

{
  const catalogRow = model("unsloth/Qwen3.5-4B-MTP-GGUF");
  const modelProfile = profile("unsloth/Qwen3.5-4B-MTP-GGUF");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled("unsloth/Qwen3.5-4B-MTP-GGUF", "nvidia-dgx-spark");
  assert.equal(result.status_code, "ok");
  assert.equal(
    catalogRow.hf_downloads,
    115139,
    "Unsloth Qwen3.5 4B MTP GGUF retains the older scrape count that qualified it for the audit queue",
  );
  assert.ok(catalogRow.tags.includes("region:us"));
  assert.equal(
    modelProfile.base_model_proof.config_compatible,
    true,
    "Unsloth Qwen3.5 4B MTP GGUF matches the base ordinary text geometry and one configured MTP layer",
  );
  assertNear(
    weightAdapter.resident_weight_gb,
    8.665620544,
    0.000000001,
    "Unsloth Qwen3.5 4B MTP GGUF resident file footprint",
  );
  assertNear(
    weightAdapter.swept_weight_gb,
    8.413425664,
    0.000000001,
    "Unsloth Qwen3.5 4B MTP GGUF swept ordinary text traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.25219488,
    0.000000001,
    "Unsloth Qwen3.5 4B MTP GGUF resident-only MTP block and GGUF overhead",
  );
  assertNear(
    weightAdapter.auxiliary_resident_params_b,
    0.120599552,
    0.000000001,
    "Unsloth Qwen3.5 4B MTP GGUF resident-only MTP draft params",
  );
  assertNear(
    catalogRow.adapter.active_weight_gb,
    8.413425664,
    0.000000001,
    "Unsloth Qwen3.5 4B MTP GGUF catalog swept ordinary text traffic",
  );
  assertNear(
    result.resident,
    8.665620544,
    0.000000001,
    "Unsloth Qwen3.5 4B MTP GGUF profiled resident file footprint",
  );
  assertNear(
    result.single.batchWeight,
    8.413425664,
    0.000000001,
    "Unsloth Qwen3.5 4B MTP GGUF profiled swept ordinary text traffic",
  );
  assertNear(
    result.alloc,
    3.328704512,
    0.000000001,
    "Unsloth Qwen3.5 4B MTP GGUF FP16 KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.100480512,
    0.000000001,
    "Unsloth Qwen3.5 4B MTP GGUF FP16 KV plus DeltaNet state read traffic",
  );
  assert.equal(result.bMem, 33);
  assert.equal(result.best.batch, 4);
  assertNear(
    result.single.aggregate,
    28.69483837129655,
    0.000000001,
    "Unsloth Qwen3.5 4B MTP GGUF DGX single",
  );
  assertNear(
    result.best.aggregate,
    85.21032940662828,
    0.000000001,
    "Unsloth Qwen3.5 4B MTP GGUF DGX aggregate",
  );
  assertNear(
    result.best.perSession,
    21.30258235165707,
    0.000000001,
    "Unsloth Qwen3.5 4B MTP GGUF DGX per-session",
  );
  assertNear(
    result.dennard,
    1085.2850817582932,
    0.000000001,
    "Unsloth Qwen3.5 4B MTP GGUF DGX Dennard",
  );
}

{
  const result = profiled(
    "unsloth/Qwen3.5-4B-MTP-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.single.aggregate,
    64.5371090109014,
    0.000000001,
    "Unsloth Qwen3.5 4B MTP GGUF M5 Max single",
  );
  assert.equal(result.best.batch, 20);
  assertNear(
    result.best.aggregate,
    403.64150503419796,
    0.000000001,
    "Unsloth Qwen3.5 4B MTP GGUF M5 Max aggregate",
  );
  assertNear(
    result.best.perSession,
    20.182075251709897,
    0.000000001,
    "Unsloth Qwen3.5 4B MTP GGUF M5 Max per-session",
  );
  assertNear(
    result.dennard,
    2440.897583148689,
    0.000000001,
    "Unsloth Qwen3.5 4B MTP GGUF M5 Max Dennard",
  );
}

{
  const modelProfile = profile("Qwen/Qwen3-4B-Instruct-2507-FP8");
  const result = profiled(
    "Qwen/Qwen3-4B-Instruct-2507-FP8",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    5.189976192,
    0.000000001,
    "Qwen3 4B Instruct 2507 FP8 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    4.412063872,
    0.000000001,
    "Qwen3 4B Instruct 2507 FP8 swept text-decode traffic",
  );
  assertNear(
    modelProfile.architecture.weight_adapter.auxiliary_resident_weight_gb,
    0.77791232,
    0.000000001,
    "Qwen3 4B Instruct 2507 FP8 resident-only input embedding footprint",
  );
  assertNear(
    result.alloc,
    14.7456,
    0.000000001,
    "Qwen3 4B Instruct 2507 FP8 full-context KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    4.718592,
    0.000000001,
    "Qwen3 4B Instruct 2507 FP8 full-context KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    29.899276002,
    0.000000001,
    "Qwen3 4B Instruct 2507 FP8 DGX single-session tok/s",
  );
  assert.equal(result.bMem, 7);
  assert.equal(result.best.batch, 1);
  assertNear(
    result.best.aggregate,
    29.899276002,
    0.000000001,
    "Qwen3 4B Instruct 2507 FP8 DGX aggregate tok/s at b*",
  );
  assertNear(
    result.dennard,
    481.768293357,
    0.000000001,
    "Qwen3 4B Instruct 2507 FP8 DGX Dennard bound",
  );
}

{
  const modelProfile = profile("Qwen/Qwen3-4B-Thinking-2507-FP8");
  const modelRow = model("Qwen/Qwen3-4B-Thinking-2507-FP8");
  const result = profiled(
    "Qwen/Qwen3-4B-Thinking-2507-FP8",
    "nvidia-dgx-spark",
  );
  assert.equal(modelProfile.status, "audited");
  assert.equal(modelRow.hf_downloads, 207284);
  assert.equal(modelRow.architecture.total_params_b, 4.411646016);
  assert.equal(modelRow.architecture.active_params_b, 4.022689856);
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    5.189976192,
    0.000000001,
    "Qwen3 4B Thinking 2507 FP8 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    4.412063872,
    0.000000001,
    "Qwen3 4B Thinking 2507 FP8 swept text-decode traffic",
  );
  assertNear(
    modelProfile.architecture.weight_adapter.auxiliary_resident_weight_gb,
    0.77791232,
    0.000000001,
    "Qwen3 4B Thinking 2507 FP8 resident-only input embedding footprint",
  );
  assertNear(
    result.alloc,
    14.7456,
    0.000000001,
    "Qwen3 4B Thinking 2507 FP8 full-context KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    4.718592,
    0.000000001,
    "Qwen3 4B Thinking 2507 FP8 full-context KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    29.899276002,
    0.000000001,
    "Qwen3 4B Thinking 2507 FP8 DGX single-session tok/s",
  );
  assert.equal(result.bMem, 7);
  assert.equal(result.best.batch, 1);
  assertNear(
    result.best.aggregate,
    29.899276002,
    0.000000001,
    "Qwen3 4B Thinking 2507 FP8 DGX aggregate tok/s at b*",
  );
  assertNear(
    result.dennard,
    481.768293357,
    0.000000001,
    "Qwen3 4B Thinking 2507 FP8 DGX Dennard bound",
  );
}

{
  const result = profiled(
    "Qwen/Qwen3-4B-Instruct-2507-FP8",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.single.aggregate,
    67.245990716,
    0.000000001,
    "Qwen3 4B Instruct 2507 FP8 M5 Max single-session tok/s",
  );
  assert.equal(result.best.batch, 5);
  assertNear(
    result.best.aggregate,
    109.623188112,
    0.000000001,
    "Qwen3 4B Instruct 2507 FP8 M5 Max aggregate tok/s at b*",
  );
  assertNear(
    result.dennard,
    1083.537480298,
    0.000000001,
    "Qwen3 4B Instruct 2507 FP8 M5 Max Dennard bound",
  );
}

{
  const modelProfile = profile("RedHatAI/Llama-3.2-1B-Instruct-FP8");
  const result = profiled(
    "RedHatAI/Llama-3.2-1B-Instruct-FP8",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    2.023887296,
    0.000000001,
    "RedHatAI Llama 3.2 1B static FP8 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    1.49855072,
    0.000000001,
    "RedHatAI Llama 3.2 1B static FP8 swept text-decode traffic",
  );
  assertNear(
    modelProfile.architecture.weight_adapter.auxiliary_resident_weight_gb,
    0.525336576,
    0.000000001,
    "RedHatAI Llama 3.2 1B static FP8 resident-only input embedding footprint",
  );
  assertNear(
    result.alloc,
    3.2768,
    0.000000001,
    "RedHatAI Llama 3.2 1B static FP8 full-context KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.048576,
    0.000000001,
    "RedHatAI Llama 3.2 1B static FP8 full-context KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    107.179590971,
    0.000000001,
    "RedHatAI Llama 3.2 1B static FP8 DGX single-session tok/s",
  );
  assert.equal(result.bMem, 36);
  assert.equal(result.best.batch, 11);
  assertNear(
    result.best.aggregate,
    230.417102866,
    0.000000001,
    "RedHatAI Llama 3.2 1B static FP8 DGX aggregate tok/s at b*",
  );
  assertNear(
    result.dennard,
    6558.965515145,
    0.000000001,
    "RedHatAI Llama 3.2 1B static FP8 DGX Dennard bound",
  );
}

{
  const result = profiled(
    "RedHatAI/Llama-3.2-1B-Instruct-FP8",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.single.aggregate,
    241.055929875,
    0.000000001,
    "RedHatAI Llama 3.2 1B static FP8 M5 Max single-session tok/s",
  );
  assert.equal(result.best.batch, 27);
  assertNear(
    result.best.aggregate,
    556.120190384,
    0.000000001,
    "RedHatAI Llama 3.2 1B static FP8 M5 Max aggregate tok/s at b*",
  );
  assertNear(
    result.dennard,
    14751.666030399,
    0.000000001,
    "RedHatAI Llama 3.2 1B static FP8 M5 Max Dennard bound",
  );
}

{
  const modelProfile = profile("RedHatAI/Meta-Llama-3.1-8B-FP8");
  const result = profiled("RedHatAI/Meta-Llama-3.1-8B-FP8", "nvidia-dgx-spark");
  assert.equal(result.status_code, "ok");
  assert.equal(modelProfile.serving.kv_store_format, "fp16");
  assert.equal(modelProfile.serving.kv_read_format, "fp16");
  assertNear(
    result.resident,
    9.081201536,
    0.000000001,
    "RedHatAI Llama 3.1 8B base static FP8 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    8.030528384,
    0.000000001,
    "RedHatAI Llama 3.1 8B base static FP8 swept text-decode traffic",
  );
  assertNear(
    modelProfile.architecture.weight_adapter.auxiliary_resident_weight_gb,
    1.050673152,
    0.000000001,
    "RedHatAI Llama 3.1 8B base static FP8 resident-only input embedding footprint",
  );
  assertNear(
    result.alloc,
    13.1072,
    0.000000001,
    "RedHatAI Llama 3.1 8B base static FP8 full-context KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    4.194304,
    0.000000001,
    "RedHatAI Llama 3.1 8B base static FP8 full-context KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    22.33159453,
    0.000000001,
    "RedHatAI Llama 3.1 8B base static FP8 DGX single-session tok/s",
  );
  assert.equal(result.bMem, 8);
  assert.equal(result.best.batch, 1);
  assertNear(
    result.best.aggregate,
    22.33159453,
    0.000000001,
    "RedHatAI Llama 3.1 8B base static FP8 DGX aggregate tok/s at b*",
  );
  assertNear(
    result.dennard,
    287.682706377,
    0.000000001,
    "RedHatAI Llama 3.1 8B base static FP8 DGX Dennard bound",
  );
}

{
  const result = profiled(
    "RedHatAI/Meta-Llama-3.1-8B-FP8",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.single.aggregate,
    50.225637515,
    0.000000001,
    "RedHatAI Llama 3.1 8B base static FP8 M5 Max single-session tok/s",
  );
  assert.equal(result.best.batch, 5);
  assertNear(
    result.best.aggregate,
    105.85459204,
    0.000000001,
    "RedHatAI Llama 3.1 8B base static FP8 M5 Max aggregate tok/s at b*",
  );
  assertNear(
    result.dennard,
    647.022643648,
    0.000000001,
    "RedHatAI Llama 3.1 8B base static FP8 M5 Max Dennard bound",
  );
}

{
  const modelProfile = profile("RedHatAI/Meta-Llama-3.1-8B-Instruct-FP8");
  const result = profiled(
    "RedHatAI/Meta-Llama-3.1-8B-Instruct-FP8",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    9.081201536,
    0.000000001,
    "RedHatAI Llama 3.1 8B static FP8 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    8.030528384,
    0.000000001,
    "RedHatAI Llama 3.1 8B static FP8 swept text-decode traffic",
  );
  assertNear(
    modelProfile.architecture.weight_adapter.auxiliary_resident_weight_gb,
    1.050673152,
    0.000000001,
    "RedHatAI Llama 3.1 8B static FP8 resident-only input embedding footprint",
  );
  assertNear(
    result.alloc,
    13.1072,
    0.000000001,
    "RedHatAI Llama 3.1 8B static FP8 full-context KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    4.194304,
    0.000000001,
    "RedHatAI Llama 3.1 8B static FP8 full-context KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    22.33159453,
    0.000000001,
    "RedHatAI Llama 3.1 8B static FP8 DGX single-session tok/s",
  );
  assert.equal(result.bMem, 8);
  assert.equal(result.best.batch, 1);
  assertNear(
    result.best.aggregate,
    22.33159453,
    0.000000001,
    "RedHatAI Llama 3.1 8B static FP8 DGX aggregate tok/s at b*",
  );
  assertNear(
    result.dennard,
    287.682706377,
    0.000000001,
    "RedHatAI Llama 3.1 8B static FP8 DGX Dennard bound",
  );
}

{
  const result = profiled(
    "RedHatAI/Meta-Llama-3.1-8B-Instruct-FP8",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.single.aggregate,
    50.225637515,
    0.000000001,
    "RedHatAI Llama 3.1 8B static FP8 M5 Max single-session tok/s",
  );
  assert.equal(result.best.batch, 5);
  assertNear(
    result.best.aggregate,
    105.85459204,
    0.000000001,
    "RedHatAI Llama 3.1 8B static FP8 M5 Max aggregate tok/s at b*",
  );
  assertNear(
    result.dennard,
    647.022643648,
    0.000000001,
    "RedHatAI Llama 3.1 8B static FP8 M5 Max Dennard bound",
  );
}

{
  const catalog = model("hugging-quants/Meta-Llama-3.1-8B-Instruct-AWQ-INT4");
  const modelProfile = profile(
    "hugging-quants/Meta-Llama-3.1-8B-Instruct-AWQ-INT4",
  );
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "hugging-quants/Meta-Llama-3.1-8B-Instruct-AWQ-INT4",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "hugging-quants/Meta-Llama-3.1-8B-Instruct-AWQ-INT4",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  const m1Result = profiled(
    "hugging-quants/Meta-Llama-3.1-8B-Instruct-AWQ-INT4",
    "apple-mac-studio-m1-ultra-128gb",
  );
  assert.equal(catalog.hf_downloads, 194297);
  assert.equal(catalog.adapter.weight_precision, "AWQ INT4");
  assertNear(
    catalog.adapter.active_weight_gb,
    4.67718144,
    0.000000001,
    "Hugging Quants Llama 3.1 8B AWQ catalog swept traffic",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(modelProfile.serving.weight_format, "int4");
  assert.equal(
    modelProfile.serving.runtime_format,
    "transformers-autoawq-awq-gemm-memory-bound",
  );
  assertNear(
    weightAdapter.resident_params_b,
    8.030261248,
    0.000000001,
    "Hugging Quants Llama 3.1 8B AWQ logical resident parameters",
  );
  assertNear(
    weightAdapter.swept_params_b,
    7.504924672,
    0.000000001,
    "Hugging Quants Llama 3.1 8B AWQ ordinary swept parameters",
  );
  assertNear(
    result.resident,
    5.727854592,
    0.000000001,
    "Hugging Quants Llama 3.1 8B AWQ resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    4.67718144,
    0.000000001,
    "Hugging Quants Llama 3.1 8B AWQ swept text-decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.050673152,
    0.000000001,
    "Hugging Quants Llama 3.1 8B AWQ resident-only input embedding footprint",
  );
  assertNear(
    result.alloc,
    13.1072,
    0.000000001,
    "Hugging Quants Llama 3.1 8B AWQ full-context KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    4.194304,
    0.000000001,
    "Hugging Quants Llama 3.1 8B AWQ full-context KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    30.772749597163287,
    0.000000001,
    "Hugging Quants Llama 3.1 8B AWQ DGX single-session tok/s",
  );
  assert.equal(result.bMem, 8);
  assert.equal(result.best.batch, 2);
  assertNear(
    result.best.aggregate,
    41.788519745194975,
    0.000000001,
    "Hugging Quants Llama 3.1 8B AWQ DGX aggregate tok/s at b*",
  );
  assertNear(
    result.best.perSession,
    20.894259872597488,
    0.000000001,
    "Hugging Quants Llama 3.1 8B AWQ DGX per-session tok/s at b*",
  );
  assertNear(
    result.dennard,
    508.8723857188016,
    0.000000001,
    "Hugging Quants Llama 3.1 8B AWQ DGX Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 6);
  assertNear(
    m5Result.best.aggregate,
    123.4460117432462,
    0.000000001,
    "Hugging Quants Llama 3.1 8B AWQ M5 aggregate tok/s at b*",
  );
  assert.equal(m1Result.status_code, "ok");
  assert.equal(m1Result.best.batch, 8);
  assertNear(
    m1Result.best.aggregate,
    167.40073002788765,
    0.000000001,
    "Hugging Quants Llama 3.1 8B AWQ M1 Ultra aggregate tok/s at b*",
  );
}

{
  const modelProfile = profile("nvidia/Llama-3.1-8B-Instruct-FP8");
  const result = profiled(
    "nvidia/Llama-3.1-8B-Instruct-FP8",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    9.081202688,
    0.000000001,
    "NVIDIA Llama 3.1 8B ModelOpt FP8 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    8.030529536,
    0.000000001,
    "NVIDIA Llama 3.1 8B ModelOpt FP8 swept text-decode traffic",
  );
  assertNear(
    modelProfile.architecture.weight_adapter.auxiliary_resident_weight_gb,
    1.050673152,
    0.000000001,
    "NVIDIA Llama 3.1 8B ModelOpt FP8 resident-only input embedding footprint",
  );
  assert.equal(modelProfile.serving.kv_store_bytes_per_scalar, 1);
  assert.equal(modelProfile.serving.kv_read_bytes_per_scalar, 1);
  assertNear(
    result.alloc,
    6.5536,
    0.000000001,
    "NVIDIA Llama 3.1 8B ModelOpt FP8 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    2.097152,
    0.000000001,
    "NVIDIA Llama 3.1 8B ModelOpt FP8 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    26.9558239,
    0.000000001,
    "NVIDIA Llama 3.1 8B ModelOpt FP8 DGX single-session tok/s",
  );
  assert.equal(result.bMem, 16);
  assert.equal(result.best.batch, 2);
  assertNear(
    result.best.aggregate,
    44.663184852,
    0.000000001,
    "NVIDIA Llama 3.1 8B ModelOpt FP8 DGX aggregate tok/s at b*",
  );
  assertNear(
    result.dennard,
    575.365324242,
    0.000000001,
    "NVIDIA Llama 3.1 8B ModelOpt FP8 DGX Dennard bound",
  );
}

{
  const result = profiled(
    "nvidia/Llama-3.1-8B-Instruct-FP8",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.single.aggregate,
    60.625918955,
    0.000000001,
    "NVIDIA Llama 3.1 8B ModelOpt FP8 M5 Max single-session tok/s",
  );
  assert.equal(result.best.batch, 10);
  assertNear(
    result.best.aggregate,
    211.70917567,
    0.000000001,
    "NVIDIA Llama 3.1 8B ModelOpt FP8 M5 Max aggregate tok/s at b*",
  );
  assertNear(
    result.dennard,
    1294.045088221,
    0.000000001,
    "NVIDIA Llama 3.1 8B ModelOpt FP8 M5 Max Dennard bound",
  );
}

{
  const modelProfile = profile("nvidia/Llama-3.1-8B-Instruct-NVFP4");
  const result = profiled(
    "nvidia/Llama-3.1-8B-Instruct-NVFP4",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    6.027749376,
    0.000000001,
    "NVIDIA Llama 3.1 8B ModelOpt NVFP4 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    4.977076224,
    0.000000001,
    "NVIDIA Llama 3.1 8B ModelOpt NVFP4 swept text-decode traffic",
  );
  assertNear(
    modelProfile.architecture.weight_adapter.auxiliary_resident_weight_gb,
    1.050673152,
    0.000000001,
    "NVIDIA Llama 3.1 8B ModelOpt NVFP4 resident-only input embedding footprint",
  );
  assert.equal(modelProfile.serving.kv_store_bytes_per_scalar, 1);
  assert.equal(modelProfile.serving.kv_read_bytes_per_scalar, 1);
  assertNear(
    result.alloc,
    6.5536,
    0.000000001,
    "NVIDIA Llama 3.1 8B ModelOpt NVFP4 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    2.097152,
    0.000000001,
    "NVIDIA Llama 3.1 8B ModelOpt NVFP4 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    38.590782112,
    0.000000001,
    "NVIDIA Llama 3.1 8B ModelOpt NVFP4 DGX single-session tok/s",
  );
  assert.equal(result.bMem, 17);
  assert.equal(result.best.batch, 4);
  assertNear(
    result.best.aggregate,
    81.701765633,
    0.000000001,
    "NVIDIA Llama 3.1 8B ModelOpt NVFP4 DGX aggregate tok/s at b*",
  );
  assertNear(
    result.dennard,
    953.910323378,
    0.000000001,
    "NVIDIA Llama 3.1 8B ModelOpt NVFP4 DGX Dennard bound",
  );
}

{
  const result = profiled(
    "nvidia/Llama-3.1-8B-Instruct-NVFP4",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.single.aggregate,
    86.793920207,
    0.000000001,
    "NVIDIA Llama 3.1 8B ModelOpt NVFP4 M5 Max single-session tok/s",
  );
  assert.equal(result.best.batch, 12);
  assertNear(
    result.best.aggregate,
    244.435669602,
    0.000000001,
    "NVIDIA Llama 3.1 8B ModelOpt NVFP4 M5 Max aggregate tok/s at b*",
  );
  assertNear(
    result.dennard,
    2145.424683348,
    0.000000001,
    "NVIDIA Llama 3.1 8B ModelOpt NVFP4 M5 Max Dennard bound",
  );
}

{
  const modelProfile = profile("bartowski/Meta-Llama-3.1-8B-Instruct-GGUF");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const kvAdapter = modelProfile.architecture.kv_adapter;
  const result = profiled(
    "bartowski/Meta-Llama-3.1-8B-Instruct-GGUF",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "bartowski/Meta-Llama-3.1-8B-Instruct-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );

  assert.equal(modelProfile.status, "audited");
  assert.equal(
    modelProfile.serving.runtime_format,
    "llama.cpp-gguf-f32-memory-bound",
  );
  assert.equal(kvAdapter.kind, "full_context");
  assert.equal(kvAdapter.layers, 32);
  assert.equal(kvAdapter.kv_heads, 8);
  assert.equal(kvAdapter.head_dim, 128);
  assertNear(
    result.resident,
    32.128885888,
    0.000000001,
    "Bartowski Llama 3.1 8B F32 GGUF resident file footprint",
  );
  assertNear(
    result.single.batchWeight,
    30.019698944,
    0.000000001,
    "Bartowski Llama 3.1 8B F32 GGUF swept text-decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    2.109186944,
    0.000000001,
    "Bartowski Llama 3.1 8B F32 GGUF input embedding plus header overhead",
  );
  assertNear(
    result.alloc,
    13.1072,
    0.000000001,
    "Bartowski Llama 3.1 8B F32 GGUF full-context FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    4.194304,
    0.000000001,
    "Bartowski Llama 3.1 8B F32 GGUF full-context FP16 KV read traffic",
  );
  assert.equal(result.status_code, "no_floor");
  assert.equal(result.bMem, 6);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    7.979189118760368,
    0.000000001,
    "Bartowski Llama 3.1 8B F32 GGUF DGX single-session throughput",
  );
  assertNear(
    result.dennard,
    60.96667653071715,
    0.000000001,
    "Bartowski Llama 3.1 8B F32 GGUF DGX Dennard bound",
  );
  assert.equal(m5Result.status_code, "no_floor");
  assert.equal(m5Result.best, null);
  assertNear(
    m5Result.single.aggregate,
    17.945868567468374,
    0.000000001,
    "Bartowski Llama 3.1 8B F32 GGUF M5 single-session throughput",
  );
  assertNear(
    m5Result.dennard,
    137.1191919042503,
    0.000000001,
    "Bartowski Llama 3.1 8B F32 GGUF M5 Dennard bound",
  );
}

{
  const modelRow = model("MaziyarPanahi/Meta-Llama-3.1-8B-Instruct-GGUF");
  const modelProfile = profile("MaziyarPanahi/Meta-Llama-3.1-8B-Instruct-GGUF");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const kvAdapter = modelProfile.architecture.kv_adapter;
  const result = profiled(
    "MaziyarPanahi/Meta-Llama-3.1-8B-Instruct-GGUF",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "MaziyarPanahi/Meta-Llama-3.1-8B-Instruct-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );

  assert.equal(modelRow.hf_downloads, 136669);
  assert.equal(modelRow.name, "Meta-Llama-3.1-8B-Instruct-GGUF GGUF Q2_K");
  assert.equal(modelRow.tags.includes("region:us"), true);
  assert.equal(modelProfile.status, "audited");
  assert.equal(
    modelProfile.serving.runtime_format,
    "llama.cpp-gguf-q2-k-memory-bound",
  );
  assert.equal(kvAdapter.kind, "full_context");
  assert.equal(kvAdapter.layers, 32);
  assert.equal(kvAdapter.kv_heads, 8);
  assert.equal(kvAdapter.head_dim, 128);
  assertNear(
    result.resident,
    3.179131808,
    0.000000001,
    "MaziyarPanahi Llama 3.1 8B Q2_K GGUF resident file footprint",
  );
  assertNear(
    result.single.batchWeight,
    2.998919168,
    0.000000001,
    "MaziyarPanahi Llama 3.1 8B Q2_K GGUF swept text-decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.18021264,
    0.000000001,
    "MaziyarPanahi Llama 3.1 8B Q2_K GGUF input embedding plus header overhead",
  );
  assertNear(
    result.alloc,
    13.1072,
    0.000000001,
    "MaziyarPanahi Llama 3.1 8B Q2_K GGUF full-context FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    4.194304,
    0.000000001,
    "MaziyarPanahi Llama 3.1 8B Q2_K GGUF full-context FP16 KV read traffic",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(result.bMem, 8);
  assert.equal(result.best.batch, 2);
  assertNear(
    result.single.aggregate,
    37.952388466755274,
    0.000000001,
    "MaziyarPanahi Llama 3.1 8B Q2_K GGUF DGX single-session throughput",
  );
  assertNear(
    result.best.aggregate,
    47.947196256471756,
    0.000000001,
    "MaziyarPanahi Llama 3.1 8B Q2_K GGUF DGX aggregate throughput",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 6);
  assertNear(
    m5Result.best.aggregate,
    130.8018318514496,
    0.000000001,
    "MaziyarPanahi Llama 3.1 8B Q2_K GGUF M5 aggregate throughput",
  );
}

{
  const result = profiled(
    "RedHatAI/Llama-3.2-1B-Instruct-FP8-dynamic",
    "nvidia-dgx-spark",
  );
  assertNear(
    result.resident,
    2.024640512,
    0.000000001,
    "RedHatAI Llama 3.2 1B FP8 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    1.499303936,
    0.000000001,
    "RedHatAI Llama 3.2 1B FP8 swept text-decode traffic",
  );
  assertNear(
    result.alloc,
    3.2768,
    0.000000001,
    "RedHatAI Llama 3.2 1B FP8 full-context KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.048576,
    0.000000001,
    "RedHatAI Llama 3.2 1B FP8 full-context KV read traffic",
  );
}

{
  const result = profiled("Qwen/Qwen3.5-4B", "nvidia-dgx-spark");
  assertNear(
    result.resident,
    9.319737856,
    0.000000001,
    "Qwen3.5 4B resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    8.411510272,
    0.000000001,
    "Qwen3.5 4B swept text-decode traffic",
  );
  assertNear(
    result.alloc,
    3.328704512,
    0.000000001,
    "Qwen3.5 4B full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.100480512,
    0.000000001,
    "Qwen3.5 4B full-attention KV plus DeltaNet state read traffic",
  );
}

{
  const repo = "Qwen/Qwen3.5-4B-Base";
  const item = model(repo);
  const modelProfile = profile(repo);
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  const m1UltraResult = profiled(repo, "apple-mac-studio-m1-ultra-128gb");
  assert.equal(item.hf_downloads, 197752);
  assert.ok(item.tags.includes("region:us"));
  assert.equal(item.architecture.total_params_b, 4.659865088);
  assert.equal(item.architecture.active_params_b, 4.205751296);
  assertNear(
    item.adapter.resident_weight_gb,
    9.319737856,
    0.000000001,
    "Qwen3.5 4B Base catalog resident footprint",
  );
  assertNear(
    item.adapter.active_weight_gb,
    8.411510272,
    0.000000001,
    "Qwen3.5 4B Base catalog swept text-decode traffic",
  );
  assert.equal(modelProfile.base_model_proof.relation, "base");
  assert.equal(modelProfile.serving.weight_format, "mixed_bf16_f32");
  assertNear(
    modelProfile.architecture.weight_adapter.auxiliary_resident_weight_gb,
    0.908227584,
    0.000000001,
    "Qwen3.5 4B Base resident visual/MTP footprint",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    9.319737856,
    0.000000001,
    "Qwen3.5 4B Base resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    8.411510272,
    0.000000001,
    "Qwen3.5 4B Base swept text-decode traffic",
  );
  assertNear(
    result.alloc,
    3.328704512,
    0.000000001,
    "Qwen3.5 4B Base full-attention KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.100480512,
    0.000000001,
    "Qwen3.5 4B Base full-attention KV plus DeltaNet state read traffic",
  );
  assert.equal(result.bMem, 33);
  assert.equal(result.best?.batch, 4);
  assertNear(
    result.single.aggregate,
    28.70061653751914,
    0.000000001,
    "Qwen3.5 4B Base DGX Spark single-session throughput",
  );
  assertNear(
    result.best?.aggregate ?? 0,
    85.2230669135809,
    0.000000001,
    "Qwen3.5 4B Base DGX Spark aggregate throughput",
  );
  assertNear(
    result.dennard,
    1079.1544398016715,
    0.000000001,
    "Qwen3.5 4B Base DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best?.batch, 20);
  assertNear(
    m5Result.best?.aggregate ?? 0,
    403.6669193416461,
    0.000000001,
    "Qwen3.5 4B Base M5 Max aggregate throughput",
  );
  assertNear(
    m5Result.best?.perSession ?? 0,
    20.183345967082307,
    0.000000001,
    "Qwen3.5 4B Base M5 Max per-session throughput",
  );
  assertNear(
    m5Result.dennard,
    2427.109252887276,
    0.000000001,
    "Qwen3.5 4B Base M5 Max Dennard bound",
  );
  assert.equal(m1UltraResult.status_code, "ok");
  assert.equal(m1UltraResult.best?.batch, 28);
  assertNear(
    m1UltraResult.best?.aggregate ?? 0,
    571.0648874730019,
    0.000000001,
    "Qwen3.5 4B Base M1 Ultra aggregate throughput",
  );
  assertNear(
    m1UltraResult.best?.perSession ?? 0,
    20.395174552607212,
    0.000000001,
    "Qwen3.5 4B Base M1 Ultra per-session throughput",
  );
}

{
  const modelProfile = profile("cyankiwi/Qwen3.5-4B-AWQ-4bit");
  const result = profiled("cyankiwi/Qwen3.5-4B-AWQ-4bit", "nvidia-dgx-spark");
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    4.040317168,
    0.000000001,
    "cyankiwi Qwen3.5 4B AWQ resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    3.286590592,
    0.000000001,
    "cyankiwi Qwen3.5 4B AWQ swept text-decode traffic",
  );
  assertNear(
    modelProfile.architecture.weight_adapter.auxiliary_resident_weight_gb,
    0.753726576,
    0.000000001,
    "cyankiwi Qwen3.5 4B AWQ resident-only visual/MTP footprint",
  );
  assertNear(
    result.alloc,
    3.328704512,
    0.000000001,
    "cyankiwi Qwen3.5 4B AWQ BF16 KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.100480512,
    0.000000001,
    "cyankiwi Qwen3.5 4B AWQ BF16 KV plus DeltaNet state read traffic",
  );
  assertNear(
    result.single.aggregate,
    62.228305292587294,
    0.000000001,
    "cyankiwi Qwen3.5 4B AWQ DGX single-session throughput",
  );
  assert.equal(result.bMem, 34);
  assert.equal(result.best?.batch, 9);
  assertNear(
    result.best?.aggregate ?? 0,
    186.26455880786804,
    0.000000001,
    "cyankiwi Qwen3.5 4B AWQ DGX aggregate throughput",
  );
  assertNear(
    result.best?.perSession ?? 0,
    20.696062089763117,
    0.000000001,
    "cyankiwi Qwen3.5 4B AWQ DGX per-session throughput",
  );
  assertNear(
    result.dennard,
    2893.668745100436,
    0.000000001,
    "cyankiwi Qwen3.5 4B AWQ DGX Dennard bound",
  );
}

{
  const repo = "ggml-org/SmolVLM-500M-Instruct-GGUF";
  const item = model(repo);
  const modelProfile = profile(repo);
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  const m1UltraResult = profiled(repo, "apple-mac-studio-m1-ultra-128gb");
  assert.equal(item.hf_downloads, 178205);
  assert.equal(item.hf_pipeline_tag, "unknown");
  assert.ok(item.tags.includes("region:us"));
  assert.equal(item.architecture.total_params_b, 0.4092528);
  assert.equal(item.architecture.active_params_b, 0.361944);
  assert.equal(modelProfile.serving.weight_format, "fp16");
  assert.equal(
    modelProfile.serving.runtime_format,
    "llama.cpp-gguf-f16-memory-bound",
  );
  assertNear(
    item.adapter.resident_weight_gb,
    0.820422912,
    0.000000001,
    "ggml-org SmolVLM 500M Instruct catalog selected F16 resident linked file",
  );
  assertNear(
    item.adapter.active_weight_gb,
    0.7240128,
    0.000000001,
    "ggml-org SmolVLM 500M Instruct catalog selected F16 swept text traffic",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    0.820422912,
    0.000000001,
    "ggml-org SmolVLM 500M Instruct selected F16 resident linked file",
  );
  assertNear(
    result.single.batchWeight,
    0.7240128,
    0.000000001,
    "ggml-org SmolVLM 500M Instruct selected F16 swept text traffic",
  );
  assertNear(
    modelProfile.architecture.weight_adapter.auxiliary_resident_weight_gb,
    0.096410112,
    0.000000001,
    "ggml-org SmolVLM 500M Instruct resident token embedding plus GGUF overhead",
  );
  assertNear(
    result.alloc,
    4.096,
    0.000000001,
    "ggml-org SmolVLM 500M Instruct FP16 full-context KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.31072,
    0.000000001,
    "ggml-org SmolVLM 500M Instruct FP16 full-context KV read traffic",
  );
  assert.equal(result.bMem, 29);
  assert.equal(result.best?.batch, 9);
  assertNear(
    result.single.aggregate,
    134.169950963586,
    0.000000001,
    "ggml-org SmolVLM 500M Instruct DGX Spark single-session throughput",
  );
  assertNear(
    result.best?.aggregate ?? 0,
    196.23828225035996,
    0.000000001,
    "ggml-org SmolVLM 500M Instruct DGX Spark aggregate throughput",
  );
  assertNear(
    result.dennard,
    10971.305158468882,
    0.000000001,
    "ggml-org SmolVLM 500M Instruct DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best?.batch, 22);
  assertNear(
    m5Result.best?.aggregate ?? 0,
    456.9711524409215,
    0.000000001,
    "ggml-org SmolVLM 500M Instruct M5 Max aggregate throughput",
  );
  assertNear(
    m5Result.best?.perSession ?? 0,
    20.771416020041887,
    0.000000001,
    "ggml-org SmolVLM 500M Instruct M5 Max per-session throughput",
  );
  assert.equal(m1UltraResult.status_code, "ok");
  assert.equal(m1UltraResult.best?.batch, 29);
  assertNear(
    m1UltraResult.best?.aggregate ?? 0,
    598.9431833408869,
    0.000000001,
    "ggml-org SmolVLM 500M Instruct M1 Ultra aggregate throughput",
  );
  assertNear(
    m1UltraResult.best?.perSession ?? 0,
    20.65321321865127,
    0.000000001,
    "ggml-org SmolVLM 500M Instruct M1 Ultra per-session throughput",
  );
}

{
  const repo = "lmstudio-community/Llama-3.2-3B-Instruct-GGUF";
  const item = model(repo);
  const modelProfile = profile(repo);
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  const m1UltraResult = profiled(repo, "apple-mac-studio-m1-ultra-128gb");
  assert.equal(item.hf_downloads, 251450);
  assert.equal(item.hf_pipeline_tag, "text-generation");
  assert.ok(item.tags.includes("region:us"));
  assert.equal(item.architecture.total_params_b, 3.212749888);
  assert.equal(item.architecture.active_params_b, 3.212749888);
  assert.equal(item.architecture.layers, 28);
  assert.equal(item.architecture.kv_heads, 8);
  assert.equal(item.architecture.head_dim, 128);
  assert.equal(modelProfile.serving.weight_format, "gguf_quantized");
  assert.equal(
    modelProfile.serving.runtime_format,
    "llama.cpp-gguf-q3-k-l-memory-bound",
  );
  assertNear(
    item.adapter.resident_weight_gb,
    1.815347488,
    0.000000001,
    "LM Studio Llama 3.2 3B Instruct catalog selected Q3_K_L resident linked file",
  );
  assertNear(
    item.adapter.active_weight_gb,
    1.80750976,
    0.000000001,
    "LM Studio Llama 3.2 3B Instruct catalog selected Q3_K_L swept text traffic",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    1.815347488,
    0.000000001,
    "LM Studio Llama 3.2 3B Instruct selected Q3_K_L resident linked file",
  );
  assertNear(
    result.single.batchWeight,
    1.80750976,
    0.000000001,
    "LM Studio Llama 3.2 3B Instruct selected Q3_K_L swept text traffic",
  );
  assertNear(
    modelProfile.architecture.weight_adapter.auxiliary_resident_weight_gb,
    0.007837728,
    0.000000001,
    "LM Studio Llama 3.2 3B Instruct resident-only GGUF overhead",
  );
  assertNear(
    result.alloc,
    11.4688,
    0.000000001,
    "LM Studio Llama 3.2 3B Instruct FP16 full-context KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    3.670016,
    0.000000001,
    "LM Studio Llama 3.2 3B Instruct FP16 full-context KV read traffic",
  );
  assert.equal(result.bMem, 10);
  assert.equal(result.best?.batch, 3);
  assertNear(
    result.single.aggregate,
    49.84002119964471,
    0.000000001,
    "LM Studio Llama 3.2 3B Instruct DGX Spark single-session throughput",
  );
  assertNear(
    result.best?.aggregate ?? 0,
    63.896727858396645,
    0.000000001,
    "LM Studio Llama 3.2 3B Instruct DGX Spark aggregate throughput",
  );
  assertNear(
    result.dennard,
    1556.4138949072844,
    0.000000001,
    "LM Studio Llama 3.2 3B Instruct DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best?.batch, 7);
  assertNear(
    m5Result.best?.aggregate ?? 0,
    156.30442652506687,
    0.000000001,
    "LM Studio Llama 3.2 3B Instruct M5 Max aggregate throughput",
  );
  assertNear(
    m5Result.best?.perSession ?? 0,
    22.329203789295267,
    0.000000001,
    "LM Studio Llama 3.2 3B Instruct M5 Max per-session throughput",
  );
  assert.equal(m1UltraResult.status_code, "ok");
  assert.equal(m1UltraResult.best?.batch, 10);
  assertNear(
    m1UltraResult.best?.aggregate ?? 0,
    207.75082080687295,
    0.000000001,
    "LM Studio Llama 3.2 3B Instruct M1 Ultra aggregate throughput",
  );
  assertNear(
    m1UltraResult.best?.perSession ?? 0,
    20.775082080687294,
    0.000000001,
    "LM Studio Llama 3.2 3B Instruct M1 Ultra per-session throughput",
  );
}

{
  const repo = "MaziyarPanahi/Llama-3.2-3B-Instruct-GGUF";
  const item = model(repo);
  const modelProfile = profile(repo);
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  const m1UltraResult = profiled(repo, "apple-mac-studio-m1-ultra-128gb");
  assert.equal(item.hf_downloads, 148669);
  assert.equal(item.hf_pipeline_tag, "text-generation");
  assert.ok(item.tags.includes("license:llama3.2"));
  assert.ok(item.tags.includes("region:us"));
  assert.equal(item.architecture.total_params_b, 3.212749888);
  assert.equal(item.architecture.active_params_b, 3.212749888);
  assert.equal(item.architecture.layers, 28);
  assert.equal(item.architecture.attention_heads, 24);
  assert.equal(item.architecture.kv_heads, 8);
  assert.equal(item.architecture.head_dim, 128);
  assert.equal(item.architecture.max_context_tokens, 131072);
  assert.equal(modelProfile.serving.weight_format, "gguf_quantized");
  assert.equal(
    modelProfile.serving.runtime_format,
    "llama.cpp-gguf-q2-k-memory-bound",
  );
  assertNear(
    item.adapter.resident_weight_gb,
    1.363935776,
    0.000000001,
    "MaziyarPanahi Llama 3.2 3B Instruct catalog selected Q2_K resident linked file",
  );
  assertNear(
    item.adapter.active_weight_gb,
    1.356097792,
    0.000000001,
    "MaziyarPanahi Llama 3.2 3B Instruct catalog selected Q2_K swept text traffic",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    1.363935776,
    0.000000001,
    "MaziyarPanahi Llama 3.2 3B Instruct selected Q2_K resident linked file",
  );
  assertNear(
    result.single.batchWeight,
    1.356097792,
    0.000000001,
    "MaziyarPanahi Llama 3.2 3B Instruct selected Q2_K swept text traffic",
  );
  assertNear(
    modelProfile.architecture.weight_adapter.auxiliary_resident_weight_gb,
    0.007837984,
    0.000000001,
    "MaziyarPanahi Llama 3.2 3B Instruct resident-only GGUF overhead",
  );
  assertNear(
    result.alloc,
    11.4688,
    0.000000001,
    "MaziyarPanahi Llama 3.2 3B Instruct FP16 full-context KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    3.670016,
    0.000000001,
    "MaziyarPanahi Llama 3.2 3B Instruct FP16 full-context KV read traffic",
  );
  assert.equal(result.bMem, 10);
  assert.equal(result.best?.batch, 3);
  assertNear(
    result.single.aggregate,
    54.31631898874445,
    0.000000001,
    "MaziyarPanahi Llama 3.2 3B Instruct DGX Spark single-session throughput",
  );
  assertNear(
    result.best?.aggregate ?? 0,
    66.22920461845385,
    0.000000001,
    "MaziyarPanahi Llama 3.2 3B Instruct DGX Spark aggregate throughput",
  );
  assertNear(
    result.dennard,
    2082.429892748311,
    0.000000001,
    "MaziyarPanahi Llama 3.2 3B Instruct DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best?.batch, 7);
  assertNear(
    m5Result.best?.aggregate ?? 0,
    158.91320939436423,
    0.000000001,
    "MaziyarPanahi Llama 3.2 3B Instruct M5 Max aggregate throughput",
  );
  assertNear(
    m5Result.best?.perSession ?? 0,
    22.701887056337746,
    0.000000001,
    "MaziyarPanahi Llama 3.2 3B Instruct M5 Max per-session throughput",
  );
  assert.equal(m1UltraResult.status_code, "ok");
  assert.equal(m1UltraResult.best?.batch, 10);
  assertNear(
    m1UltraResult.best?.aggregate ?? 0,
    210.21509901800488,
    0.000000001,
    "MaziyarPanahi Llama 3.2 3B Instruct M1 Ultra aggregate throughput",
  );
  assertNear(
    m1UltraResult.best?.perSession ?? 0,
    21.02150990180049,
    0.000000001,
    "MaziyarPanahi Llama 3.2 3B Instruct M1 Ultra per-session throughput",
  );
}

{
  const repo = "mratsim/GLM-4-32B-0414.w4a16-gptq";
  const item = model(repo);
  const modelProfile = profile(repo);
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  const m1UltraResult = profiled(repo, "apple-mac-studio-m1-ultra-128gb");
  assert.equal(item.hf_downloads, 148059);
  assert.equal(item.hf_pipeline_tag, "text-generation");
  assert.ok(item.tags.includes("compressed-tensors"));
  assert.ok(item.tags.includes("region:us"));
  assert.equal(item.architecture.total_params_b, 32.566081536);
  assert.equal(item.architecture.active_params_b, 31.634946048);
  assert.equal(item.architecture.layers, 61);
  assert.equal(item.architecture.attention_heads, 48);
  assert.equal(item.architecture.kv_heads, 2);
  assert.equal(item.architecture.head_dim, 128);
  assert.equal(item.architecture.max_context_tokens, 32768);
  assert.equal(modelProfile.serving.weight_format, "int4");
  assert.equal(
    modelProfile.serving.runtime_format,
    "vllm-compressed-tensors-gptq-glm4-w4a16-memory-bound",
  );
  assertNear(
    item.adapter.resident_weight_gb,
    19.678365408,
    0.000000001,
    "mratsim GLM 4 32B GPTQ catalog resident tensor payload",
  );
  assertNear(
    item.adapter.active_weight_gb,
    17.816094432,
    0.000000001,
    "mratsim GLM 4 32B GPTQ catalog swept text traffic",
  );
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    19.678365408,
    0.000000001,
    "mratsim GLM 4 32B GPTQ resident tensor payload",
  );
  assertNear(
    result.single.batchWeight,
    17.816094432,
    0.000000001,
    "mratsim GLM 4 32B GPTQ swept text traffic",
  );
  assertNear(
    modelProfile.architecture.weight_adapter.auxiliary_resident_weight_gb,
    1.862270976,
    0.000000001,
    "mratsim GLM 4 32B GPTQ resident-only input embedding",
  );
  assertNear(
    result.alloc,
    6.2464,
    0.000000001,
    "mratsim GLM 4 32B GPTQ BF16 full-context KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.998848,
    0.000000001,
    "mratsim GLM 4 32B GPTQ BF16 full-context KV read traffic",
  );
  assert.equal(result.bMem, 16);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    13.777481359679381,
    0.000000001,
    "mratsim GLM 4 32B GPTQ DGX Spark single-session throughput",
  );
  assertNear(
    result.dennard,
    246.10189009906148,
    0.000000001,
    "mratsim GLM 4 32B GPTQ DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best?.batch, 6);
  assertNear(
    m5Result.best?.aggregate ?? 0,
    123.58607983978942,
    0.000000001,
    "mratsim GLM 4 32B GPTQ M5 Max aggregate throughput",
  );
  assertNear(
    m5Result.best?.perSession ?? 0,
    20.597679973298238,
    0.000000001,
    "mratsim GLM 4 32B GPTQ M5 Max per-session throughput",
  );
  assert.equal(m1UltraResult.status_code, "ok");
  assert.equal(m1UltraResult.best?.batch, 11);
  assertNear(
    m1UltraResult.best?.aggregate ?? 0,
    221.0865162420112,
    0.000000001,
    "mratsim GLM 4 32B GPTQ M1 Ultra aggregate throughput",
  );
  assertNear(
    m1UltraResult.best?.perSession ?? 0,
    20.0987742038192,
    0.000000001,
    "mratsim GLM 4 32B GPTQ M1 Ultra per-session throughput",
  );
}

{
  const modelProfile = profile("stepfun-ai/Step3-VL-10B");
  const result = profiled("stepfun-ai/Step3-VL-10B", "nvidia-dgx-spark");
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    20.343500288,
    0.000000001,
    "Step3-VL 10B BF16 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    15.136811008,
    0.000000001,
    "Step3-VL 10B BF16 swept text-decode traffic",
  );
  assertNear(
    modelProfile.architecture.weight_adapter.auxiliary_resident_weight_gb,
    5.20668928,
    0.000000001,
    "Step3-VL 10B BF16 resident-only input/vision/projector footprint",
  );
  assertNear(
    result.alloc,
    14.7456,
    0.000000001,
    "Step3-VL 10B BF16 full-context KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    4.718592,
    0.000000001,
    "Step3-VL 10B BF16 full-context KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    13.749406138470459,
    0.000000001,
    "Step3-VL 10B BF16 DGX single-session throughput",
  );
  assert.equal(result.bMem, 6);
  assert.equal(result.best, null);
  assertNear(
    result.dennard,
    121.89094355282006,
    0.000000001,
    "Step3-VL 10B BF16 DGX Dennard bound",
  );
}

{
  const result = profiled(
    "stepfun-ai/Step3-VL-10B",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(result.bMem, 6);
  assert.equal(result.best?.batch, 3);
  assertNear(
    result.single.aggregate,
    30.923572780296197,
    0.000000001,
    "Step3-VL 10B BF16 M5 Max single-session throughput",
  );
  assertNear(
    result.best?.aggregate ?? 0,
    62.882803744747356,
    0.000000001,
    "Step3-VL 10B BF16 M5 Max aggregate throughput",
  );
  assertNear(
    result.best?.perSession ?? 0,
    20.960934581582453,
    0.000000001,
    "Step3-VL 10B BF16 M5 Max per-session throughput",
  );
  assertNear(
    result.dennard,
    274.1430012506649,
    0.000000001,
    "Step3-VL 10B BF16 M5 Max Dennard bound",
  );
}

{
  const modelProfile = profile("stepfun-ai/step3");
  const modelRow = model("stepfun-ai/step3");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const kvAdapter = modelProfile.architecture.kv_adapter;
  const result = profiled("stepfun-ai/step3", "nvidia-dgx-spark");
  assert.equal(modelProfile.status, "audited");
  assert.equal(modelRow.hf_downloads, 164103);
  assert.equal(modelRow.architecture.type, "Sparse MoE multimodal transformer");
  assert.equal(modelRow.architecture.active_params_b, 37.91798272);
  assert.equal(modelRow.architecture.kv_heads, 1);
  assert.equal(modelRow.architecture.routed_experts, 48);
  assert.equal(modelRow.architecture.routed_experts_per_token, 3);
  assert.equal(modelRow.architecture.shared_experts_per_token, 1);
  assert.equal(modelRow.adapter.kind, "moe");
  assert.equal(modelRow.adapter.kv_alloc_gb_per_1k_tokens, 0.062464);
  assert.equal(weightAdapter.kind, "moe_distinct_experts_exact");
  assert.equal(weightAdapter.routed_experts, 48);
  assert.equal(weightAdapter.routed_experts_per_token, 3);
  assert.equal(weightAdapter.shared_experts_per_token, 1);
  assert.equal(kvAdapter.kind, "full_context");
  assert.equal(kvAdapter.layers, 61);
  assert.equal(kvAdapter.kv_heads, 1);
  assert.equal(kvAdapter.head_dim, 256);
  assert.equal(result.status_code, "resident_not_fit");
  assertNear(
    result.resident,
    641.939825664,
    0.000000001,
    "Step3 BF16 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    75.83596544,
    0.000000001,
    "Step3 BF16 active MoE text-decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    11.197441024,
    0.000000001,
    "Step3 BF16 resident-only input/vision/projector footprint",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    12.33125376,
    0.000000001,
    "Step3 BF16 per-expert routed traffic",
  );
  assertNear(
    result.alloc,
    6.2464,
    0.000000001,
    "Step3 BF16 one-head full-context KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.998848,
    0.000000001,
    "Step3 BF16 one-head full-context KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    3.5074279481693074,
    0.000000001,
    "Step3 BF16 DGX single-session throughput",
  );
}

{
  const modelProfile = profile("Qwen/Qwen1.5-0.5B-Chat");
  const modelRow = model("Qwen/Qwen1.5-0.5B-Chat");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const kvAdapter = modelProfile.architecture.kv_adapter;
  const dgxResult = profiled("Qwen/Qwen1.5-0.5B-Chat", "nvidia-dgx-spark");
  const m5Result = profiled(
    "Qwen/Qwen1.5-0.5B-Chat",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(modelProfile.status, "audited");
  assert.equal(modelRow.hf_downloads, 179717);
  assert.equal(modelRow.architecture.total_params_b, 0.619570176);
  assert.equal(modelRow.architecture.active_params_b, 0.463987712);
  assert.equal(modelRow.architecture.kv_heads, 16);
  assert.equal(modelRow.adapter.resident_weight_gb, 1.239140352);
  assert.equal(modelRow.adapter.active_weight_gb, 0.927975424);
  assert.equal(weightAdapter.kind, "dense_resident_swept");
  assert.equal(kvAdapter.kind, "full_context");
  assert.equal(kvAdapter.layers, 24);
  assert.equal(kvAdapter.kv_heads, 16);
  assert.equal(kvAdapter.head_dim, 64);
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.311164928,
    0.000000001,
    "Qwen1.5 0.5B Chat resident-only input embedding",
  );
  assert.equal(dgxResult.status_code, "ok");
  assertNear(
    dgxResult.resident,
    1.239140352,
    0.000000001,
    "Qwen1.5 0.5B Chat BF16 resident footprint",
  );
  assertNear(
    dgxResult.single.batchWeight,
    0.927975424,
    0.000000001,
    "Qwen1.5 0.5B Chat BF16 swept text-decode traffic",
  );
  assertNear(
    dgxResult.alloc,
    9.8304,
    0.000000001,
    "Qwen1.5 0.5B Chat BF16 full-context KV allocation",
  );
  assertNear(
    dgxResult.single.readTraffic,
    3.145728,
    0.000000001,
    "Qwen1.5 0.5B Chat BF16 full-context KV read traffic",
  );
  assert.equal(dgxResult.best?.batch, 4);
  assertNear(
    dgxResult.best?.aggregate ?? 0,
    80.82370652132228,
    0.000000001,
    "Qwen1.5 0.5B Chat DGX aggregate throughput",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best?.batch, 9);
  assertNear(
    m5Result.best?.aggregate ?? 0,
    188.99074256118865,
    0.000000001,
    "Qwen1.5 0.5B Chat M5 Max aggregate throughput",
  );
}

{
  const repo = "Qwen/Qwen1.5-7B";
  const modelProfile = profile(repo);
  const modelRow = model(repo);
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const kvAdapter = modelProfile.architecture.kv_adapter;
  const dgxResult = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  const m1UltraResult = profiled(repo, "apple-mac-studio-m1-ultra-128gb");
  assert.equal(modelProfile.status, "audited");
  assert.equal(modelRow.hf_downloads, 111122);
  assert.equal(modelRow.tags.includes("region:us"), true);
  assert.equal(modelRow.architecture.total_params_b, 7.721324544);
  assert.equal(modelRow.architecture.active_params_b, 7.098994688);
  assert.equal(modelRow.architecture.kv_heads, 32);
  assert.equal(modelRow.adapter.resident_weight_gb, 15.442649088);
  assert.equal(modelRow.adapter.active_weight_gb, 14.197989376);
  assert.equal(weightAdapter.kind, "dense_resident_swept");
  assert.equal(kvAdapter.kind, "full_context");
  assert.equal(kvAdapter.layers, 32);
  assert.equal(kvAdapter.kv_heads, 32);
  assert.equal(kvAdapter.head_dim, 128);
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.244659712,
    0.000000001,
    "Qwen1.5 7B resident-only input embedding",
  );
  assert.equal(dgxResult.status_code, "no_floor");
  assert.equal(dgxResult.bMem, 1);
  assert.equal(dgxResult.best, null);
  assertNear(
    dgxResult.resident,
    15.442649088,
    0.000000001,
    "Qwen1.5 7B BF16 resident footprint",
  );
  assertNear(
    dgxResult.single.batchWeight,
    14.197989376,
    0.000000001,
    "Qwen1.5 7B BF16 swept text-decode traffic",
  );
  assertNear(
    dgxResult.alloc,
    52.4288,
    0.000000001,
    "Qwen1.5 7B BF16 full-context KV allocation",
  );
  assertNear(
    dgxResult.single.readTraffic,
    16.777216,
    0.000000001,
    "Qwen1.5 7B BF16 full-context KV read traffic",
  );
  assertNear(
    dgxResult.single.aggregate,
    8.813500885179733,
    0.000000001,
    "Qwen1.5 7B DGX single-session throughput",
  );
  assert.equal(m5Result.status_code, "no_floor");
  assertNear(
    m5Result.single.aggregate,
    19.822306020147824,
    0.000000001,
    "Qwen1.5 7B M5 Max single-session throughput below floor",
  );
  assert.equal(m1UltraResult.status_code, "ok");
  assert.equal(m1UltraResult.best?.batch, 1);
  assertNear(
    m1UltraResult.best?.aggregate ?? 0,
    25.82710882103951,
    0.000000001,
    "Qwen1.5 7B M1 Ultra aggregate throughput",
  );
}

{
  const modelProfile = profile("Qwen/Qwen2.5-7B-Instruct-GGUF");
  const modelRow = model("Qwen/Qwen2.5-7B-Instruct-GGUF");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const kvAdapter = modelProfile.architecture.kv_adapter;
  const dgxResult = profiled(
    "Qwen/Qwen2.5-7B-Instruct-GGUF",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "Qwen/Qwen2.5-7B-Instruct-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  const m1UltraResult = profiled(
    "Qwen/Qwen2.5-7B-Instruct-GGUF",
    "apple-mac-studio-m1-ultra-128gb",
  );
  assert.equal(modelProfile.status, "audited");
  assert.equal(modelRow.name, "Qwen2.5-7B-Instruct-GGUF GGUF Q2_K");
  assert.equal(modelRow.hf_downloads, 107559);
  assert.equal(modelRow.tags.includes("region:us"), true);
  assert.equal(modelRow.architecture.detail, "qwen2 GGUF (Qwen2ForCausalLM)");
  assert.equal(modelRow.architecture.total_params_b, 7.615616512);
  assert.equal(modelRow.architecture.active_params_b, 7.070619136);
  assert.equal(modelRow.architecture.max_context_tokens, 131072);
  assert.equal(modelRow.adapter.weight_precision, "GGUF Q2_K");
  assert.equal(modelRow.adapter.resident_weight_gb, 3.01594);
  assert.equal(modelRow.adapter.active_weight_gb, 2.831159296);
  assert.equal(weightAdapter.kind, "dense_resident_swept");
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.184780704,
    0.000000001,
    "Qwen Qwen2.5 7B Instruct Q2_K resident-only token/header footprint",
  );
  assert.equal(kvAdapter.kind, "full_context");
  assert.equal(kvAdapter.layers, 28);
  assert.equal(kvAdapter.kv_heads, 4);
  assert.equal(kvAdapter.head_dim, 128);
  assert.equal(dgxResult.status_code, "ok");
  assertNear(
    dgxResult.resident,
    3.01594,
    0.000000001,
    "Qwen Qwen2.5 7B Instruct Q2_K selected resident footprint",
  );
  assertNear(
    dgxResult.single.batchWeight,
    2.831159296,
    0.000000001,
    "Qwen Qwen2.5 7B Instruct Q2_K swept text-decode traffic",
  );
  assertNear(
    dgxResult.alloc,
    5.7344,
    0.000000001,
    "Qwen Qwen2.5 7B Instruct Q2_K FP16 KV allocation",
  );
  assertNear(
    dgxResult.single.readTraffic,
    1.835008,
    0.000000001,
    "Qwen Qwen2.5 7B Instruct Q2_K FP16 KV read traffic",
  );
  assert.equal(dgxResult.bMem, 20);
  assert.equal(dgxResult.best?.batch, 5);
  assertNear(
    dgxResult.single.aggregate,
    58.50626063793834,
    0.000000001,
    "Qwen Qwen2.5 7B Instruct Q2_K DGX single-session throughput",
  );
  assertNear(
    dgxResult.best?.aggregate ?? 0,
    113.69126618236007,
    0.000000001,
    "Qwen Qwen2.5 7B Instruct Q2_K DGX aggregate throughput",
  );
  assertNear(
    dgxResult.dennard,
    1967.1480530745496,
    0.000000001,
    "Qwen Qwen2.5 7B Instruct Q2_K DGX Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best?.batch, 15);
  assertNear(
    m5Result.best?.aggregate ?? 0,
    303.3968659398119,
    0.000000001,
    "Qwen Qwen2.5 7B Instruct Q2_K M5 Max aggregate throughput",
  );
  assert.equal(m1UltraResult.status_code, "ok");
  assert.equal(m1UltraResult.best?.batch, 20);
  assertNear(
    m1UltraResult.best?.aggregate ?? 0,
    404.74237351392844,
    0.000000001,
    "Qwen Qwen2.5 7B Instruct Q2_K M1 Ultra aggregate throughput",
  );
}

{
  const modelProfile = profile("MaziyarPanahi/Qwen2.5-7B-Instruct-GGUF");
  const modelRow = model("MaziyarPanahi/Qwen2.5-7B-Instruct-GGUF");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const kvAdapter = modelProfile.architecture.kv_adapter;
  const dgxResult = profiled(
    "MaziyarPanahi/Qwen2.5-7B-Instruct-GGUF",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "MaziyarPanahi/Qwen2.5-7B-Instruct-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(modelProfile.status, "audited");
  assert.equal(modelRow.name, "Qwen2.5-7B-Instruct-GGUF GGUF FP16");
  assert.equal(modelRow.hf_downloads, 124355);
  assert.equal(modelRow.architecture.detail, "qwen2 GGUF (Qwen2ForCausalLM)");
  assert.equal(modelRow.architecture.total_params_b, 7.615616512);
  assert.equal(modelRow.architecture.active_params_b, 7.070619136);
  assert.equal(modelRow.architecture.layers, 28);
  assert.equal(modelRow.architecture.kv_heads, 4);
  assert.equal(modelRow.adapter.weight_precision, "GGUF FP16");
  assert.equal(modelRow.adapter.resident_weight_gb, 15.237853632);
  assert.equal(modelRow.adapter.active_weight_gb, 14.141904896);
  assert.equal(weightAdapter.kind, "dense_resident_swept");
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.095948736,
    0.000000001,
    "MaziyarPanahi Qwen2.5 7B GGUF resident-only token/header footprint",
  );
  assert.equal(kvAdapter.kind, "full_context");
  assert.equal(kvAdapter.layers, 28);
  assert.equal(kvAdapter.kv_heads, 4);
  assert.equal(kvAdapter.head_dim, 128);
  assert.equal(dgxResult.status_code, "no_floor");
  assertNear(
    dgxResult.resident,
    15.237853632,
    0.000000001,
    "MaziyarPanahi Qwen2.5 7B GGUF selected FP16 resident footprint",
  );
  assertNear(
    dgxResult.single.batchWeight,
    14.141904896,
    0.000000001,
    "MaziyarPanahi Qwen2.5 7B GGUF swept text-decode traffic",
  );
  assertNear(
    dgxResult.alloc,
    5.7344,
    0.000000001,
    "MaziyarPanahi Qwen2.5 7B GGUF FP16 KV allocation",
  );
  assertNear(
    dgxResult.single.readTraffic,
    1.835008,
    0.000000001,
    "MaziyarPanahi Qwen2.5 7B GGUF FP16 KV read traffic",
  );
  assertNear(
    dgxResult.single.aggregate,
    17.087155808951593,
    0.000000001,
    "MaziyarPanahi Qwen2.5 7B GGUF DGX single-session throughput",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best?.batch, 9);
  assertNear(
    m5Result.best?.aggregate ?? 0,
    180.25260673112913,
    0.000000001,
    "MaziyarPanahi Qwen2.5 7B GGUF M5 Max aggregate throughput",
  );
}

{
  const modelProfile = profile("MaziyarPanahi/Qwen2-7B-Instruct-GGUF");
  const modelRow = model("MaziyarPanahi/Qwen2-7B-Instruct-GGUF");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const kvAdapter = modelProfile.architecture.kv_adapter;
  const dgxResult = profiled(
    "MaziyarPanahi/Qwen2-7B-Instruct-GGUF",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "MaziyarPanahi/Qwen2-7B-Instruct-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  const m1UltraResult = profiled(
    "MaziyarPanahi/Qwen2-7B-Instruct-GGUF",
    "apple-mac-studio-m1-ultra-128gb",
  );
  assert.equal(modelProfile.status, "audited");
  assert.equal(modelRow.name, "Qwen2-7B-Instruct-GGUF GGUF FP16");
  assert.equal(modelRow.hf_downloads, 113445);
  assert.ok(modelRow.tags.includes("region:us"));
  assert.equal(modelRow.architecture.detail, "qwen2 GGUF (Qwen2ForCausalLM)");
  assert.equal(modelRow.architecture.total_params_b, 7.615616512);
  assert.equal(modelRow.architecture.active_params_b, 7.070619136);
  assert.equal(modelRow.architecture.layers, 28);
  assert.equal(modelRow.architecture.kv_heads, 4);
  assert.equal(modelRow.adapter.weight_precision, "GGUF FP16");
  assert.equal(modelRow.adapter.resident_weight_gb, 15.237850656);
  assert.equal(modelRow.adapter.active_weight_gb, 14.141904896);
  assert.equal(weightAdapter.kind, "dense_resident_swept");
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.09594576,
    0.000000001,
    "MaziyarPanahi Qwen2 7B GGUF resident-only token/header footprint",
  );
  assert.equal(kvAdapter.kind, "full_context");
  assert.equal(kvAdapter.layers, 28);
  assert.equal(kvAdapter.kv_heads, 4);
  assert.equal(kvAdapter.head_dim, 128);
  assert.equal(dgxResult.status_code, "no_floor");
  assertNear(
    dgxResult.resident,
    15.237850656,
    0.000000001,
    "MaziyarPanahi Qwen2 7B GGUF selected FP16 resident footprint",
  );
  assertNear(
    dgxResult.single.batchWeight,
    14.141904896,
    0.000000001,
    "MaziyarPanahi Qwen2 7B GGUF swept text-decode traffic",
  );
  assertNear(
    dgxResult.alloc,
    5.7344,
    0.000000001,
    "MaziyarPanahi Qwen2 7B GGUF FP16 KV allocation",
  );
  assertNear(
    dgxResult.single.readTraffic,
    1.835008,
    0.000000001,
    "MaziyarPanahi Qwen2 7B GGUF FP16 KV read traffic",
  );
  assertNear(
    dgxResult.single.aggregate,
    17.087155808951593,
    0.000000001,
    "MaziyarPanahi Qwen2 7B GGUF DGX single-session throughput",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best?.batch, 9);
  assertNear(
    m5Result.best?.aggregate ?? 0,
    180.25260673112913,
    0.000000001,
    "MaziyarPanahi Qwen2 7B GGUF M5 Max aggregate throughput",
  );
  assert.equal(m1UltraResult.status_code, "ok");
  assert.equal(m1UltraResult.best?.batch, 14);
  assertNear(
    m1UltraResult.best?.aggregate ?? 0,
    281.18084076040657,
    0.000000001,
    "MaziyarPanahi Qwen2 7B GGUF M1 Ultra aggregate throughput",
  );
}

{
  const modelProfile = profile("MaziyarPanahi/QwQ-32B-GGUF");
  const modelRow = model("MaziyarPanahi/QwQ-32B-GGUF");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const kvAdapter = modelProfile.architecture.kv_adapter;
  const dgxResult = profiled("MaziyarPanahi/QwQ-32B-GGUF", "nvidia-dgx-spark");
  const m5Result = profiled(
    "MaziyarPanahi/QwQ-32B-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  const m1UltraResult = profiled(
    "MaziyarPanahi/QwQ-32B-GGUF",
    "apple-mac-studio-m1-ultra-128gb",
  );
  assert.equal(modelProfile.status, "audited");
  assert.equal(modelRow.name, "QwQ-32B-GGUF GGUF Q2_K");
  assert.equal(modelRow.license, "apache-2.0");
  assert.equal(modelRow.hf_downloads, 112246);
  assert.ok(modelRow.tags.includes("region:us"));
  assert.equal(modelRow.architecture.detail, "llama GGUF / Qwen2-derived");
  assert.equal(modelRow.architecture.total_params_b, 32.763876352);
  assert.equal(modelRow.architecture.max_context_tokens, 131072);
  assert.equal(modelRow.adapter.weight_precision, "GGUF Q2_K");
  assert.equal(modelRow.adapter.resident_weight_gb, 12.313707552);
  assert.equal(modelRow.adapter.active_weight_gb, 12.051652608);
  assert.equal(weightAdapter.kind, "dense_resident_swept");
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.262054944,
    0.000000001,
    "MaziyarPanahi QwQ 32B Q2_K GGUF resident-only token/header footprint",
  );
  assert.equal(kvAdapter.kind, "full_context");
  assert.equal(kvAdapter.layers, 64);
  assert.equal(kvAdapter.kv_heads, 8);
  assert.equal(kvAdapter.head_dim, 128);
  assert.equal(dgxResult.status_code, "no_floor");
  assertNear(
    dgxResult.resident,
    12.313707552,
    0.000000001,
    "MaziyarPanahi QwQ 32B Q2_K GGUF selected resident footprint",
  );
  assertNear(
    dgxResult.single.batchWeight,
    12.051652608,
    0.000000001,
    "MaziyarPanahi QwQ 32B Q2_K GGUF swept text-decode traffic",
  );
  assertNear(
    dgxResult.alloc,
    26.2144,
    0.000000001,
    "MaziyarPanahi QwQ 32B Q2_K GGUF FP16 KV allocation",
  );
  assertNear(
    dgxResult.single.readTraffic,
    8.388608,
    0.000000001,
    "MaziyarPanahi QwQ 32B Q2_K GGUF FP16 KV read traffic",
  );
  assertNear(
    dgxResult.single.aggregate,
    13.35599409594377,
    0.000000001,
    "MaziyarPanahi QwQ 32B Q2_K GGUF DGX single-session throughput",
  );
  assert.equal(dgxResult.bMem, 4);
  assert.equal(dgxResult.best, null);
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best?.batch, 2);
  assertNear(
    m5Result.best?.aggregate ?? 0,
    42.596191224071504,
    0.000000001,
    "MaziyarPanahi QwQ 32B Q2_K GGUF M5 Max aggregate throughput",
  );
  assert.equal(m1UltraResult.status_code, "ok");
  assert.equal(m1UltraResult.best?.batch, 3);
  assertNear(
    m1UltraResult.best?.aggregate ?? 0,
    64.48583350447015,
    0.000000001,
    "MaziyarPanahi QwQ 32B Q2_K GGUF M1 Ultra aggregate throughput",
  );
}

{
  const modelProfile = profile("Qwen/Qwen1.5-MoE-A2.7B");
  const modelRow = model("Qwen/Qwen1.5-MoE-A2.7B");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const kvAdapter = modelProfile.architecture.kv_adapter;
  const result = profiled("Qwen/Qwen1.5-MoE-A2.7B", "nvidia-dgx-spark");
  assert.equal(modelProfile.status, "audited");
  assert.equal(modelRow.hf_downloads, 216320);
  assert.equal(modelRow.architecture.shared_experts_per_token, 1);
  assert.equal(weightAdapter.kind, "moe_distinct_experts_exact");
  assert.equal(kvAdapter.kind, "full_context");
  assert.equal(kvAdapter.layers, 24);
  assert.equal(kvAdapter.kv_heads, 16);
  assert.equal(kvAdapter.head_dim, 128);
  assertNear(
    weightAdapter.resident_weight_gb,
    28.631568384,
    0.000000001,
    "Qwen1.5 MoE A2.7B resident footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    28.009238528,
    0.000000001,
    "Qwen1.5 MoE A2.7B main resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.622329856,
    0.000000001,
    "Qwen1.5 MoE A2.7B resident-only embedding footprint",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    3.095072768,
    0.000000001,
    "Qwen1.5 MoE A2.7B fixed ordinary decode traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.415236096,
    0.000000001,
    "Qwen1.5 MoE A2.7B per-expert traffic",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.single.batchWeight,
    4.756017152,
    0.000000001,
    "Qwen1.5 MoE A2.7B single-session MoE decode traffic",
  );
  assertNear(
    result.alloc,
    19.6608,
    0.000000001,
    "Qwen1.5 MoE A2.7B BF16 full-context KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    6.291456,
    0.000000001,
    "Qwen1.5 MoE A2.7B BF16 full-context KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    24.71153323876392,
    0.000000001,
    "Qwen1.5 MoE A2.7B DGX single-session throughput",
  );
  assert.equal(result.bMem, 4);
  assert.equal(result.best?.batch, 1);
  assertNear(
    result.best?.aggregate ?? 0,
    24.71153323876392,
    0.000000001,
    "Qwen1.5 MoE A2.7B DGX aggregate throughput",
  );
  assertNear(
    result.dennard,
    266.75601416123743,
    0.000000001,
    "Qwen1.5 MoE A2.7B DGX Dennard bound",
  );
}

{
  const result = profiled(
    "Qwen/Qwen1.5-MoE-A2.7B",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(result.bMem, 4);
  assert.equal(result.best?.batch, 3);
  assertNear(
    result.single.aggregate,
    55.57832017802581,
    0.000000001,
    "Qwen1.5 MoE A2.7B M5 Max single-session throughput",
  );
  assertNear(
    result.best?.aggregate ?? 0,
    69.17668882054073,
    0.000000001,
    "Qwen1.5 MoE A2.7B M5 Max aggregate throughput",
  );
  assertNear(
    result.best?.perSession ?? 0,
    23.05889627351358,
    0.000000001,
    "Qwen1.5 MoE A2.7B M5 Max per-session throughput",
  );
}

{
  const repo = "nm-testing/Qwen1.5-MoE-A2.7B-Chat-quantized.w4a16";
  const modelProfile = profile(repo);
  const modelRow = model(repo);
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const kvAdapter = modelProfile.architecture.kv_adapter;
  const dgxResult = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  assert.equal(modelProfile.status, "audited");
  assert.equal(modelRow.hf_downloads, 143934);
  assert.ok(modelRow.tags.includes("region:us"));
  assert.equal(modelRow.architecture.max_context_tokens, 32768);
  assert.equal(weightAdapter.kind, "moe_distinct_experts_exact");
  assert.equal(kvAdapter.kind, "full_context");
  assert.equal(kvAdapter.layers, 24);
  assert.equal(kvAdapter.kv_heads, 16);
  assert.equal(kvAdapter.head_dim, 128);
  assertNear(
    weightAdapter.resident_weight_gb,
    8.310237312,
    0.000000001,
    "NM Testing Qwen1.5 MoE Chat W4A16 resident footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    7.687907456,
    0.000000001,
    "NM Testing Qwen1.5 MoE Chat W4A16 main resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.622329856,
    0.000000001,
    "NM Testing Qwen1.5 MoE Chat W4A16 resident-only input embedding",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    1.264654976,
    0.000000001,
    "NM Testing Qwen1.5 MoE Chat W4A16 fixed ordinary traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.107054208,
    0.000000001,
    "NM Testing Qwen1.5 MoE Chat W4A16 per-expert traffic",
  );
  assert.equal(dgxResult.status_code, "ok");
  assertNear(
    dgxResult.single.batchWeight,
    1.692871808,
    0.000000001,
    "NM Testing Qwen1.5 MoE Chat W4A16 single-session decode traffic",
  );
  assertNear(
    dgxResult.alloc,
    19.6608,
    0.000000001,
    "NM Testing Qwen1.5 MoE Chat W4A16 BF16 KV allocation",
  );
  assertNear(
    dgxResult.single.readTraffic,
    6.291456,
    0.000000001,
    "NM Testing Qwen1.5 MoE Chat W4A16 BF16 KV read traffic",
  );
  assert.equal(dgxResult.bMem, 5);
  assert.equal(dgxResult.best?.batch, 1);
  assertNear(
    dgxResult.best?.aggregate ?? 0,
    34.19198291513835,
    0.000000001,
    "NM Testing Qwen1.5 MoE Chat W4A16 DGX aggregate throughput",
  );
  assertNear(
    dgxResult.dennard,
    916.1166098526915,
    0.000000001,
    "NM Testing Qwen1.5 MoE Chat W4A16 DGX Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.bMem, 5);
  assert.equal(m5Result.best?.batch, 4);
  assertNear(
    m5Result.best?.aggregate ?? 0,
    87.77840961118311,
    0.000000001,
    "NM Testing Qwen1.5 MoE Chat W4A16 M5 Max aggregate throughput",
  );
  assertNear(
    m5Result.best?.perSession ?? 0,
    21.944602402795777,
    0.000000001,
    "NM Testing Qwen1.5 MoE Chat W4A16 M5 Max per-session throughput",
  );
}

{
  const modelProfile = profile("stepfun-ai/Step-3.5-Flash");
  const modelRow = model("stepfun-ai/Step-3.5-Flash");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const kvAdapter = modelProfile.architecture.kv_adapter;
  const result = profiled("stepfun-ai/Step-3.5-Flash", "nvidia-dgx-spark");
  assert.equal(modelProfile.status, "audited");
  assert.equal(modelRow.hf_downloads, 178273);
  assert.equal(modelRow.architecture.type, "MoE transformer");
  assert.equal(modelRow.architecture.routed_experts, 288);
  assert.equal(modelRow.architecture.routed_experts_per_token, 8);
  assert.equal(modelRow.architecture.shared_experts_per_token, 1);
  assert.equal(weightAdapter.kind, "moe_distinct_experts_exact");
  assert.equal(kvAdapter.kind, "layered_kv");
  assert.equal(kvAdapter.components[0].layers, 12);
  assert.equal(kvAdapter.components[1].layers, 33);
  assertNear(
    weightAdapter.resident_weight_gb,
    398.768626944,
    0.000000001,
    "Step 3.5 Flash BF16 resident footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    392.856368896,
    0.000000001,
    "Step 3.5 Flash BF16 main resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    5.912258048,
    0.000000001,
    "Step 3.5 Flash BF16 resident-only input/MTP footprint",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    12.349110016,
    0.000000001,
    "Step 3.5 Flash BF16 fixed ordinary decode traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    1.32120576,
    0.000000001,
    "Step 3.5 Flash BF16 per-expert traffic",
  );
  assert.equal(result.status_code, "resident_not_fit");
  assertNear(
    result.single.batchWeight,
    22.918756096,
    0.000000001,
    "Step 3.5 Flash BF16 single-session MoE decode traffic",
  );
  assertNear(
    result.single.batchWeight - weightAdapter.fixed_weight_gb,
    10.56964608,
    0.000000001,
    "Step 3.5 Flash BF16 eight routed experts traffic",
  );
  assertNear(
    result.alloc,
    4.984406016,
    0.000000001,
    "Step 3.5 Flash BF16 full/sliding KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.642070016,
    0.000000001,
    "Step 3.5 Flash BF16 full/sliding KV read traffic",
  );
  assert.equal(result.bMem, 0);
  assert.equal(result.best, null);
  assert.equal(result.dennard, 0);
}

{
  const modelProfile = profile("stepfun-ai/Step-3.7-Flash");
  const modelRow = model("stepfun-ai/Step-3.7-Flash");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const kvAdapter = modelProfile.architecture.kv_adapter;
  const result = profiled("stepfun-ai/Step-3.7-Flash", "nvidia-dgx-spark");
  assert.equal(modelProfile.status, "audited");
  assert.equal(modelRow.hf_downloads, 147982);
  assert.equal(modelRow.architecture.type, "MoE transformer");
  assert.equal(modelRow.architecture.routed_experts, 288);
  assert.equal(modelRow.architecture.routed_experts_per_token, 8);
  assert.equal(modelRow.architecture.shared_experts_per_token, 1);
  assert.equal(weightAdapter.kind, "moe_distinct_experts_exact");
  assert.equal(kvAdapter.kind, "layered_kv");
  assert.equal(kvAdapter.components[0].layers, 12);
  assert.equal(kvAdapter.components[1].layers, 33);
  assertNear(
    weightAdapter.resident_weight_gb,
    402.730656512,
    0.000000001,
    "Step 3.7 Flash BF16 resident footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    392.856368896,
    0.000000001,
    "Step 3.7 Flash BF16 main resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    9.874287616,
    0.000000001,
    "Step 3.7 Flash BF16 resident-only input/vision/MTP footprint",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    12.349110016,
    0.000000001,
    "Step 3.7 Flash BF16 fixed ordinary decode traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    1.32120576,
    0.000000001,
    "Step 3.7 Flash BF16 per-expert traffic",
  );
  assert.equal(result.status_code, "resident_not_fit");
  assertNear(
    result.single.batchWeight,
    22.918756096,
    0.000000001,
    "Step 3.7 Flash BF16 single-session MoE decode traffic",
  );
  assertNear(
    result.single.batchWeight - weightAdapter.fixed_weight_gb,
    10.56964608,
    0.000000001,
    "Step 3.7 Flash BF16 eight routed experts traffic",
  );
  assertNear(
    result.alloc,
    4.984406016,
    0.000000001,
    "Step 3.7 Flash BF16 full/sliding KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.642070016,
    0.000000001,
    "Step 3.7 Flash BF16 full/sliding KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    11.115261300865479,
    0.000000001,
    "Step 3.7 Flash BF16 DGX single-session throughput",
  );
  assert.equal(result.bMem, 0);
  assert.equal(result.best, null);
  assert.equal(result.dennard, 0);
}

{
  const result = profiled(
    "stepfun-ai/Step-3.7-Flash",
    "apple-mac-studio-m3-ultra-512gb-launch-configuration",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(result.bMem, 20);
  assert.equal(result.best?.batch, 2);
  assertNear(
    result.single.aggregate,
    33.34578390259644,
    0.000000001,
    "Step 3.7 Flash BF16 M3 Ultra 512GB single-session throughput",
  );
  assertNear(
    result.best?.aggregate ?? 0,
    44.902619383413224,
    0.000000001,
    "Step 3.7 Flash BF16 M3 Ultra 512GB aggregate throughput",
  );
  assertNear(
    result.best?.perSession ?? 0,
    22.451309691706612,
    0.000000001,
    "Step 3.7 Flash BF16 M3 Ultra 512GB per-session throughput",
  );
  assertNear(
    result.dennard,
    726.0348072278412,
    0.000000001,
    "Step 3.7 Flash BF16 M3 Ultra 512GB Dennard bound",
  );
}

{
  const result = profiled(
    "stepfun-ai/Step-3.7-Flash",
    "nvidia-msi-xpertstation-ws300-dgx-station-gb300",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(result.bMem, 67);
  assert.equal(result.best?.batch, 44);
  assertNear(
    result.single.aggregate,
    289.07822430822307,
    0.000000001,
    "Step 3.7 Flash BF16 GB300 single-session throughput",
  );
  assertNear(
    result.best?.aggregate ?? 0,
    880.1447118451046,
    0.000000001,
    "Step 3.7 Flash BF16 GB300 aggregate throughput",
  );
  assertNear(
    result.best?.perSession ?? 0,
    20.003288905570557,
    0.000000001,
    "Step 3.7 Flash BF16 GB300 per-session throughput",
  );
  assertNear(
    result.dennard,
    20961.90563756888,
    0.000000001,
    "Step 3.7 Flash BF16 GB300 Dennard bound",
  );
}

{
  const modelProfile = profile("stepfun-ai/Step-3.7-Flash-NVFP4");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "stepfun-ai/Step-3.7-Flash-NVFP4",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "resident_not_fit");
  assertNear(
    weightAdapter.resident_weight_gb,
    129.241354856,
    0.000000001,
    "Step 3.7 Flash NVFP4 resident footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    119.36706724,
    0.000000001,
    "Step 3.7 Flash NVFP4 main resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    9.874287616,
    0.000000001,
    "Step 3.7 Flash NVFP4 resident-only input/vision/MTP footprint",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    12.349110376,
    0.000000001,
    "Step 3.7 Flash NVFP4 fixed ordinary decode traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.371590128,
    0.000000001,
    "Step 3.7 Flash NVFP4 per-expert traffic",
  );
  assertNear(
    result.single.batchWeight,
    15.3218314,
    0.000000001,
    "Step 3.7 Flash NVFP4 single-session MoE decode traffic",
  );
  assertNear(
    result.single.batchWeight - weightAdapter.fixed_weight_gb,
    2.972721024,
    0.000000001,
    "Step 3.7 Flash NVFP4 eight routed experts traffic",
  );
  assertNear(
    result.alloc,
    2.492203008,
    0.000000001,
    "Step 3.7 Flash NVFP4 FP8 full/sliding KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.821035008,
    0.000000001,
    "Step 3.7 Flash NVFP4 FP8 full/sliding KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    16.911494718478746,
    0.000000001,
    "Step 3.7 Flash NVFP4 DGX single-session throughput",
  );
  assert.equal(result.bMem, 0);
  assert.equal(result.best, null);
  assert.equal(result.dennard, 0);
}

{
  const result = profiled(
    "stepfun-ai/Step-3.7-Flash-NVFP4",
    "apple-mac-studio-m2-ultra-192gb",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(result.bMem, 21);
  assert.equal(result.best?.batch, 7);
  assertNear(
    result.single.aggregate,
    49.55749368052379,
    0.000000001,
    "Step 3.7 Flash NVFP4 M2 Ultra 192GB single-session throughput",
  );
  assertNear(
    result.best?.aggregate ?? 0,
    150.337976167946,
    0.000000001,
    "Step 3.7 Flash NVFP4 M2 Ultra 192GB aggregate throughput",
  );
  assertNear(
    result.best?.perSession ?? 0,
    21.476853738278002,
    0.000000001,
    "Step 3.7 Flash NVFP4 M2 Ultra 192GB per-session throughput",
  );
  assertNear(
    result.dennard,
    1147.224957019117,
    0.000000001,
    "Step 3.7 Flash NVFP4 M2 Ultra 192GB Dennard bound",
  );
}

{
  const result = profiled(
    "stepfun-ai/Step-3.7-Flash-NVFP4",
    "nvidia-msi-xpertstation-ws300-dgx-station-gb300",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(result.bMem, 245);
  assert.equal(result.best?.batch, 245);
  assertNear(
    result.single.aggregate,
    439.82275641464867,
    0.000000001,
    "Step 3.7 Flash NVFP4 GB300 single-session throughput",
  );
  assertNear(
    result.best?.aggregate ?? 0,
    5428.930887832472,
    0.000000001,
    "Step 3.7 Flash NVFP4 GB300 aggregate throughput",
  );
  assertNear(
    result.best?.perSession ?? 0,
    22.15890158298968,
    0.000000001,
    "Step 3.7 Flash NVFP4 GB300 per-session throughput",
  );
  assertNear(
    result.dennard,
    113562.22076739495,
    0.000000001,
    "Step 3.7 Flash NVFP4 GB300 Dennard bound",
  );
}

{
  const modelProfile = profile("unsloth/Step-3.7-Flash-GGUF");
  const modelRow = model("unsloth/Step-3.7-Flash-GGUF");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const kvAdapter = modelProfile.architecture.kv_adapter;
  const result = profiled("unsloth/Step-3.7-Flash-GGUF", "nvidia-dgx-spark");
  assert.equal(modelProfile.status, "audited");
  assert.equal(modelRow.hf_downloads, 105722);
  assert.equal(modelRow.architecture.type, "MoE transformer");
  assert.equal(modelRow.architecture.routed_experts, 288);
  assert.equal(modelRow.architecture.routed_experts_per_token, 8);
  assert.equal(modelRow.architecture.shared_experts_per_token, 1);
  assert.equal(
    modelRow.adapter.weight_precision,
    "GGUF UD-Q4_K_S/Q8_0/Q6_K/F32",
  );
  assert.equal(weightAdapter.kind, "moe_distinct_experts_exact");
  assert.equal(kvAdapter.kind, "layered_kv");
  assert.equal(kvAdapter.components[0].layers, 12);
  assert.equal(kvAdapter.components[1].layers, 33);
  assert.equal(kvAdapter.components[1].window_tokens, 512);
  assertNear(
    weightAdapter.resident_weight_gb,
    114.163192448,
    0.000000001,
    "Unsloth Step 3.7 Flash GGUF UD-Q4_K_S resident footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    113.596957184,
    0.000000001,
    "Unsloth Step 3.7 Flash GGUF UD-Q4_K_S main resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.566235264,
    0.000000001,
    "Unsloth Step 3.7 Flash GGUF UD-Q4_K_S token/header resident footprint",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    6.579290624,
    0.000000001,
    "Unsloth Step 3.7 Flash GGUF UD-Q4_K_S fixed ordinary decode traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.37158912,
    0.000000001,
    "Unsloth Step 3.7 Flash GGUF UD-Q4_K_S per-expert traffic",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.single.batchWeight,
    9.552003584,
    0.000000001,
    "Unsloth Step 3.7 Flash GGUF UD-Q4_K_S single-session MoE decode traffic",
  );
  assertNear(
    result.alloc,
    4.984406016,
    0.000000001,
    "Unsloth Step 3.7 Flash GGUF UD-Q4_K_S FP16 full/sliding KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.642070016,
    0.000000001,
    "Unsloth Step 3.7 Flash GGUF UD-Q4_K_S FP16 full/sliding KV read traffic",
  );
  assert.equal(result.bMem, 1);
  assert.equal(result.best?.batch, 1);
  assertNear(
    result.single.aggregate,
    24.387904685565044,
    0.000000001,
    "Unsloth Step 3.7 Flash GGUF UD-Q4_K_S DGX single-session throughput",
  );
  assertNear(
    result.best?.aggregate ?? 0,
    24.387904685565044,
    0.000000001,
    "Unsloth Step 3.7 Flash GGUF UD-Q4_K_S DGX aggregate throughput",
  );
  assertNear(
    result.dennard,
    33.468028720814246,
    0.000000001,
    "Unsloth Step 3.7 Flash GGUF UD-Q4_K_S DGX Dennard bound",
  );
}

{
  const result = profiled(
    "unsloth/Step-3.7-Flash-GGUF",
    "apple-mac-studio-m2-ultra-192gb",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(result.bMem, 14);
  assert.equal(result.best?.batch, 7);
  assertNear(
    result.single.aggregate,
    71.46638735696716,
    0.000000001,
    "Unsloth Step 3.7 Flash GGUF UD-Q4_K_S M2 Ultra 192GB single-session throughput",
  );
  assertNear(
    result.best?.aggregate ?? 0,
    150.42935246458552,
    0.000000001,
    "Unsloth Step 3.7 Flash GGUF UD-Q4_K_S M2 Ultra 192GB aggregate throughput",
  );
  assertNear(
    result.best?.perSession ?? 0,
    21.489907494940788,
    0.000000001,
    "Unsloth Step 3.7 Flash GGUF UD-Q4_K_S M2 Ultra 192GB per-session throughput",
  );
  assertNear(
    result.dennard,
    1173.4551004844373,
    0.000000001,
    "Unsloth Step 3.7 Flash GGUF UD-Q4_K_S M2 Ultra 192GB Dennard bound",
  );
}

{
  const modelProfile = profile("lmstudio-community/GLM-4.6V-Flash-MLX-4bit");
  const modelRow = model("lmstudio-community/GLM-4.6V-Flash-MLX-4bit");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "lmstudio-community/GLM-4.6V-Flash-MLX-4bit",
    "nvidia-dgx-spark",
  );
  assert.equal(modelProfile.status, "audited");
  assert.equal(modelRow.hf_downloads, 111225);
  assert.equal(modelRow.architecture.type, "Dense transformer");
  assert.equal(modelRow.architecture.layers, 40);
  assert.equal(modelRow.architecture.kv_heads, 2);
  assert.equal(
    modelRow.adapter.weight_precision,
    "MLX 4-bit affine + BF16 side tensors",
  );
  assert.equal(weightAdapter.kind, "dense_resident_swept");
  assertNear(
    weightAdapter.resident_weight_gb,
    7.073866752,
    0.000000001,
    "GLM 4.6V Flash MLX 4-bit resident payload",
  );
  assertNear(
    weightAdapter.swept_weight_gb,
    4.93969408,
    0.000000001,
    "GLM 4.6V Flash MLX 4-bit ordinary text swept traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    2.134172672,
    0.000000001,
    "GLM 4.6V Flash MLX 4-bit resident-only embedding and vision payload",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.single.batchWeight,
    4.93969408,
    0.000000001,
    "GLM 4.6V Flash MLX 4-bit DGX swept text traffic",
  );
  assertNear(
    result.alloc,
    4.096,
    0.000000001,
    "GLM 4.6V Flash MLX 4-bit full-context KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.31072,
    0.000000001,
    "GLM 4.6V Flash MLX 4-bit full-context KV read traffic",
  );
  assert.equal(result.bMem, 27);
  assert.equal(result.best?.batch, 6);
  assertNear(
    result.single.aggregate,
    43.677106269413756,
    0.000000001,
    "GLM 4.6V Flash MLX 4-bit DGX single-session throughput",
  );
  assertNear(
    result.best?.aggregate ?? 0,
    127.92863158113616,
    0.000000001,
    "GLM 4.6V Flash MLX 4-bit DGX aggregate throughput",
  );
  assertNear(
    result.best?.perSession ?? 0,
    21.321438596856026,
    0.000000001,
    "GLM 4.6V Flash MLX 4-bit DGX per-session throughput",
  );
  assertNear(
    result.dennard,
    1523.6917045579469,
    0.000000001,
    "GLM 4.6V Flash MLX 4-bit DGX Dennard bound",
  );
}

{
  const result = profiled(
    "lmstudio-community/GLM-4.6V-Flash-MLX-4bit",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(result.bMem, 27);
  assert.equal(result.best?.batch, 19);
  assertNear(
    result.single.aggregate,
    98.23349175611739,
    0.000000001,
    "GLM 4.6V Flash MLX 4-bit M5 Max single-session throughput",
  );
  assertNear(
    result.best?.aggregate ?? 0,
    390.90754177886845,
    0.000000001,
    "GLM 4.6V Flash MLX 4-bit M5 Max aggregate throughput",
  );
  assertNear(
    result.best?.perSession ?? 0,
    20.574081146256233,
    0.000000001,
    "GLM 4.6V Flash MLX 4-bit M5 Max per-session throughput",
  );
  assertNear(
    result.dennard,
    3426.9110131816096,
    0.000000001,
    "GLM 4.6V Flash MLX 4-bit M5 Max Dennard bound",
  );
}

{
  const modelProfile = profile("lmstudio-community/GLM-4.6V-Flash-MLX-6bit");
  const modelRow = model("lmstudio-community/GLM-4.6V-Flash-MLX-6bit");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "lmstudio-community/GLM-4.6V-Flash-MLX-6bit",
    "nvidia-dgx-spark",
  );
  assert.equal(modelProfile.status, "audited");
  assert.equal(modelRow.hf_downloads, 108813);
  assert.ok(modelRow.tags.includes("region:us"));
  assert.equal(modelRow.architecture.type, "Dense transformer");
  assert.equal(modelRow.architecture.layers, 40);
  assert.equal(modelRow.architecture.kv_heads, 2);
  assert.equal(
    modelRow.adapter.weight_precision,
    "MLX 6-bit affine + BF16 side tensors",
  );
  assert.equal(weightAdapter.kind, "dense_resident_swept");
  assertNear(
    weightAdapter.resident_weight_gb,
    9.423725568,
    0.000000001,
    "GLM 4.6V Flash MLX 6-bit resident payload",
  );
  assertNear(
    weightAdapter.swept_weight_gb,
    7.134363648,
    0.000000001,
    "GLM 4.6V Flash MLX 6-bit ordinary text swept traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    2.28936192,
    0.000000001,
    "GLM 4.6V Flash MLX 6-bit resident-only embedding and vision payload",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.single.batchWeight,
    7.134363648,
    0.000000001,
    "GLM 4.6V Flash MLX 6-bit DGX swept text traffic",
  );
  assertNear(
    result.alloc,
    4.096,
    0.000000001,
    "GLM 4.6V Flash MLX 6-bit full-context KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.31072,
    0.000000001,
    "GLM 4.6V Flash MLX 6-bit full-context KV read traffic",
  );
  assert.equal(result.bMem, 26);
  assert.equal(result.best?.batch, 4);
  assertNear(
    result.single.aggregate,
    32.32650040886842,
    0.000000001,
    "GLM 4.6V Flash MLX 6-bit DGX single-session throughput",
  );
  assertNear(
    result.best?.aggregate ?? 0,
    88.22642835963343,
    0.000000001,
    "GLM 4.6V Flash MLX 6-bit DGX aggregate throughput",
  );
  assertNear(
    result.best?.perSession ?? 0,
    22.056607089908358,
    0.000000001,
    "GLM 4.6V Flash MLX 6-bit DGX per-session throughput",
  );
  assertNear(
    result.dennard,
    1033.0216187979206,
    0.000000001,
    "GLM 4.6V Flash MLX 6-bit DGX Dennard bound",
  );
}

{
  const result = profiled(
    "lmstudio-community/GLM-4.6V-Flash-MLX-6bit",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(result.bMem, 26);
  assert.equal(result.best?.batch, 17);
  assertNear(
    result.single.aggregate,
    72.7050228976015,
    0.000000001,
    "GLM 4.6V Flash MLX 6-bit M5 Max single-session throughput",
  );
  assertNear(
    result.best?.aggregate ?? 0,
    354.83362134192765,
    0.000000001,
    "GLM 4.6V Flash MLX 6-bit M5 Max aggregate throughput",
  );
  assertNear(
    result.best?.perSession ?? 0,
    20.87256596128986,
    0.000000001,
    "GLM 4.6V Flash MLX 6-bit M5 Max per-session throughput",
  );
  assertNear(
    result.dennard,
    2323.352651801917,
    0.000000001,
    "GLM 4.6V Flash MLX 6-bit M5 Max Dennard bound",
  );
}

{
  const modelProfile = profile("lmstudio-community/GLM-4.6V-Flash-MLX-8bit");
  const modelRow = model("lmstudio-community/GLM-4.6V-Flash-MLX-8bit");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "lmstudio-community/GLM-4.6V-Flash-MLX-8bit",
    "nvidia-dgx-spark",
  );
  assert.equal(modelProfile.status, "audited");
  assert.equal(modelRow.hf_downloads, 109777);
  assert.ok(modelRow.tags.includes("region:us"));
  assert.equal(modelRow.architecture.type, "Dense transformer");
  assert.equal(modelRow.architecture.layers, 40);
  assert.equal(modelRow.architecture.kv_heads, 2);
  assert.equal(
    modelRow.adapter.weight_precision,
    "MLX 8-bit affine + BF16 side tensors",
  );
  assert.equal(weightAdapter.kind, "dense_resident_swept");
  assertNear(
    weightAdapter.resident_weight_gb,
    11.773584384,
    0.000000001,
    "GLM 4.6V Flash MLX 8-bit resident payload",
  );
  assertNear(
    weightAdapter.swept_weight_gb,
    9.329033216,
    0.000000001,
    "GLM 4.6V Flash MLX 8-bit ordinary text swept traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    2.444551168,
    0.000000001,
    "GLM 4.6V Flash MLX 8-bit resident-only embedding and vision payload",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.single.batchWeight,
    9.329033216,
    0.000000001,
    "GLM 4.6V Flash MLX 8-bit DGX swept text traffic",
  );
  assertNear(
    result.alloc,
    4.096,
    0.000000001,
    "GLM 4.6V Flash MLX 8-bit full-context KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.31072,
    0.000000001,
    "GLM 4.6V Flash MLX 8-bit full-context KV read traffic",
  );
  assert.equal(result.bMem, 26);
  assert.equal(result.best?.batch, 3);
  assertNear(
    result.single.aggregate,
    25.658489859470066,
    0.000000001,
    "GLM 4.6V Flash MLX 8-bit DGX single-session throughput",
  );
  assertNear(
    result.best?.aggregate ?? 0,
    61.759148415985194,
    0.000000001,
    "GLM 4.6V Flash MLX 8-bit DGX aggregate throughput",
  );
  assertNear(
    result.best?.perSession ?? 0,
    20.586382805328398,
    0.000000001,
    "GLM 4.6V Flash MLX 8-bit DGX per-session throughput",
  );
  assertNear(
    result.dennard,
    773.2133340868147,
    0.000000001,
    "GLM 4.6V Flash MLX 8-bit DGX Dennard bound",
  );
}

{
  const result = profiled(
    "lmstudio-community/GLM-4.6V-Flash-MLX-8bit",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(result.bMem, 26);
  assert.equal(result.best?.batch, 16);
  assertNear(
    result.single.aggregate,
    57.70810539822205,
    0.000000001,
    "GLM 4.6V Flash MLX 8-bit M5 Max single-session throughput",
  );
  assertNear(
    result.best?.aggregate ?? 0,
    324.2185028757991,
    0.000000001,
    "GLM 4.6V Flash MLX 8-bit M5 Max aggregate throughput",
  );
  assertNear(
    result.best?.perSession ?? 0,
    20.263656429737445,
    0.000000001,
    "GLM 4.6V Flash MLX 8-bit M5 Max per-session throughput",
  );
  assertNear(
    result.dennard,
    1739.0219308765722,
    0.000000001,
    "GLM 4.6V Flash MLX 8-bit M5 Max Dennard bound",
  );
}

{
  const modelProfile = profile("zai-org/chatglm2-6b");
  const result = profiled("zai-org/chatglm2-6b", "nvidia-dgx-spark");
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    12.487168064,
    0.000000001,
    "ChatGLM2 6B FP16 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    11.954491456,
    0.000000001,
    "ChatGLM2 6B FP16 swept text-decode traffic",
  );
  assertNear(
    modelProfile.architecture.weight_adapter.auxiliary_resident_weight_gb,
    0.532676608,
    0.000000001,
    "ChatGLM2 6B FP16 resident-only input embedding footprint",
  );
  assertNear(
    result.alloc,
    2.8672,
    0.000000001,
    "ChatGLM2 6B FP16 multi-query KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.917504,
    0.000000001,
    "ChatGLM2 6B FP16 multi-query KV read traffic",
  );
  assert.equal(result.bMem, 37);
  assert.equal(result.best?.batch, 1);
  assertNear(
    result.single.aggregate,
    21.20883284438599,
    0.000000001,
    "ChatGLM2 6B FP16 DGX single-session throughput",
  );
  assertNear(
    result.best?.aggregate ?? 0,
    21.20883284438599,
    0.000000001,
    "ChatGLM2 6B FP16 DGX aggregate throughput",
  );
  assertNear(
    result.best?.perSession ?? 0,
    21.20883284438599,
    0.000000001,
    "ChatGLM2 6B FP16 DGX per-session throughput",
  );
  assertNear(
    result.dennard,
    856.3155974960654,
    0.000000001,
    "ChatGLM2 6B FP16 DGX Dennard bound",
  );
}

{
  const result = profiled(
    "zai-org/chatglm2-6b",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(result.bMem, 37);
  assert.equal(result.best?.batch, 20);
  assertNear(
    result.single.aggregate,
    47.70045189176923,
    0.000000001,
    "ChatGLM2 6B FP16 M5 Max single-session throughput",
  );
  assertNear(
    result.best?.aggregate ?? 0,
    405.2193913327451,
    0.000000001,
    "ChatGLM2 6B FP16 M5 Max aggregate throughput",
  );
  assertNear(
    result.best?.perSession ?? 0,
    20.260969566637254,
    0.000000001,
    "ChatGLM2 6B FP16 M5 Max per-session throughput",
  );
  assertNear(
    result.dennard,
    1925.9259225735684,
    0.000000001,
    "ChatGLM2 6B FP16 M5 Max Dennard bound",
  );
}

{
  const catalogRow = model("zai-org/chatglm3-6b");
  const modelProfile = profile("zai-org/chatglm3-6b");
  const result = profiled("zai-org/chatglm3-6b", "nvidia-dgx-spark");

  assert.equal(catalogRow.hf_downloads, 114420);
  assert.equal(catalogRow.tags.includes("region:us"), true);
  assert.equal(catalogRow.architecture.max_context_tokens, 8192);
  assert.equal(catalogRow.adapter.resident_weight_gb, 12.487168064);
  assert.equal(catalogRow.adapter.active_weight_gb, 11.954491456);
  assert.equal(modelProfile.architecture.max_context_tokens, 8192);
  assert.equal(modelProfile.architecture.kv_adapter.kind, "full_context");
  assert.equal(modelProfile.architecture.kv_adapter.layers, 28);
  assert.equal(modelProfile.architecture.kv_adapter.kv_heads, 2);
  assert.equal(modelProfile.architecture.kv_adapter.head_dim, 128);
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    12.487168064,
    0.000000001,
    "ChatGLM3 6B FP16 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    11.954491456,
    0.000000001,
    "ChatGLM3 6B FP16 swept text-decode traffic",
  );
  assertNear(
    modelProfile.architecture.weight_adapter.auxiliary_resident_weight_gb,
    0.532676608,
    0.000000001,
    "ChatGLM3 6B FP16 resident-only input embedding footprint",
  );
  assertNear(
    result.alloc,
    2.8672,
    0.000000001,
    "ChatGLM3 6B FP16 multi-query KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.917504,
    0.000000001,
    "ChatGLM3 6B FP16 multi-query KV read traffic",
  );
  assert.equal(result.bMem, 37);
  assert.equal(result.best?.batch, 1);
  assertNear(
    result.single.aggregate,
    21.20883284438599,
    0.000000001,
    "ChatGLM3 6B FP16 DGX single-session throughput",
  );
  assertNear(
    result.best?.aggregate ?? 0,
    21.20883284438599,
    0.000000001,
    "ChatGLM3 6B FP16 DGX aggregate throughput",
  );
  assertNear(
    result.best?.perSession ?? 0,
    21.20883284438599,
    0.000000001,
    "ChatGLM3 6B FP16 DGX per-session throughput",
  );
  assertNear(
    result.dennard,
    856.3155974960654,
    0.000000001,
    "ChatGLM3 6B FP16 DGX Dennard bound",
  );
}

{
  const result = profiled(
    "zai-org/chatglm3-6b",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(result.bMem, 37);
  assert.equal(result.best?.batch, 20);
  assertNear(
    result.single.aggregate,
    47.70045189176923,
    0.000000001,
    "ChatGLM3 6B FP16 M5 Max single-session throughput",
  );
  assertNear(
    result.best?.aggregate ?? 0,
    405.2193913327451,
    0.000000001,
    "ChatGLM3 6B FP16 M5 Max aggregate throughput",
  );
  assertNear(
    result.best?.perSession ?? 0,
    20.260969566637254,
    0.000000001,
    "ChatGLM3 6B FP16 M5 Max per-session throughput",
  );
  assertNear(
    result.dennard,
    1925.9259225735684,
    0.000000001,
    "ChatGLM3 6B FP16 M5 Max Dennard bound",
  );
}

{
  const item = profile("allenai/Molmo2-8B");
  const result = profiled("allenai/Molmo2-8B", "nvidia-dgx-spark");
  assert.equal(item.serving.weight_format, "fp32");
  assert.equal(item.serving.kv_store_format, "fp32");
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    34.64681248,
    0.000000001,
    "Molmo2 8B resident F32 multimodal package",
  );
  assertNear(
    result.single.batchWeight,
    30.273622016,
    0.000000001,
    "Molmo2 8B ordinary text-decode swept traffic",
  );
  assertNear(
    item.architecture.weight_adapter.auxiliary_resident_weight_gb,
    4.373190464,
    0.000000001,
    "Molmo2 8B resident-only input embedding and vision tensors",
  );
  assertNear(
    result.alloc,
    29.4912,
    0.000000001,
    "Molmo2 8B F32 full-context KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    9.437184,
    0.000000001,
    "Molmo2 8B F32 full-context KV read traffic",
  );
  assert.equal(result.bMem, 2);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    6.874703069,
    0.000001,
    "Molmo2 8B DGX Spark single-session bound",
  );
}

{
  const row = model("allenai/Molmo2-O-7B");
  const item = profile("allenai/Molmo2-O-7B");
  const weightAdapter = item.architecture.weight_adapter;
  const kvAdapter = item.architecture.kv_adapter;
  const result = profiled("allenai/Molmo2-O-7B", "nvidia-dgx-spark");
  const m5Result = profiled(
    "allenai/Molmo2-O-7B",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(row.hf_downloads, 161905);
  assert.ok(row.tags.includes("region:us"));
  assert.equal(item.serving.weight_format, "fp32");
  assert.equal(item.serving.kv_store_format, "fp32");
  assert.equal(weightAdapter.kind, "dense_resident_swept");
  assertNear(
    weightAdapter.resident_weight_gb,
    31.043147584,
    0.000000001,
    "Molmo2-O 7B resident F32 multimodal package",
  );
  assertNear(
    weightAdapter.swept_weight_gb,
    27.549089792,
    0.000000001,
    "Molmo2-O 7B ordinary text-decode swept traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    3.494057792,
    0.000000001,
    "Molmo2-O 7B resident-only input embedding and vision tensors",
  );
  assert.equal(kvAdapter.kind, "full_context");
  assert.equal(kvAdapter.layers, 32);
  assert.equal(kvAdapter.kv_heads, 32);
  assert.equal(kvAdapter.head_dim, 128);
  assertNear(
    result.alloc,
    104.8576,
    0.000000001,
    "Molmo2-O 7B F32 full-context KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    33.554432,
    0.000000001,
    "Molmo2-O 7B F32 full-context KV read traffic",
  );
  assert.equal(result.status_code, "no_session_capacity");
  assert.equal(result.bMem, 0);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    4.46782758167865,
    0.000000001,
    "Molmo2-O 7B DGX Spark single-session bound",
  );
  assertNear(
    result.dennard,
    8.406880747725348,
    0.000000001,
    "Molmo2-O 7B DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "no_session_capacity");
  assertNear(
    m5Result.single.aggregate,
    10.048520641577621,
    0.000000001,
    "Molmo2-O 7B M5 Max single-session bound",
  );
}

{
  const item = profile("deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B");
  const result = profiled(
    "deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    3.554176,
    0.000000001,
    "DeepSeek R1 Distill Qwen 1.5B resident BF16 package",
  );
  assertNear(
    result.single.batchWeight,
    3.087428608,
    0.000000001,
    "DeepSeek R1 Distill Qwen 1.5B ordinary text-decode swept traffic",
  );
  assertNear(
    item.architecture.weight_adapter.auxiliary_resident_weight_gb,
    0.466747392,
    0.000000001,
    "DeepSeek R1 Distill Qwen 1.5B resident-only input embedding",
  );
  assertNear(
    result.alloc,
    2.8672,
    0.000000001,
    "DeepSeek R1 Distill Qwen 1.5B BF16 full-context KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.917504,
    0.000000001,
    "DeepSeek R1 Distill Qwen 1.5B BF16 full-context KV read traffic",
  );
  assert.equal(result.bMem, 40);
  assert.equal(result.best.batch, 11);
  assertNear(
    result.single.aggregate,
    68.165941033,
    0.000001,
    "DeepSeek R1 Distill Qwen 1.5B DGX Spark single-session bound",
  );
  assertNear(
    result.best.aggregate,
    227.845693562,
    0.000001,
    "DeepSeek R1 Distill Qwen 1.5B DGX Spark aggregate bound",
  );
}

{
  const item = profile("deepseek-ai/DeepSeek-R1-Distill-Llama-8B");
  const result = profiled(
    "deepseek-ai/DeepSeek-R1-Distill-Llama-8B",
    "nvidia-dgx-spark",
  );
  const m5MaxResult = profiled(
    "deepseek-ai/DeepSeek-R1-Distill-Llama-8B",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "no_floor");
  assert.equal(item.base_model_proof.config_compatible, false);
  assert.equal(item.architecture.max_context_tokens, 131072);
  assertNear(
    result.resident,
    16.060522496,
    0.000000001,
    "DeepSeek R1 Distill Llama 8B resident BF16 package",
  );
  assertNear(
    result.single.batchWeight,
    15.009849344,
    0.000000001,
    "DeepSeek R1 Distill Llama 8B ordinary text-decode swept traffic",
  );
  assertNear(
    item.architecture.weight_adapter.auxiliary_resident_weight_gb,
    1.050673152,
    0.000000001,
    "DeepSeek R1 Distill Llama 8B resident-only input embedding",
  );
  assertNear(
    result.alloc,
    13.1072,
    0.000000001,
    "DeepSeek R1 Distill Llama 8B BF16 full-context KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    4.194304,
    0.000000001,
    "DeepSeek R1 Distill Llama 8B BF16 full-context KV read traffic",
  );
  assert.equal(result.bMem, 7);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    14.215674865213158,
    0.000000001,
    "DeepSeek R1 Distill Llama 8B DGX Spark single-session bound",
  );
  assertNear(
    result.dennard,
    144.23043617542254,
    0.000000001,
    "DeepSeek R1 Distill Llama 8B DGX Spark Dennard bound",
  );
  assert.equal(m5MaxResult.status_code, "ok");
  assert.equal(m5MaxResult.best.batch, 3);
  assertNear(
    m5MaxResult.single.aggregate,
    31.97225042945377,
    0.000000001,
    "DeepSeek R1 Distill Llama 8B M5 Max single-session bound",
  );
  assertNear(
    m5MaxResult.best.aggregate,
    66.75663870809146,
    0.000000001,
    "DeepSeek R1 Distill Llama 8B M5 Max aggregate bound",
  );
}

{
  const item = profile("deepseek-ai/DeepSeek-R1-Distill-Qwen-7B");
  const result = profiled(
    "deepseek-ai/DeepSeek-R1-Distill-Qwen-7B",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "no_floor");
  assert.equal(item.architecture.max_context_tokens, 131072);
  assertNear(
    result.resident,
    15.231233024,
    0.000000001,
    "DeepSeek R1 Distill Qwen 7B resident BF16 package",
  );
  assertNear(
    result.single.batchWeight,
    14.141238272,
    0.000000001,
    "DeepSeek R1 Distill Qwen 7B ordinary text-decode swept traffic",
  );
  assertNear(
    item.architecture.weight_adapter.auxiliary_resident_weight_gb,
    1.089994752,
    0.000000001,
    "DeepSeek R1 Distill Qwen 7B resident-only input embedding",
  );
  assertNear(
    result.alloc,
    5.7344,
    0.000000001,
    "DeepSeek R1 Distill Qwen 7B BF16 full-context KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.835008,
    0.000000001,
    "DeepSeek R1 Distill Qwen 7B BF16 full-context KV read traffic",
  );
  assert.equal(result.bMem, 18);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    17.08786878670369,
    0.000000001,
    "DeepSeek R1 Distill Qwen 7B DGX Spark single-session bound",
  );
  assertNear(
    result.dennard,
    352.7110421882862,
    0.000000001,
    "DeepSeek R1 Distill Qwen 7B DGX Spark Dennard bound",
  );
}

{
  const result = profiled(
    "deepseek-ai/DeepSeek-R1-Distill-Qwen-7B",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(result.best.batch, 9);
  assertNear(
    result.single.aggregate,
    38.43205653859365,
    0.000000001,
    "DeepSeek R1 Distill Qwen 7B M5 Max single-session bound",
  );
  assertNear(
    result.best.aggregate,
    180.2565263389568,
    0.000000001,
    "DeepSeek R1 Distill Qwen 7B M5 Max aggregate bound",
  );
}

{
  const item = profile("deepseek-ai/DeepSeek-R1-Distill-Qwen-14B");
  const result = profiled(
    "deepseek-ai/DeepSeek-R1-Distill-Qwen-14B",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    29.540067328,
    0.000000001,
    "DeepSeek R1 Distill Qwen 14B resident BF16 package",
  );
  assertNear(
    result.single.batchWeight,
    27.982931968,
    0.000000001,
    "DeepSeek R1 Distill Qwen 14B ordinary text-decode swept traffic",
  );
  assertNear(
    item.architecture.weight_adapter.auxiliary_resident_weight_gb,
    1.55713536,
    0.000000001,
    "DeepSeek R1 Distill Qwen 14B resident-only input embedding",
  );
  assertNear(
    result.alloc,
    19.6608,
    0.000000001,
    "DeepSeek R1 Distill Qwen 14B BF16 full-context KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    6.291456,
    0.000000001,
    "DeepSeek R1 Distill Qwen 14B BF16 full-context KV read traffic",
  );
  assert.equal(result.bMem, 4);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    7.965131289,
    0.000000001,
    "DeepSeek R1 Distill Qwen 14B DGX Spark single-session bound",
  );
  assertNear(
    result.dennard,
    44.887405647,
    0.000000001,
    "DeepSeek R1 Distill Qwen 14B DGX Spark Dennard bound",
  );
}

{
  const result = profiled(
    "deepseek-ai/DeepSeek-R1-Distill-Qwen-14B",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.single.aggregate,
    17.914251323,
    0.000000001,
    "DeepSeek R1 Distill Qwen 14B M5 Max single-session bound",
  );
  assert.equal(result.bMem, 4);
  assert.equal(result.best, null);
  assertNear(
    result.dennard,
    100.955557023,
    0.000000001,
    "DeepSeek R1 Distill Qwen 14B M5 Max Dennard bound",
  );
}

{
  const item = profile("deepseek-ai/DeepSeek-R1-Distill-Llama-70B");
  const result = profiled(
    "deepseek-ai/DeepSeek-R1-Distill-Llama-70B",
    "nvidia-dgx-spark",
  );
  const m2UltraResult = profiled(
    "deepseek-ai/DeepSeek-R1-Distill-Llama-70B",
    "apple-mac-studio-m2-ultra-192gb",
  );
  const a100Result = profiled(
    "deepseek-ai/DeepSeek-R1-Distill-Llama-70B",
    "nvidia-dgx-station-a100-320g",
  );
  assert.equal(result.status_code, "resident_not_fit");
  assertNear(
    result.resident,
    141.107412992,
    0.000000001,
    "DeepSeek R1 Distill Llama 70B resident BF16 package",
  );
  assertNear(
    result.single.batchWeight,
    139.006066688,
    0.000000001,
    "DeepSeek R1 Distill Llama 70B ordinary text-decode swept traffic",
  );
  assertNear(
    item.architecture.weight_adapter.auxiliary_resident_weight_gb,
    2.101346304,
    0.000000001,
    "DeepSeek R1 Distill Llama 70B resident-only input embedding",
  );
  assertNear(
    result.alloc,
    32.768,
    0.000000001,
    "DeepSeek R1 Distill Llama 70B BF16 full-context KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    10.48576,
    0.000000001,
    "DeepSeek R1 Distill Llama 70B BF16 full-context KV read traffic",
  );
  assert.equal(result.bMem, 0);
  assert.equal(result.best, null);
  assert.equal(m2UltraResult.status_code, "no_floor");
  assert.equal(m2UltraResult.bMem, 1);
  assertNear(
    m2UltraResult.single.aggregate,
    5.351463138,
    0.000000001,
    "DeepSeek R1 Distill Llama 70B M2 Ultra single-session bound",
  );
  assert.equal(a100Result.status_code, "ok");
  assert.equal(a100Result.best.batch, 5);
  assertNear(
    a100Result.best.aggregate,
    213.022845344,
    0.000001,
    "DeepSeek R1 Distill Llama 70B A100 aggregate bound",
  );
  assertNear(
    a100Result.best.perSession,
    42.604569069,
    0.000001,
    "DeepSeek R1 Distill Llama 70B A100 per-session bound",
  );
}

{
  const item = profile("casperhansen/deepseek-r1-distill-llama-70b-awq");
  const result = profiled(
    "casperhansen/deepseek-r1-distill-llama-70b-awq",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    39.767785472,
    0.000000001,
    "Casper Hansen DeepSeek R1 Distill Llama 70B AWQ resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    37.666439168,
    0.000000001,
    "Casper Hansen DeepSeek R1 Distill Llama 70B AWQ swept text-decode traffic",
  );
  assertNear(
    item.architecture.weight_adapter.auxiliary_resident_weight_gb,
    2.101346304,
    0.000000001,
    "Casper Hansen DeepSeek R1 Distill Llama 70B AWQ resident-only input embedding",
  );
  assertNear(
    result.alloc,
    32.768,
    0.000000001,
    "Casper Hansen DeepSeek R1 Distill Llama 70B AWQ BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    10.48576,
    0.000000001,
    "Casper Hansen DeepSeek R1 Distill Llama 70B AWQ BF16 KV read traffic",
  );
  assert.equal(result.bMem, 2);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    5.669522985804245,
    0.000000001,
    "Casper Hansen DeepSeek R1 Distill Llama 70B AWQ DGX Spark single-session throughput",
  );
  assertNear(
    result.dennard,
    17.746263507777513,
    0.000000001,
    "Casper Hansen DeepSeek R1 Distill Llama 70B AWQ DGX Spark Dennard bound",
  );

  const gb300Result = profiled(
    "casperhansen/deepseek-r1-distill-llama-70b-awq",
    "nvidia-msi-xpertstation-ws300-dgx-station-gb300",
  );
  assert.equal(gb300Result.status_code, "ok");
  assert.equal(gb300Result.bMem, 21);
  assert.equal(gb300Result.best.batch, 21);
  assertNear(
    gb300Result.single.aggregate,
    147.44913259783934,
    0.000000001,
    "Casper Hansen DeepSeek R1 Distill Llama 70B AWQ GB300 single-session throughput",
  );
  assertNear(
    gb300Result.best.aggregate,
    578.2041486479711,
    0.000000001,
    "Casper Hansen DeepSeek R1 Distill Llama 70B AWQ GB300 aggregate throughput",
  );
  assertNear(
    gb300Result.best.perSession,
    27.533530887998626,
    0.000000001,
    "Casper Hansen DeepSeek R1 Distill Llama 70B AWQ GB300 per-session throughput",
  );
  assertNear(
    gb300Result.dennard,
    4028.0600362045348,
    0.000000001,
    "Casper Hansen DeepSeek R1 Distill Llama 70B AWQ GB300 Dennard bound",
  );
}

{
  const item = profile("zai-org/GLM-4.1V-9B-Thinking");
  const result = profiled("zai-org/GLM-4.1V-9B-Thinking", "nvidia-dgx-spark");
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    20.585554944,
    0.000000001,
    "GLM 4.1V 9B Thinking resident BF16 multimodal package",
  );
  assertNear(
    result.single.batchWeight,
    17.559044096,
    0.000000001,
    "GLM 4.1V 9B Thinking ordinary text-decode swept traffic",
  );
  assertNear(
    item.architecture.weight_adapter.auxiliary_resident_weight_gb,
    3.026510848,
    0.000000001,
    "GLM 4.1V 9B Thinking resident-only vision plus input embedding",
  );
  assertNear(
    result.alloc,
    4.096,
    0.000000001,
    "GLM 4.1V 9B Thinking BF16 full-context KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.31072,
    0.000000001,
    "GLM 4.1V 9B Thinking BF16 full-context KV read traffic",
  );
  assert.equal(result.bMem, 24);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    14.467589,
    0.000001,
    "GLM 4.1V 9B Thinking DGX Spark single-session bound",
  );
  assertNear(
    result.dennard,
    377.356054,
    0.000001,
    "GLM 4.1V 9B Thinking DGX Spark Dennard bound",
  );
}

{
  const item = profile("zai-org/GLM-4.6V-Flash");
  const result = profiled("zai-org/GLM-4.6V-Flash", "nvidia-dgx-spark");
  assert.equal(result.status_code, "no_floor");
  assert.equal(item.architecture.max_context_tokens, 131072);
  assertNear(
    result.resident,
    20.585554944,
    0.000000001,
    "GLM 4.6V Flash resident BF16 multimodal package",
  );
  assertNear(
    result.single.batchWeight,
    17.559044096,
    0.000000001,
    "GLM 4.6V Flash ordinary text-decode swept traffic",
  );
  assertNear(
    item.architecture.weight_adapter.auxiliary_resident_weight_gb,
    3.026510848,
    0.000000001,
    "GLM 4.6V Flash resident-only vision plus input embedding",
  );
  assertNear(
    result.alloc,
    4.096,
    0.000000001,
    "GLM 4.6V Flash BF16 full-context KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.31072,
    0.000000001,
    "GLM 4.6V Flash BF16 full-context KV read traffic",
  );
  assert.equal(result.bMem, 24);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    14.467589,
    0.000001,
    "GLM 4.6V Flash DGX Spark single-session bound",
  );
  assertNear(
    result.dennard,
    377.356054,
    0.000001,
    "GLM 4.6V Flash DGX Spark Dennard bound",
  );
}

{
  const item = profile("cyankiwi/GLM-4.5-Air-AWQ-4bit");
  const result = profiled("cyankiwi/GLM-4.5-Air-AWQ-4bit", "nvidia-dgx-spark");
  const m5Result = profiled(
    "cyankiwi/GLM-4.5-Air-AWQ-4bit",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    63.394045248,
    0.000000001,
    "cyankiwi GLM 4.5 Air AWQ resident package",
  );
  assertNear(
    item.architecture.weight_adapter.fixed_weight_gb,
    6.095381824,
    0.000000001,
    "cyankiwi GLM 4.5 Air AWQ fixed decode traffic",
  );
  assertNear(
    item.architecture.weight_adapter.routed_expert_weight_gb,
    0.43794648,
    0.000000001,
    "cyankiwi GLM 4.5 Air AWQ routed expert group",
  );
  assertNear(
    item.architecture.weight_adapter.auxiliary_resident_weight_gb,
    1.241513984,
    0.000000001,
    "cyankiwi GLM 4.5 Air AWQ resident-only input embedding",
  );
  assertNear(
    result.single.batchWeight,
    9.598953664,
    0.000000001,
    "cyankiwi GLM 4.5 Air AWQ single-session active traffic",
  );
  assertNear(
    result.alloc,
    18.8416,
    0.000000001,
    "cyankiwi GLM 4.5 Air AWQ BF16 full-context KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    6.029312,
    0.000000001,
    "cyankiwi GLM 4.5 Air AWQ BF16 full-context KV read traffic",
  );
  assert.equal(result.bMem, 3);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    17.468349071,
    0.000001,
    "cyankiwi GLM 4.5 Air AWQ DGX Spark single-session bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 2);
  assertNear(
    m5Result.best.aggregate,
    49.233875465,
    0.000001,
    "cyankiwi GLM 4.5 Air AWQ M5 Max aggregate bound",
  );
}

{
  const modelRow = model("zai-org/GLM-4.5");
  const item = profile("zai-org/GLM-4.5");
  const result = profiled("zai-org/GLM-4.5", "nvidia-dgx-spark");
  const gb300Result = profiled(
    "zai-org/GLM-4.5",
    "nvidia-msi-xpertstation-ws300-dgx-station-gb300",
  );
  assert.equal(modelRow.hf_downloads, 144724);
  assert.equal(modelRow.tags.includes("region:us"), true);
  assertNear(
    modelRow.architecture.active_params_b,
    32.856334144,
    0.000000001,
    "GLM 4.5 catalog active logical parameters",
  );
  assert.equal(item.status, "audited");
  assert.equal(result.status_code, "resident_not_fit");
  assertNear(
    result.resident,
    716.675611392,
    0.000000001,
    "GLM 4.5 BF16/F32 resident package",
  );
  assertNear(
    item.architecture.weight_adapter.fixed_weight_gb,
    32.116293248,
    0.000000001,
    "GLM 4.5 BF16/F32 fixed decode traffic",
  );
  assertNear(
    item.architecture.weight_adapter.routed_expert_weight_gb,
    4.19954688,
    0.000000001,
    "GLM 4.5 BF16/F32 routed expert group",
  );
  assertNear(
    item.architecture.weight_adapter.auxiliary_resident_weight_gb,
    12.631817344,
    0.000000001,
    "GLM 4.5 BF16/F32 resident-only input embedding and NTP layer",
  );
  assertNear(
    result.single.batchWeight,
    65.712668288,
    0.000000001,
    "GLM 4.5 BF16/F32 single-session active traffic",
  );
  assertNear(
    result.alloc,
    37.6832,
    0.000000001,
    "GLM 4.5 BF16/F32 full-context BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    12.058624,
    0.000000001,
    "GLM 4.5 BF16/F32 full-context BF16 KV read traffic",
  );
  assert.equal(result.bMem, 0);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    3.510292705,
    0.000001,
    "GLM 4.5 BF16/F32 DGX Spark single-session bound",
  );
  assert.equal(gb300Result.status_code, "no_session_capacity");
  assert.equal(gb300Result.bMem, 0);
  assert.equal(gb300Result.best, null);
  assertNear(
    gb300Result.single.aggregate,
    91.293326768,
    0.000001,
    "GLM 4.5 BF16/F32 GB300 single-session bound",
  );
}

{
  const item = profile("zai-org/GLM-4.5-Air");
  const result = profiled("zai-org/GLM-4.5-Air", "nvidia-dgx-spark");
  const gb300Result = profiled(
    "zai-org/GLM-4.5-Air",
    "nvidia-msi-xpertstation-ws300-dgx-station-gb300",
  );
  assert.equal(result.status_code, "resident_not_fit");
  assertNear(
    result.resident,
    220.93766144,
    0.000000001,
    "GLM 4.5 Air BF16/F32 resident package",
  );
  assertNear(
    item.architecture.weight_adapter.fixed_weight_gb,
    13.149673984,
    0.000000001,
    "GLM 4.5 Air BF16/F32 fixed decode traffic",
  );
  assertNear(
    item.architecture.weight_adapter.routed_expert_weight_gb,
    1.55713536,
    0.000000001,
    "GLM 4.5 Air BF16/F32 routed expert group",
  );
  assertNear(
    item.architecture.weight_adapter.auxiliary_resident_weight_gb,
    8.474661376,
    0.000000001,
    "GLM 4.5 Air BF16/F32 resident-only input embedding and NTP layer",
  );
  assertNear(
    result.single.batchWeight,
    25.606756864,
    0.000000001,
    "GLM 4.5 Air BF16/F32 single-session active traffic",
  );
  assertNear(
    result.alloc,
    18.8416,
    0.000000001,
    "GLM 4.5 Air BF16/F32 full-context BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    6.029312,
    0.000000001,
    "GLM 4.5 Air BF16/F32 full-context BF16 KV read traffic",
  );
  assert.equal(result.bMem, 0);
  assert.equal(result.best, null);
  assert.equal(gb300Result.status_code, "ok");
  assert.equal(gb300Result.best.batch, 27);
  assertNear(
    gb300Result.best.aggregate,
    563.227804747,
    0.000001,
    "GLM 4.5 Air BF16/F32 GB300 aggregate bound",
  );
  assertNear(
    gb300Result.best.perSession,
    20.860289065,
    0.000001,
    "GLM 4.5 Air BF16/F32 GB300 per-session bound",
  );
}

{
  const repo = "zai-org/GLM-4.5V";
  const modelRow = model(repo);
  const item = profile(repo);
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  const m1Result = profiled(repo, "apple-mac-studio-m1-ultra-128gb");

  assert.equal(modelRow.hf_downloads, 134414);
  assert.equal(modelRow.tags.includes("region:us"), true);
  assertNear(
    modelRow.architecture.total_params_b,
    107.71093312,
    0.000000001,
    "GLM 4.5V catalog total logical parameters",
  );
  assertNear(
    modelRow.architecture.active_params_b,
    12.803372672,
    0.000000001,
    "GLM 4.5V catalog active logical parameters",
  );
  assert.equal(item.status, "audited");
  assert.equal(item.architecture.max_context_tokens, 65536);
  assertNear(
    weightAdapter.resident_weight_gb,
    215.42187776,
    0.000000001,
    "GLM 4.5V BF16/F32 resident package",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    212.463000064,
    0.000000001,
    "GLM 4.5V BF16/F32 main resident text package",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    2.958877696,
    0.000000001,
    "GLM 4.5V BF16/F32 visual and input embedding residency",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    13.149673984,
    0.000000001,
    "GLM 4.5V BF16/F32 fixed decode traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    1.55713536,
    0.000000001,
    "GLM 4.5V BF16/F32 routed expert group",
  );
  assert.equal(weightAdapter.routed_experts, 128);
  assert.equal(weightAdapter.routed_experts_per_token, 8);
  assert.equal(weightAdapter.shared_experts_per_token, 1);
  assert.equal(item.architecture.kv_adapter.kind, "full_context");
  assert.equal(item.architecture.kv_adapter.layers, 46);
  assert.equal(item.architecture.kv_adapter.kv_heads, 8);
  assert.equal(item.architecture.kv_adapter.head_dim, 128);
  assert.equal(item.architecture.kv_adapter.kv_scalar_multiplier, 2);
  assert.equal(result.status_code, "resident_not_fit");
  assertNear(
    result.resident,
    215.42187776,
    0.000000001,
    "GLM 4.5V BF16/F32 DGX resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    25.606756864,
    0.000000001,
    "GLM 4.5V BF16/F32 single-session active traffic",
  );
  assertNear(
    result.alloc,
    18.8416,
    0.000000001,
    "GLM 4.5V BF16/F32 full-context BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    6.029312,
    0.000000001,
    "GLM 4.5V BF16/F32 full-context BF16 KV read traffic",
  );
  assert.equal(result.bMem, 0);
  assert.equal(result.best, null);
  assert.equal(result.dennard, 0);
  assertNear(
    result.single.aggregate,
    8.629390749324676,
    0.000000001,
    "GLM 4.5V BF16/F32 DGX Spark single-session bound",
  );
  assert.equal(m5Result.status_code, "resident_not_fit");
  assertNear(
    m5Result.single.aggregate,
    19.408226813499454,
    0.000000001,
    "GLM 4.5V BF16/F32 M5 Max single-session bound",
  );
  assert.equal(m1Result.status_code, "resident_not_fit");
  assertNear(
    m1Result.single.aggregate,
    25.28759193941297,
    0.000000001,
    "GLM 4.5V BF16/F32 M1 Ultra single-session bound",
  );
}

{
  const item = profile("Doradus-AI/RnJ-1-Instruct-FP8");
  const result = profiled("Doradus-AI/RnJ-1-Instruct-FP8", "nvidia-dgx-spark");
  assert.equal(item.serving.weight_format, "fp8");
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    11.995496448,
    0.000000001,
    "Doradus RnJ-1 Instruct FP8 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    9.894150144,
    0.000000001,
    "Doradus RnJ-1 Instruct FP8 swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    2.101346304,
    0.000000001,
    "Doradus RnJ-1 Instruct FP8 resident-only input embedding footprint",
  );
  assertNear(
    result.alloc,
    13.1072,
    0.000000001,
    "Doradus RnJ-1 Instruct FP8 BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    4.194304,
    0.000000001,
    "Doradus RnJ-1 Instruct FP8 BF16 KV read traffic",
  );
  assert.equal(result.bMem, 8);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    19.377569548,
    0.000001,
    "Doradus RnJ-1 Instruct FP8 DGX Spark single-session throughput",
  );
  assertNear(
    result.dennard,
    227.361062036,
    0.000001,
    "Doradus RnJ-1 Instruct FP8 DGX Spark Dennard bound",
  );
}

{
  const row = model("MaziyarPanahi/gemma-3-27b-it-GGUF");
  const item = profile("MaziyarPanahi/gemma-3-27b-it-GGUF");
  const result = profiled(
    "MaziyarPanahi/gemma-3-27b-it-GGUF",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "MaziyarPanahi/gemma-3-27b-it-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  const m1Result = profiled(
    "MaziyarPanahi/gemma-3-27b-it-GGUF",
    "apple-mac-studio-m1-ultra-128gb",
  );

  assert.equal(row.hf_downloads, 114543);
  assert.equal(row.license, "gemma");
  assert.equal(row.tags.includes("region:us"), true);
  assert.equal(row.architecture.detail, "gemma3 (GGUF Q2_K)");
  assertNear(
    row.adapter.active_weight_gb,
    10.49687552,
    0.000000001,
    "MaziyarPanahi Gemma 3 27B Q2_K catalog active text traffic",
  );
  assert.equal(item.status, "audited");
  assert.equal(item.serving.weight_format, "gguf_quantized");
  assert.equal(
    item.serving.runtime_format,
    "llama.cpp-gguf-q2-k-q3-k-memory-bound",
  );
  assert.equal(item.architecture.kv_adapter.kind, "layered_kv");
  assert.equal(item.architecture.kv_adapter.components[0].layers, 10);
  assert.equal(item.architecture.kv_adapter.components[1].layers, 52);
  assertNear(
    item.architecture.weight_adapter.resident_weight_gb,
    10.503436704,
    0.000000001,
    "MaziyarPanahi Gemma 3 27B Q2_K resident footprint",
  );
  assertNear(
    item.architecture.weight_adapter.swept_weight_gb,
    10.49687552,
    0.000000001,
    "MaziyarPanahi Gemma 3 27B Q2_K swept text-decode traffic",
  );
  assertNear(
    item.architecture.weight_adapter.auxiliary_resident_weight_gb,
    0.006561184,
    0.000000001,
    "MaziyarPanahi Gemma 3 27B Q2_K GGUF overhead footprint",
  );
  assertNear(
    row.adapter.kv_alloc_gb_per_1k_tokens,
    0.08628207616,
    0.000000001,
    "MaziyarPanahi Gemma 3 27B Q2_K legacy allocation display coefficient",
  );
  assertNear(
    row.adapter.kv_read_gb_per_1k_tokens,
    0.095551488,
    0.000000001,
    "MaziyarPanahi Gemma 3 27B Q2_K legacy read display coefficient",
  );
  assertNear(
    result.alloc,
    8.628207616,
    0.000000001,
    "MaziyarPanahi Gemma 3 27B Q2_K layered KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    3.057647616,
    0.000000001,
    "MaziyarPanahi Gemma 3 27B Q2_K layered KV read traffic",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(result.bMem, 12);
  assert.equal(result.best.batch, 1);
  assertNear(
    result.single.aggregate,
    20.140878233844198,
    0.000000001,
    "MaziyarPanahi Gemma 3 27B Q2_K DGX Spark single-session throughput",
  );
  assertNear(
    result.best.aggregate,
    20.140878233844198,
    0.000000001,
    "MaziyarPanahi Gemma 3 27B Q2_K DGX Spark aggregate throughput",
  );
  assertNear(
    result.dennard,
    330.05210102067275,
    0.000000001,
    "MaziyarPanahi Gemma 3 27B Q2_K DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 6);
  assertNear(
    m5Result.single.aggregate,
    45.29853199846277,
    0.000000001,
    "MaziyarPanahi Gemma 3 27B Q2_K M5 Max single-session throughput",
  );
  assertNear(
    m5Result.best.aggregate,
    127.72702212561977,
    0.000000001,
    "MaziyarPanahi Gemma 3 27B Q2_K M5 Max aggregate throughput",
  );
  assertNear(
    m5Result.best.perSession,
    21.287837020936628,
    0.000000001,
    "MaziyarPanahi Gemma 3 27B Q2_K M5 Max per-session throughput",
  );
  assert.equal(m1Result.status_code, "ok");
  assert.equal(m1Result.best.batch, 9);
  assertNear(
    m1Result.best.aggregate,
    189.39541374476963,
    0.000000001,
    "MaziyarPanahi Gemma 3 27B Q2_K M1 Ultra aggregate throughput",
  );
  assertNear(
    m1Result.best.perSession,
    21.04393486052996,
    0.000000001,
    "MaziyarPanahi Gemma 3 27B Q2_K M1 Ultra per-session throughput",
  );
}

{
  const item = profile("RedHatAI/gemma-3-27b-it-FP8-dynamic");
  const result = profiled(
    "RedHatAI/gemma-3-27b-it-FP8-dynamic",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "RedHatAI/gemma-3-27b-it-FP8-dynamic",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(item.serving.weight_format, "fp8");
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    29.274133728,
    0.000000001,
    "RedHatAI Gemma 3 27B FP8 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    28.428013056,
    0.000000001,
    "RedHatAI Gemma 3 27B FP8 swept text-decode traffic",
  );
  assertNear(
    item.architecture.weight_adapter.auxiliary_resident_weight_gb,
    0.846120672,
    0.000000001,
    "RedHatAI Gemma 3 27B FP8 resident-only vision/projector footprint",
  );
  assertNear(
    result.alloc,
    8.628207616,
    0.000000001,
    "RedHatAI Gemma 3 27B FP8 layered KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    3.057647616,
    0.000000001,
    "RedHatAI Gemma 3 27B FP8 layered KV read traffic",
  );
  assert.equal(result.bMem, 10);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    8.670613675,
    0.000001,
    "RedHatAI Gemma 3 27B FP8 DGX Spark single-session throughput",
  );
  assertNear(
    result.dennard,
    100.977979776,
    0.000001,
    "RedHatAI Gemma 3 27B FP8 DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "no_floor");
  assertNear(
    m5Result.single.aggregate,
    19.500940647,
    0.000001,
    "RedHatAI Gemma 3 27B FP8 M5 Max single-session throughput",
  );
  assertNear(
    m5Result.dennard,
    227.107983818,
    0.000001,
    "RedHatAI Gemma 3 27B FP8 M5 Max Dennard bound",
  );
}

{
  const item = profile("ISTA-DASLab/gemma-3-27b-it-GPTQ-4b-128g");
  const result = profiled(
    "ISTA-DASLab/gemma-3-27b-it-GPTQ-4b-128g",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "ISTA-DASLab/gemma-3-27b-it-GPTQ-4b-128g",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(item.serving.weight_format, "int4");
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    16.867252224,
    0.000000001,
    "ISTA-DASLab Gemma 3 27B GPTQ resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    16.021131552,
    0.000000001,
    "ISTA-DASLab Gemma 3 27B GPTQ swept text-decode traffic",
  );
  assertNear(
    item.architecture.weight_adapter.auxiliary_resident_weight_gb,
    0.846120672,
    0.000000001,
    "ISTA-DASLab Gemma 3 27B GPTQ resident-only vision/projector footprint",
  );
  assertNear(
    result.alloc,
    8.628207616,
    0.000000001,
    "ISTA-DASLab Gemma 3 27B GPTQ layered KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    3.057647616,
    0.000000001,
    "ISTA-DASLab Gemma 3 27B GPTQ layered KV read traffic",
  );
  assert.equal(result.bMem, 11);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    14.309091667,
    0.000001,
    "ISTA-DASLab Gemma 3 27B GPTQ DGX Spark single-session throughput",
  );
  assertNear(
    result.dennard,
    203.678628834,
    0.000001,
    "ISTA-DASLab Gemma 3 27B GPTQ DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 4);
  assertNear(
    m5Result.single.aggregate,
    32.182352686,
    0.000001,
    "ISTA-DASLab Gemma 3 27B GPTQ M5 Max single-session throughput",
  );
  assertNear(
    m5Result.best.aggregate,
    86.932753997,
    0.000001,
    "ISTA-DASLab Gemma 3 27B GPTQ M5 Max aggregate throughput",
  );
  assertNear(
    m5Result.best.perSession,
    21.733188499,
    0.000001,
    "ISTA-DASLab Gemma 3 27B GPTQ M5 Max per-session throughput",
  );
  assertNear(
    m5Result.dennard,
    458.090395986,
    0.000001,
    "ISTA-DASLab Gemma 3 27B GPTQ M5 Max Dennard bound",
  );
}

{
  const row = model("pytorch/gemma-3-27b-it-AWQ-INT4");
  const item = profile("pytorch/gemma-3-27b-it-AWQ-INT4");
  const result = profiled(
    "pytorch/gemma-3-27b-it-AWQ-INT4",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "pytorch/gemma-3-27b-it-AWQ-INT4",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(row.hf_downloads, 184232);
  assert.equal(row.adapter.weight_precision, "TorchAO AWQ INT4");
  assert.equal(item.serving.weight_format, "int4");
  assert.equal(
    item.serving.runtime_format,
    "vllm-torchao-awq-int4-pytorch-bin-text-decode-memory-bound",
  );
  assert.equal(item.architecture.kv_adapter.kind, "layered_kv");
  assert.equal(item.architecture.kv_adapter.components[0].layers, 10);
  assert.equal(item.architecture.kv_adapter.components[1].layers, 52);
  assertNear(
    item.architecture.weight_adapter.resident_params_b,
    27.43240664,
    0.000000001,
    "PyTorch Gemma 3 27B AWQ logical resident params",
  );
  assertNear(
    result.resident,
    17.2737272,
    0.000000001,
    "PyTorch Gemma 3 27B AWQ resident archive storage",
  );
  assertNear(
    result.single.batchWeight,
    16.427606528,
    0.000000001,
    "PyTorch Gemma 3 27B AWQ swept text-decode traffic",
  );
  assertNear(
    item.architecture.weight_adapter.auxiliary_resident_weight_gb,
    0.846120672,
    0.000000001,
    "PyTorch Gemma 3 27B AWQ resident-only vision/projector footprint",
  );
  assertNear(
    row.adapter.kv_alloc_gb_per_1k_tokens,
    0.08628207616,
    0.000000001,
    "PyTorch Gemma 3 27B AWQ legacy allocation display coefficient",
  );
  assertNear(
    result.alloc,
    8.628207616,
    0.000000001,
    "PyTorch Gemma 3 27B AWQ layered KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    3.057647616,
    0.000000001,
    "PyTorch Gemma 3 27B AWQ layered KV read traffic",
  );
  assert.equal(result.status_code, "no_floor");
  assert.equal(result.bMem, 11);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    14.01059478,
    0.000001,
    "PyTorch Gemma 3 27B AWQ DGX Spark single-session throughput",
  );
  assertNear(
    result.dennard,
    197.856033848,
    0.000001,
    "PyTorch Gemma 3 27B AWQ DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 4);
  assertNear(
    m5Result.single.aggregate,
    31.51100804,
    0.000001,
    "PyTorch Gemma 3 27B AWQ M5 Max single-session throughput",
  );
  assertNear(
    m5Result.best.aggregate,
    85.699738915,
    0.000001,
    "PyTorch Gemma 3 27B AWQ M5 Max aggregate throughput",
  );
  assertNear(
    m5Result.best.perSession,
    21.424934729,
    0.000001,
    "PyTorch Gemma 3 27B AWQ M5 Max per-session throughput",
  );
  assertNear(
    m5Result.dennard,
    444.994889313,
    0.000001,
    "PyTorch Gemma 3 27B AWQ M5 Max Dennard bound",
  );
}

{
  const item = profile("XiaomiMiMo/MiMo-7B-RL");
  const result = profiled("XiaomiMiMo/MiMo-7B-RL", "nvidia-dgx-spark");
  const m5Result = profiled(
    "XiaomiMiMo/MiMo-7B-RL",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(item.serving.weight_format, "bf16");
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    15.666819072,
    0.000000001,
    "Xiaomi MiMo 7B RL resident BF16 package",
  );
  assertNear(
    result.single.batchWeight,
    14.002675712,
    0.000000001,
    "Xiaomi MiMo 7B RL ordinary text-decode swept traffic",
  );
  assertNear(
    item.architecture.weight_adapter.auxiliary_resident_weight_gb,
    1.66414336,
    0.000000001,
    "Xiaomi MiMo 7B RL resident-only input embedding and MTP tensors",
  );
  assertNear(
    result.alloc,
    14.7456,
    0.000000001,
    "Xiaomi MiMo 7B RL BF16 full-context KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    4.718592,
    0.000000001,
    "Xiaomi MiMo 7B RL BF16 full-context KV read traffic",
  );
  assert.equal(result.bMem, 7);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    14.582345822,
    0.000001,
    "Xiaomi MiMo 7B RL DGX Spark single-session bound",
  );
  assertNear(
    result.dennard,
    137.946795293,
    0.000001,
    "Xiaomi MiMo 7B RL DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 3);
  assertNear(
    m5Result.single.aggregate,
    32.796924303,
    0.000001,
    "Xiaomi MiMo 7B RL M5 Max single-session bound",
  );
  assertNear(
    m5Result.best.aggregate,
    65.415528483,
    0.000001,
    "Xiaomi MiMo 7B RL M5 Max aggregate bound",
  );
  assertNear(
    m5Result.best.perSession,
    21.805176161,
    0.000001,
    "Xiaomi MiMo 7B RL M5 Max per-session bound",
  );
}

{
  const item = profile("XiaomiMiMo/MiMo-7B-Base");
  const result = profiled("XiaomiMiMo/MiMo-7B-Base", "nvidia-dgx-spark");
  const m5Result = profiled(
    "XiaomiMiMo/MiMo-7B-Base",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(item.serving.weight_format, "bf16");
  assert.equal(item.architecture.kv_adapter.kind, "full_context");
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    15.666819072,
    0.000000001,
    "Xiaomi MiMo 7B Base resident BF16 package",
  );
  assertNear(
    result.single.batchWeight,
    14.002675712,
    0.000000001,
    "Xiaomi MiMo 7B Base ordinary text-decode swept traffic",
  );
  assertNear(
    item.architecture.weight_adapter.auxiliary_resident_weight_gb,
    1.66414336,
    0.000000001,
    "Xiaomi MiMo 7B Base resident-only input embedding and MTP tensors",
  );
  assertNear(
    result.alloc,
    14.7456,
    0.000000001,
    "Xiaomi MiMo 7B Base BF16 full-context KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    4.718592,
    0.000000001,
    "Xiaomi MiMo 7B Base BF16 full-context KV read traffic",
  );
  assert.equal(result.bMem, 7);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    14.582345822,
    0.000001,
    "Xiaomi MiMo 7B Base DGX Spark single-session bound",
  );
  assertNear(
    result.dennard,
    137.946795293,
    0.000001,
    "Xiaomi MiMo 7B Base DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 3);
  assertNear(
    m5Result.single.aggregate,
    32.796924303,
    0.000001,
    "Xiaomi MiMo 7B Base M5 Max single-session bound",
  );
  assertNear(
    m5Result.best.aggregate,
    65.415528483,
    0.000001,
    "Xiaomi MiMo 7B Base M5 Max aggregate bound",
  );
  assertNear(
    m5Result.best.perSession,
    21.805176161,
    0.000001,
    "Xiaomi MiMo 7B Base M5 Max per-session bound",
  );
}

{
  const item = profile("XiaomiMiMo/MiMo-V2.5");
  const result = profiled("XiaomiMiMo/MiMo-V2.5", "nvidia-dgx-spark");
  const m5Result = profiled(
    "XiaomiMiMo/MiMo-V2.5",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  const gb300Result = profiled(
    "XiaomiMiMo/MiMo-V2.5",
    "nvidia-msi-xpertstation-ws300-dgx-station-gb300",
  );
  const weightAdapter = item.architecture.weight_adapter;
  const kvAdapter = item.architecture.kv_adapter;
  assert.equal(item.serving.weight_format, "fp8");
  assert.equal(weightAdapter.kind, "moe_distinct_experts_exact");
  assert.equal(kvAdapter.kind, "layered_kv");
  assert.equal(kvAdapter.components.length, 4);
  assert.equal(result.status_code, "resident_not_fit");
  assertNear(
    result.resident,
    315.031102208,
    0.000000001,
    "Xiaomi MiMo V2.5 resident FP8/BF16/F32 package",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    310.612355968,
    0.000000001,
    "Xiaomi MiMo V2.5 ordinary-language resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    4.41874624,
    0.000000001,
    "Xiaomi MiMo V2.5 resident-only modal/input/MTP tensors",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    7.743236992,
    0.000000001,
    "Xiaomi MiMo V2.5 fixed ordinary text-decode traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    1.183082496,
    0.000000001,
    "Xiaomi MiMo V2.5 per-expert routed traffic",
  );
  assertNear(
    result.single.batchWeight,
    17.20789696,
    0.000000001,
    "Xiaomi MiMo V2.5 ordinary single-session active traffic",
  );
  assertNear(
    result.alloc,
    2.32955904,
    0.000000001,
    "Xiaomi MiMo V2.5 hybrid full/sliding KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.76283904,
    0.000000001,
    "Xiaomi MiMo V2.5 hybrid full/sliding KV read traffic",
  );
  assert.equal(result.bMem, 0);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    15.191364449,
    0.000001,
    "Xiaomi MiMo V2.5 DGX Spark theoretical single-session bound",
  );
  assert.equal(m5Result.status_code, "resident_not_fit");
  assertNear(
    m5Result.single.aggregate,
    34.166658505,
    0.000001,
    "Xiaomi MiMo V2.5 M5 Max theoretical single-session bound",
  );
  assert.equal(gb300Result.status_code, "ok");
  assert.equal(gb300Result.bMem, 182);
  assert.equal(gb300Result.best.batch, 84);
  assertNear(
    gb300Result.single.aggregate,
    395.086767732,
    0.000001,
    "Xiaomi MiMo V2.5 GB300 single-session bound",
  );
  assertNear(
    gb300Result.best.aggregate,
    1686.407603477,
    0.000001,
    "Xiaomi MiMo V2.5 GB300 aggregate bound",
  );
  assertNear(
    gb300Result.best.perSession,
    20.076280994,
    0.000001,
    "Xiaomi MiMo V2.5 GB300 per-session bound",
  );
  assertNear(
    gb300Result.dennard,
    75268.62400912,
    0.000001,
    "Xiaomi MiMo V2.5 GB300 Dennard bound",
  );
}

{
  const repo = "XiaomiMiMo/MiMo-V2.5-Pro";
  const catalogRow = model(repo);
  const item = profile(repo);
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  const gb300Result = profiled(
    repo,
    "nvidia-msi-xpertstation-ws300-dgx-station-gb300",
  );
  const weightAdapter = item.architecture.weight_adapter;
  const kvAdapter = item.architecture.kv_adapter;
  assert.equal(catalogRow.hf_downloads, 101692);
  assert.equal(catalogRow.architecture.total_params_b, 1023.244718976);
  assert.equal(catalogRow.architecture.active_params_b, 40.959508608);
  assert.equal(catalogRow.adapter.resident_weight_gb, 1033.369538304);
  assert.equal(catalogRow.adapter.active_weight_gb, 49.438742016);
  assert.equal(item.serving.weight_format, "fp8");
  assert.equal(weightAdapter.kind, "moe_distinct_experts_exact");
  assert.equal(kvAdapter.kind, "layered_kv");
  assert.equal(kvAdapter.components.length, 4);
  assert.equal(result.status_code, "resident_not_fit");
  assertNear(
    result.resident,
    1033.369538304,
    0.000000001,
    "Xiaomi MiMo V2.5 Pro resident FP8/BF16/F32 package",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    1029.031048704,
    0.000000001,
    "Xiaomi MiMo V2.5 Pro ordinary-language resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    4.3384896,
    0.000000001,
    "Xiaomi MiMo V2.5 Pro resident-only input/MTP tensors",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    28.596352512,
    0.000000001,
    "Xiaomi MiMo V2.5 Pro fixed ordinary text-decode traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    2.605298688,
    0.000000001,
    "Xiaomi MiMo V2.5 Pro per-expert routed traffic",
  );
  assertNear(
    result.single.batchWeight,
    49.438742016,
    0.000000001,
    "Xiaomi MiMo V2.5 Pro ordinary single-session active traffic",
  );
  assertNear(
    result.alloc,
    5.1593216,
    0.000000001,
    "Xiaomi MiMo V2.5 Pro hybrid full/sliding KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.6777216,
    0.000000001,
    "Xiaomi MiMo V2.5 Pro hybrid full/sliding KV read traffic",
  );
  assert.equal(result.bMem, 0);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    5.340745049,
    0.000001,
    "Xiaomi MiMo V2.5 Pro DGX Spark theoretical single-session bound",
  );
  assert.equal(m5Result.status_code, "resident_not_fit");
  assertNear(
    m5Result.single.aggregate,
    12.011785569,
    0.000001,
    "Xiaomi MiMo V2.5 Pro M5 Max theoretical single-session bound",
  );
  assert.equal(gb300Result.status_code, "resident_not_fit");
  assertNear(
    gb300Result.single.aggregate,
    138.898497622,
    0.000001,
    "Xiaomi MiMo V2.5 Pro GB300 theoretical single-session bound",
  );
}

{
  const item = profile("RedHatAI/gemma-3-27b-it-quantized.w4a16");
  const result = profiled(
    "RedHatAI/gemma-3-27b-it-quantized.w4a16",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "RedHatAI/gemma-3-27b-it-quantized.w4a16",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(item.serving.weight_format, "int4");
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    19.68651264,
    0.000000001,
    "RedHatAI Gemma 3 27B W4A16 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    16.021131552,
    0.000000001,
    "RedHatAI Gemma 3 27B W4A16 swept text-decode traffic",
  );
  assertNear(
    item.architecture.weight_adapter.auxiliary_resident_weight_gb,
    3.665381088,
    0.000000001,
    "RedHatAI Gemma 3 27B W4A16 resident-only embedding/vision/projector footprint",
  );
  assertNear(
    result.alloc,
    8.628207616,
    0.000000001,
    "RedHatAI Gemma 3 27B W4A16 layered KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    3.057647616,
    0.000000001,
    "RedHatAI Gemma 3 27B W4A16 layered KV read traffic",
  );
  assert.equal(result.bMem, 11);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    14.309091667,
    0.000001,
    "RedHatAI Gemma 3 27B W4A16 DGX Spark single-session throughput",
  );
  assertNear(
    result.dennard,
    198.110823183,
    0.000001,
    "RedHatAI Gemma 3 27B W4A16 DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 4);
  assertNear(
    m5Result.single.aggregate,
    32.182352686,
    0.000001,
    "RedHatAI Gemma 3 27B W4A16 M5 Max single-session throughput",
  );
  assertNear(
    m5Result.best.aggregate,
    86.932753997,
    0.000001,
    "RedHatAI Gemma 3 27B W4A16 M5 Max aggregate throughput",
  );
  assertNear(
    m5Result.best.perSession,
    21.733188499,
    0.000001,
    "RedHatAI Gemma 3 27B W4A16 M5 Max per-session throughput",
  );
  assertNear(
    m5Result.dennard,
    445.567931995,
    0.000001,
    "RedHatAI Gemma 3 27B W4A16 M5 Max Dennard bound",
  );
}

{
  const repo = "abhishekchohan/gemma-3-12b-it-quantized-W4A16";
  const item = profile(repo);
  const modelRow = model(repo);
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  assert.equal(item.status, "audited");
  assert.equal(item.base_model_proof.config_compatible, false);
  assert.equal(item.serving.weight_format, "int4");
  assert.equal(modelRow.hf_downloads, 195261);
  assert.equal(modelRow.architecture.layers, 48);
  assert.equal(modelRow.architecture.max_context_tokens, 131072);
  assertNear(
    item.architecture.weight_adapter.resident_weight_gb,
    8.405170656,
    0.000000001,
    "abhishekchohan Gemma 3 12B W4A16 resident footprint",
  );
  assertNear(
    item.architecture.weight_adapter.swept_weight_gb,
    7.562588928,
    0.000000001,
    "abhishekchohan Gemma 3 12B W4A16 swept text-decode traffic",
  );
  assertNear(
    item.architecture.weight_adapter.auxiliary_resident_weight_gb,
    0.842581728,
    0.000000001,
    "abhishekchohan Gemma 3 12B W4A16 resident-only vision/projector footprint",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.alloc,
    6.88914432,
    0.000000001,
    "abhishekchohan Gemma 3 12B W4A16 layered KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    2.43269632,
    0.000000001,
    "abhishekchohan Gemma 3 12B W4A16 layered KV read traffic",
  );
  assert.equal(result.bMem, 16);
  assert.equal(result.best.batch, 2);
  assertNear(
    result.single.aggregate,
    27.312877344,
    0.000001,
    "abhishekchohan Gemma 3 12B W4A16 DGX Spark single-session throughput",
  );
  assertNear(
    result.best.aggregate,
    43.933119551,
    0.000001,
    "abhishekchohan Gemma 3 12B W4A16 DGX Spark aggregate throughput",
  );
  assertNear(
    result.dennard,
    584.750958089,
    0.000001,
    "abhishekchohan Gemma 3 12B W4A16 DGX Spark Dennard bound",
  );
  assert.equal(m5Result.best.batch, 9);
  assertNear(
    m5Result.single.aggregate,
    61.428962232,
    0.000001,
    "abhishekchohan Gemma 3 12B W4A16 M5 Max single-session throughput",
  );
  assertNear(
    m5Result.best.aggregate,
    187.596396439,
    0.000001,
    "abhishekchohan Gemma 3 12B W4A16 M5 Max aggregate throughput",
  );
  assertNear(
    m5Result.best.perSession,
    20.844044049,
    0.000001,
    "abhishekchohan Gemma 3 12B W4A16 M5 Max per-session throughput",
  );
  assertNear(
    m5Result.dennard,
    1315.154169475,
    0.000001,
    "abhishekchohan Gemma 3 12B W4A16 M5 Max Dennard bound",
  );
}

{
  const result = profiled(
    "hugging-quants/Meta-Llama-3.1-70B-Instruct-AWQ-INT4",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    39.767785472,
    0.000000001,
    "Hugging Quants Llama 3.1 70B AWQ resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    37.666439168,
    0.000000001,
    "Hugging Quants Llama 3.1 70B AWQ swept traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    2.101346304,
    0.000000001,
    "Hugging Quants Llama 3.1 70B AWQ input embedding footprint",
  );
  assertNear(
    result.alloc,
    32.768,
    0.000000001,
    "Hugging Quants Llama 3.1 70B AWQ FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    10.48576,
    0.000000001,
    "Hugging Quants Llama 3.1 70B AWQ FP16 KV read traffic",
  );
  assert.equal(result.bMem, 2);
  assertNear(
    result.single.aggregate,
    5.669522985804245,
    0.000000001,
    "Hugging Quants Llama 3.1 70B AWQ DGX single-session throughput",
  );
  assert.equal(result.best, null);
  assertNear(
    result.dennard,
    17.746263507777513,
    0.000000001,
    "Hugging Quants Llama 3.1 70B AWQ DGX Dennard bound",
  );
}

{
  const modelProfile = profile("casperhansen/llama-3.3-70b-instruct-awq");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(
    "casperhansen/llama-3.3-70b-instruct-awq",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    39.767785472,
    0.000000001,
    "Casper Hansen Llama 3.3 70B AWQ resident footprint",
  );
  assertNear(
    weightAdapter.swept_weight_gb,
    37.666439168,
    0.000000001,
    "Casper Hansen Llama 3.3 70B AWQ swept tensor footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    2.101346304,
    0.000000001,
    "Casper Hansen Llama 3.3 70B AWQ input embedding footprint",
  );
  assertNear(
    result.single.batchWeight,
    37.666439168,
    0.000000001,
    "Casper Hansen Llama 3.3 70B AWQ swept traffic",
  );
  assertNear(
    result.alloc,
    32.768,
    0.000000001,
    "Casper Hansen Llama 3.3 70B AWQ FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    10.48576,
    0.000000001,
    "Casper Hansen Llama 3.3 70B AWQ FP16 KV read traffic",
  );
  assert.equal(result.bMem, 2);
  assertNear(
    result.single.aggregate,
    5.669522985804245,
    0.000000001,
    "Casper Hansen Llama 3.3 70B AWQ DGX single-session throughput",
  );
  assert.equal(result.best, null);
  assertNear(
    result.dennard,
    17.746263507777513,
    0.000000001,
    "Casper Hansen Llama 3.3 70B AWQ DGX Dennard bound",
  );
}

{
  const repo = "MaziyarPanahi/Meta-Llama-3.1-70B-Instruct-GGUF";
  const modelProfile = profile(repo);
  const modelRow = model(repo);
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const kvAdapter = modelProfile.architecture.kv_adapter;
  const dgxResult = profiled(repo, "nvidia-dgx-spark");
  const m2Result = profiled(repo, "apple-mac-studio-m2-ultra-128gb");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");

  assert.equal(modelProfile.status, "audited");
  assert.equal(modelRow.name, "Meta-Llama-3.1-70B-Instruct-GGUF GGUF IQ1_M");
  assert.equal(modelRow.license, "llama3.1");
  assert.equal(modelRow.hf_downloads, 122003);
  assert.ok(modelRow.tags.includes("region:us"));
  assert.equal(modelRow.architecture.detail, "llama GGUF (LlamaForCausalLM)");
  assert.equal(modelRow.architecture.total_params_b, 70.553706496);
  assert.equal(modelRow.architecture.active_params_b, 69.503033344);
  assert.equal(modelRow.architecture.layers, 80);
  assert.equal(modelRow.architecture.attention_heads, 64);
  assert.equal(modelRow.architecture.kv_heads, 8);
  assert.equal(modelRow.architecture.head_dim, 128);
  assert.equal(modelRow.architecture.max_context_tokens, 131072);
  assert.equal(modelRow.adapter.weight_precision, "GGUF IQ1_M");
  assert.equal(modelRow.adapter.resident_weight_gb, 16.751196288);
  assert.equal(modelRow.adapter.active_weight_gb, 16.39858176);
  assert.equal(modelRow.adapter.kv_alloc_gb_per_1k_tokens, 0.32768);
  assert.equal(weightAdapter.kind, "dense_resident_swept");
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.352614528,
    0.000000001,
    "MaziyarPanahi Llama 3.1 70B IQ1_M GGUF token/header resident overhead",
  );
  assert.equal(kvAdapter.kind, "full_context");
  assert.equal(kvAdapter.layers, 80);
  assert.equal(kvAdapter.kv_heads, 8);
  assert.equal(kvAdapter.head_dim, 128);
  assert.equal(dgxResult.status_code, "no_floor");
  assertNear(
    dgxResult.resident,
    16.751196288,
    0.000000001,
    "MaziyarPanahi Llama 3.1 70B IQ1_M GGUF selected resident footprint",
  );
  assertNear(
    dgxResult.single.batchWeight,
    16.39858176,
    0.000000001,
    "MaziyarPanahi Llama 3.1 70B IQ1_M GGUF swept text-decode traffic",
  );
  assertNear(
    dgxResult.alloc,
    32.768,
    0.000000001,
    "MaziyarPanahi Llama 3.1 70B IQ1_M GGUF FP16 KV allocation",
  );
  assertNear(
    dgxResult.single.readTraffic,
    10.48576,
    0.000000001,
    "MaziyarPanahi Llama 3.1 70B IQ1_M GGUF FP16 KV read traffic",
  );
  assertNear(
    dgxResult.single.aggregate,
    10.154609788742695,
    0.000000001,
    "MaziyarPanahi Llama 3.1 70B IQ1_M GGUF DGX single-session throughput",
  );
  assert.equal(dgxResult.bMem, 3);
  assert.equal(dgxResult.best, null);
  assert.equal(m2Result.status_code, "ok");
  assert.equal(m2Result.best?.batch, 2);
  assertNear(
    m2Result.best?.aggregate ?? 0,
    42.8149757331568,
    0.000000001,
    "MaziyarPanahi Llama 3.1 70B IQ1_M GGUF M2 Ultra aggregate throughput",
  );
  assertNear(
    m2Result.best?.perSession ?? 0,
    21.4074878665784,
    0.000000001,
    "MaziyarPanahi Llama 3.1 70B IQ1_M GGUF M2 Ultra per-session throughput",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best?.batch, 1);
  assertNear(
    m5Result.best?.aggregate ?? 0,
    22.83857293145793,
    0.000000001,
    "MaziyarPanahi Llama 3.1 70B IQ1_M GGUF M5 Max aggregate throughput",
  );
}

{
  const modelProfile = profile("MaziyarPanahi/Llama-3.3-70B-Instruct-GGUF");
  const modelRow = model("MaziyarPanahi/Llama-3.3-70B-Instruct-GGUF");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const kvAdapter = modelProfile.architecture.kv_adapter;
  const dgxResult = profiled(
    "MaziyarPanahi/Llama-3.3-70B-Instruct-GGUF",
    "nvidia-dgx-spark",
  );
  const m2Result = profiled(
    "MaziyarPanahi/Llama-3.3-70B-Instruct-GGUF",
    "apple-mac-studio-m2-ultra-128gb",
  );
  assert.equal(modelProfile.status, "audited");
  assert.equal(modelRow.name, "Llama-3.3-70B-Instruct-GGUF GGUF Q2_K");
  assert.equal(modelRow.license, "llama3.3");
  assert.equal(modelRow.hf_downloads, 125907);
  assert.equal(modelRow.architecture.detail, "llama GGUF (LlamaForCausalLM)");
  assert.equal(modelRow.architecture.total_params_b, 70.55370656);
  assert.equal(modelRow.architecture.active_params_b, 69.503033408);
  assert.equal(modelRow.architecture.layers, 80);
  assert.equal(modelRow.architecture.attention_heads, 64);
  assert.equal(modelRow.architecture.kv_heads, 8);
  assert.equal(modelRow.architecture.head_dim, 128);
  assert.equal(modelRow.architecture.max_context_tokens, 131072);
  assert.equal(modelRow.adapter.weight_precision, "GGUF Q2_K");
  assert.equal(modelRow.adapter.resident_weight_gb, 26.37511344);
  assert.equal(modelRow.adapter.active_weight_gb, 26.022494464);
  assert.equal(modelRow.adapter.kv_alloc_gb_per_1k_tokens, 0.32768);
  assert.equal(weightAdapter.kind, "dense_resident_swept");
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.352618976,
    0.000000001,
    "MaziyarPanahi Llama 3.3 70B GGUF token/header resident overhead",
  );
  assert.equal(kvAdapter.kind, "full_context");
  assert.equal(kvAdapter.layers, 80);
  assert.equal(kvAdapter.kv_heads, 8);
  assert.equal(kvAdapter.head_dim, 128);
  assert.equal(dgxResult.status_code, "no_floor");
  assertNear(
    dgxResult.resident,
    26.37511344,
    0.000000001,
    "MaziyarPanahi Llama 3.3 70B GGUF selected Q2_K resident footprint",
  );
  assertNear(
    dgxResult.single.batchWeight,
    26.022494464,
    0.000000001,
    "MaziyarPanahi Llama 3.3 70B GGUF swept text-decode traffic",
  );
  assertNear(
    dgxResult.alloc,
    32.768,
    0.000000001,
    "MaziyarPanahi Llama 3.3 70B GGUF FP16 KV allocation",
  );
  assertNear(
    dgxResult.single.readTraffic,
    10.48576,
    0.000000001,
    "MaziyarPanahi Llama 3.3 70B GGUF FP16 KV read traffic",
  );
  assertNear(
    dgxResult.single.aggregate,
    7.47776096140667,
    0.000000001,
    "MaziyarPanahi Llama 3.3 70B GGUF DGX single-session throughput",
  );
  assert.equal(dgxResult.bMem, 2);
  assert.equal(dgxResult.best, null);
  assert.equal(m2Result.status_code, "ok");
  assert.equal(m2Result.best?.batch, 1);
  assertNear(
    m2Result.best?.aggregate ?? 0,
    21.91285263415874,
    0.000000001,
    "MaziyarPanahi Llama 3.3 70B GGUF M2 Ultra aggregate throughput",
  );
}

{
  const repo = "cortecs/Llama-3.3-70B-Instruct-FP8-Dynamic";
  const modelProfile = profile(repo);
  const modelRow = model(repo);
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const kvAdapter = modelProfile.architecture.kv_adapter;
  assert.equal(modelProfile.status, "audited");
  assert.equal(modelRow.hf_downloads, 145566);
  assert.ok(modelRow.tags.includes("region:us"));
  assert.equal(modelRow.architecture.total_params_b, 70.560423936);
  assert.equal(modelRow.architecture.active_params_b, 69.509750784);
  assert.equal(modelRow.adapter.weight_precision, "FP8");
  assert.equal(modelRow.adapter.resident_weight_gb, 72.669806592);
  assert.equal(modelRow.adapter.active_weight_gb, 70.568460288);
  assert.equal(weightAdapter.kind, "dense_resident_swept");
  assertNear(
    weightAdapter.resident_params_b,
    70.560423936,
    0.000000001,
    "cortecs Llama 3.3 70B FP8 resident storage-accounting params",
  );
  assertNear(
    weightAdapter.swept_params_b,
    69.509750784,
    0.000000001,
    "cortecs Llama 3.3 70B FP8 swept storage-accounting params",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    2.101346304,
    0.000000001,
    "cortecs Llama 3.3 70B FP8 resident input embedding footprint",
  );
  assert.equal(kvAdapter.kind, "full_context");
  assert.equal(kvAdapter.layers, 80);
  assert.equal(kvAdapter.kv_heads, 8);
  assert.equal(kvAdapter.head_dim, 128);
  const dgxResult = profiled(repo, "nvidia-dgx-spark");
  assert.equal(dgxResult.status_code, "no_floor");
  assertNear(
    dgxResult.resident,
    72.669806592,
    0.000000001,
    "cortecs Llama 3.3 70B FP8 resident tensor payload",
  );
  assertNear(
    dgxResult.single.batchWeight,
    70.568460288,
    0.000000001,
    "cortecs Llama 3.3 70B FP8 swept text-decode traffic",
  );
  assertNear(
    dgxResult.alloc,
    32.768,
    0.000000001,
    "cortecs Llama 3.3 70B FP8 FP16 KV allocation",
  );
  assertNear(
    dgxResult.single.readTraffic,
    10.48576,
    0.000000001,
    "cortecs Llama 3.3 70B FP8 FP16 KV read traffic",
  );
  assert.equal(dgxResult.bMem, 1);
  assert.equal(dgxResult.best, null);
  assertNear(
    dgxResult.single.aggregate,
    3.3681157998927467,
    0.000000001,
    "cortecs Llama 3.3 70B FP8 DGX single-session throughput",
  );
  assertNear(
    dgxResult.dennard,
    5.5877935166179835,
    0.000000001,
    "cortecs Llama 3.3 70B FP8 DGX Dennard bound",
  );
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  assert.equal(m5Result.status_code, "no_floor");
  assertNear(
    m5Result.single.aggregate,
    7.575176194630573,
    0.000000001,
    "cortecs Llama 3.3 70B FP8 M5 Max single-session throughput",
  );
  assert.equal(m5Result.bMem, 1);
  const m1UltraResult = profiled(repo, "apple-mac-studio-m1-ultra-128gb");
  assert.equal(m1UltraResult.status_code, "no_floor");
  assertNear(
    m1UltraResult.single.aggregate,
    9.869936409942115,
    0.000000001,
    "cortecs Llama 3.3 70B FP8 M1 Ultra single-session throughput",
  );
  assert.equal(m1UltraResult.bMem, 1);
}

{
  const result = profiled(
    "casperhansen/llama-3.3-70b-instruct-awq",
    "nvidia-msi-xpertstation-ws300-dgx-station-gb300",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(result.bMem, 21);
  assert.equal(result.best?.batch, 21);
  assertNear(
    result.single.aggregate,
    147.44913259783934,
    0.000000001,
    "Casper Hansen Llama 3.3 70B AWQ GB300 single-session throughput",
  );
  assertNear(
    result.best?.aggregate ?? 0,
    578.2041486479711,
    0.000000001,
    "Casper Hansen Llama 3.3 70B AWQ GB300 aggregate throughput",
  );
  assertNear(
    result.best?.perSession ?? 0,
    27.533530887998626,
    0.000000001,
    "Casper Hansen Llama 3.3 70B AWQ GB300 per-session throughput",
  );
  assertNear(
    result.dennard,
    4028.0600362045348,
    0.000000001,
    "Casper Hansen Llama 3.3 70B AWQ GB300 Dennard bound",
  );
}

{
  const result = profiled(
    "hugging-quants/Meta-Llama-3.1-70B-Instruct-AWQ-INT4",
    "nvidia-msi-xpertstation-ws300-dgx-station-gb300",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(result.bMem, 21);
  assert.equal(result.best?.batch, 21);
  assertNear(
    result.single.aggregate,
    147.44913259783934,
    0.000000001,
    "Hugging Quants Llama 3.1 70B AWQ GB300 single-session throughput",
  );
  assertNear(
    result.best?.aggregate ?? 0,
    578.2041486479711,
    0.000000001,
    "Hugging Quants Llama 3.1 70B AWQ GB300 aggregate throughput",
  );
  assertNear(
    result.best?.perSession ?? 0,
    27.533530887998626,
    0.000000001,
    "Hugging Quants Llama 3.1 70B AWQ GB300 per-session throughput",
  );
  assertNear(
    result.dennard,
    4028.0600362045348,
    0.000000001,
    "Hugging Quants Llama 3.1 70B AWQ GB300 Dennard bound",
  );
}

{
  const modelProfile = profile("Weni/Llama-Guard-3-8B-AWQ");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled("Weni/Llama-Guard-3-8B-AWQ", "nvidia-dgx-spark");
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    5.727854592,
    0.000000001,
    "Weni Llama Guard 3 8B AWQ resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    4.67718144,
    0.000000001,
    "Weni Llama Guard 3 8B AWQ swept text-decode traffic",
  );
  assertNear(
    result.resident - result.single.batchWeight,
    1.050673152,
    0.000000001,
    "Weni Llama Guard 3 8B AWQ resident-only input-embedding footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.050673152,
    0.000000001,
    "Weni Llama Guard 3 8B AWQ auxiliary resident bytes",
  );
  assertNear(
    result.alloc,
    13.1072,
    0.000000001,
    "Weni Llama Guard 3 8B AWQ full-context KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    4.194304,
    0.000000001,
    "Weni Llama Guard 3 8B AWQ full-context KV read traffic",
  );
  assert.equal(result.bMem, 8);
  assert.equal(result.best.batch, 2);
  assertNear(
    result.single.aggregate,
    30.772749597163287,
    0.000000001,
    "Weni Llama Guard 3 8B AWQ DGX single-session tok/s",
  );
  assertNear(
    result.best.aggregate,
    41.788519745194975,
    0.000000001,
    "Weni Llama Guard 3 8B AWQ DGX aggregate tok/s",
  );
  assertNear(
    result.best.perSession,
    20.894259872597488,
    0.000000001,
    "Weni Llama Guard 3 8B AWQ DGX per-session tok/s",
  );
  assertNear(
    result.dennard,
    508.8723857188016,
    0.000000001,
    "Weni Llama Guard 3 8B AWQ DGX Dennard bound",
  );
}

{
  const result = profiled(
    "Weni/Llama-Guard-3-8B-AWQ",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(result.bMem, 8);
  assert.equal(result.best.batch, 6);
  assertNear(
    result.single.aggregate,
    69.21050641999362,
    0.000000001,
    "Weni Llama Guard 3 8B AWQ M5 Max single-session tok/s",
  );
  assertNear(
    result.best.aggregate,
    123.4460117432462,
    0.000000001,
    "Weni Llama Guard 3 8B AWQ M5 Max aggregate tok/s",
  );
  assertNear(
    result.best.perSession,
    20.574335290541033,
    0.000000001,
    "Weni Llama Guard 3 8B AWQ M5 Max per-session tok/s",
  );
  assertNear(
    result.dennard,
    1144.4968675140813,
    0.000000001,
    "Weni Llama Guard 3 8B AWQ M5 Max Dennard bound",
  );
}

for (const repo of [
  "meta-llama/Llama-3.1-405B",
  "meta-llama/Llama-3.1-405B-Instruct",
  "meta-llama/Llama-3.1-8B",
  "meta-llama/Llama-3.1-8B-Instruct",
  "meta-llama/Llama-Guard-3-8B",
  "meta-llama/Llama-3.1-70B-Instruct",
  "meta-llama/Llama-3.3-70B-Instruct",
  "meta-llama/Llama-4-Scout-17B-16E-Instruct",
  "nvidia/Llama-4-Scout-17B-16E-Instruct-FP8",
  "meta-llama/Llama-2-7b-hf",
  "meta-llama/Llama-2-7b-chat-hf",
  "meta-llama/Meta-Llama-3-8B",
  "meta-llama/Meta-Llama-3-8B-Instruct",
  "meta-llama/Meta-Llama-3-70B",
  "meta-llama/Llama-3.2-1B",
  "meta-llama/Llama-3.2-1B-Instruct",
  "meta-llama/Llama-3.2-3B",
  "meta-llama/Llama-3.2-3B-Instruct",
  "google/gemma-3-270m",
  "google/gemma-3-270m-it",
  "google/gemma-3-1b-it",
  "google/gemma-2-9b-it",
  "google/gemma-2-2b-it",
  "google/gemma-1.1-2b-it",
  "google/gemma-2b",
  "google/gemma-3-4b-it",
  "google/gemma-3-12b-it",
  "google/gemma-3-27b-it",
  "google/gemma-3n-E2B-it",
  "google/medgemma-1.5-4b-it",
  "google/medgemma-4b-it",
  "google/gemma-4-E4B-it-assistant",
  "google/gemma-4-31B-it-assistant",
  "google/diffusiongemma-26B-A4B-it",
  "nvidia/diffusiongemma-26B-A4B-it-NVFP4",
  "RedHatAI/diffusiongemma-26B-A4B-it-NVFP4",
  "RedHatAI/diffusiongemma-26B-A4B-it-FP8-dynamic",
  "unsloth/diffusiongemma-26B-A4B-it-GGUF",
  "nvidia/Nemotron-Labs-Diffusion-8B-Base",
  "inclusionAI/LLaDA2.0-mini",
  "MiniMaxAI/MiniMax-M3-MXFP8",
  "MiniMaxAI/MiniMax-M3",
  "nvidia/LocateAnything-3B",
  "nvidia/Cosmos-Reason2-2B",
  "nvidia/Cosmos-Reason2-8B",
  "nvidia/KVzap-mlp-Qwen3-8B",
  "microsoft/kosmos-2.5",
  "microsoft/Florence-2-base",
  "microsoft/Florence-2-large",
  "CohereLabs/aya-vision-8b",
  "Qwen/Qwen3-TTS-12Hz-1.7B-Base",
  "allenai/wildguard",
]) {
  const result = profiled(repo, "nvidia-dgx-spark");
  assert.equal(result.status_code, "unsupported_profile");
  assert.match(result.warnings.join("\n"), /production bounds require audited/);
}

{
  const row = model("inclusionAI/LLaDA2.0-mini");
  const item = profile("inclusionAI/LLaDA2.0-mini");
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled("inclusionAI/LLaDA2.0-mini", "nvidia-dgx-spark");
  assert.equal(row.hf_downloads, 146675);
  assert.ok(row.tags.includes("region:us"));
  assert.equal(
    row.architecture.detail,
    "llada2_moe block diffusion (LLaDA2MoeModelLM)",
  );
  assert.equal(row.architecture.shared_experts_per_token, 1);
  assertNear(
    row.architecture.total_params_b,
    16.255643392,
    0.000000001,
    "LLaDA2 Mini catalog BF16 safetensors parameter count",
  );
  assertNear(
    row.architecture.active_params_b,
    1.373204224,
    0.000000001,
    "LLaDA2 Mini catalog exact active parameter estimate",
  );
  assertNear(
    row.adapter.resident_weight_gb,
    32.511286784,
    0.000000001,
    "LLaDA2 Mini catalog resident tensor payload",
  );
  assertNear(
    row.adapter.active_weight_gb,
    2.746408448,
    0.000000001,
    "LLaDA2 Mini catalog active BF16 tensor estimate",
  );
  assert.equal(row.adapter.kv_alloc_gb_per_1k_tokens, 0);
  assert.equal(row.adapter.kv_read_gb_per_1k_tokens, 0);
  assert.equal(item.status, "unsupported");
  assert.equal(item.architecture.kv_adapter.kind, "unknown");
  assert.equal(
    item.serving.runtime_format,
    "unsupported-llada2-block-diffusion-transformers-bf16",
  );
  assert.equal(item.serving.weight_format, "bf16");
  assertNear(
    weightAdapter.resident_weight_gb,
    32.511286784,
    0.000000001,
    "LLaDA2 Mini resident tensor payload",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    1.146281472,
    0.000000001,
    "LLaDA2 Mini fixed non-embedding traffic bytes",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.119537664,
    0.000000001,
    "LLaDA2 Mini uniform routed expert group bytes",
  );
  assert.equal(weightAdapter.routed_experts, 256);
  assert.equal(weightAdapter.routed_experts_per_token, 8);
  assert.equal(weightAdapter.shared_experts_per_token, 1);
  assert.match(item.unsupported_reason, /block-wise diffusion/);
  assert.equal(result.status_code, "unsupported_profile");
  assert.match(result.warnings.join("\n"), /production bounds require audited/);
}

{
  const item = profile("allenai/wildguard");
  const result = profiled("allenai/wildguard", "nvidia-dgx-spark");
  assert.equal(item.status, "unsupported");
  assert.equal(item.architecture.kv_adapter.kind, "unknown");
  assert.equal(item.serving.runtime_format, "unsupported-gated-config");
  assert.equal(item.serving.weight_format, "bf16");
  assertNear(
    item.architecture.weight_adapter.total_params_b,
    7.248031744,
    0.000000001,
    "AllenAI WildGuard API safetensors parameter count",
  );
  assert.equal(result.status_code, "unsupported_profile");
  assert.match(result.warnings.join("\n"), /production bounds require audited/);
}

{
  const row = model("microsoft/kosmos-2.5");
  const item = profile("microsoft/kosmos-2.5");
  const result = profiled("microsoft/kosmos-2.5", "nvidia-dgx-spark");
  assert.equal(row.hf_downloads, 100827);
  assert.ok(row.tags.includes("region:us"));
  assert.equal(row.hf_pipeline_tag, "image-text-to-text");
  assert.equal(row.architecture.type, "Multimodal document transformer");
  assert.equal(
    row.architecture.detail,
    "kosmos-2.5 image-text-to-text (Kosmos2_5ForConditionalGeneration)",
  );
  assertNear(
    row.architecture.total_params_b,
    1.374646272,
    0.000000001,
    "Kosmos 2.5 catalog F32 safetensors parameter count",
  );
  assertNear(
    row.adapter.resident_weight_gb,
    5.498585088,
    0.000000001,
    "Kosmos 2.5 catalog resident F32 tensor payload",
  );
  assertNear(
    row.adapter.active_weight_gb,
    5.498585088,
    0.000000001,
    "Kosmos 2.5 catalog fail-closed active tensor payload",
  );
  assert.equal(item.status, "unsupported");
  assert.equal(item.architecture.kv_adapter.kind, "unknown");
  assert.equal(
    item.serving.runtime_format,
    "unsupported-kosmos2-5-image-conditioned-document-generation",
  );
  assert.equal(item.serving.weight_format, "fp32");
  assertNear(
    item.architecture.weight_adapter.total_params_b,
    1.374646272,
    0.000000001,
    "Kosmos 2.5 API safetensors parameter count",
  );
  assert.match(item.unsupported_reason, /image-conditioned document/);
  assert.equal(result.status_code, "unsupported_profile");
  assert.match(result.warnings.join("\n"), /production bounds require audited/);
}

{
  const row = model("CohereLabs/aya-vision-8b");
  const item = profile("CohereLabs/aya-vision-8b");
  const result = profiled("CohereLabs/aya-vision-8b", "nvidia-dgx-spark");
  assert.equal(row.hf_downloads, 161292);
  assert.equal(item.status, "unsupported");
  assert.equal(item.architecture.kv_adapter.kind, "unknown");
  assert.equal(item.serving.runtime_format, "unsupported-gated-config");
  assert.equal(item.serving.weight_format, "fp16");
  assertNear(
    item.architecture.weight_adapter.total_params_b,
    8.631842032,
    0.000000001,
    "CohereLabs Aya Vision 8B API safetensors parameter count",
  );
  assert.equal(result.status_code, "unsupported_profile");
  assert.match(result.warnings.join("\n"), /production bounds require audited/);
}

{
  const row = model("meta-llama/Meta-Llama-3-70B");
  const item = profile("meta-llama/Meta-Llama-3-70B");
  const result = profiled("meta-llama/Meta-Llama-3-70B", "nvidia-dgx-spark");
  assert.equal(row.hf_downloads, 149077);
  assert.equal(item.status, "unsupported");
  assert.equal(item.architecture.kv_adapter.kind, "unknown");
  assert.equal(item.serving.runtime_format, "unsupported-gated-config");
  assert.equal(item.serving.weight_format, "bf16");
  assertNear(
    item.architecture.weight_adapter.total_params_b,
    70.553706496,
    0.000000001,
    "Meta Llama 3 70B API safetensors parameter count",
  );
  assert.equal(result.status_code, "unsupported_profile");
  assert.match(result.warnings.join("\n"), /production bounds require audited/);
}

{
  const row = model("meta-llama/Llama-Guard-4-12B");
  const item = profile("meta-llama/Llama-Guard-4-12B");
  const result = profiled("meta-llama/Llama-Guard-4-12B", "nvidia-dgx-spark");
  assert.equal(row.hf_downloads, 153621);
  assert.equal(row.tags.includes("region:us"), true);
  assert.equal(row.architecture.detail, "llama4 gated config unavailable");
  assert.equal(row.architecture.max_context_tokens, null);
  assert.equal(item.status, "unsupported");
  assert.equal(item.architecture.kv_adapter.kind, "unknown");
  assert.equal(item.serving.runtime_format, "unsupported-gated-config");
  assert.equal(item.serving.weight_format, "bf16");
  assertNear(
    item.architecture.weight_adapter.total_params_b,
    12.001097216,
    0.000000001,
    "Meta Llama Guard 4 12B API safetensors parameter count",
  );
  assert.equal(result.status_code, "unsupported_profile");
  assert.match(result.warnings.join("\n"), /production bounds require audited/);
}

{
  const item = profile("meta-llama/Llama-3.1-405B");
  const result = profiled("meta-llama/Llama-3.1-405B", "nvidia-dgx-spark");
  assert.equal(item.status, "unsupported");
  assert.equal(item.architecture.kv_adapter.kind, "unknown");
  assert.equal(item.serving.runtime_format, "unsupported-gated-config");
  assert.equal(item.serving.weight_format, "bf16");
  assertNear(
    item.architecture.weight_adapter.total_params_b,
    405.8533888,
    0.000000001,
    "Meta Llama 3.1 405B API safetensors parameter count",
  );
  assert.equal(result.status_code, "unsupported_profile");
  assert.match(result.warnings.join("\n"), /production bounds require audited/);
}

{
  const item = profile("meta-llama/Llama-3.1-405B-Instruct");
  const result = profiled(
    "meta-llama/Llama-3.1-405B-Instruct",
    "nvidia-dgx-spark",
  );
  assert.equal(item.status, "unsupported");
  assert.equal(item.architecture.kv_adapter.kind, "unknown");
  assert.equal(item.serving.runtime_format, "unsupported-gated-config");
  assert.equal(item.serving.weight_format, "bf16");
  assertNear(
    item.architecture.weight_adapter.total_params_b,
    405.8533888,
    0.000000001,
    "Meta Llama 3.1 405B Instruct API safetensors parameter count",
  );
  assert.equal(result.status_code, "unsupported_profile");
  assert.match(result.warnings.join("\n"), /production bounds require audited/);
}

{
  const item = profile("meta-llama/Llama-2-7b-chat-hf");
  const result = profiled("meta-llama/Llama-2-7b-chat-hf", "nvidia-dgx-spark");
  assert.equal(item.status, "unsupported");
  assert.equal(item.architecture.kv_adapter.kind, "unknown");
  assert.equal(item.serving.runtime_format, "unsupported-gated-config");
  assert.equal(item.serving.weight_format, "fp16");
  assertNear(
    item.architecture.weight_adapter.total_params_b,
    6.738417664,
    0.000000001,
    "Meta Llama 2 7B Chat HF API safetensors parameter count",
  );
  assert.equal(result.status_code, "unsupported_profile");
  assert.match(result.warnings.join("\n"), /production bounds require audited/);
}

{
  const item = profile("meta-llama/Llama-2-13b-chat-hf");
  const result = profiled("meta-llama/Llama-2-13b-chat-hf", "nvidia-dgx-spark");
  assert.equal(item.status, "unsupported");
  assert.equal(item.architecture.kv_adapter.kind, "unknown");
  assert.equal(item.serving.runtime_format, "unsupported-gated-config");
  assert.equal(item.serving.weight_format, "fp16");
  assertNear(
    item.architecture.weight_adapter.total_params_b,
    13.01586688,
    0.000000001,
    "Meta Llama 2 13B Chat HF API safetensors parameter count",
  );
  assertNear(
    item.serving.weight_bytes_per_param,
    2.0000003933660393,
    0.000000000000001,
    "Meta Llama 2 13B Chat HF API dtype-weighted bytes per parameter",
  );
  assert.equal(result.status_code, "unsupported_profile");
  assert.match(result.warnings.join("\n"), /production bounds require audited/);
}

{
  const item = profile("nvidia/Llama-4-Scout-17B-16E-Instruct-FP8");
  const result = profiled(
    "nvidia/Llama-4-Scout-17B-16E-Instruct-FP8",
    "nvidia-dgx-spark",
  );
  assert.equal(item.status, "unsupported");
  assert.equal(item.architecture.kv_adapter.kind, "unknown");
  assert.equal(item.serving.runtime_format, "unsupported-gated-config");
  assert.equal(item.serving.weight_format, "fp8");
  assertNear(
    item.architecture.weight_adapter.total_params_b,
    108.641793536,
    0.000000001,
    "NVIDIA Llama 4 Scout FP8 API safetensors parameter count",
  );
  assertNear(
    item.serving.weight_bytes_per_param,
    1.0271104944067775,
    0.000000000000001,
    "NVIDIA Llama 4 Scout FP8 API dtype-weighted bytes per parameter",
  );
  assert.equal(result.status_code, "unsupported_profile");
  assert.match(result.warnings.join("\n"), /production bounds require audited/);
}

{
  const catalog = model("meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8");
  const item = profile("meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8");
  const result = profiled(
    "meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8",
    "nvidia-dgx-spark",
  );
  assert.equal(catalog.hf_downloads, 108194);
  assert.ok(catalog.tags.includes("region:us"));
  assert.equal(catalog.architecture.type, "Unknown gated multimodal MoE");
  assert.equal(catalog.architecture.max_context_tokens, null);
  assert.equal(catalog.adapter.weight_precision, "FP8 + BF16 side tensors");
  assertNear(
    catalog.adapter.resident_weight_gb,
    416.752626688,
    0.000000001,
    "Meta Llama 4 Maverick FP8 catalog stored dtype bytes",
  );
  assert.equal(item.status, "unsupported");
  assert.equal(item.architecture.kv_adapter.kind, "unknown");
  assert.equal(item.serving.runtime_format, "unsupported-gated-config");
  assert.equal(item.serving.weight_format, "fp8");
  assertNear(
    item.architecture.weight_adapter.total_params_b,
    401.649841664,
    0.000000001,
    "Meta Llama 4 Maverick FP8 API safetensors parameter count",
  );
  assertNear(
    item.serving.weight_bytes_per_param,
    1.037601869731681,
    0.000000000000001,
    "Meta Llama 4 Maverick FP8 API dtype-weighted bytes per parameter",
  );
  assert.match(item.unsupported_reason, /MoE routing/);
  assert.equal(result.status_code, "unsupported_profile");
  assert.match(result.warnings.join("\n"), /production bounds require audited/);
}

{
  const item = profile("nvidia/Cosmos-Reason2-8B");
  const result = profiled("nvidia/Cosmos-Reason2-8B", "nvidia-dgx-spark");
  assert.equal(item.status, "unsupported");
  assert.equal(item.architecture.kv_adapter.kind, "unknown");
  assert.equal(item.serving.runtime_format, "unsupported-gated-config");
  assert.equal(item.serving.weight_format, "bf16");
  assertNear(
    item.architecture.weight_adapter.total_params_b,
    8.767123696,
    0.000000001,
    "NVIDIA Cosmos Reason2 8B API safetensors parameter count",
  );
  assert.equal(result.status_code, "unsupported_profile");
  assert.match(result.warnings.join("\n"), /production bounds require audited/);
}

{
  const item = profile("google/gemma-2-9b-it");
  const result = profiled("google/gemma-2-9b-it", "nvidia-dgx-spark");
  assert.equal(item.status, "unsupported");
  assert.equal(item.architecture.kv_adapter.kind, "unknown");
  assert.equal(item.serving.runtime_format, "unsupported-gated-config");
  assert.equal(item.serving.weight_format, "bf16");
  assertNear(
    item.architecture.weight_adapter.total_params_b,
    9.241705984,
    0.000000001,
    "Google Gemma 2 9B IT API safetensors parameter count",
  );
  assert.equal(result.status_code, "unsupported_profile");
  assert.match(result.warnings.join("\n"), /production bounds require audited/);
}

{
  const item = profile("google/gemma-2-2b-it");
  const result = profiled("google/gemma-2-2b-it", "nvidia-dgx-spark");
  assert.equal(item.status, "unsupported");
  assert.equal(item.architecture.kv_adapter.kind, "unknown");
  assert.equal(item.serving.runtime_format, "unsupported-gated-config");
  assert.equal(item.serving.weight_format, "bf16");
  assertNear(
    item.architecture.weight_adapter.total_params_b,
    2.614341888,
    0.000000001,
    "Google Gemma 2 2B IT API safetensors parameter count",
  );
  assert.equal(result.status_code, "unsupported_profile");
  assert.match(result.warnings.join("\n"), /production bounds require audited/);
}

{
  const item = profile("google/gemma-2-2b");
  const result = profiled("google/gemma-2-2b", "nvidia-dgx-spark");
  assert.equal(item.status, "unsupported");
  assert.equal(item.architecture.kv_adapter.kind, "unknown");
  assert.equal(item.serving.runtime_format, "unsupported-gated-config");
  assert.equal(item.serving.weight_format, "fp32");
  assertNear(
    item.architecture.weight_adapter.total_params_b,
    2.614341888,
    0.000000001,
    "Google Gemma 2 2B API safetensors parameter count",
  );
  assert.equal(result.status_code, "unsupported_profile");
  assert.match(result.warnings.join("\n"), /production bounds require audited/);
}

{
  const catalog = model("google/gemma-1.1-2b-it");
  const item = profile("google/gemma-1.1-2b-it");
  const result = profiled("google/gemma-1.1-2b-it", "nvidia-dgx-spark");
  assert.equal(catalog.hf_downloads, 198323);
  assert.equal(catalog.architecture.detail, "gated config unavailable");
  assert.equal(catalog.architecture.max_context_tokens, null);
  assert.equal(item.status, "unsupported");
  assert.equal(item.architecture.kv_adapter.kind, "unknown");
  assert.equal(item.serving.runtime_format, "unsupported-gated-config");
  assert.equal(item.serving.weight_format, "bf16");
  assertNear(
    item.architecture.weight_adapter.total_params_b,
    2.506172416,
    0.000000001,
    "Google Gemma 1.1 2B IT API safetensors parameter count",
  );
  assertNear(
    catalog.adapter.resident_weight_gb,
    5.012344832,
    0.000000001,
    "Google Gemma 1.1 2B IT catalog API BF16 resident estimate",
  );
  assert.equal(result.status_code, "unsupported_profile");
  assert.match(result.warnings.join("\n"), /production bounds require audited/);
}

{
  const catalog = model("google/gemma-2b");
  const item = profile("google/gemma-2b");
  const result = profiled("google/gemma-2b", "nvidia-dgx-spark");
  assert.equal(catalog.hf_downloads, 117744);
  assert.ok(catalog.tags.includes("region:us"));
  assert.equal(catalog.architecture.detail, "gemma (gated config unavailable)");
  assert.equal(catalog.architecture.max_context_tokens, 8192);
  assert.equal(catalog.adapter.weight_precision, "BF16");
  assert.equal(item.status, "unsupported");
  assert.equal(item.architecture.max_context_tokens, 8192);
  assert.equal(item.architecture.kv_adapter.kind, "unknown");
  assert.equal(item.serving.runtime_format, "unsupported-gated-config");
  assert.equal(item.serving.weight_format, "bf16");
  assertNear(
    item.architecture.weight_adapter.total_params_b,
    2.506172416,
    0.000000001,
    "Google Gemma 2B API safetensors parameter count",
  );
  assertNear(
    catalog.adapter.resident_weight_gb,
    5.012344832,
    0.000000001,
    "Google Gemma 2B catalog API BF16 resident estimate",
  );
  assert.equal(result.status_code, "unsupported_profile");
  assert.match(result.warnings.join("\n"), /production bounds require audited/);
}

{
  const item = profile("bartowski/gemma-2-2b-it-GGUF");
  const weightAdapter = item.architecture.weight_adapter;
  const kvAdapter = item.architecture.kv_adapter;
  const result = profiled("bartowski/gemma-2-2b-it-GGUF", "nvidia-dgx-spark");
  const m5Result = profiled(
    "bartowski/gemma-2-2b-it-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );

  assert.equal(item.status, "audited");
  assert.equal(item.serving.runtime_format, "llama.cpp-gguf-f32-memory-bound");
  assert.equal(kvAdapter.kind, "layered_kv");
  assert.equal(kvAdapter.components[0].kind, "full_context");
  assert.equal(kvAdapter.components[0].layers, 13);
  assert.equal(kvAdapter.components[1].kind, "sliding_window");
  assert.equal(kvAdapter.components[1].layers, 13);
  assert.equal(kvAdapter.components[1].window_tokens, 4096);
  assertNear(
    result.resident,
    10.463413856,
    0.000000001,
    "Bartowski Gemma 2 2B F32 GGUF resident file footprint",
  );
  assertNear(
    result.single.batchWeight,
    10.457367552,
    0.000000001,
    "Bartowski Gemma 2 2B F32 GGUF swept text decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.006046304,
    0.000000001,
    "Bartowski Gemma 2 2B F32 GGUF header overhead",
  );
  assertNear(
    result.alloc,
    5.542903808,
    0.000000001,
    "Bartowski Gemma 2 2B F32 GGUF layered FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.922039808,
    0.000000001,
    "Bartowski Gemma 2 2B F32 GGUF layered FP16 KV read traffic",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(result.bMem, 19);
  assert.equal(result.best.batch, 1);
  assertNear(
    result.single.aggregate,
    22.05275196631061,
    0.000000001,
    "Bartowski Gemma 2 2B F32 GGUF DGX single-session throughput",
  );
  assertNear(
    result.best.aggregate,
    22.05275196631061,
    0.000000001,
    "Bartowski Gemma 2 2B F32 GGUF DGX aggregate throughput",
  );
  assertNear(
    result.dennard,
    515.8959682675738,
    0.000000001,
    "Bartowski Gemma 2 2B F32 GGUF DGX Dennard bound",
  );
  assert.equal(m5Result.best.batch, 10);
  assertNear(
    m5Result.single.aggregate,
    49.59849709639089,
    0.000000001,
    "Bartowski Gemma 2 2B F32 GGUF M5 single-session throughput",
  );
  assertNear(
    m5Result.best.aggregate,
    206.88889036105724,
    0.000000001,
    "Bartowski Gemma 2 2B F32 GGUF M5 aggregate throughput",
  );
  assertNear(
    m5Result.best.perSession,
    20.688889036105724,
    0.000000001,
    "Bartowski Gemma 2 2B F32 GGUF M5 per-session throughput",
  );
  assertNear(
    m5Result.dennard,
    1160.293496396668,
    0.000000001,
    "Bartowski Gemma 2 2B F32 GGUF M5 Dennard bound",
  );
}

{
  const repo = "MaziyarPanahi/gemma-2-2b-it-GGUF";
  const item = profile(repo);
  const catalog = model(repo);
  const weightAdapter = item.architecture.weight_adapter;
  const kvAdapter = item.architecture.kv_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");

  assert.equal(item.status, "audited");
  assert.equal(item.serving.runtime_format, "llama.cpp-gguf-fp16-memory-bound");
  assert.equal(catalog.name, "gemma-2-2b-it-GGUF GGUF FP16");
  assert.equal(catalog.license, "gemma");
  assert.equal(catalog.hf_downloads, 119685);
  assert.ok(catalog.tags.includes("region:us"));
  assert.ok(catalog.tags.includes("gemma2"));
  assert.equal(catalog.architecture.detail, "gemma2");
  assert.equal(catalog.architecture.layers, 26);
  assert.equal(catalog.architecture.attention_heads, 8);
  assert.equal(catalog.architecture.kv_heads, 4);
  assert.equal(catalog.architecture.head_dim, 256);
  assert.equal(catalog.architecture.max_context_tokens, 8192);
  assert.equal(catalog.adapter.weight_precision, "GGUF FP16");
  assert.equal(kvAdapter.kind, "layered_kv");
  assert.equal(kvAdapter.components[0].kind, "full_context");
  assert.equal(kvAdapter.components[0].layers, 13);
  assert.equal(kvAdapter.components[1].kind, "sliding_window");
  assert.equal(kvAdapter.components[1].layers, 13);
  assert.equal(kvAdapter.components[1].window_tokens, 4096);
  assertNear(
    catalog.adapter.resident_weight_gb,
    5.235213952,
    0.000000001,
    "MaziyarPanahi Gemma 2 2B FP16 GGUF catalog resident file footprint",
  );
  assertNear(
    catalog.adapter.active_weight_gb,
    5.229167616,
    0.000000001,
    "MaziyarPanahi Gemma 2 2B FP16 GGUF catalog swept tensor spans",
  );
  assertNear(
    result.resident,
    5.235213952,
    0.000000001,
    "MaziyarPanahi Gemma 2 2B FP16 GGUF resident file footprint",
  );
  assertNear(
    result.single.batchWeight,
    5.229167616,
    0.000000001,
    "MaziyarPanahi Gemma 2 2B FP16 GGUF swept tied-output traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.006046336,
    0.000000001,
    "MaziyarPanahi Gemma 2 2B FP16 GGUF header overhead",
  );
  assertNear(
    result.alloc,
    5.542903808,
    0.000000001,
    "MaziyarPanahi Gemma 2 2B FP16 GGUF layered FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.922039808,
    0.000000001,
    "MaziyarPanahi Gemma 2 2B FP16 GGUF layered FP16 KV read traffic",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(result.bMem, 20);
  assert.equal(result.best.batch, 4);
  assertNear(
    result.single.aggregate,
    38.17537148814773,
    0.000000001,
    "MaziyarPanahi Gemma 2 2B FP16 GGUF DGX single-session throughput",
  );
  assertNear(
    result.best.aggregate,
    84.53761469766287,
    0.000000001,
    "MaziyarPanahi Gemma 2 2B FP16 GGUF DGX aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    21.13440367441572,
    0.000000001,
    "MaziyarPanahi Gemma 2 2B FP16 GGUF DGX per-session throughput",
  );
  assertNear(
    result.dennard,
    1080.9395158040297,
    0.000000001,
    "MaziyarPanahi Gemma 2 2B FP16 GGUF DGX Dennard bound",
  );
  assert.equal(m5Result.best.batch, 13);
  assertNear(
    m5Result.single.aggregate,
    85.859626716933,
    0.000000001,
    "MaziyarPanahi Gemma 2 2B FP16 GGUF M5 single-session throughput",
  );
  assertNear(
    m5Result.best.aggregate,
    264.16743384437285,
    0.000000001,
    "MaziyarPanahi Gemma 2 2B FP16 GGUF M5 aggregate throughput",
  );
  assertNear(
    m5Result.best.perSession,
    20.320571834182527,
    0.000000001,
    "MaziyarPanahi Gemma 2 2B FP16 GGUF M5 per-session throughput",
  );
  assertNear(
    m5Result.dennard,
    2431.1240392075983,
    0.000000001,
    "MaziyarPanahi Gemma 2 2B FP16 GGUF M5 Dennard bound",
  );
}

{
  const item = profile("google/paligemma-3b-pt-224");
  const result = profiled("google/paligemma-3b-pt-224", "nvidia-dgx-spark");
  assert.equal(item.status, "unsupported");
  assert.equal(item.architecture.kv_adapter.kind, "unknown");
  assert.equal(item.serving.runtime_format, "unsupported-gated-config");
  assert.equal(item.serving.weight_format, "fp32");
  assertNear(
    item.architecture.weight_adapter.total_params_b,
    2.92346648,
    0.000000001,
    "Google PaliGemma 3B PT 224 API safetensors parameter count",
  );
  assert.equal(result.status_code, "unsupported_profile");
  assert.match(result.warnings.join("\n"), /production bounds require audited/);
}

{
  const item = profile("google/paligemma-3b-mix-224");
  const result = profiled("google/paligemma-3b-mix-224", "nvidia-dgx-spark");
  assert.equal(item.status, "unsupported");
  assert.equal(item.architecture.kv_adapter.kind, "unknown");
  assert.equal(item.serving.runtime_format, "unsupported-gated-config");
  assert.equal(item.serving.weight_format, "fp32");
  assertNear(
    item.architecture.weight_adapter.total_params_b,
    2.92346648,
    0.000000001,
    "Google PaliGemma 3B Mix 224 API safetensors parameter count",
  );
  assert.equal(result.status_code, "unsupported_profile");
  assert.match(result.warnings.join("\n"), /production bounds require audited/);
}

{
  const item = profile("google/paligemma-3b-ft-cococap-448");
  const result = profiled(
    "google/paligemma-3b-ft-cococap-448",
    "nvidia-dgx-spark",
  );
  assert.equal(item.status, "unsupported");
  assert.equal(item.architecture.kv_adapter.kind, "unknown");
  assert.equal(item.serving.runtime_format, "unsupported-gated-config");
  assert.equal(item.serving.weight_format, "fp32");
  assertNear(
    item.architecture.weight_adapter.total_params_b,
    2.924351216,
    0.000000001,
    "Google PaliGemma 3B FT COCOCap 448 API safetensors parameter count",
  );
  assert.equal(result.status_code, "unsupported_profile");
  assert.match(result.warnings.join("\n"), /production bounds require audited/);
}

{
  const item = profile("google/medgemma-1.5-4b-it");
  const result = profiled("google/medgemma-1.5-4b-it", "nvidia-dgx-spark");
  assert.equal(item.status, "unsupported");
  assert.equal(item.architecture.kv_adapter.kind, "unknown");
  assert.equal(item.serving.runtime_format, "unsupported-gated-config");
  assert.equal(item.serving.weight_format, "bf16");
  assertNear(
    item.architecture.weight_adapter.total_params_b,
    4.300079472,
    0.000000001,
    "Google MedGemma 1.5 4B IT API safetensors parameter count",
  );
  assert.equal(result.status_code, "unsupported_profile");
  assert.match(result.warnings.join("\n"), /production bounds require audited/);
}

{
  const item = profile("google/medgemma-4b-it");
  const modelRow = model("google/medgemma-4b-it");
  const result = profiled("google/medgemma-4b-it", "nvidia-dgx-spark");
  assert.equal(item.status, "unsupported");
  assert.equal(item.architecture.kv_adapter.kind, "unknown");
  assert.equal(item.serving.runtime_format, "unsupported-gated-config");
  assert.equal(item.serving.weight_format, "bf16");
  assert.equal(modelRow.hf_downloads, 291353);
  assert.equal(modelRow.architecture.max_context_tokens, null);
  assertNear(
    item.architecture.weight_adapter.total_params_b,
    4.300079472,
    0.000000001,
    "Google MedGemma 4B IT API safetensors parameter count",
  );
  assertNear(
    modelRow.adapter.resident_weight_gb,
    8.600158944,
    0.000000001,
    "Google MedGemma 4B IT API BF16 resident bytes",
  );
  assert.equal(result.status_code, "unsupported_profile");
  assert.match(result.warnings.join("\n"), /production bounds require audited/);
}

{
  const item = profile("google/gemma-3n-E2B-it");
  const result = profiled("google/gemma-3n-E2B-it", "nvidia-dgx-spark");
  assert.equal(item.status, "unsupported");
  assert.equal(item.architecture.kv_adapter.kind, "unknown");
  assert.equal(item.serving.runtime_format, "unsupported-gated-config");
  assert.equal(item.serving.weight_format, "bf16");
  assertNear(
    item.architecture.weight_adapter.total_params_b,
    5.439438272,
    0.000000001,
    "Google Gemma 3n E2B API safetensors parameter count",
  );
  assert.equal(result.status_code, "unsupported_profile");
  assert.match(result.warnings.join("\n"), /production bounds require audited/);
}

{
  const item = profile("google/gemma-4-E4B-it-assistant");
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(
    "google/gemma-4-E4B-it-assistant",
    "nvidia-dgx-spark",
  );
  assert.equal(item.status, "unsupported");
  assert.equal(result.status_code, "unsupported_profile");
  assert.equal(item.architecture.kv_adapter.kind, "unknown");
  assert.equal(
    item.serving.runtime_format,
    "unsupported-gemma4-mtp-assistant-drafter",
  );
  assertNear(
    weightAdapter.resident_weight_gb,
    0.15913268,
    0.000000001,
    "Gemma 4 E4B assistant resident drafter package",
  );
  assertNear(
    weightAdapter.swept_weight_gb,
    0.15913268,
    0.000000001,
    "Gemma 4 E4B assistant recorded drafter tensor bytes",
  );
  assert.match(result.warnings.join("\n"), /production bounds require audited/);
}

{
  const item = profile("google/gemma-4-26B-A4B-it-assistant");
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(
    "google/gemma-4-26B-A4B-it-assistant",
    "nvidia-dgx-spark",
  );
  assert.equal(item.status, "unsupported");
  assert.equal(result.status_code, "unsupported_profile");
  assert.equal(item.architecture.kv_adapter.kind, "unknown");
  assert.equal(
    item.serving.runtime_format,
    "unsupported-gemma4-mtp-assistant-drafter",
  );
  assertNear(
    weightAdapter.resident_weight_gb,
    0.839422472,
    0.000000001,
    "Gemma 4 26B A4B assistant resident drafter package",
  );
  assertNear(
    weightAdapter.swept_weight_gb,
    0.839422472,
    0.000000001,
    "Gemma 4 26B A4B assistant recorded drafter tensor bytes",
  );
  assert.match(result.warnings.join("\n"), /production bounds require audited/);
}

{
  const item = profile("google/gemma-4-31B-it-assistant");
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(
    "google/gemma-4-31B-it-assistant",
    "nvidia-dgx-spark",
  );
  assert.equal(item.status, "unsupported");
  assert.equal(result.status_code, "unsupported_profile");
  assert.equal(item.architecture.kv_adapter.kind, "unknown");
  assert.equal(
    item.serving.runtime_format,
    "unsupported-gemma4-mtp-assistant-drafter",
  );
  assertNear(
    weightAdapter.resident_weight_gb,
    0.939037192,
    0.000000001,
    "Gemma 4 31B assistant resident drafter package",
  );
  assertNear(
    weightAdapter.swept_weight_gb,
    0.939037192,
    0.000000001,
    "Gemma 4 31B assistant recorded drafter tensor bytes",
  );
  assert.match(result.warnings.join("\n"), /production bounds require audited/);
}

{
  const repo = "google/gemma-4-31B-it-qat-q4_0-unquantized-assistant";
  const item = profile(repo);
  const modelRow = model(repo);
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  assert.equal(
    modelRow.name,
    "Gemma 4 31B QAT Q4_0 Unquantized Assistant Drafter BF16",
  );
  assert.equal(modelRow.hf_downloads, 143335);
  assert.equal(modelRow.adapter.weight_precision, "BF16");
  assert.equal(item.status, "unsupported");
  assert.equal(result.status_code, "unsupported_profile");
  assert.equal(item.architecture.kv_adapter.kind, "unknown");
  assert.equal(
    item.serving.runtime_format,
    "unsupported-gemma4-mtp-assistant-drafter",
  );
  assertNear(
    weightAdapter.resident_params_b,
    0.469518596,
    0.000000001,
    "Gemma 4 31B QAT unquantized assistant BF16 parameter count",
  );
  assertNear(
    weightAdapter.resident_weight_gb,
    0.939037192,
    0.000000001,
    "Gemma 4 31B QAT unquantized assistant resident drafter package",
  );
  assertNear(
    weightAdapter.swept_weight_gb,
    0.939037192,
    0.000000001,
    "Gemma 4 31B QAT unquantized assistant recorded drafter tensor bytes",
  );
  assert.match(result.warnings.join("\n"), /production bounds require audited/);
}

{
  const repo = "MiniMaxAI/MiniMax-VL-01";
  const item = profile(repo);
  const catalogRow = model(repo);
  const weightAdapter = item.architecture.weight_adapter;
  const kvAdapter = item.architecture.kv_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");

  assert.equal(item.status, "audited");
  assert.equal(
    item.serving.runtime_format,
    "transformers-minimax-vl01-text01-lightning-moe-memory-bound",
  );
  assert.equal(kvAdapter.kind, "layered_kv");
  assert.equal(kvAdapter.components[0].kind, "recurrent_state");
  assert.equal(kvAdapter.components[1].kind, "full_context");
  assertNear(
    kvAdapter.components[0].alloc_gb_per_session,
    0.29360128,
    0.000000001,
    "MiniMax VL 01 Lightning state allocation",
  );
  assertNear(
    kvAdapter.components[0].read_gb_per_output_token,
    0.29360128,
    0.000000001,
    "MiniMax VL 01 Lightning state read traffic",
  );
  assert.equal(kvAdapter.components[1].layers, 10);
  assert.equal(kvAdapter.components[1].kv_heads, 8);
  assert.equal(kvAdapter.components[1].head_dim, 128);
  assert.equal(catalogRow.hf_downloads, 112771);
  assert.equal(catalogRow.tags.includes("region:us"), true);
  assert.equal(catalogRow.license, "other");
  assert.equal(
    catalogRow.architecture.detail,
    "minimax_vl_01 (MiniMaxVL01ForConditionalGeneration, MiniMaxText01 Lightning/MoE text)",
  );
  assertNear(
    catalogRow.architecture.total_params_b,
    456.437219328,
    0.000000001,
    "MiniMax VL 01 catalog total logical params",
  );
  assertNear(
    catalogRow.adapter.resident_weight_gb,
    915.366670336,
    0.000000001,
    "MiniMax VL 01 catalog resident payload",
  );
  assertNear(
    catalogRow.adapter.active_weight_gb,
    94.37968384,
    0.000000001,
    "MiniMax VL 01 catalog single-token ordinary text traffic",
  );
  assertNear(
    catalogRow.adapter.kv_alloc_gb_per_1k_tokens,
    0.04096,
    0.000000001,
    "MiniMax VL 01 catalog full-attention K/V allocation coefficient",
  );
  assertNear(
    catalogRow.adapter.kv_read_gb_per_1k_tokens,
    0.04096,
    0.000000001,
    "MiniMax VL 01 catalog full-attention K/V read coefficient",
  );
  assertNear(
    catalogRow.adapter.kv_alloc_fixed_gb,
    0.29360128,
    0.000000001,
    "MiniMax VL 01 catalog recurrent state allocation",
  );
  assertNear(
    catalogRow.adapter.kv_read_fixed_gb,
    0.29360128,
    0.000000001,
    "MiniMax VL 01 catalog recurrent state read",
  );
  assertNear(
    weightAdapter.resident_weight_gb,
    915.366670336,
    0.000000001,
    "MiniMax VL 01 resident package",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    909.75238144,
    0.000000001,
    "MiniMax VL 01 ordinary text main package",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    5.614288896,
    0.000000001,
    "MiniMax VL 01 multimodal/input auxiliary package",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    40.021504,
    0.000000001,
    "MiniMax VL 01 fixed ordinary text traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    27.17908992,
    0.000000001,
    "MiniMax VL 01 routed expert group traffic",
  );
  assert.equal(weightAdapter.routed_experts, 32);
  assert.equal(weightAdapter.routed_experts_per_token, 2);
  assert.equal(result.status_code, "resident_not_fit");
  assertNear(
    result.resident,
    915.366670336,
    0.000000001,
    "MiniMax VL 01 profiled resident payload",
  );
  assertNear(
    result.alloc,
    4.38960128,
    0.000000001,
    "MiniMax VL 01 profiled default allocation",
  );
  assertNear(
    result.single.readTraffic,
    1.60432128,
    0.000000001,
    "MiniMax VL 01 profiled default read traffic",
  );
}

{
  const item = profile("MiniMaxAI/MiniMax-M3-MXFP8");
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled("MiniMaxAI/MiniMax-M3-MXFP8", "nvidia-dgx-spark");
  assert.equal(item.status, "unsupported");
  assert.equal(result.status_code, "unsupported_profile");
  assert.equal(item.architecture.kv_adapter.kind, "unknown");
  assert.equal(item.serving.runtime_format, "unsupported-minimax-m3-msa-mxfp8");
  assert.match(item.unsupported_reason, /MiniMax Sparse Attention/);
  assertNear(
    weightAdapter.resident_weight_gb,
    443.74208512,
    0.000000001,
    "MiniMax M3 MXFP8 resident package",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    439.549553664,
    0.000000001,
    "MiniMax M3 MXFP8 ordinary text main package",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    4.192531456,
    0.000000001,
    "MiniMax M3 MXFP8 multimodal/input auxiliary package",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    13.517319168,
    0.000000001,
    "MiniMax M3 MXFP8 fixed ordinary text traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    3.328376832,
    0.000000001,
    "MiniMax M3 MXFP8 routed expert group traffic",
  );
  assert.equal(weightAdapter.routed_experts, 128);
  assert.equal(weightAdapter.routed_experts_per_token, 4);
  assert.match(result.warnings.join("\n"), /production bounds require audited/);
}

{
  const item = profile("MiniMaxAI/MiniMax-M3");
  const catalogRow = model("MiniMaxAI/MiniMax-M3");
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled("MiniMaxAI/MiniMax-M3", "nvidia-dgx-spark");
  assert.equal(item.status, "unsupported");
  assert.equal(result.status_code, "unsupported_profile");
  assert.equal(item.architecture.kv_adapter.kind, "unknown");
  assert.equal(item.serving.runtime_format, "unsupported-minimax-m3-msa-bf16");
  assert.match(item.unsupported_reason, /MiniMax Sparse Attention/);
  assert.equal(catalogRow.hf_downloads, 226766);
  assert.equal(catalogRow.tags.includes("region:us"), true);
  assert.equal(
    catalogRow.architecture.detail,
    "minimax_m3_vl (MiniMaxM3SparseForCausalLM)",
  );
  assertNear(
    catalogRow.architecture.total_params_b,
    427.04014016,
    0.000000001,
    "MiniMax M3 catalog total logical params",
  );
  assertNear(
    catalogRow.adapter.resident_weight_gb,
    854.17295872,
    0.000000001,
    "MiniMax M3 catalog resident payload",
  );
  assertNear(
    catalogRow.adapter.active_weight_gb,
    49.55622912,
    0.000000001,
    "MiniMax M3 catalog single-token ordinary text traffic",
  );
  assert.equal(catalogRow.adapter.kv_alloc_gb_per_1k_tokens, 0);
  assert.equal(catalogRow.adapter.kv_read_gb_per_1k_tokens, 0);
  assertNear(
    weightAdapter.resident_weight_gb,
    854.17295872,
    0.000000001,
    "MiniMax M3 resident package",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    849.980427264,
    0.000000001,
    "MiniMax M3 ordinary text main package",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    4.192531456,
    0.000000001,
    "MiniMax M3 multimodal/input auxiliary package",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    23.736093696,
    0.000000001,
    "MiniMax M3 fixed ordinary text traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    6.455033856,
    0.000000001,
    "MiniMax M3 routed expert group traffic",
  );
  assert.equal(weightAdapter.routed_experts, 128);
  assert.equal(weightAdapter.routed_experts_per_token, 4);
  assert.match(result.warnings.join("\n"), /production bounds require audited/);
}

{
  const item = profile("nvidia/KVzap-mlp-Qwen3-8B");
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled("nvidia/KVzap-mlp-Qwen3-8B", "nvidia-dgx-spark");
  assert.equal(item.status, "unsupported");
  assert.equal(result.status_code, "unsupported_profile");
  assert.equal(item.architecture.kv_adapter.kind, "unknown");
  assert.equal(
    item.serving.runtime_format,
    "unsupported-kvzap-auxiliary-pruner",
  );
  assert.match(item.unsupported_reason, /auxiliary hidden-state scorer/);
  assertNear(
    weightAdapter.resident_weight_gb,
    0.302654592,
    0.000000001,
    "KVzap MLP Qwen3 8B resident auxiliary scorer bytes",
  );
  assert.match(result.warnings.join("\n"), /production bounds require audited/);
}

{
  const item = profile("nvidia/LocateAnything-3B");
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled("nvidia/LocateAnything-3B", "nvidia-dgx-spark");
  assert.equal(item.status, "unsupported");
  assert.equal(result.status_code, "unsupported_profile");
  assert.equal(item.architecture.kv_adapter.kind, "unknown");
  assert.equal(
    item.serving.runtime_format,
    "unsupported-locateanything-hybrid-box-decoding",
  );
  assertNear(
    weightAdapter.resident_weight_gb,
    7.661331936,
    0.000000001,
    "LocateAnything resident package",
  );
  assertNear(
    weightAdapter.swept_weight_gb,
    6.800310272,
    0.000000001,
    "LocateAnything language tensor bytes",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.861021664,
    0.000000001,
    "LocateAnything vision/projector/input auxiliary bytes",
  );
  assert.match(result.warnings.join("\n"), /production bounds require audited/);
}

{
  const item = profile("RedHatAI/diffusiongemma-26B-A4B-it-NVFP4");
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(
    "RedHatAI/diffusiongemma-26B-A4B-it-NVFP4",
    "nvidia-dgx-spark",
  );
  assert.equal(item.status, "unsupported");
  assert.equal(item.serving.weight_format, "nvfp4");
  assert.equal(item.architecture.kv_adapter.kind, "unknown");
  assert.equal(
    item.serving.runtime_format,
    "unsupported-block-diffusion-vllm-compressed-tensors-nvfp4",
  );
  assert.equal(result.status_code, "unsupported_profile");
  assertNear(
    weightAdapter.resident_weight_gb,
    18.048607656,
    0.000000001,
    "RedHatAI DiffusionGemma NVFP4 resident package",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    16.903018764,
    0.000000001,
    "RedHatAI DiffusionGemma NVFP4 decoder package",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.145588892,
    0.000000001,
    "RedHatAI DiffusionGemma NVFP4 encoder package",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    4.056559884,
    0.000000001,
    "RedHatAI DiffusionGemma NVFP4 fixed decoder traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.10036296,
    0.000000001,
    "RedHatAI DiffusionGemma NVFP4 routed expert group",
  );
  assert.equal(weightAdapter.routed_experts, 128);
  assert.equal(weightAdapter.routed_experts_per_token, 8);
  assert.match(result.warnings.join("\n"), /production bounds require audited/);
}

{
  const item = profile("RedHatAI/diffusiongemma-26B-A4B-it-FP8-dynamic");
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(
    "RedHatAI/diffusiongemma-26B-A4B-it-FP8-dynamic",
    "nvidia-dgx-spark",
  );
  assert.equal(item.status, "unsupported");
  assert.equal(item.serving.weight_format, "fp8");
  assert.equal(item.architecture.kv_adapter.kind, "unknown");
  assert.equal(
    item.serving.runtime_format,
    "unsupported-block-diffusion-vllm-compressed-tensors-fp8-dynamic",
  );
  assert.equal(result.status_code, "unsupported_profile");
  assertNear(
    weightAdapter.resident_weight_gb,
    27.197665496,
    0.000000001,
    "RedHatAI DiffusionGemma FP8 Dynamic resident package",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    26.052076604,
    0.000000001,
    "RedHatAI DiffusionGemma FP8 Dynamic decoder package",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.145588892,
    0.000000001,
    "RedHatAI DiffusionGemma FP8 Dynamic encoder package",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    3.181651004,
    0.000000001,
    "RedHatAI DiffusionGemma FP8 Dynamic fixed decoder traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.1786752,
    0.000000001,
    "RedHatAI DiffusionGemma FP8 Dynamic routed expert group",
  );
  assert.equal(weightAdapter.routed_experts, 128);
  assert.equal(weightAdapter.routed_experts_per_token, 8);
  assert.match(result.warnings.join("\n"), /production bounds require audited/);
}

{
  const item = profile("nvidia/diffusiongemma-26B-A4B-it-NVFP4");
  assert.equal(item.status, "unsupported");
  assert.equal(item.serving.weight_format, "nvfp4");
  assert.equal(item.architecture.kv_adapter.kind, "unknown");
  assertNear(
    item.architecture.weight_adapter.resident_weight_gb,
    18.818050776,
    0.000000001,
    "NVIDIA DiffusionGemma NVFP4 resident package",
  );
  assertNear(
    item.architecture.weight_adapter.main_resident_weight_gb,
    17.672461884,
    0.000000001,
    "NVIDIA DiffusionGemma NVFP4 decoder package",
  );
  assertNear(
    item.architecture.weight_adapter.fixed_weight_gb,
    4.826003004,
    0.000000001,
    "NVIDIA DiffusionGemma NVFP4 fixed decoder tensors",
  );
  assertNear(
    item.architecture.weight_adapter.routed_expert_weight_gb,
    0.10036296,
    0.000000001,
    "NVIDIA DiffusionGemma NVFP4 routed expert group",
  );
}

{
  const item = profile("unsloth/diffusiongemma-26B-A4B-it-GGUF");
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(
    "unsloth/diffusiongemma-26B-A4B-it-GGUF",
    "nvidia-dgx-spark",
  );
  assert.equal(item.status, "unsupported");
  assert.equal(item.serving.weight_format, "bf16");
  assert.equal(item.architecture.kv_adapter.kind, "unknown");
  assert.equal(
    item.serving.runtime_format,
    "unsupported-block-diffusion-llama.cpp-gguf-bf16",
  );
  assert.equal(result.status_code, "unsupported_profile");
  assertNear(
    weightAdapter.resident_weight_gb,
    50.5408344,
    0.000000001,
    "Unsloth DiffusionGemma BF16 GGUF resident file footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    50.525009792,
    0.000000001,
    "Unsloth DiffusionGemma BF16 GGUF tensor spans",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.015824608,
    0.000000001,
    "Unsloth DiffusionGemma BF16 GGUF metadata/header overhead",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    4.849023872,
    0.000000001,
    "Unsloth DiffusionGemma BF16 GGUF fixed tensor spans",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.35684364,
    0.000000001,
    "Unsloth DiffusionGemma BF16 GGUF routed expert group",
  );
  assert.equal(weightAdapter.routed_experts, 128);
  assert.equal(weightAdapter.routed_experts_per_token, 8);
  assert.match(result.warnings.join("\n"), /production bounds require audited/);
}

{
  const item = profile("nvidia/Nemotron-Labs-Diffusion-8B-Base");
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(
    "nvidia/Nemotron-Labs-Diffusion-8B-Base",
    "nvidia-dgx-spark",
  );
  assert.equal(item.status, "unsupported");
  assert.equal(result.status_code, "unsupported_profile");
  assert.equal(item.architecture.kv_adapter.kind, "unknown");
  assert.equal(
    item.serving.runtime_format,
    "unsupported-nemotron-labs-diffusion-tri-mode",
  );
  assert.match(item.unsupported_reason, /AR, diffusion, and self-speculation/);
  assertNear(
    weightAdapter.resident_weight_gb,
    16.97910784,
    0.000000001,
    "Nemotron-Labs-Diffusion 8B Base resident package",
  );
  assertNear(
    weightAdapter.swept_weight_gb,
    15.905366016,
    0.000000001,
    "Nemotron-Labs-Diffusion 8B Base AR-mode swept bytes",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.073741824,
    0.000000001,
    "Nemotron-Labs-Diffusion 8B Base input embedding bytes",
  );
  assert.match(result.warnings.join("\n"), /production bounds require audited/);
}

{
  const item = profile("nvidia/Nemotron-Labs-Diffusion-8B");
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(
    "nvidia/Nemotron-Labs-Diffusion-8B",
    "nvidia-dgx-spark",
  );
  assert.equal(item.status, "unsupported");
  assert.equal(result.status_code, "unsupported_profile");
  assert.equal(item.architecture.kv_adapter.kind, "unknown");
  assert.equal(
    item.serving.runtime_format,
    "unsupported-nemotron-labs-diffusion-tri-mode",
  );
  assert.match(item.unsupported_reason, /AR, diffusion, and self-speculation/);
  assertNear(
    weightAdapter.resident_weight_gb,
    16.97910784,
    0.000000001,
    "Nemotron-Labs-Diffusion 8B resident package",
  );
  assertNear(
    weightAdapter.swept_weight_gb,
    15.905366016,
    0.000000001,
    "Nemotron-Labs-Diffusion 8B AR-mode swept bytes",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.073741824,
    0.000000001,
    "Nemotron-Labs-Diffusion 8B input embedding bytes",
  );
  assert.match(
    weightAdapter.notes,
    /linear_spec_lora\/adapter_model\.safetensors/,
  );
  assert.match(result.warnings.join("\n"), /production bounds require audited/);
}

{
  const result = profiled("nvidia/Qwen3.6-35B-A3B-NVFP4", "nvidia-dgx-spark");
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    23.407580856,
    0.000000001,
    "Qwen DGX NVFP4 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    2.254637784,
    0.000000001,
    "Qwen DGX NVFP4 single-session decode traffic",
  );
  assertNear(result.single.aggregate, 103, 1, "Qwen DGX single");
  assert.equal(result.best.batch, 13);
  assertNear(result.best.aggregate, 275, 1, "Qwen DGX aggregate");
  assertNear(result.dennard, 10700, 100, "Qwen DGX Dennard");
  assertNear(
    result.alloc,
    1.08888064,
    0.000000001,
    "Qwen DGX FP8 KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.39256064,
    0.000000001,
    "Qwen DGX FP8 KV plus DeltaNet state read traffic",
  );
}

{
  const repo = "ykarout/Qwen3.6-35B-A3B-NVFP4";
  const item = profile(repo);
  const modelRow = model(repo);
  const weightAdapter = item.architecture.weight_adapter;
  const kvAdapter = item.architecture.kv_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  const gb300Result = profiled(
    repo,
    "nvidia-msi-xpertstation-ws300-dgx-station-gb300",
  );

  assert.equal(item.status, "audited");
  assert.equal(modelRow.hf_downloads, 202525);
  assert.equal(item.serving.weight_format, "nvfp4");
  assert.equal(item.serving.kv_store_format, "fp8");
  assert.equal(item.serving.kv_read_format, "fp8");
  assert.equal(weightAdapter.kind, "moe_distinct_experts_exact");
  assert.equal(kvAdapter.kind, "layered_kv");
  assert.equal(kvAdapter.components.length, 2);
  assertNear(
    result.resident,
    23.909370592,
    0.000000001,
    "ykarout Qwen3.6 NVFP4 resident footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    21.999109376,
    0.000000001,
    "ykarout Qwen3.6 NVFP4 ordinary text resident bytes",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.910261216,
    0.000000001,
    "ykarout Qwen3.6 NVFP4 resident-only visual/input bytes",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    3.879593216,
    0.000000001,
    "ykarout Qwen3.6 NVFP4 fixed ordinary text traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.07077936,
    0.000000001,
    "ykarout Qwen3.6 NVFP4 per-expert traffic",
  );
  assertNear(
    result.single.batchWeight,
    4.445828096,
    0.000000001,
    "ykarout Qwen3.6 NVFP4 single-session decode traffic",
  );
  assertNear(
    result.alloc,
    1.08888064,
    0.000000001,
    "ykarout Qwen3.6 NVFP4 FP8 KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.39256064,
    0.000000001,
    "ykarout Qwen3.6 NVFP4 FP8 KV plus DeltaNet state read traffic",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(result.bMem, 88);
  assertNear(
    result.single.aggregate,
    56.423742468,
    0.000001,
    "ykarout Qwen3.6 NVFP4 DGX Spark single-session throughput",
  );
  assert.equal(result.best.batch, 11);
  assertNear(
    result.best.aggregate,
    221.805215405,
    0.000001,
    "ykarout Qwen3.6 NVFP4 DGX Spark aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    20.164110491,
    0.000001,
    "ykarout Qwen3.6 NVFP4 DGX Spark per-session throughput",
  );
  assertNear(
    result.dennard,
    5418.895085656,
    0.000001,
    "ykarout Qwen3.6 NVFP4 DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 36);
  assertNear(
    m5Result.single.aggregate,
    126.901750459,
    0.000001,
    "ykarout Qwen3.6 NVFP4 M5 Max single-session throughput",
  );
  assertNear(
    m5Result.best.aggregate,
    728.221200356,
    0.000001,
    "ykarout Qwen3.6 NVFP4 M5 Max aggregate throughput",
  );
  assertNear(
    m5Result.dennard,
    12187.551584589,
    0.000001,
    "ykarout Qwen3.6 NVFP4 M5 Max Dennard bound",
  );
  assert.equal(gb300Result.status_code, "ok");
  assert.equal(gb300Result.bMem, 657);
  assert.equal(gb300Result.best.batch, 657);
  assertNear(
    gb300Result.best.aggregate,
    16664.913145437,
    0.000001,
    "ykarout Qwen3.6 NVFP4 GB300 aggregate throughput",
  );
}

{
  const repo = "lyf/Qwen3.6-35B-A3B-Uncensored-HauhauCS-Aggressive-NVFP4";
  const item = profile(repo);
  const modelRow = model(repo);
  const weightAdapter = item.architecture.weight_adapter;
  const kvAdapter = item.architecture.kv_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  const gb300Result = profiled(
    repo,
    "nvidia-msi-xpertstation-ws300-dgx-station-gb300",
  );

  assert.equal(item.status, "audited");
  assert.equal(modelRow.hf_downloads, 136193);
  assert.equal(modelRow.tags.includes("region:us"), true);
  assert.equal(modelRow.architecture.shared_experts_per_token, 1);
  assert.equal(item.serving.weight_format, "nvfp4");
  assert.equal(item.serving.kv_store_format, "fp8");
  assert.equal(item.serving.kv_read_format, "fp8");
  assert.equal(weightAdapter.kind, "moe_distinct_experts_exact");
  assert.equal(kvAdapter.kind, "layered_kv");
  assert.equal(kvAdapter.components.length, 2);
  assertNear(
    modelRow.architecture.total_params_b,
    35.1072,
    0.000000001,
    "lyf Qwen3.6 HauhauCS NVFP4 catalog logical resident params",
  );
  assertNear(
    modelRow.adapter.kv_alloc_gb_per_1k_tokens,
    0.01024,
    0.000000001,
    "lyf Qwen3.6 HauhauCS NVFP4 catalog FP8 full-attention K/V allocation",
  );
  assertNear(
    modelRow.adapter.kv_alloc_fixed_gb,
    0.06488064,
    0.000000001,
    "lyf Qwen3.6 HauhauCS NVFP4 catalog DeltaNet allocation",
  );
  assertNear(
    result.resident,
    23.336710112,
    0.000000001,
    "lyf Qwen3.6 HauhauCS NVFP4 resident footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    21.426448896,
    0.000000001,
    "lyf Qwen3.6 HauhauCS NVFP4 ordinary text resident bytes",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.910261216,
    0.000000001,
    "lyf Qwen3.6 HauhauCS NVFP4 resident-only visual/input bytes",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    3.306809856,
    0.000000001,
    "lyf Qwen3.6 HauhauCS NVFP4 fixed ordinary text traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.07077984,
    0.000000001,
    "lyf Qwen3.6 HauhauCS NVFP4 per-expert traffic",
  );
  assertNear(
    result.single.batchWeight,
    3.873048576,
    0.000000001,
    "lyf Qwen3.6 HauhauCS NVFP4 single-session decode traffic",
  );
  assertNear(
    result.alloc,
    1.08888064,
    0.000000001,
    "lyf Qwen3.6 HauhauCS NVFP4 FP8 KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.39256064,
    0.000000001,
    "lyf Qwen3.6 HauhauCS NVFP4 FP8 KV plus DeltaNet state read traffic",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(result.bMem, 88);
  assert.equal(result.best.batch, 11);
  assertNear(
    result.single.aggregate,
    64.000236819,
    0.000001,
    "lyf Qwen3.6 HauhauCS NVFP4 DGX Spark single-session throughput",
  );
  assertNear(
    result.best.aggregate,
    231.602897358,
    0.000001,
    "lyf Qwen3.6 HauhauCS NVFP4 DGX Spark aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    21.054808851,
    0.000001,
    "lyf Qwen3.6 HauhauCS NVFP4 DGX Spark per-session throughput",
  );
  assertNear(
    result.dennard,
    6257.357943331,
    0.000001,
    "lyf Qwen3.6 HauhauCS NVFP4 DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 37);
  assertNear(
    m5Result.single.aggregate,
    143.941924567,
    0.000001,
    "lyf Qwen3.6 HauhauCS NVFP4 M5 Max single-session throughput",
  );
  assertNear(
    m5Result.best.aggregate,
    748.439189102,
    0.000001,
    "lyf Qwen3.6 HauhauCS NVFP4 M5 Max aggregate throughput",
  );
  assertNear(
    m5Result.dennard,
    14073.325191228,
    0.000001,
    "lyf Qwen3.6 HauhauCS NVFP4 M5 Max Dennard bound",
  );
  assert.equal(gb300Result.status_code, "ok");
  assert.equal(gb300Result.bMem, 658);
  assert.equal(gb300Result.best.batch, 658);
  assertNear(
    gb300Result.best.aggregate,
    16701.024036057,
    0.000001,
    "lyf Qwen3.6 HauhauCS NVFP4 GB300 aggregate throughput",
  );
}

{
  const repo = "unsloth/Qwen3.6-35B-A3B-NVFP4";
  const item = profile(repo);
  const modelRow = model(repo);
  const weightAdapter = item.architecture.weight_adapter;
  const kvAdapter = item.architecture.kv_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");

  assert.equal(item.status, "audited");
  assert.equal(modelRow.hf_downloads, 184698);
  assert.equal(modelRow.tags.includes("region:us"), true);
  assert.equal(modelRow.architecture.shared_experts_per_token, 1);
  assert.equal(item.serving.weight_format, "nvfp4");
  assert.equal(item.serving.kv_store_format, "bf16");
  assert.equal(item.serving.kv_read_format, "bf16");
  assert.equal(weightAdapter.kind, "moe_distinct_experts_exact");
  assert.equal(kvAdapter.kind, "layered_kv");
  assert.equal(kvAdapter.components.length, 2);
  assertNear(
    modelRow.adapter.kv_alloc_gb_per_1k_tokens,
    0.02048,
    0.000000001,
    "Unsloth Qwen3.6 NVFP4 catalog BF16 full-attention K/V allocation",
  );
  assertNear(
    modelRow.adapter.kv_alloc_fixed_gb,
    0.06488064,
    0.000000001,
    "Unsloth Qwen3.6 NVFP4 catalog DeltaNet allocation",
  );
  assertNear(
    result.resident,
    24.664233168,
    0.000000001,
    "Unsloth Qwen3.6 NVFP4 resident footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    21.064690416,
    0.000000001,
    "Unsloth Qwen3.6 NVFP4 ordinary text resident bytes",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    3.599542752,
    0.000000001,
    "Unsloth Qwen3.6 NVFP4 resident-only visual/MTP/input bytes",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    2.945051376,
    0.000000001,
    "Unsloth Qwen3.6 NVFP4 fixed ordinary text traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.07077984,
    0.000000001,
    "Unsloth Qwen3.6 NVFP4 per-expert traffic",
  );
  assertNear(
    result.single.batchWeight,
    3.511290096,
    0.000000001,
    "Unsloth Qwen3.6 NVFP4 single-session decode traffic",
  );
  assertNear(
    result.alloc,
    2.11288064,
    0.000000001,
    "Unsloth Qwen3.6 NVFP4 BF16 KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.72024064,
    0.000000001,
    "Unsloth Qwen3.6 NVFP4 BF16 KV plus DeltaNet state read traffic",
  );
  assert.equal(result.status_code, "ok");
}

{
  const modelProfile = profile("AEON-7/Qwen3.6-35B-A3B-heretic-NVFP4");
  const weightAdapter = modelProfile.architecture.weight_adapter;
  assert.equal(modelProfile.status, "audited");
  assert.equal(weightAdapter.kind, "moe_distinct_experts_exact");
  assert.equal(modelProfile.serving.kv_store_format, "bf16");
  assert.equal(modelProfile.serving.kv_read_format, "bf16");
  assertNear(
    weightAdapter.main_resident_weight_gb,
    21.426448896,
    0.000000001,
    "AEON Qwen3.6 Heretic NVFP4 ordinary text resident bytes",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.910261216,
    0.000000001,
    "AEON Qwen3.6 Heretic NVFP4 resident-only embed plus vision bytes",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    3.306809856,
    0.000000001,
    "AEON Qwen3.6 Heretic NVFP4 fixed ordinary text traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.07077984,
    0.000000001,
    "AEON Qwen3.6 Heretic NVFP4 per-expert traffic",
  );

  const result = profiled(
    "AEON-7/Qwen3.6-35B-A3B-heretic-NVFP4",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    23.336710112,
    0.000000001,
    "AEON Qwen3.6 Heretic NVFP4 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    3.873048576,
    0.000000001,
    "AEON Qwen3.6 Heretic NVFP4 single-session decode traffic",
  );
  assertNear(
    result.alloc,
    2.11288064,
    0.000000001,
    "AEON Qwen3.6 Heretic NVFP4 BF16 KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.72024064,
    0.000000001,
    "AEON Qwen3.6 Heretic NVFP4 BF16 KV plus DeltaNet state read traffic",
  );
  assertNear(
    result.single.aggregate,
    59.4,
    0.1,
    "AEON Qwen3.6 Heretic DGX single",
  );
  assert.equal(result.best.batch, 8);
  assertNear(
    result.best.aggregate,
    166.3,
    0.1,
    "AEON Qwen3.6 Heretic DGX aggregate",
  );
  assertNear(result.dennard, 3224.8, 0.1, "AEON Qwen3.6 Heretic DGX Dennard");
}

{
  const result = profiled("nvidia/Gemma-4-26B-A4B-NVFP4", "nvidia-dgx-spark");
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    18.782360732,
    0.000000001,
    "Gemma DGX NVFP4 resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    5.5932167,
    0.000000001,
    "Gemma DGX NVFP4 exact active traffic",
  );
  assertNear(
    result.alloc,
    0.3608576,
    0.000000001,
    "Gemma DGX NVFP4 FP8 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.1867776,
    0.000000001,
    "Gemma DGX NVFP4 FP8 KV read traffic",
  );
  assertNear(result.single.aggregate, 48, 1, "Gemma DGX single");
  assert.equal(result.best.batch, 11);
  assertNear(
    result.best.aggregate,
    224.52408936670525,
    0.000000001,
    "Gemma DGX aggregate",
  );
  assertNear(
    result.dennard,
    13690.564285893495,
    0.000000001,
    "Gemma DGX Dennard",
  );
}

{
  const result = profiled(
    "RedHatAI/gemma-4-26B-A4B-it-NVFP4",
    "nvidia-dgx-spark",
  );
  const item = profile("RedHatAI/gemma-4-26B-A4B-it-NVFP4");
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    16.417035012,
    0.000000001,
    "RedHatAI Gemma 4 NVFP4 resident package",
  );
  assertNear(
    result.single.batchWeight,
    3.22789098,
    0.000000001,
    "RedHatAI Gemma 4 NVFP4 single-session decode traffic",
  );
  assertNear(
    item.architecture.weight_adapter.fixed_weight_gb,
    2.4249873,
    0.000000001,
    "RedHatAI Gemma 4 NVFP4 fixed text traffic",
  );
  assertNear(
    item.architecture.weight_adapter.routed_expert_weight_gb,
    0.10036296,
    0.000000001,
    "RedHatAI Gemma 4 NVFP4 routed expert group",
  );
  assertNear(
    item.architecture.weight_adapter.auxiliary_resident_weight_gb,
    1.145588832,
    0.000000001,
    "RedHatAI Gemma 4 NVFP4 resident vision package",
  );
  assertNear(
    result.alloc,
    0.7217152,
    0.000000001,
    "RedHatAI Gemma 4 NVFP4 BF16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.3735552,
    0.000000001,
    "RedHatAI Gemma 4 NVFP4 BF16 KV read traffic",
  );
  assert.equal(result.bMem, 143);
  assertNear(
    result.single.aggregate,
    75.80288205223158,
    0.0001,
    "RedHatAI Gemma 4 DGX single",
  );
  assert.equal(result.best.batch, 11);
  assertNear(
    result.best.aggregate,
    229.86509065026783,
    0.000001,
    "RedHatAI Gemma 4 DGX aggregate",
  );
  assertNear(
    result.best.perSession,
    20.89682642275162,
    0.000001,
    "RedHatAI Gemma 4 DGX per-session",
  );
  assertNear(
    result.dennard,
    12138.535001620381,
    0.00001,
    "RedHatAI Gemma 4 DGX Dennard",
  );
}

{
  const catalog = model("LargitData/gemma-4-26b-a4b-it-fp8");
  const item = profile("LargitData/gemma-4-26b-a4b-it-fp8");
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(
    "LargitData/gemma-4-26b-a4b-it-fp8",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "LargitData/gemma-4-26b-a4b-it-fp8",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(catalog.hf_downloads, 150515);
  assert.equal(catalog.architecture.routed_experts_per_token, 8);
  assert.equal(catalog.architecture.shared_experts_per_token, 1);
  assertNear(
    catalog.adapter.kv_alloc_gb_per_1k_tokens,
    0.10496,
    0.000000001,
    "LargitData Gemma 4 FP8 catalog should expose FP8 first-1K KV",
  );
  assert.equal(item.serving.kv_store_format, "fp8");
  assert.equal(item.serving.kv_read_format, "fp8");
  assertNear(
    weightAdapter.resident_weight_gb,
    27.161975452,
    0.000000001,
    "LargitData Gemma 4 FP8 resident package",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.145588832,
    0.000000001,
    "LargitData Gemma 4 FP8 resident vision package",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    3.14596102,
    0.000000001,
    "LargitData Gemma 4 FP8 fixed ordinary text traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.1786752,
    0.000000001,
    "LargitData Gemma 4 FP8 routed expert group",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.single.batchWeight,
    4.57536262,
    0.000000001,
    "LargitData Gemma 4 FP8 single-session decode traffic",
  );
  assertNear(
    result.alloc,
    0.3608576,
    0.000000001,
    "LargitData Gemma 4 FP8 FP8 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.1867776,
    0.000000001,
    "LargitData Gemma 4 FP8 FP8 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    57.32716538951472,
    0.000000001,
    "LargitData Gemma 4 FP8 DGX single-session throughput",
  );
  assert.equal(result.best.batch, 7);
  assertNear(
    result.best.aggregate,
    149.68528178854265,
    0.000000001,
    "LargitData Gemma 4 FP8 DGX aggregate throughput at b*",
  );
  assertNear(
    result.best.perSession,
    21.383611684077522,
    0.000000001,
    "LargitData Gemma 4 FP8 DGX per-session throughput at b*",
  );
  assertNear(
    result.dennard,
    15350.66385330092,
    0.000000001,
    "LargitData Gemma 4 FP8 DGX Dennard bound",
  );
  assert.equal(m5Result.best.batch, 36);
  assertNear(
    m5Result.best.aggregate,
    724.7113185201279,
    0.000000001,
    "LargitData Gemma 4 FP8 M5 Max aggregate throughput at b*",
  );
}

{
  const catalog = model("MaziyarPanahi/Mixtral-8x22B-v0.1-GGUF");
  const item = profile("MaziyarPanahi/Mixtral-8x22B-v0.1-GGUF");
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(
    "MaziyarPanahi/Mixtral-8x22B-v0.1-GGUF",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "MaziyarPanahi/Mixtral-8x22B-v0.1-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(catalog.hf_downloads, 131580);
  assert.equal(catalog.adapter.weight_precision, "GGUF IQ1_M");
  assertNear(
    catalog.adapter.active_weight_gb,
    10.00845312,
    0.000000001,
    "MaziyarPanahi Mixtral IQ1_M catalog active traffic",
  );
  assert.equal(
    item.serving.runtime_format,
    "llama.cpp-gguf-iq1-m-moe-memory-bound",
  );
  assert.equal(item.architecture.kv_adapter.kind, "full_context");
  assertNear(
    weightAdapter.resident_weight_gb,
    32.732397728,
    0.000000001,
    "MaziyarPanahi Mixtral IQ1_M resident file footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    32.667131904,
    0.000000001,
    "MaziyarPanahi Mixtral IQ1_M swept tensor footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.065265824,
    0.000000001,
    "MaziyarPanahi Mixtral IQ1_M resident token/header bytes",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    2.455560192,
    0.000000001,
    "MaziyarPanahi Mixtral IQ1_M fixed ordinary text traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    3.776446464,
    0.000000001,
    "MaziyarPanahi Mixtral IQ1_M routed expert group",
  );
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.single.batchWeight,
    10.00845312,
    0.000000001,
    "MaziyarPanahi Mixtral IQ1_M single-session decode traffic",
  );
  assertNear(
    result.alloc,
    22.9376,
    0.000000001,
    "MaziyarPanahi Mixtral IQ1_M FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    7.340032,
    0.000000001,
    "MaziyarPanahi Mixtral IQ1_M FP16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    15.736244295202185,
    0.000000001,
    "MaziyarPanahi Mixtral IQ1_M DGX single-session throughput",
  );
  assert.equal(result.bMem, 3);
  assert.equal(result.best, null);
  assertNear(
    result.dennard,
    103.77691506294462,
    0.000000001,
    "MaziyarPanahi Mixtral IQ1_M DGX Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 2);
  assertNear(
    m5Result.best.aggregate,
    40.45703693138038,
    0.000000001,
    "MaziyarPanahi Mixtral IQ1_M M5 Max aggregate throughput at b*",
  );
  assertNear(
    m5Result.best.perSession,
    20.22851846569019,
    0.000000001,
    "MaziyarPanahi Mixtral IQ1_M M5 Max per-session throughput at b*",
  );
}

{
  const result = profiled(
    "unsloth/gemma-4-26B-A4B-it-GGUF",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    16.551046944,
    0.000000001,
    "Unsloth Gemma 4 MXFP4_MOE GGUF resident file footprint",
  );
  assertNear(
    result.single.batchWeight,
    3.450961856,
    0.000000001,
    "Unsloth Gemma 4 MXFP4_MOE GGUF single-session decode traffic",
  );
  assertNear(
    result.alloc,
    0.7217152,
    0.000000001,
    "Unsloth Gemma 4 layered FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.3735552,
    0.000000001,
    "Unsloth Gemma 4 layered FP16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    71.38156164625038,
    0.000000001,
    "Unsloth Gemma 4 DGX single",
  );
  assert.equal(result.best.batch, 10);
  assertNear(
    result.best.aggregate,
    210.79259284362638,
    0.000000001,
    "Unsloth Gemma 4 DGX aggregate",
  );
  assertNear(
    result.dennard,
    11339.20836487981,
    0.000000001,
    "Unsloth Gemma 4 DGX Dennard",
  );
}

{
  const repo = "bartowski/google_gemma-4-26B-A4B-it-GGUF";
  const catalogRow = model(repo);
  const item = profile(repo);
  const weightAdapter = item.architecture.weight_adapter;
  const kvAdapter = item.architecture.kv_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  const m1Result = profiled(repo, "apple-mac-studio-m1-ultra-128gb");

  assert.equal(catalogRow.hf_downloads, 106081);
  assert.equal(catalogRow.tags.includes("region:us"), true);
  assert.equal(catalogRow.architecture.total_params_b, 25.233142046);
  assert.equal(catalogRow.architecture.routed_experts_per_token, 8);
  assert.equal(catalogRow.architecture.shared_experts_per_token, 1);
  assertNear(
    catalogRow.adapter.active_weight_gb,
    2.04619712,
    0.000000001,
    "Bartowski Gemma 4 IQ2_M catalog active text-decode traffic",
  );
  assert.equal(item.status, "audited");
  assert.equal(item.model_family, "gemma4-moe");
  assert.equal(item.base_model_proof.config_compatible, true);
  assert.equal(
    item.serving.runtime_format,
    "llama.cpp-gguf-iq2-m-moe-memory-bound",
  );
  assertNear(
    weightAdapter.resident_weight_gb,
    10.700620704,
    0.000000001,
    "Bartowski Gemma 4 IQ2_M resident file footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    10.6847984,
    0.000000001,
    "Bartowski Gemma 4 IQ2_M tensor spans",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.015822304,
    0.000000001,
    "Bartowski Gemma 4 IQ2_M metadata/header overhead",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    1.470290368,
    0.000000001,
    "Bartowski Gemma 4 IQ2_M fixed text traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.071988344,
    0.000000001,
    "Bartowski Gemma 4 IQ2_M routed expert group",
  );
  assert.equal(weightAdapter.routed_experts, 128);
  assert.equal(weightAdapter.routed_experts_per_token, 8);
  assert.equal(weightAdapter.shared_experts_per_token, 1);
  assert.equal(kvAdapter.kind, "layered_kv");
  assert.equal(kvAdapter.components.length, 2);
  assert.equal(kvAdapter.components[0].kind, "full_context");
  assert.equal(kvAdapter.components[0].layers, 5);
  assert.equal(kvAdapter.components[0].kv_heads, 2);
  assert.equal(kvAdapter.components[0].kv_scalar_multiplier, 1);
  assert.equal(kvAdapter.components[1].kind, "sliding_window");
  assert.equal(kvAdapter.components[1].layers, 25);
  assert.equal(kvAdapter.components[1].kv_heads, 8);
  assert.equal(kvAdapter.components[1].window_tokens, 1024);
  assert.equal(kvAdapter.components[1].kv_scalar_multiplier, 2);
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    10.700620704,
    0.000000001,
    "Bartowski Gemma 4 IQ2_M DGX resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    2.04619712,
    0.000000001,
    "Bartowski Gemma 4 IQ2_M DGX single-token active text-decode traffic",
  );
  assertNear(
    result.alloc,
    0.7217152,
    0.000000001,
    "Bartowski Gemma 4 IQ2_M layered FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.3735552,
    0.000000001,
    "Bartowski Gemma 4 IQ2_M layered FP16 KV read traffic",
  );
  assert.equal(result.bMem, 151);
  assert.equal(result.best.batch, 16);
  assertNear(
    result.single.aggregate,
    112.82146430590055,
    0.000000001,
    "Bartowski Gemma 4 IQ2_M DGX single-session throughput",
  );
  assertNear(
    result.best.aggregate,
    326.44193910166183,
    0.000000001,
    "Bartowski Gemma 4 IQ2_M DGX aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    20.402621193853864,
    0.000000001,
    "Bartowski Gemma 4 IQ2_M DGX per-session throughput",
  );
  assertNear(
    result.dennard,
    20205.379952633684,
    0.000000001,
    "Bartowski Gemma 4 IQ2_M DGX Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 54);
  assertNear(
    m5Result.best.aggregate,
    1084.438691190993,
    0.000000001,
    "Bartowski Gemma 4 IQ2_M M5 Max aggregate throughput",
  );
  assertNear(
    m5Result.best.perSession,
    20.08219798501839,
    0.000000001,
    "Bartowski Gemma 4 IQ2_M M5 Max per-session throughput",
  );
  assert.equal(m1Result.status_code, "ok");
  assert.equal(m1Result.best.batch, 78);
  assertNear(
    m1Result.best.aggregate,
    1569.3338925587154,
    0.000000001,
    "Bartowski Gemma 4 IQ2_M M1 Ultra aggregate throughput",
  );
  assertNear(
    m1Result.best.perSession,
    20.1196652892143,
    0.000000001,
    "Bartowski Gemma 4 IQ2_M M1 Ultra per-session throughput",
  );
}

{
  const repo = "Jiunsong/supergemma4-26b-uncensored-gguf-v2";
  const catalogRow = model(repo);
  const item = profile(repo);
  const weightAdapter = item.architecture.weight_adapter;
  const kvAdapter = item.architecture.kv_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  const m1Result = profiled(repo, "apple-mac-studio-m1-ultra-128gb");

  assert.equal(catalogRow.hf_downloads, 104781);
  assert.equal(catalogRow.tags.includes("region:us"), true);
  assert.equal(catalogRow.architecture.total_params_b, 25.233142046);
  assert.equal(catalogRow.architecture.routed_experts_per_token, 8);
  assert.equal(catalogRow.architecture.shared_experts_per_token, 1);
  assertNear(
    catalogRow.adapter.active_weight_gb,
    2.595649408,
    0.000000001,
    "Jiunsong SuperGemma4 Q4_K_M catalog active text-decode traffic",
  );
  assert.equal(item.status, "audited");
  assert.equal(item.model_family, "gemma4-moe");
  assert.equal(item.base_model_proof.config_compatible, true);
  assert.equal(
    item.serving.runtime_format,
    "llama.cpp-gguf-q4-k-m-moe-memory-bound",
  );
  assertNear(
    weightAdapter.resident_weight_gb,
    16.796015232,
    0.000000001,
    "Jiunsong SuperGemma4 Q4_K_M resident file footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    16.780193728,
    0.000000001,
    "Jiunsong SuperGemma4 Q4_K_M tensor spans",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.015821504,
    0.000000001,
    "Jiunsong SuperGemma4 Q4_K_M metadata/header overhead",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    1.65001312,
    0.000000001,
    "Jiunsong SuperGemma4 Q4_K_M fixed text traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.118204536,
    0.000000001,
    "Jiunsong SuperGemma4 Q4_K_M routed expert group",
  );
  assert.equal(weightAdapter.routed_experts, 128);
  assert.equal(weightAdapter.routed_experts_per_token, 8);
  assert.equal(weightAdapter.shared_experts_per_token, 1);
  assert.equal(kvAdapter.kind, "layered_kv");
  assert.equal(kvAdapter.components.length, 2);
  assert.equal(kvAdapter.components[0].kind, "full_context");
  assert.equal(kvAdapter.components[0].layers, 5);
  assert.equal(kvAdapter.components[0].kv_heads, 2);
  assert.equal(kvAdapter.components[0].kv_scalar_multiplier, 1);
  assert.equal(kvAdapter.components[1].kind, "sliding_window");
  assert.equal(kvAdapter.components[1].layers, 25);
  assert.equal(kvAdapter.components[1].kv_heads, 8);
  assert.equal(kvAdapter.components[1].window_tokens, 1024);
  assert.equal(kvAdapter.components[1].kv_scalar_multiplier, 2);
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    16.796015232,
    0.000000001,
    "Jiunsong SuperGemma4 Q4_K_M DGX resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    2.595649408,
    0.000000001,
    "Jiunsong SuperGemma4 Q4_K_M DGX single-token active text-decode traffic",
  );
  assertNear(
    result.alloc,
    0.7217152,
    0.000000001,
    "Jiunsong SuperGemma4 Q4_K_M layered FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.3735552,
    0.000000001,
    "Jiunsong SuperGemma4 Q4_K_M layered FP16 KV read traffic",
  );
  assert.equal(result.bMem, 142);
  assert.equal(result.best.batch, 11);
  assertNear(
    result.single.aggregate,
    91.94381527781867,
    0.000000001,
    "Jiunsong SuperGemma4 Q4_K_M DGX single-session throughput",
  );
  assertNear(
    result.best.aggregate,
    223.27024540876283,
    0.000000001,
    "Jiunsong SuperGemma4 Q4_K_M DGX aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    20.297295037160257,
    0.000000001,
    "Jiunsong SuperGemma4 Q4_K_M DGX per-session throughput",
  );
  assertNear(
    result.dennard,
    15039.9789582251,
    0.000000001,
    "Jiunsong SuperGemma4 Q4_K_M DGX Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 40);
  assertNear(
    m5Result.best.aggregate,
    803.1999133617825,
    0.000000001,
    "Jiunsong SuperGemma4 Q4_K_M M5 Max aggregate throughput",
  );
  assertNear(
    m5Result.best.perSession,
    20.079997834044562,
    0.000000001,
    "Jiunsong SuperGemma4 Q4_K_M M5 Max per-session throughput",
  );
  assert.equal(m1Result.status_code, "ok");
  assert.equal(m1Result.best.batch, 62);
  assertNear(
    m1Result.best.aggregate,
    1250.507966425548,
    0.000000001,
    "Jiunsong SuperGemma4 Q4_K_M M1 Ultra aggregate throughput",
  );
  assertNear(
    m1Result.best.perSession,
    20.169483329444322,
    0.000000001,
    "Jiunsong SuperGemma4 Q4_K_M M1 Ultra per-session throughput",
  );
}

{
  const item = profile("ggml-org/gemma-4-26B-A4B-it-GGUF");
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(
    "ggml-org/gemma-4-26B-A4B-it-GGUF",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "ggml-org/gemma-4-26B-A4B-it-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  const m1Result = profiled(
    "ggml-org/gemma-4-26B-A4B-it-GGUF",
    "apple-mac-studio-m1-ultra-128gb",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(
    item.serving.runtime_format,
    "llama.cpp-gguf-bf16-moe-memory-bound",
  );
  assertNear(
    result.resident,
    50.505134624,
    0.000000001,
    "ggml-org Gemma 4 BF16 GGUF resident file footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    50.489312376,
    0.000000001,
    "ggml-org Gemma 4 BF16 GGUF tensor spans",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.015822248,
    0.000000001,
    "ggml-org Gemma 4 BF16 GGUF metadata/header overhead",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    4.813341816,
    0.000000001,
    "ggml-org Gemma 4 BF16 GGUF fixed text traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.35684352,
    0.000000001,
    "ggml-org Gemma 4 BF16 GGUF routed expert group",
  );
  assertNear(
    result.single.batchWeight,
    7.668089976,
    0.000000001,
    "ggml-org Gemma 4 BF16 GGUF single-session decode traffic",
  );
  assertNear(
    result.alloc,
    0.7217152,
    0.000000001,
    "ggml-org Gemma 4 layered FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.3735552,
    0.000000001,
    "ggml-org Gemma 4 layered FP16 KV read traffic",
  );
  assert.equal(result.bMem, 96);
  assertNear(
    result.single.aggregate,
    33.94827725236605,
    0.000000001,
    "ggml-org Gemma 4 DGX single",
  );
  assert.equal(result.best.batch, 2);
  assertNear(
    result.best.aggregate,
    49.22676661444323,
    0.000000001,
    "ggml-org Gemma 4 DGX aggregate",
  );
  assertNear(
    result.best.perSession,
    24.613383307221614,
    0.000000001,
    "ggml-org Gemma 4 DGX per-session",
  );
  assertNear(
    result.dennard,
    3428.169705612102,
    0.000000001,
    "ggml-org Gemma 4 DGX Dennard",
  );
  assert.equal(m5Result.best.batch, 10);
  assertNear(
    m5Result.best.aggregate,
    202.84362206933184,
    0.000000001,
    "ggml-org Gemma 4 M5 Max aggregate",
  );
  assertNear(
    m5Result.best.perSession,
    20.284362206933185,
    0.000000001,
    "ggml-org Gemma 4 M5 Max per-session",
  );
  assert.equal(m1Result.best.batch, 15);
  assertNear(
    m1Result.best.aggregate,
    309.7226579685134,
    0.000000001,
    "ggml-org Gemma 4 M1 Ultra aggregate",
  );
  assertNear(
    m1Result.best.perSession,
    20.648177197900893,
    0.000000001,
    "ggml-org Gemma 4 M1 Ultra per-session",
  );
}

{
  const repo = "ReadyArt/Melody1437-26B-A4B-v2.0-GGUF";
  const catalogRow = model(repo);
  const item = profile(repo);
  const weightAdapter = item.architecture.weight_adapter;
  const kvAdapter = item.architecture.kv_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");

  assert.equal(catalogRow.hf_downloads, 156079);
  assert.equal(catalogRow.tags.includes("region:us"), true);
  assert.equal(catalogRow.architecture.type, "MoE transformer");
  assertNear(
    catalogRow.adapter.active_weight_gb,
    3.466505336,
    0.000000001,
    "ReadyArt Melody1437 catalog active text-decode traffic",
  );
  assert.equal(item.status, "audited");
  assert.equal(item.model_family, "gemma4-moe");
  assert.equal(item.base_model_proof.config_compatible, false);
  assert.equal(
    item.serving.runtime_format,
    "llama.cpp-gguf-hb16-q4-k-m-moe-memory-bound",
  );
  assertNear(
    weightAdapter.resident_weight_gb,
    17.666858464,
    0.000000001,
    "ReadyArt Melody1437 HB16 Q4_K_M resident file footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    17.651035256,
    0.000000001,
    "ReadyArt Melody1437 HB16 Q4_K_M tensor spans",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.015823208,
    0.000000001,
    "ReadyArt Melody1437 HB16 Q4_K_M metadata/header overhead",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    2.520870008,
    0.000000001,
    "ReadyArt Melody1437 HB16 Q4_K_M fixed text traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.118204416,
    0.000000001,
    "ReadyArt Melody1437 HB16 Q4_K_M routed expert group",
  );
  assert.equal(weightAdapter.routed_experts, 128);
  assert.equal(weightAdapter.routed_experts_per_token, 8);
  assert.equal(weightAdapter.shared_experts_per_token, 1);
  assert.equal(kvAdapter.kind, "layered_kv");
  assert.equal(kvAdapter.components.length, 2);
  assert.equal(kvAdapter.components[0].kind, "full_context");
  assert.equal(kvAdapter.components[0].layers, 5);
  assert.equal(kvAdapter.components[0].kv_heads, 2);
  assert.equal(kvAdapter.components[0].kv_scalar_multiplier, 1);
  assert.equal(kvAdapter.components[1].kind, "sliding_window");
  assert.equal(kvAdapter.components[1].layers, 25);
  assert.equal(kvAdapter.components[1].kv_heads, 8);
  assert.equal(kvAdapter.components[1].window_tokens, 1024);
  assert.equal(kvAdapter.components[1].kv_scalar_multiplier, 2);
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    17.666858464,
    0.000000001,
    "ReadyArt Melody1437 DGX resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    3.466505336,
    0.000000001,
    "ReadyArt Melody1437 DGX single-token active text-decode traffic",
  );
  assertNear(
    result.alloc,
    0.7217152,
    0.000000001,
    "ReadyArt Melody1437 layered FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.3735552,
    0.000000001,
    "ReadyArt Melody1437 layered FP16 KV read traffic",
  );
  assert.equal(result.bMem, 141);
  assert.equal(result.best.batch, 10);
  assertNear(
    result.single.aggregate,
    71.09262925432174,
    0.000000001,
    "ReadyArt Melody1437 DGX single-session throughput",
  );
  assertNear(
    result.best.aggregate,
    202.95264725924986,
    0.000000001,
    "ReadyArt Melody1437 DGX aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    20.295264725924987,
    0.000000001,
    "ReadyArt Melody1437 DGX per-session throughput",
  );
  assertNear(
    result.dennard,
    11166.606922424593,
    0.000000001,
    "ReadyArt Melody1437 DGX Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 38);
  assertNear(
    m5Result.best.aggregate,
    763.888878567681,
    0.000000001,
    "ReadyArt Melody1437 M5 Max aggregate throughput",
  );
  assertNear(
    m5Result.best.perSession,
    20.102338909675815,
    0.000000001,
    "ReadyArt Melody1437 M5 Max per-session throughput",
  );
}

{
  const repo = "ReadyArt/Dark-Scarlett-v0.3-26B-A4B-GGUF";
  const catalogRow = model(repo);
  const item = profile(repo);
  const weightAdapter = item.architecture.weight_adapter;
  const kvAdapter = item.architecture.kv_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");

  assert.equal(catalogRow.hf_downloads, 144312);
  assert.equal(catalogRow.tags.includes("region:us"), true);
  assert.equal(catalogRow.architecture.type, "MoE transformer");
  assert.equal(catalogRow.architecture.routed_experts_per_token, 8);
  assert.equal(catalogRow.architecture.shared_experts_per_token, 1);
  assertNear(
    catalogRow.adapter.active_weight_gb,
    2.304475008,
    0.000000001,
    "ReadyArt Dark Scarlett catalog active text-decode traffic",
  );
  assert.equal(item.status, "audited");
  assert.equal(item.model_family, "gemma4-moe");
  assert.equal(item.base_model_proof.config_compatible, true);
  assert.equal(item.base_model_proof.relation, "finetune");
  assert.equal(
    item.serving.runtime_format,
    "llama.cpp-gguf-iq4-xs-moe-memory-bound",
  );
  assertNear(
    weightAdapter.resident_weight_gb,
    13.917726432,
    0.000000001,
    "ReadyArt Dark Scarlett i1-IQ4_XS resident file footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    13.901903808,
    0.000000001,
    "ReadyArt Dark Scarlett i1-IQ4_XS tensor spans",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.015822624,
    0.000000001,
    "ReadyArt Dark Scarlett i1-IQ4_XS metadata/header overhead",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    1.531313088,
    0.000000001,
    "ReadyArt Dark Scarlett i1-IQ4_XS fixed text traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.09664524,
    0.000000001,
    "ReadyArt Dark Scarlett i1-IQ4_XS routed expert group",
  );
  assert.equal(weightAdapter.routed_experts, 128);
  assert.equal(weightAdapter.routed_experts_per_token, 8);
  assert.equal(weightAdapter.shared_experts_per_token, 1);
  assert.equal(kvAdapter.kind, "layered_kv");
  assert.equal(kvAdapter.components.length, 2);
  assert.equal(kvAdapter.components[0].kind, "full_context");
  assert.equal(kvAdapter.components[0].layers, 5);
  assert.equal(kvAdapter.components[0].kv_heads, 2);
  assert.equal(kvAdapter.components[0].kv_scalar_multiplier, 1);
  assert.equal(kvAdapter.components[1].kind, "sliding_window");
  assert.equal(kvAdapter.components[1].layers, 25);
  assert.equal(kvAdapter.components[1].kv_heads, 8);
  assert.equal(kvAdapter.components[1].window_tokens, 1024);
  assert.equal(kvAdapter.components[1].kv_scalar_multiplier, 2);
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    13.917726432,
    0.000000001,
    "ReadyArt Dark Scarlett DGX resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    2.304475008,
    0.000000001,
    "ReadyArt Dark Scarlett DGX single-token active text-decode traffic",
  );
  assertNear(
    result.alloc,
    0.7217152,
    0.000000001,
    "ReadyArt Dark Scarlett layered FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.3735552,
    0.000000001,
    "ReadyArt Dark Scarlett layered FP16 KV read traffic",
  );
  assert.equal(result.bMem, 146);
  assert.equal(result.best.batch, 13);
  assertNear(
    result.single.aggregate,
    101.94059767678318,
    0.000000001,
    "ReadyArt Dark Scarlett DGX single-session throughput",
  );
  assertNear(
    result.best.aggregate,
    264.6084879227165,
    0.000000001,
    "ReadyArt Dark Scarlett DGX aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    20.354499070978193,
    0.000000001,
    "ReadyArt Dark Scarlett DGX per-session throughput",
  );
  assertNear(
    result.dennard,
    17412.759890047833,
    0.000000001,
    "ReadyArt Dark Scarlett DGX Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 46);
  assertNear(
    m5Result.best.aggregate,
    927.5530340207642,
    0.000000001,
    "ReadyArt Dark Scarlett M5 Max aggregate throughput",
  );
  assertNear(
    m5Result.best.perSession,
    20.164196391755745,
    0.000000001,
    "ReadyArt Dark Scarlett M5 Max per-session throughput",
  );
}

{
  const repo = "MaziyarPanahi/Meta-Llama-3.1-405B-Instruct-GGUF";
  const catalogRow = model(repo);
  const item = profile(repo);
  const weightAdapter = item.architecture.weight_adapter;
  const kvAdapter = item.architecture.kv_adapter;
  const dgxResult = profiled(repo, "nvidia-dgx-spark");
  const gb300Result = profiled(
    repo,
    "nvidia-msi-xpertstation-ws300-dgx-station-gb300",
  );

  assert.equal(catalogRow.hf_downloads, 108344);
  assert.equal(catalogRow.tags.includes("region:us"), true);
  assert.equal(catalogRow.architecture.type, "Dense transformer");
  assert.equal(catalogRow.architecture.layers, 126);
  assert.equal(catalogRow.architecture.attention_heads, 128);
  assert.equal(catalogRow.architecture.kv_heads, 16);
  assert.equal(catalogRow.architecture.head_dim, 128);
  assert.equal(catalogRow.architecture.max_context_tokens, 131072);
  assertNear(
    catalogRow.adapter.active_weight_gb,
    150.508109824,
    0.000000001,
    "MaziyarPanahi Llama 3.1 405B catalog swept text-decode traffic",
  );
  assert.equal(item.status, "audited");
  assert.equal(item.model_family, "llama31-dense");
  assert.equal(item.base_model_proof.config_compatible, false);
  assert.equal(item.base_model_proof.relation, "quantized");
  assert.equal(
    item.serving.runtime_format,
    "llama.cpp-gguf-q2-k-split-memory-bound",
  );
  assertNear(
    weightAdapter.resident_weight_gb,
    151.205502336,
    0.000000001,
    "MaziyarPanahi Llama 3.1 405B Q2_K split resident footprint",
  );
  assertNear(
    weightAdapter.swept_weight_gb,
    150.508109824,
    0.000000001,
    "MaziyarPanahi Llama 3.1 405B Q2_K split swept traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.697392512,
    0.000000001,
    "MaziyarPanahi Llama 3.1 405B Q2_K split resident-only token/header bytes",
  );
  assert.equal(kvAdapter.kind, "full_context");
  assert.equal(kvAdapter.layers, 126);
  assert.equal(kvAdapter.kv_heads, 16);
  assert.equal(kvAdapter.head_dim, 128);
  assert.equal(kvAdapter.kv_scalar_multiplier, 2);
  assert.equal(dgxResult.status_code, "resident_not_fit");
  assertNear(
    dgxResult.resident,
    151.205502336,
    0.000000001,
    "MaziyarPanahi Llama 3.1 405B DGX resident footprint",
  );
  assertNear(
    dgxResult.free,
    -31.205502335999995,
    0.000000001,
    "MaziyarPanahi Llama 3.1 405B DGX free memory",
  );
  assert.equal(dgxResult.bMem, 0);
  assertNear(
    dgxResult.single.batchWeight,
    150.508109824,
    0.000000001,
    "MaziyarPanahi Llama 3.1 405B DGX single swept traffic",
  );
  assertNear(
    dgxResult.alloc,
    103.2192,
    0.000000001,
    "MaziyarPanahi Llama 3.1 405B full-context FP16 KV allocation",
  );
  assertNear(
    dgxResult.single.readTraffic,
    33.030144,
    0.000000001,
    "MaziyarPanahi Llama 3.1 405B full-context FP16 KV read traffic",
  );
  assert.equal(gb300Result.status_code, "ok");
  assert.equal(gb300Result.bMem, 5);
  assert.equal(gb300Result.best.batch, 5);
  assertNear(
    gb300Result.single.aggregate,
    38.68403372088518,
    0.000000001,
    "MaziyarPanahi Llama 3.1 405B GB300 single-session throughput",
  );
  assertNear(
    gb300Result.best.aggregate,
    112.46319331473643,
    0.000000001,
    "MaziyarPanahi Llama 3.1 405B GB300 aggregate throughput",
  );
  assertNear(
    gb300Result.best.perSession,
    22.492638662947286,
    0.000000001,
    "MaziyarPanahi Llama 3.1 405B GB300 per-session throughput",
  );
  assertNear(
    gb300Result.dennard,
    269.09256670010353,
    0.000000001,
    "MaziyarPanahi Llama 3.1 405B GB300 Dennard bound",
  );
}

{
  const repo = "MaziyarPanahi/DeepSeek-V3-0324-GGUF";
  const catalogRow = model(repo);
  const item = profile(repo);
  const weightAdapter = item.architecture.weight_adapter;
  const kvAdapter = item.architecture.kv_adapter;
  const dgxResult = profiled(repo, "nvidia-dgx-spark");
  const gb300Result = profiled(
    repo,
    "nvidia-msi-xpertstation-ws300-dgx-station-gb300",
  );

  assert.equal(catalogRow.hf_downloads, 108352);
  assert.equal(catalogRow.tags.includes("region:us"), true);
  assert.equal(catalogRow.architecture.type, "MLA MoE transformer");
  assert.equal(catalogRow.architecture.layers, 61);
  assert.equal(catalogRow.architecture.routed_experts, 256);
  assert.equal(catalogRow.architecture.routed_experts_per_token, 8);
  assert.equal(catalogRow.architecture.shared_experts_per_token, 1);
  assert.equal(catalogRow.architecture.kv_lora_rank, 512);
  assert.equal(catalogRow.architecture.qk_rope_head_dim, 64);
  assertNear(
    catalogRow.adapter.active_weight_gb,
    9.204629504,
    0.000000001,
    "MaziyarPanahi DeepSeek V3 0324 catalog active text-decode traffic",
  );
  assert.equal(item.status, "audited");
  assert.equal(item.model_family, "deepseek-v3-moe");
  assert.equal(item.base_model_proof.config_compatible, true);
  assert.equal(item.base_model_proof.relation, "quantized");
  assert.equal(
    item.serving.runtime_format,
    "llama.cpp-gguf-iq1-m-deepseek-v3-absorb-mla-memory-bound",
  );
  assertNear(
    weightAdapter.resident_weight_gb,
    148.882857728,
    0.000000001,
    "MaziyarPanahi DeepSeek V3 0324 IQ1_M split resident footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    148.573487104,
    0.000000001,
    "MaziyarPanahi DeepSeek V3 0324 IQ1_M split main resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.309370624,
    0.000000001,
    "MaziyarPanahi DeepSeek V3 0324 IQ1_M split resident-only token/header bytes",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    4.708859904,
    0.000000001,
    "MaziyarPanahi DeepSeek V3 0324 IQ1_M split fixed traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.5619712,
    0.000000001,
    "MaziyarPanahi DeepSeek V3 0324 IQ1_M split routed expert group",
  );
  assert.equal(weightAdapter.routed_experts, 256);
  assert.equal(weightAdapter.routed_experts_per_token, 8);
  assert.equal(weightAdapter.shared_experts_per_token, 1);
  assert.equal(kvAdapter.kind, "compressed_state");
  assertNear(
    kvAdapter.alloc_formula.gb_per_1k_context_tokens,
    0.070272,
    0.000000001,
    "MaziyarPanahi DeepSeek V3 0324 IQ1_M absorb-MLA allocation coefficient",
  );
  assertNear(
    kvAdapter.read_formula.gb_per_1k_context_tokens,
    0.070272,
    0.000000001,
    "MaziyarPanahi DeepSeek V3 0324 IQ1_M absorb-MLA read coefficient",
  );
  assert.equal(dgxResult.status_code, "resident_not_fit");
  assertNear(
    dgxResult.resident,
    148.882857728,
    0.000000001,
    "MaziyarPanahi DeepSeek V3 0324 DGX resident footprint",
  );
  assertNear(
    dgxResult.free,
    -28.882857728000005,
    0.000000001,
    "MaziyarPanahi DeepSeek V3 0324 DGX free memory",
  );
  assert.equal(dgxResult.bMem, 0);
  assertNear(
    dgxResult.single.batchWeight,
    9.204629504,
    0.000000001,
    "MaziyarPanahi DeepSeek V3 0324 DGX single active text-decode traffic",
  );
  assertNear(
    dgxResult.alloc,
    7.0272,
    0.000000001,
    "MaziyarPanahi DeepSeek V3 0324 absorb-MLA allocation",
  );
  assertNear(
    dgxResult.single.readTraffic,
    2.248704,
    0.000000001,
    "MaziyarPanahi DeepSeek V3 0324 absorb-MLA read traffic",
  );
  assert.equal(gb300Result.status_code, "ok");
  assert.equal(gb300Result.bMem, 84);
  assert.equal(gb300Result.best.batch, 84);
  assertNear(
    gb300Result.single.aggregate,
    619.9068592144263,
    0.000000001,
    "MaziyarPanahi DeepSeek V3 0324 GB300 single-session throughput",
  );
  assertNear(
    gb300Result.best.aggregate,
    1821.2319118329963,
    0.000000001,
    "MaziyarPanahi DeepSeek V3 0324 GB300 aggregate throughput",
  );
  assertNear(
    gb300Result.best.perSession,
    21.681332283726146,
    0.000000001,
    "MaziyarPanahi DeepSeek V3 0324 GB300 per-session throughput",
  );
  assertNear(
    gb300Result.dennard,
    64884.84570358248,
    0.000000001,
    "MaziyarPanahi DeepSeek V3 0324 GB300 Dennard bound",
  );
}

{
  const repo = "ReadyArt/Serenity-26B-A4B-GGUF";
  const catalogRow = model(repo);
  const item = profile(repo);
  const weightAdapter = item.architecture.weight_adapter;
  const kvAdapter = item.architecture.kv_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  const m1Result = profiled(repo, "apple-mac-studio-m1-ultra-128gb");

  assert.equal(catalogRow.hf_downloads, 151391);
  assert.equal(catalogRow.tags.includes("region:us"), true);
  assert.equal(catalogRow.architecture.type, "MoE transformer");
  assertNear(
    catalogRow.adapter.active_weight_gb,
    4.201566656,
    0.000000001,
    "ReadyArt Serenity catalog active text-decode traffic",
  );
  assert.equal(item.status, "audited");
  assert.equal(item.model_family, "gemma4-moe");
  assert.equal(item.base_model_proof.config_compatible, false);
  assert.equal(
    item.serving.runtime_format,
    "llama.cpp-gguf-hb16-q6-k-moe-memory-bound",
  );
  assertNear(
    weightAdapter.resident_weight_gb,
    23.509242304,
    0.000000001,
    "ReadyArt Serenity HB16 Q6_K resident file footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    23.493419456,
    0.000000001,
    "ReadyArt Serenity HB16 Q6_K tensor spans",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.015822848,
    0.000000001,
    "ReadyArt Serenity HB16 Q6_K metadata/header overhead",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    2.915443136,
    0.000000001,
    "ReadyArt Serenity HB16 Q6_K fixed text traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.16076544,
    0.000000001,
    "ReadyArt Serenity HB16 Q6_K routed expert group",
  );
  assert.equal(weightAdapter.routed_experts, 128);
  assert.equal(weightAdapter.routed_experts_per_token, 8);
  assert.equal(weightAdapter.shared_experts_per_token, 1);
  assert.equal(kvAdapter.kind, "layered_kv");
  assert.equal(kvAdapter.components.length, 2);
  assert.equal(kvAdapter.components[0].kind, "full_context");
  assert.equal(kvAdapter.components[0].layers, 5);
  assert.equal(kvAdapter.components[0].kv_heads, 2);
  assert.equal(kvAdapter.components[0].kv_scalar_multiplier, 1);
  assert.equal(kvAdapter.components[1].kind, "sliding_window");
  assert.equal(kvAdapter.components[1].layers, 25);
  assert.equal(kvAdapter.components[1].kv_heads, 8);
  assert.equal(kvAdapter.components[1].window_tokens, 1024);
  assert.equal(kvAdapter.components[1].kv_scalar_multiplier, 2);
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    23.509242304,
    0.000000001,
    "ReadyArt Serenity DGX resident footprint",
  );
  assertNear(
    result.single.batchWeight,
    4.201566656,
    0.000000001,
    "ReadyArt Serenity DGX single-token active text-decode traffic",
  );
  assertNear(
    result.alloc,
    0.7217152,
    0.000000001,
    "ReadyArt Serenity layered FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.3735552,
    0.000000001,
    "ReadyArt Serenity layered FP16 KV read traffic",
  );
  assert.equal(result.bMem, 133);
  assert.equal(result.best.batch, 7);
  assertNear(
    result.single.aggregate,
    59.67054181124744,
    0.000000001,
    "ReadyArt Serenity DGX single-session throughput",
  );
  assertNear(
    result.best.aggregate,
    146.88240323295605,
    0.000000001,
    "ReadyArt Serenity DGX aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    20.983200461850863,
    0.000000001,
    "ReadyArt Serenity DGX per-session throughput",
  );
  assertNear(
    result.dennard,
    8687.028651377164,
    0.000000001,
    "ReadyArt Serenity DGX Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 28);
  assertNear(
    m5Result.best.aggregate,
    562.2813351242876,
    0.000000001,
    "ReadyArt Serenity M5 Max aggregate throughput",
  );
  assertNear(
    m5Result.best.perSession,
    20.081476254438844,
    0.000000001,
    "ReadyArt Serenity M5 Max per-session throughput",
  );
  assert.equal(m1Result.status_code, "ok");
  assert.equal(m1Result.best.batch, 46);
  assertNear(
    m1Result.best.aggregate,
    928.8251602015171,
    0.000000001,
    "ReadyArt Serenity M1 Ultra aggregate throughput",
  );
  assertNear(
    m1Result.best.perSession,
    20.191851308728634,
    0.000000001,
    "ReadyArt Serenity M1 Ultra per-session throughput",
  );
}

{
  const item = profile("unsloth/gemma-4-26B-A4B-it-qat-GGUF");
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(
    "unsloth/gemma-4-26B-A4B-it-qat-GGUF",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    14.24904512,
    0.000000001,
    "Unsloth Gemma 4 QAT GGUF resident file footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    14.233223104,
    0.000000001,
    "Unsloth Gemma 4 QAT GGUF tensor spans",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.015822016,
    0.000000001,
    "Unsloth Gemma 4 QAT GGUF metadata/header overhead",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    1.386856384,
    0.000000001,
    "Unsloth Gemma 4 QAT GGUF fixed text traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.10036224,
    0.000000001,
    "Unsloth Gemma 4 QAT GGUF routed expert group",
  );
  assertNear(
    result.single.batchWeight,
    2.189754304,
    0.000000001,
    "Unsloth Gemma 4 QAT GGUF single-session decode traffic",
  );
  assertNear(
    result.alloc,
    0.7217152,
    0.000000001,
    "Unsloth Gemma 4 QAT layered FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.3735552,
    0.000000001,
    "Unsloth Gemma 4 QAT layered FP16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    106.5029406608871,
    0.000001,
    "Unsloth Gemma 4 QAT DGX single",
  );
  assert.equal(result.best.batch, 13);
  assertNear(
    result.best.aggregate,
    262.15128026361475,
    0.000001,
    "Unsloth Gemma 4 QAT DGX aggregate",
  );
  assertNear(
    result.best.perSession,
    20.165483097201136,
    0.000001,
    "Unsloth Gemma 4 QAT DGX per-session",
  );
  assertNear(
    result.dennard,
    18267.77710483906,
    0.000001,
    "Unsloth Gemma 4 QAT DGX Dennard",
  );
}

{
  const item = profile("unsloth/gemma-4-31B-it-qat-GGUF");
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled(
    "unsloth/gemma-4-31B-it-qat-GGUF",
    "nvidia-dgx-spark",
  );
  const m5Result = profiled(
    "unsloth/gemma-4-31B-it-qat-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "no_floor");
  assertNear(
    result.resident,
    17.287668064,
    0.000000001,
    "Unsloth Gemma 4 31B QAT GGUF resident file footprint",
  );
  assertNear(
    weightAdapter.swept_weight_gb,
    17.271834864,
    0.000000001,
    "Unsloth Gemma 4 31B QAT GGUF swept tensor spans",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.0158332,
    0.000000001,
    "Unsloth Gemma 4 31B QAT GGUF metadata/header overhead",
  );
  assertNear(
    result.single.batchWeight,
    17.271834864,
    0.000000001,
    "Unsloth Gemma 4 31B QAT GGUF single-session decode traffic",
  );
  assertNear(
    result.alloc,
    4.9348608,
    0.000000001,
    "Unsloth Gemma 4 31B QAT layered FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    2.1495808,
    0.000000001,
    "Unsloth Gemma 4 31B QAT layered FP16 KV read traffic",
  );
  assert.equal(result.bMem, 20);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    14.056647812035626,
    0.000000001,
    "Unsloth Gemma 4 31B QAT DGX single",
  );
  assertNear(
    result.dennard,
    328.98178487948337,
    0.000000001,
    "Unsloth Gemma 4 31B QAT DGX Dennard",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 6);
  assertNear(
    m5Result.best.aggregate,
    122.11080796747264,
    0.000000001,
    "Unsloth Gemma 4 31B QAT M5 aggregate",
  );
  assertNear(
    m5Result.best.perSession,
    20.351801327912106,
    0.000000001,
    "Unsloth Gemma 4 31B QAT M5 per-session",
  );
}

{
  const repo = "unsloth/gemma-3-270m-it-GGUF";
  const row = model(repo);
  const item = profile(repo);
  const [fullKv, slidingKv] = item.architecture.kv_adapter.components;
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  const m1Result = profiled(repo, "apple-mac-studio-m1-ultra-128gb");

  assert.equal(row.hf_downloads, 105716);
  assert.equal(row.license, "gemma");
  assert.ok(row.tags.includes("region:us"));
  assert.equal(row.adapter.weight_precision, "GGUF F16/F32");
  assert.equal(row.architecture.layers, 18);
  assert.equal(row.architecture.kv_heads, 1);
  assert.equal(row.architecture.head_dim, 256);
  assert.equal(row.architecture.max_context_tokens, 32768);
  assert.equal(item.status, "audited");
  assert.equal(item.serving.runtime_format, "llama.cpp-gguf-f16-memory-bound");
  assert.equal(item.architecture.kv_adapter.kind, "layered_kv");
  assert.equal(fullKv.layers, 3);
  assert.equal(fullKv.kv_heads, 1);
  assert.equal(fullKv.head_dim, 256);
  assert.equal(slidingKv.layers, 15);
  assert.equal(slidingKv.kv_heads, 1);
  assert.equal(slidingKv.head_dim, 256);
  assert.equal(slidingKv.window_tokens, 512);
  assertNear(
    row.adapter.kv_alloc_gb_per_1k_tokens,
    0.01093632,
    0.000000001,
    "Unsloth Gemma 3 270M GGUF legacy first-1K KV coefficient",
  );
  assertNear(
    row.adapter.kv_read_gb_per_1k_tokens,
    0.01093632,
    0.000000001,
    "Unsloth Gemma 3 270M GGUF legacy first-1K read coefficient",
  );
  assertNear(
    result.resident,
    0.542835488,
    0.000000001,
    "Unsloth Gemma 3 270M F16 GGUF resident file footprint",
  );
  assertNear(
    result.single.batchWeight,
    0.536308224,
    0.000000001,
    "Unsloth Gemma 3 270M F16 GGUF swept tensor traffic",
  );
  assertNear(
    item.architecture.weight_adapter.auxiliary_resident_weight_gb,
    0.006527264,
    0.000000001,
    "Unsloth Gemma 3 270M F16 GGUF resident-only overhead",
  );
  assertNear(
    result.alloc,
    0.31506432,
    0.000000001,
    "Unsloth Gemma 3 270M layered FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.10616832,
    0.000000001,
    "Unsloth Gemma 3 270M layered FP16 KV read traffic",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(result.bMem, 379);
  assert.equal(result.best.batch, 123);
  assertNear(
    result.single.aggregate,
    424.91823639245575,
    0.000000001,
    "Unsloth Gemma 3 270M DGX Spark single-session throughput",
  );
  assertNear(
    result.best.aggregate,
    2469.950083714471,
    0.000000001,
    "Unsloth Gemma 3 270M DGX Spark aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    20.080894989548543,
    0.000000001,
    "Unsloth Gemma 3 270M DGX Spark per-session throughput",
  );
  assertNear(
    result.dennard,
    193001.7152713321,
    0.000000001,
    "Unsloth Gemma 3 270M DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 284);
  assertNear(
    m5Result.best.aggregate,
    5682.200491553591,
    0.000000001,
    "Unsloth Gemma 3 270M M5 Max aggregate throughput",
  );
  assertNear(
    m5Result.best.perSession,
    20.00774820969574,
    0.000000001,
    "Unsloth Gemma 3 270M M5 Max per-session throughput",
  );
  assert.equal(m1Result.status_code, "ok");
  assert.equal(m1Result.best.batch, 371);
  assertNear(
    m1Result.best.aggregate,
    7433.984264056301,
    0.000000001,
    "Unsloth Gemma 3 270M M1 Ultra aggregate throughput",
  );
}

{
  const result = profiled(
    "Andycurrent/Gemma-3-1B-it-GLM-4.7-Flash-Heretic-Uncensored-Thinking_GGUF",
    "nvidia-dgx-spark",
  );
  assertNear(
    result.resident,
    2.006574688,
    0.000000001,
    "Andycurrent Gemma 3 1B F16 GGUF resident file footprint",
  );
  assertNear(
    result.single.batchWeight,
    2.000040448,
    0.000000001,
    "Andycurrent Gemma 3 1B F16 GGUF swept tensor traffic",
  );
  assertNear(
    result.alloc,
    0.421134336,
    0.000000001,
    "Andycurrent Gemma 3 1B layered FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.142606336,
    0.000000001,
    "Andycurrent Gemma 3 1B layered FP16 KV read traffic",
  );
}

{
  const repo = "MaziyarPanahi/gemma-3-1b-it-GGUF";
  const row = model(repo);
  const item = profile(repo);
  const [fullKv, slidingKv] = item.architecture.kv_adapter.components;
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");

  assert.equal(row.hf_downloads, 122255);
  assert.equal(row.license, "gemma");
  assert.ok(row.tags.includes("region:us"));
  assert.equal(row.adapter.weight_precision, "GGUF FP16");
  assert.equal(row.architecture.max_context_tokens, 32768);
  assert.equal(item.status, "audited");
  assert.equal(item.serving.runtime_format, "llama.cpp-gguf-f16-memory-bound");
  assert.equal(item.architecture.kv_adapter.kind, "layered_kv");
  assert.equal(fullKv.layers, 4);
  assert.equal(slidingKv.layers, 22);
  assert.equal(slidingKv.window_tokens, 512);
  assertNear(
    row.adapter.kv_alloc_gb_per_1k_tokens,
    0.015630336,
    0.000000001,
    "MaziyarPanahi Gemma 3 1B GGUF legacy first-1K KV coefficient",
  );
  assertNear(
    result.resident,
    2.0065736,
    0.000000001,
    "MaziyarPanahi Gemma 3 1B F16 GGUF resident file footprint",
  );
  assertNear(
    result.single.batchWeight,
    2.000040448,
    0.000000001,
    "MaziyarPanahi Gemma 3 1B F16 GGUF swept tensor traffic",
  );
  assertNear(
    item.architecture.weight_adapter.auxiliary_resident_weight_gb,
    0.006533152,
    0.000000001,
    "MaziyarPanahi Gemma 3 1B F16 GGUF metadata/header overhead",
  );
  assertNear(
    result.alloc,
    0.421134336,
    0.000000001,
    "MaziyarPanahi Gemma 3 1B layered FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.142606336,
    0.000000001,
    "MaziyarPanahi Gemma 3 1B layered FP16 KV read traffic",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(result.bMem, 280);
  assert.equal(result.best.batch, 81);
  assertNear(
    result.best.aggregate,
    1631.8167846288543,
    0.000000001,
    "MaziyarPanahi Gemma 3 1B DGX Spark aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    20.145886229985855,
    0.000000001,
    "MaziyarPanahi Gemma 3 1B DGX Spark per-session throughput",
  );
  assertNear(
    result.dennard,
    38243.79919562377,
    0.000000001,
    "MaziyarPanahi Gemma 3 1B DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 201);
  assertNear(
    m5Result.best.aggregate,
    4024.730830656377,
    0.000000001,
    "MaziyarPanahi Gemma 3 1B M5 Max aggregate throughput",
  );
}

{
  const repo = "MaziyarPanahi/gemma-3-4b-it-GGUF";
  const row = model(repo);
  const item = profile(repo);
  const kvAdapter = item.architecture.kv_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");

  assert.equal(row.hf_downloads, 142375);
  assert.equal(row.adapter.weight_precision, "GGUF FP16/F32");
  assert.equal(item.status, "audited");
  assert.equal(
    item.serving.runtime_format,
    "llama.cpp-gguf-f16-f32-memory-bound",
  );
  assert.equal(kvAdapter.kind, "layered_kv");
  assert.equal(kvAdapter.components[0].layers, 5);
  assert.equal(kvAdapter.components[1].layers, 29);
  assert.equal(kvAdapter.components[1].window_tokens, 1024);
  assertNear(
    row.adapter.kv_alloc_gb_per_1k_tokens,
    0.02169634816,
    0.000000001,
    "MaziyarPanahi Gemma 3 4B GGUF legacy allocation display coefficient",
  );
  assertNear(
    row.adapter.kv_read_gb_per_1k_tokens,
    0.024281088,
    0.000000001,
    "MaziyarPanahi Gemma 3 4B GGUF legacy read display coefficient",
  );
  assertNear(
    result.resident,
    7.767474368,
    0.000000001,
    "MaziyarPanahi Gemma 3 4B FP16 GGUF resident file footprint",
  );
  assertNear(
    result.single.batchWeight,
    7.760934912,
    0.000000001,
    "MaziyarPanahi Gemma 3 4B FP16 GGUF swept tensor traffic",
  );
  assertNear(
    item.architecture.weight_adapter.auxiliary_resident_weight_gb,
    0.006539456,
    0.000000001,
    "MaziyarPanahi Gemma 3 4B FP16 GGUF resident-only overhead",
  );
  assertNear(
    result.alloc,
    2.169634816,
    0.000000001,
    "MaziyarPanahi Gemma 3 4B layered FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    0.776994816,
    0.000000001,
    "MaziyarPanahi Gemma 3 4B layered FP16 KV read traffic",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(result.bMem, 51);
  assert.equal(result.best.batch, 7);
  assertNear(
    result.single.aggregate,
    31.974964505,
    0.000001,
    "MaziyarPanahi Gemma 3 4B DGX Spark single-session throughput",
  );
  assertNear(
    result.best.aggregate,
    144.773839136,
    0.000001,
    "MaziyarPanahi Gemma 3 4B DGX Spark aggregate throughput",
  );
  assertNear(
    result.best.perSession,
    20.681977019,
    0.000001,
    "MaziyarPanahi Gemma 3 4B DGX Spark per-session throughput",
  );
  assertNear(
    result.dennard,
    1819.619996085,
    0.000001,
    "MaziyarPanahi Gemma 3 4B DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 29);
  assertNear(
    m5Result.best.aggregate,
    587.777336151,
    0.000001,
    "MaziyarPanahi Gemma 3 4B M5 Max aggregate throughput",
  );
  assertNear(
    m5Result.dennard,
    4092.478672513,
    0.000001,
    "MaziyarPanahi Gemma 3 4B M5 Max Dennard bound",
  );
}

{
  const repo = "MaziyarPanahi/gemma-3-12b-it-GGUF";
  const row = model(repo);
  const item = profile(repo);
  const kvAdapter = item.architecture.kv_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");

  assert.equal(row.hf_downloads, 117347);
  assert.equal(row.license, "gemma");
  assert.ok(row.tags.includes("region:us"));
  assert.equal(row.adapter.weight_precision, "GGUF FP16/F32");
  assert.equal(row.architecture.max_context_tokens, 131072);
  assert.equal(item.status, "audited");
  assert.equal(
    item.serving.runtime_format,
    "llama.cpp-gguf-f16-f32-memory-bound",
  );
  assert.equal(kvAdapter.kind, "layered_kv");
  assert.equal(kvAdapter.components[0].layers, 8);
  assert.equal(kvAdapter.components[1].layers, 40);
  assert.equal(kvAdapter.components[1].window_tokens, 1024);
  assertNear(
    row.adapter.kv_alloc_gb_per_1k_tokens,
    0.065536,
    0.000000001,
    "MaziyarPanahi Gemma 3 12B GGUF full-context KV coefficient",
  );
  assertNear(
    row.adapter.kv_alloc_fixed_gb,
    0.33554432,
    0.000000001,
    "MaziyarPanahi Gemma 3 12B GGUF sliding-window fixed KV coefficient",
  );
  assertNear(
    result.resident,
    23.539658528,
    0.000000001,
    "MaziyarPanahi Gemma 3 12B FP16 GGUF resident file footprint",
  );
  assertNear(
    result.single.batchWeight,
    23.533108224,
    0.000000001,
    "MaziyarPanahi Gemma 3 12B FP16 GGUF swept tensor traffic",
  );
  assertNear(
    item.architecture.weight_adapter.auxiliary_resident_weight_gb,
    0.006550304,
    0.000000001,
    "MaziyarPanahi Gemma 3 12B FP16 GGUF resident-only overhead",
  );
  assertNear(
    result.alloc,
    6.88914432,
    0.000000001,
    "MaziyarPanahi Gemma 3 12B layered FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    2.43269632,
    0.000000001,
    "MaziyarPanahi Gemma 3 12B layered FP16 KV read traffic",
  );
  assert.equal(result.status_code, "no_floor");
  assert.equal(result.bMem, 14);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    10.513827889961645,
    0.000000001,
    "MaziyarPanahi Gemma 3 12B DGX Spark single-session throughput",
  );
  assertNear(
    result.dennard,
    162.43023295101244,
    0.000000001,
    "MaziyarPanahi Gemma 3 12B DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 2);
  assertNear(
    m5Result.single.aggregate,
    23.646484704895418,
    0.000000001,
    "MaziyarPanahi Gemma 3 12B M5 Max single-session throughput",
  );
  assertNear(
    m5Result.best.aggregate,
    43.241719197815186,
    0.000000001,
    "MaziyarPanahi Gemma 3 12B M5 Max aggregate throughput",
  );
  assertNear(
    m5Result.best.perSession,
    21.620859598907593,
    0.000000001,
    "MaziyarPanahi Gemma 3 12B M5 Max per-session throughput",
  );
}

{
  const repo = "unsloth/gemma-3-12b-it-GGUF";
  const row = model(repo);
  const item = profile(repo);
  const kvAdapter = item.architecture.kv_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");

  assert.equal(row.hf_downloads, 108980);
  assert.equal(row.license, "gemma");
  assert.ok(row.tags.includes("region:us"));
  assert.equal(row.adapter.weight_precision, "GGUF BF16/F32");
  assert.equal(row.architecture.max_context_tokens, 131072);
  assert.equal(item.status, "audited");
  assert.equal(
    item.serving.runtime_format,
    "llama.cpp-gguf-bf16-f32-memory-bound",
  );
  assert.equal(kvAdapter.kind, "layered_kv");
  assert.equal(kvAdapter.components[0].layers, 8);
  assert.equal(kvAdapter.components[1].layers, 40);
  assert.equal(kvAdapter.components[1].window_tokens, 1024);
  assertNear(
    row.adapter.kv_alloc_gb_per_1k_tokens,
    0.065536,
    0.000000001,
    "Unsloth Gemma 3 12B GGUF full-context KV coefficient",
  );
  assertNear(
    row.adapter.kv_alloc_fixed_gb,
    0.33554432,
    0.000000001,
    "Unsloth Gemma 3 12B GGUF sliding-window fixed KV coefficient",
  );
  assertNear(
    result.resident,
    23.54015152,
    0.000000001,
    "Unsloth Gemma 3 12B BF16 GGUF resident file footprint",
  );
  assertNear(
    result.single.batchWeight,
    23.533599744,
    0.000000001,
    "Unsloth Gemma 3 12B BF16 GGUF swept tensor traffic",
  );
  assertNear(
    item.architecture.weight_adapter.auxiliary_resident_weight_gb,
    0.006551776,
    0.000000001,
    "Unsloth Gemma 3 12B BF16 GGUF resident-only overhead",
  );
  assertNear(
    result.alloc,
    6.88914432,
    0.000000001,
    "Unsloth Gemma 3 12B layered FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    2.43269632,
    0.000000001,
    "Unsloth Gemma 3 12B layered FP16 KV read traffic",
  );
  assert.equal(result.status_code, "no_floor");
  assert.equal(result.bMem, 14);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    10.513628872101272,
    0.000000001,
    "Unsloth Gemma 3 12B DGX Spark single-session throughput",
  );
  assertNear(
    result.dennard,
    162.42601031696242,
    0.000000001,
    "Unsloth Gemma 3 12B DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 2);
  assertNear(
    m5Result.single.aggregate,
    23.64603709696037,
    0.000000001,
    "Unsloth Gemma 3 12B M5 Max single-session throughput",
  );
  assertNear(
    m5Result.best.aggregate,
    43.240970785000655,
    0.000000001,
    "Unsloth Gemma 3 12B M5 Max aggregate throughput",
  );
  assertNear(
    m5Result.best.perSession,
    21.620485392500328,
    0.000000001,
    "Unsloth Gemma 3 12B M5 Max per-session throughput",
  );
}

{
  const repo = "MaziyarPanahi/Meta-Llama-3-8B-Instruct-GGUF";
  const row = model(repo);
  const item = profile(repo);
  const kvAdapter = item.architecture.kv_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");

  assert.equal(row.hf_downloads, 142135);
  assert.equal(row.adapter.weight_precision, "GGUF FP16/F32");
  assert.equal(item.status, "audited");
  assert.equal(
    item.serving.runtime_format,
    "llama.cpp-gguf-f16-f32-memory-bound",
  );
  assert.equal(kvAdapter.kind, "full_context");
  assert.equal(kvAdapter.layers, 32);
  assert.equal(kvAdapter.kv_heads, 8);
  assert.equal(kvAdapter.head_dim, 128);
  assertNear(
    result.resident,
    16.06940384,
    0.000000001,
    "MaziyarPanahi Llama 3 8B FP16 GGUF resident file footprint",
  );
  assertNear(
    result.single.batchWeight,
    15.010381824,
    0.000000001,
    "MaziyarPanahi Llama 3 8B FP16 GGUF swept tensor traffic",
  );
  assertNear(
    item.architecture.weight_adapter.auxiliary_resident_weight_gb,
    1.059022016,
    0.000000001,
    "MaziyarPanahi Llama 3 8B FP16 GGUF resident-only input/header overhead",
  );
  assertNear(
    result.alloc,
    13.1072,
    0.000000001,
    "MaziyarPanahi Llama 3 8B FP16 GGUF KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    4.194304,
    0.000000001,
    "MaziyarPanahi Llama 3 8B FP16 GGUF KV read traffic",
  );
  assert.equal(result.status_code, "no_floor");
  assert.equal(result.bMem, 7);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    14.215280713,
    0.000001,
    "MaziyarPanahi Llama 3 8B DGX Spark single-session throughput",
  );
  assertNear(
    result.dennard,
    144.212996069,
    0.000001,
    "MaziyarPanahi Llama 3 8B DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 3);
  assertNear(
    m5Result.best.aggregate,
    66.755350476,
    0.000001,
    "MaziyarPanahi Llama 3 8B M5 Max aggregate throughput",
  );
  assertNear(
    m5Result.best.perSession,
    22.251783492,
    0.000001,
    "MaziyarPanahi Llama 3 8B M5 Max per-session throughput",
  );
}

{
  const repo = "MaziyarPanahi/Llama-3-8B-Instruct-32k-v0.1-GGUF";
  const row = model(repo);
  const item = profile(repo);
  const kvAdapter = item.architecture.kv_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");

  assert.equal(row.hf_downloads, 122730);
  assert.ok(row.tags.includes("region:us"));
  assert.equal(row.adapter.weight_precision, "GGUF FP16");
  assert.equal(row.architecture.max_context_tokens, 8192);
  assert.equal(item.status, "audited");
  assert.equal(
    item.serving.runtime_format,
    "llama.cpp-gguf-f16-f32-memory-bound",
  );
  assert.equal(kvAdapter.kind, "full_context");
  assert.equal(kvAdapter.layers, 32);
  assert.equal(kvAdapter.kv_heads, 8);
  assert.equal(kvAdapter.head_dim, 128);
  assertNear(
    result.resident,
    16.068890944,
    0.000000001,
    "MaziyarPanahi Llama 3 8B 32k v0.1 FP16 GGUF resident file footprint",
  );
  assertNear(
    result.single.batchWeight,
    15.010381824,
    0.000000001,
    "MaziyarPanahi Llama 3 8B 32k v0.1 FP16 GGUF swept tensor traffic",
  );
  assertNear(
    item.architecture.weight_adapter.auxiliary_resident_weight_gb,
    1.05850912,
    0.000000001,
    "MaziyarPanahi Llama 3 8B 32k v0.1 FP16 GGUF resident-only input/header overhead",
  );
  assertNear(
    result.alloc,
    13.1072,
    0.000000001,
    "MaziyarPanahi Llama 3 8B 32k v0.1 FP16 GGUF KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    4.194304,
    0.000000001,
    "MaziyarPanahi Llama 3 8B 32k v0.1 FP16 GGUF KV read traffic",
  );
  assert.equal(result.status_code, "no_floor");
  assert.equal(result.bMem, 7);
  assert.equal(result.best, null);
  assertNear(
    result.single.aggregate,
    14.215280713357638,
    0.000000001,
    "MaziyarPanahi Llama 3 8B 32k v0.1 DGX Spark single-session throughput",
  );
  assertNear(
    result.dennard,
    144.21370775850832,
    0.000000001,
    "MaziyarPanahi Llama 3 8B 32k v0.1 DGX Spark Dennard bound",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 3);
  assertNear(
    m5Result.best.aggregate,
    66.7553504756968,
    0.000000001,
    "MaziyarPanahi Llama 3 8B 32k v0.1 M5 Max aggregate throughput",
  );
  assertNear(
    m5Result.best.perSession,
    22.251783491898934,
    0.000000001,
    "MaziyarPanahi Llama 3 8B 32k v0.1 M5 Max per-session throughput",
  );
}

{
  const result = profiled("antirez/deepseek-v4-gguf", "nvidia-dgx-spark");
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    86.720111488,
    0.000000001,
    "DeepSeek DS4 q2-imatrix resident file footprint",
  );
  assertNear(
    result.single.batchWeight,
    9.568419904,
    0.000000001,
    "DeepSeek DS4 q2-imatrix single-session decode traffic",
  );
  assertNear(result.single.aggregate, 28, 1, "DeepSeek DGX single");
  assert.equal(result.best.batch, 3);
  assertNear(result.best.aggregate, 62, 1, "DeepSeek DGX aggregate");
  assertNear(result.dennard, 3024, 100, "DeepSeek DGX Dennard");
}

{
  const item = profile(
    "huihui-ai/Huihui-DeepSeek-V4-Flash-abliterated-ds4-GGUF",
  );
  const modelRow = model(
    "huihui-ai/Huihui-DeepSeek-V4-Flash-abliterated-ds4-GGUF",
  );
  assert.equal(item.serving.runtime_format, "ds4-gguf-q2-k-memory-bound");
  assert.equal(modelRow.adapter.weight_precision, "GGUF Q2_K");
  assertNear(
    item.architecture.weight_adapter.resident_weight_gb,
    99.705676384,
    0.000000001,
    "Huihui DeepSeek DS4 Q2_K resident file footprint",
  );
  assertNear(
    item.architecture.weight_adapter.main_resident_weight_gb,
    98.641279324,
    0.000000001,
    "Huihui DeepSeek DS4 Q2_K main resident footprint",
  );
  assertNear(
    item.architecture.weight_adapter.auxiliary_resident_weight_gb,
    1.06439706,
    0.000000001,
    "Huihui DeepSeek DS4 Q2_K auxiliary resident footprint",
  );
  assertNear(
    item.architecture.weight_adapter.fixed_weight_gb,
    7.742323036,
    0.000000001,
    "Huihui DeepSeek DS4 Q2_K fixed decode traffic",
  );
  assertNear(
    item.architecture.weight_adapter.routed_expert_weight_gb,
    0.355074048,
    0.000000001,
    "Huihui DeepSeek DS4 Q2_K routed expert traffic",
  );
  assertNear(
    modelRow.adapter.kv_alloc_gb_per_1k_tokens,
    0.00314,
    0.000000001,
    "Huihui DeepSeek DS4 Q2_K catalog compressed-state allocation",
  );
  assertNear(
    modelRow.adapter.kv_read_gb_per_1k_tokens,
    0.00121875,
    0.000000001,
    "Huihui DeepSeek DS4 Q2_K catalog compressed-state read",
  );

  const result = profiled(
    "huihui-ai/Huihui-DeepSeek-V4-Flash-abliterated-ds4-GGUF",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.single.batchWeight,
    9.872767324,
    0.000000001,
    "Huihui DeepSeek DS4 Q2_K single-session decode traffic",
  );
  assertNear(
    result.single.aggregate,
    27.543019430951283,
    0.000000001,
    "Huihui DeepSeek DS4 Q2_K DGX single-session throughput",
  );
  assert.equal(result.best.batch, 2);
  assertNear(
    result.best.aggregate,
    45.38170757209826,
    0.000000001,
    "Huihui DeepSeek DS4 Q2_K DGX aggregate throughput at b*",
  );
  assertNear(
    result.best.perSession,
    22.69085378604913,
    0.000000001,
    "Huihui DeepSeek DS4 Q2_K DGX per-session throughput at b*",
  );
  assertNear(
    result.dennard,
    1787.181575152751,
    0.000000001,
    "Huihui DeepSeek DS4 Q2_K DGX Dennard bound",
  );
}

{
  const result = profiled(
    "nvidia/Qwen3.6-35B-A3B-NVFP4",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assertNear(result.single.aggregate, 232, 1, "Qwen M5 Max single");
  assert.equal(result.best.batch, 40);
  assertNear(result.best.aggregate, 807, 2, "Qwen M5 Max aggregate");
  assertNear(result.dennard, 24200, 100, "Qwen M5 Max Dennard");
}

{
  const result = profiled(
    "nvidia/Gemma-4-26B-A4B-NVFP4",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.single.aggregate,
    106.22847846061025,
    0.000000001,
    "Gemma M5 Max single",
  );
  assert.equal(result.best.batch, 70);
  assertNear(
    result.best.aggregate,
    1405.907747777152,
    0.000000001,
    "Gemma M5 Max aggregate",
  );
  assertNear(
    result.dennard,
    30791.232496478413,
    0.000000001,
    "Gemma M5 Max Dennard",
  );
}

{
  const result = profiled(
    "antirez/deepseek-v4-gguf",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assertNear(result.single.aggregate, 64, 1, "DeepSeek M5 Max single");
  assert.equal(result.best.batch, 14);
  assertNear(result.best.aggregate, 284, 2, "DeepSeek M5 Max aggregate");
  assertNear(result.dennard, 6801, 100, "DeepSeek M5 Max Dennard");
}

{
  const result = profiled(
    "huihui-ai/Huihui-DeepSeek-V4-Flash-abliterated-ds4-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.single.aggregate,
    61.94657117437395,
    0.000000001,
    "Huihui DeepSeek DS4 Q2_K M5 Max single-session throughput",
  );
  assert.equal(result.best.batch, 11);
  assertNear(
    result.best.aggregate,
    232.54156025287242,
    0.000000001,
    "Huihui DeepSeek DS4 Q2_K M5 Max aggregate throughput at b*",
  );
  assertNear(
    result.best.perSession,
    21.14014184117022,
    0.000000001,
    "Huihui DeepSeek DS4 Q2_K M5 Max per-session throughput at b*",
  );
  assertNear(
    result.dennard,
    4019.5219309296303,
    0.000000001,
    "Huihui DeepSeek DS4 Q2_K M5 Max Dennard bound",
  );
}

{
  const item = profile("janhq/Jan-v3.5-4B-gguf");
  const weightAdapter = item.architecture.weight_adapter;
  const result = profiled("janhq/Jan-v3.5-4B-gguf", "nvidia-dgx-spark");
  const m5Result = profiled(
    "janhq/Jan-v3.5-4B-gguf",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(result.status_code, "ok");
  assert.equal(
    item.serving.runtime_format,
    "llama.cpp-gguf-q3-k-l-memory-bound",
  );
  assert.equal(item.architecture.kv_adapter.kind, "full_context");
  assertNear(
    result.resident,
    2.406913376,
    0.000000001,
    "Jan v3.5 4B Q3_K_L GGUF resident file footprint",
  );
  assertNear(
    result.single.batchWeight,
    2.233828864,
    0.000000001,
    "Jan v3.5 4B Q3_K_L GGUF swept text decode traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.173084512,
    0.000000001,
    "Jan v3.5 4B Q3_K_L GGUF input embedding plus header overhead",
  );
  assertNear(
    result.alloc,
    14.7456,
    0.000000001,
    "Jan v3.5 4B Q3_K_L GGUF full-context FP16 KV allocation",
  );
  assertNear(
    result.single.readTraffic,
    4.718592,
    0.000000001,
    "Jan v3.5 4B Q3_K_L GGUF full-context FP16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    39.266897867706525,
    0.000000001,
    "Jan v3.5 4B Q3_K_L GGUF DGX single-session throughput",
  );
  assert.equal(result.bMem, 7);
  assert.equal(result.best.batch, 2);
  assertNear(
    result.best.aggregate,
    46.78257203230172,
    0.000000001,
    "Jan v3.5 4B Q3_K_L GGUF DGX aggregate throughput",
  );
  assertNear(
    result.dennard,
    974.612753291355,
    0.000000001,
    "Jan v3.5 4B Q3_K_L GGUF DGX Dennard bound",
  );
  assert.equal(m5Result.best.batch, 6);
  assertNear(
    m5Result.best.aggregate,
    120.60743378524599,
    0.000000001,
    "Jan v3.5 4B Q3_K_L GGUF M5 Max aggregate throughput",
  );
  assertNear(
    m5Result.dennard,
    2191.98619238422,
    0.000000001,
    "Jan v3.5 4B Q3_K_L GGUF M5 Max Dennard bound",
  );
}

{
  const result = profiled(
    "nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-NVFP4",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    22.40548488,
    0.000000001,
    "Nemotron DGX NVFP4 resident footprint",
  );
  assertNear(
    result.alloc,
    0.332070912,
    0.000000001,
    "Nemotron DGX FP8 KV plus Mamba state allocation",
  );
  assertNear(
    result.single.batchWeight,
    3.076681008,
    0.000000001,
    "Nemotron DGX exact single-session decode traffic",
  );
  assertNear(
    result.single.readTraffic,
    0.123174912,
    0.000000001,
    "Nemotron DGX FP8 KV plus Mamba state read traffic",
  );
  assertNear(result.single.aggregate, 85, 1, "Nemotron DGX single");
  assert.equal(result.best.batch, 17);
  assertNear(result.best.aggregate, 341, 2, "Nemotron DGX aggregate");
  assertNear(result.dennard, 26078, 100, "Nemotron DGX Dennard");
}

{
  const result = profiled("Qwen/Qwen3.5-35B-A3B", "nvidia-dgx-spark");
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    71.903655008,
    0.000000001,
    "Qwen3.5 35B A3B DGX BF16 resident footprint",
  );
  assertNear(
    result.alloc,
    2.11288064,
    0.000000001,
    "Qwen3.5 35B A3B DGX BF16 KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.batchWeight,
    5.892868736,
    0.000000001,
    "Qwen3.5 35B A3B DGX exact single-session decode traffic",
  );
  assertNear(
    result.single.readTraffic,
    0.72024064,
    0.000000001,
    "Qwen3.5 35B A3B DGX BF16 KV plus DeltaNet state read traffic",
  );
  assertNear(result.single.aggregate, 41, 1, "Qwen3.5 35B A3B DGX single");
  assert.equal(result.best.batch, 3);
  assertNear(result.best.aggregate, 69, 1, "Qwen3.5 35B A3B DGX aggregate");
  assertNear(result.dennard, 1055, 50, "Qwen3.5 35B A3B DGX Dennard");
}

{
  const result = profiled("Qwen/Qwen3-Coder-Next", "nvidia-dgx-spark");
  assert.equal(result.status_code, "resident_not_fit");
  assertNear(
    result.resident,
    159.348782592,
    0.000000001,
    "Qwen3-Coder-Next BF16 DGX resident footprint",
  );
  assertNear(
    result.alloc,
    2.535456768,
    0.000000001,
    "Qwen3-Coder-Next BF16 DGX BF16 KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.batchWeight,
    7.12752896,
    0.000000001,
    "Qwen3-Coder-Next BF16 DGX exact single-session decode traffic",
  );
  assertNear(
    result.single.readTraffic,
    0.864288768,
    0.000000001,
    "Qwen3-Coder-Next BF16 DGX BF16 KV plus DeltaNet state read traffic",
  );
}

{
  const result = profiled("Qwen/Qwen3-Coder-Next-FP8", "nvidia-dgx-spark");
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    80.362904064,
    0.000000001,
    "Qwen3-Coder-Next FP8 DGX resident footprint",
  );
  assertNear(
    result.alloc,
    2.535456768,
    0.000000001,
    "Qwen3-Coder-Next FP8 DGX BF16 KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.batchWeight,
    3.931859456,
    0.000000001,
    "Qwen3-Coder-Next FP8 DGX exact single-session decode traffic",
  );
  assertNear(
    result.single.readTraffic,
    0.864288768,
    0.000000001,
    "Qwen3-Coder-Next FP8 DGX BF16 KV plus DeltaNet state read traffic",
  );
  assertNear(result.single.aggregate, 57, 1, "Qwen3-Coder-Next FP8 DGX single");
  assert.equal(result.best.batch, 4);
  assertNear(
    result.best.aggregate,
    93,
    1,
    "Qwen3-Coder-Next FP8 DGX aggregate",
  );
  assertNear(result.dennard, 1085, 50, "Qwen3-Coder-Next FP8 DGX Dennard");
}

{
  const catalogRow = model("lmstudio-community/Qwen3-Coder-Next-MLX-4bit");
  const item = profile("lmstudio-community/Qwen3-Coder-Next-MLX-4bit");
  const weightAdapter = item.architecture.weight_adapter;
  assert.equal(catalogRow.hf_downloads, 181136);
  assert.ok(catalogRow.tags.includes("region:us"));
  assert.equal(catalogRow.architecture.shared_experts_per_token, 1);
  assert.equal(item.base_model_proof.config_compatible, true);
  assert.equal(item.serving.weight_format, "mlx_quantized");
  assert.equal(weightAdapter.kind, "moe_distinct_experts_exact");
  assertNear(
    weightAdapter.resident_weight_gb,
    44.84406016,
    0.000000001,
    "LM Studio Qwen3-Coder-Next MLX 4-bit resident footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    44.669029888,
    0.000000001,
    "LM Studio Qwen3-Coder-Next MLX 4-bit main resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.175030272,
    0.000000001,
    "LM Studio Qwen3-Coder-Next MLX 4-bit auxiliary resident footprint",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    1.182486016,
    0.000000001,
    "LM Studio Qwen3-Coder-Next MLX 4-bit fixed traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.084934656,
    0.000000001,
    "LM Studio Qwen3-Coder-Next MLX 4-bit routed expert traffic",
  );
  assertNear(
    catalogRow.adapter.active_weight_gb,
    2.031832576,
    0.000000001,
    "LM Studio Qwen3-Coder-Next MLX 4-bit catalog active traffic",
  );

  const result = profiled(
    "lmstudio-community/Qwen3-Coder-Next-MLX-4bit",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    44.84406016,
    0.000000001,
    "LM Studio Qwen3-Coder-Next MLX 4-bit DGX resident footprint",
  );
  assertNear(
    result.alloc,
    2.535456768,
    0.000000001,
    "LM Studio Qwen3-Coder-Next MLX 4-bit DGX BF16 KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.batchWeight,
    2.031832576,
    0.000000001,
    "LM Studio Qwen3-Coder-Next MLX 4-bit DGX exact single-session decode traffic",
  );
  assertNear(
    result.single.readTraffic,
    0.864288768,
    0.000000001,
    "LM Studio Qwen3-Coder-Next MLX 4-bit DGX BF16 KV plus DeltaNet state read traffic",
  );
  assertNear(
    result.single.aggregate,
    94.26400608717036,
    0.000000001,
    "LM Studio Qwen3-Coder-Next MLX 4-bit DGX single",
  );
  assert.equal(result.bMem, 29);
  assert.equal(result.best.batch, 7);
  assertNear(
    result.best.aggregate,
    148.82378272450924,
    0.000000001,
    "LM Studio Qwen3-Coder-Next MLX 4-bit DGX aggregate",
  );
  assertNear(
    result.best.perSession,
    21.260540389215606,
    0.000000001,
    "LM Studio Qwen3-Coder-Next MLX 4-bit DGX per-session",
  );
  assertNear(
    result.dennard,
    3982.738830578161,
    0.000000001,
    "LM Studio Qwen3-Coder-Next MLX 4-bit DGX Dennard",
  );

  const m5Result = profiled(
    "lmstudio-community/Qwen3-Coder-Next-MLX-4bit",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 18);
  assertNear(
    m5Result.single.aggregate,
    212.00769134623664,
    0.000000001,
    "LM Studio Qwen3-Coder-Next MLX 4-bit M5 single",
  );
  assertNear(
    m5Result.best.aggregate,
    371.6723135916243,
    0.000000001,
    "LM Studio Qwen3-Coder-Next MLX 4-bit M5 aggregate",
  );
  assertNear(
    m5Result.best.perSession,
    20.648461866201348,
    0.000000001,
    "LM Studio Qwen3-Coder-Next MLX 4-bit M5 per-session",
  );
  assertNear(
    m5Result.dennard,
    8957.515172069563,
    0.000000001,
    "LM Studio Qwen3-Coder-Next MLX 4-bit M5 Dennard",
  );
}

{
  const catalogRow = model("bullpoint/Qwen3-Coder-Next-AWQ-4bit");
  const item = profile("bullpoint/Qwen3-Coder-Next-AWQ-4bit");
  const weightAdapter = item.architecture.weight_adapter;
  assert.equal(catalogRow.hf_downloads, 154238);
  assert.ok(catalogRow.tags.includes("region:us"));
  assert.equal(catalogRow.architecture.shared_experts_per_token, 1);
  assertNear(
    catalogRow.architecture.active_params_b,
    3.56376448,
    0.000000001,
    "Bullpoint Qwen3-Coder-Next AWQ 4-bit active logical params",
  );
  assert.equal(item.base_model_proof.config_compatible, true);
  assert.equal(item.serving.weight_format, "int4");
  assert.equal(weightAdapter.kind, "moe_distinct_experts_exact");
  assertNear(
    weightAdapter.resident_weight_gb,
    48.217683456,
    0.000000001,
    "Bullpoint Qwen3-Coder-Next AWQ 4-bit resident footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    47.5953536,
    0.000000001,
    "Bullpoint Qwen3-Coder-Next AWQ 4-bit main resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.622329856,
    0.000000001,
    "Bullpoint Qwen3-Coder-Next AWQ 4-bit auxiliary resident footprint",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    4.10763008,
    0.000000001,
    "Bullpoint Qwen3-Coder-Next AWQ 4-bit fixed traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.08493696,
    0.000000001,
    "Bullpoint Qwen3-Coder-Next AWQ 4-bit routed expert traffic",
  );
  assertNear(
    catalogRow.adapter.active_weight_gb,
    4.95699968,
    0.000000001,
    "Bullpoint Qwen3-Coder-Next AWQ 4-bit catalog active traffic",
  );

  const result = profiled(
    "bullpoint/Qwen3-Coder-Next-AWQ-4bit",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    48.217683456,
    0.000000001,
    "Bullpoint Qwen3-Coder-Next AWQ 4-bit DGX resident footprint",
  );
  assertNear(
    result.alloc,
    2.535456768,
    0.000000001,
    "Bullpoint Qwen3-Coder-Next AWQ 4-bit DGX BF16 KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.batchWeight,
    4.95699968,
    0.000000001,
    "Bullpoint Qwen3-Coder-Next AWQ 4-bit DGX exact single-session decode traffic",
  );
  assertNear(
    result.single.readTraffic,
    0.864288768,
    0.000000001,
    "Bullpoint Qwen3-Coder-Next AWQ 4-bit DGX BF16 KV plus DeltaNet state read traffic",
  );
  assertNear(
    result.single.aggregate,
    46.89683434150968,
    0.000000001,
    "Bullpoint Qwen3-Coder-Next AWQ 4-bit DGX single",
  );
  assert.equal(result.bMem, 28);
  assert.equal(result.best.batch, 5);
  assertNear(
    result.best.aggregate,
    109.08447526452355,
    0.000000001,
    "Bullpoint Qwen3-Coder-Next AWQ 4-bit DGX aggregate",
  );
  assertNear(
    result.best.perSession,
    21.81689505290471,
    0.000000001,
    "Bullpoint Qwen3-Coder-Next AWQ 4-bit DGX per-session",
  );
  assertNear(
    result.dennard,
    1559.2114525429954,
    0.000000001,
    "Bullpoint Qwen3-Coder-Next AWQ 4-bit DGX Dennard",
  );

  const m5Result = profiled(
    "bullpoint/Qwen3-Coder-Next-AWQ-4bit",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 16);
  assertNear(
    m5Result.single.aggregate,
    105.47493144940273,
    0.000000001,
    "Bullpoint Qwen3-Coder-Next AWQ 4-bit M5 single",
  );
  assertNear(
    m5Result.best.aggregate,
    330.7086869463485,
    0.000000001,
    "Bullpoint Qwen3-Coder-Next AWQ 4-bit M5 aggregate",
  );
  assertNear(
    m5Result.best.perSession,
    20.66929293414678,
    0.000000001,
    "Bullpoint Qwen3-Coder-Next AWQ 4-bit M5 per-session",
  );
  assertNear(
    m5Result.dennard,
    3506.797918906224,
    0.000000001,
    "Bullpoint Qwen3-Coder-Next AWQ 4-bit M5 Dennard",
  );

  const m1UltraResult = profiled(
    "bullpoint/Qwen3-Coder-Next-AWQ-4bit",
    "apple-mac-studio-m1-ultra-128gb",
  );
  assert.equal(m1UltraResult.status_code, "ok");
  assert.equal(m1UltraResult.best.batch, 23);
  assertNear(
    m1UltraResult.best.aggregate,
    461.7731949395392,
    0.000000001,
    "Bullpoint Qwen3-Coder-Next AWQ 4-bit M1 Ultra aggregate",
  );
  assertNear(
    m1UltraResult.best.perSession,
    20.07709543215388,
    0.000000001,
    "Bullpoint Qwen3-Coder-Next AWQ 4-bit M1 Ultra per-session",
  );
}

{
  const catalogRow = model("cyankiwi/Qwen3-Coder-Next-AWQ-4bit");
  const item = profile("cyankiwi/Qwen3-Coder-Next-AWQ-4bit");
  const weightAdapter = item.architecture.weight_adapter;
  assert.equal(catalogRow.hf_downloads, 118028);
  assert.ok(catalogRow.tags.includes("region:us"));
  assert.equal(catalogRow.architecture.shared_experts_per_token, 1);
  assertNear(
    catalogRow.architecture.active_params_b,
    3.56376448,
    0.000000001,
    "Cyankiwi Qwen3-Coder-Next AWQ 4-bit active logical params",
  );
  assert.equal(item.base_model_proof.config_compatible, true);
  assert.equal(item.serving.weight_format, "int4");
  assert.equal(weightAdapter.kind, "moe_distinct_experts_exact");
  assertNear(
    weightAdapter.resident_weight_gb,
    48.217683456,
    0.000000001,
    "Cyankiwi Qwen3-Coder-Next AWQ 4-bit resident footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    47.5953536,
    0.000000001,
    "Cyankiwi Qwen3-Coder-Next AWQ 4-bit main resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.622329856,
    0.000000001,
    "Cyankiwi Qwen3-Coder-Next AWQ 4-bit auxiliary resident footprint",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    4.10763008,
    0.000000001,
    "Cyankiwi Qwen3-Coder-Next AWQ 4-bit fixed traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.08493696,
    0.000000001,
    "Cyankiwi Qwen3-Coder-Next AWQ 4-bit routed expert traffic",
  );
  assertNear(
    catalogRow.adapter.active_weight_gb,
    4.95699968,
    0.000000001,
    "Cyankiwi Qwen3-Coder-Next AWQ 4-bit catalog active traffic",
  );

  const result = profiled(
    "cyankiwi/Qwen3-Coder-Next-AWQ-4bit",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    48.217683456,
    0.000000001,
    "Cyankiwi Qwen3-Coder-Next AWQ 4-bit DGX resident footprint",
  );
  assertNear(
    result.alloc,
    2.535456768,
    0.000000001,
    "Cyankiwi Qwen3-Coder-Next AWQ 4-bit DGX BF16 KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.batchWeight,
    4.95699968,
    0.000000001,
    "Cyankiwi Qwen3-Coder-Next AWQ 4-bit DGX exact single-session decode traffic",
  );
  assertNear(
    result.single.readTraffic,
    0.864288768,
    0.000000001,
    "Cyankiwi Qwen3-Coder-Next AWQ 4-bit DGX BF16 KV plus DeltaNet state read traffic",
  );
  assertNear(
    result.single.aggregate,
    46.89683434150968,
    0.000000001,
    "Cyankiwi Qwen3-Coder-Next AWQ 4-bit DGX single",
  );
  assert.equal(result.bMem, 28);
  assert.equal(result.best.batch, 5);
  assertNear(
    result.best.aggregate,
    109.08447526452355,
    0.000000001,
    "Cyankiwi Qwen3-Coder-Next AWQ 4-bit DGX aggregate",
  );
  assertNear(
    result.best.perSession,
    21.81689505290471,
    0.000000001,
    "Cyankiwi Qwen3-Coder-Next AWQ 4-bit DGX per-session",
  );
  assertNear(
    result.dennard,
    1559.2114525429954,
    0.000000001,
    "Cyankiwi Qwen3-Coder-Next AWQ 4-bit DGX Dennard",
  );

  const m5Result = profiled(
    "cyankiwi/Qwen3-Coder-Next-AWQ-4bit",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 16);
  assertNear(
    m5Result.single.aggregate,
    105.47493144940273,
    0.000000001,
    "Cyankiwi Qwen3-Coder-Next AWQ 4-bit M5 single",
  );
  assertNear(
    m5Result.best.aggregate,
    330.7086869463485,
    0.000000001,
    "Cyankiwi Qwen3-Coder-Next AWQ 4-bit M5 aggregate",
  );
  assertNear(
    m5Result.best.perSession,
    20.66929293414678,
    0.000000001,
    "Cyankiwi Qwen3-Coder-Next AWQ 4-bit M5 per-session",
  );
  assertNear(
    m5Result.dennard,
    3506.797918906224,
    0.000000001,
    "Cyankiwi Qwen3-Coder-Next AWQ 4-bit M5 Dennard",
  );

  const m1UltraResult = profiled(
    "cyankiwi/Qwen3-Coder-Next-AWQ-4bit",
    "apple-mac-studio-m1-ultra-128gb",
  );
  assert.equal(m1UltraResult.status_code, "ok");
  assert.equal(m1UltraResult.best.batch, 23);
  assertNear(
    m1UltraResult.best.aggregate,
    461.7731949395392,
    0.000000001,
    "Cyankiwi Qwen3-Coder-Next AWQ 4-bit M1 Ultra aggregate",
  );
  assertNear(
    m1UltraResult.best.perSession,
    20.07709543215388,
    0.000000001,
    "Cyankiwi Qwen3-Coder-Next AWQ 4-bit M1 Ultra per-session",
  );
}

{
  const catalogRow = model("cyankiwi/Qwen3-Coder-Next-AWQ-8bit");
  const item = profile("cyankiwi/Qwen3-Coder-Next-AWQ-8bit");
  const weightAdapter = item.architecture.weight_adapter;
  assert.equal(catalogRow.hf_downloads, 108320);
  assert.ok(catalogRow.tags.includes("region:us"));
  assert.equal(catalogRow.architecture.shared_experts_per_token, 1);
  assertNear(
    catalogRow.architecture.active_params_b,
    3.56376448,
    0.000000001,
    "Cyankiwi Qwen3-Coder-Next AWQ 8-bit active logical params",
  );
  assert.equal(item.base_model_proof.config_compatible, true);
  assert.equal(item.serving.weight_format, "int8");
  assert.equal(weightAdapter.kind, "moe_distinct_experts_exact");
  assertNear(
    weightAdapter.resident_weight_gb,
    86.87238912,
    0.000000001,
    "Cyankiwi Qwen3-Coder-Next AWQ 8-bit resident footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    86.250059264,
    0.000000001,
    "Cyankiwi Qwen3-Coder-Next AWQ 8-bit main resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.622329856,
    0.000000001,
    "Cyankiwi Qwen3-Coder-Next AWQ 8-bit auxiliary resident footprint",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    4.10763008,
    0.000000001,
    "Cyankiwi Qwen3-Coder-Next AWQ 8-bit fixed traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.160434432,
    0.000000001,
    "Cyankiwi Qwen3-Coder-Next AWQ 8-bit routed expert traffic",
  );
  assertNear(
    catalogRow.adapter.active_weight_gb,
    5.7119744,
    0.000000001,
    "Cyankiwi Qwen3-Coder-Next AWQ 8-bit catalog active traffic",
  );

  const result = profiled(
    "cyankiwi/Qwen3-Coder-Next-AWQ-8bit",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    86.87238912,
    0.000000001,
    "Cyankiwi Qwen3-Coder-Next AWQ 8-bit DGX resident footprint",
  );
  assertNear(
    result.alloc,
    2.535456768,
    0.000000001,
    "Cyankiwi Qwen3-Coder-Next AWQ 8-bit DGX BF16 KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.batchWeight,
    5.7119744,
    0.000000001,
    "Cyankiwi Qwen3-Coder-Next AWQ 8-bit DGX exact single-session decode traffic",
  );
  assertNear(
    result.single.readTraffic,
    0.864288768,
    0.000000001,
    "Cyankiwi Qwen3-Coder-Next AWQ 8-bit DGX BF16 KV plus DeltaNet state read traffic",
  );
  assertNear(
    result.single.aggregate,
    41.5129372146197,
    0.000000001,
    "Cyankiwi Qwen3-Coder-Next AWQ 8-bit DGX single",
  );
  assert.equal(result.bMem, 13);
  assert.equal(result.best.batch, 3);
  assertNear(
    result.best.aggregate,
    71.7154281199137,
    0.000000001,
    "Cyankiwi Qwen3-Coder-Next AWQ 8-bit DGX aggregate",
  );
  assertNear(
    result.best.perSession,
    23.9051427066379,
    0.000000001,
    "Cyankiwi Qwen3-Coder-Next AWQ 8-bit DGX per-session",
  );
  assertNear(
    result.dennard,
    624.4681620384944,
    0.000000001,
    "Cyankiwi Qwen3-Coder-Next AWQ 8-bit DGX Dennard",
  );

  const m5Result = profiled(
    "cyankiwi/Qwen3-Coder-Next-AWQ-8bit",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 11);
  assertNear(
    m5Result.single.aggregate,
    93.36609322262451,
    0.000000001,
    "Cyankiwi Qwen3-Coder-Next AWQ 8-bit M5 single",
  );
  assertNear(
    m5Result.best.aggregate,
    227.89604151539808,
    0.000000001,
    "Cyankiwi Qwen3-Coder-Next AWQ 8-bit M5 aggregate",
  );
  assertNear(
    m5Result.best.perSession,
    20.71782195594528,
    0.000000001,
    "Cyankiwi Qwen3-Coder-Next AWQ 8-bit M5 per-session",
  );
  assertNear(
    m5Result.dennard,
    1404.4815072953684,
    0.000000001,
    "Cyankiwi Qwen3-Coder-Next AWQ 8-bit M5 Dennard",
  );

  const m1UltraResult = profiled(
    "cyankiwi/Qwen3-Coder-Next-AWQ-8bit",
    "apple-mac-studio-m1-ultra-128gb",
  );
  assert.equal(m1UltraResult.status_code, "ok");
  assert.equal(m1UltraResult.best.batch, 13);
  assertNear(
    m1UltraResult.best.aggregate,
    306.5809732232428,
    0.000000001,
    "Cyankiwi Qwen3-Coder-Next AWQ 8-bit M1 Ultra aggregate",
  );
  assertNear(
    m1UltraResult.best.perSession,
    23.583151786403292,
    0.000000001,
    "Cyankiwi Qwen3-Coder-Next AWQ 8-bit M1 Ultra per-session",
  );
}

{
  const catalogRow = model("Mungert/Hunyuan-MT-7B-GGUF");
  const item = profile("Mungert/Hunyuan-MT-7B-GGUF");
  const weightAdapter = item.architecture.weight_adapter;
  assert.equal(catalogRow.hf_downloads, 170812);
  assert.ok(catalogRow.tags.includes("region:us"));
  assert.equal(catalogRow.architecture.layers, 32);
  assert.equal(catalogRow.architecture.kv_heads, 8);
  assert.equal(catalogRow.architecture.head_dim, 128);
  assert.equal(catalogRow.architecture.max_context_tokens, 262144);
  assert.equal(item.base_model_proof.config_compatible, false);
  assert.equal(item.serving.weight_format, "gguf_quantized");
  assert.equal(weightAdapter.kind, "dense_resident_swept");
  assertNear(
    weightAdapter.resident_params_b,
    7.504932864,
    0.000000001,
    "Mungert Hunyuan-MT-7B GGUF resident logical params",
  );
  assertNear(
    weightAdapter.swept_params_b,
    7.504932864,
    0.000000001,
    "Mungert Hunyuan-MT-7B GGUF swept logical params",
  );
  assertNear(
    weightAdapter.resident_weight_gb,
    10.865575104,
    0.000000001,
    "Mungert Hunyuan-MT-7B GGUF resident footprint",
  );
  assertNear(
    weightAdapter.swept_weight_gb,
    10.858053632,
    0.000000001,
    "Mungert Hunyuan-MT-7B GGUF swept traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.007521472,
    0.000000001,
    "Mungert Hunyuan-MT-7B GGUF metadata/header overhead",
  );
  assertNear(
    catalogRow.adapter.active_weight_gb,
    10.858053632,
    0.000000001,
    "Mungert Hunyuan-MT-7B GGUF catalog active traffic",
  );

  const result = profiled("Mungert/Hunyuan-MT-7B-GGUF", "nvidia-dgx-spark");
  assert.equal(result.status_code, "no_floor");
  assert.equal(result.best, null);
  assert.equal(result.bMem, 8);
  assertNear(
    result.resident,
    10.865575104,
    0.000000001,
    "Mungert Hunyuan-MT-7B GGUF DGX resident footprint",
  );
  assertNear(
    result.alloc,
    13.1072,
    0.000000001,
    "Mungert Hunyuan-MT-7B GGUF DGX FP16 KV allocation",
  );
  assertNear(
    result.single.batchWeight,
    10.858053632,
    0.000000001,
    "Mungert Hunyuan-MT-7B GGUF DGX exact single-session decode traffic",
  );
  assertNear(
    result.single.readTraffic,
    4.194304,
    0.000000001,
    "Mungert Hunyuan-MT-7B GGUF DGX FP16 KV read traffic",
  );
  assertNear(
    result.single.aggregate,
    18.136693710998856,
    0.000000001,
    "Mungert Hunyuan-MT-7B GGUF DGX single",
  );
  assertNear(
    result.dennard,
    209.3449565317409,
    0.000000001,
    "Mungert Hunyuan-MT-7B GGUF DGX Dennard",
  );

  const m5Result = profiled(
    "Mungert/Hunyuan-MT-7B-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 4);
  assertNear(
    m5Result.single.aggregate,
    40.79095215587288,
    0.000000001,
    "Mungert Hunyuan-MT-7B GGUF M5 single",
  );
  assertNear(
    m5Result.best.aggregate,
    88.87193910914833,
    0.000000001,
    "Mungert Hunyuan-MT-7B GGUF M5 aggregate",
  );
  assertNear(
    m5Result.best.perSession,
    22.217984777287082,
    0.000000001,
    "Mungert Hunyuan-MT-7B GGUF M5 per-session",
  );

  const m1UltraResult = profiled(
    "Mungert/Hunyuan-MT-7B-GGUF",
    "apple-mac-studio-m1-ultra-128gb",
  );
  assert.equal(m1UltraResult.status_code, "ok");
  assert.equal(m1UltraResult.best.batch, 6);
  assertNear(
    m1UltraResult.best.aggregate,
    133.24495627689345,
    0.000000001,
    "Mungert Hunyuan-MT-7B GGUF M1 Ultra aggregate",
  );
  assertNear(
    m1UltraResult.best.perSession,
    22.207492712815576,
    0.000000001,
    "Mungert Hunyuan-MT-7B GGUF M1 Ultra per-session",
  );
}

{
  const catalogRow = model("lmstudio-community/Qwen3-Coder-Next-MLX-6bit");
  const item = profile("lmstudio-community/Qwen3-Coder-Next-MLX-6bit");
  const weightAdapter = item.architecture.weight_adapter;
  assert.equal(catalogRow.hf_downloads, 179477);
  assert.ok(catalogRow.tags.includes("region:us"));
  assert.equal(catalogRow.architecture.shared_experts_per_token, 1);
  assert.equal(item.base_model_proof.config_compatible, true);
  assert.equal(item.serving.weight_format, "mlx_quantized");
  assert.equal(weightAdapter.kind, "moe_distinct_experts_exact");
  assertNear(
    weightAdapter.resident_weight_gb,
    64.749702656,
    0.000000001,
    "LM Studio Qwen3-Coder-Next MLX 6-bit resident footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    64.496881152,
    0.000000001,
    "LM Studio Qwen3-Coder-Next MLX 6-bit main resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.252821504,
    0.000000001,
    "LM Studio Qwen3-Coder-Next MLX 6-bit auxiliary resident footprint",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    1.682984448,
    0.000000001,
    "LM Studio Qwen3-Coder-Next MLX 6-bit fixed traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.122683392,
    0.000000001,
    "LM Studio Qwen3-Coder-Next MLX 6-bit routed expert traffic",
  );
  assertNear(
    catalogRow.adapter.active_weight_gb,
    2.909818368,
    0.000000001,
    "LM Studio Qwen3-Coder-Next MLX 6-bit catalog active traffic",
  );

  const result = profiled(
    "lmstudio-community/Qwen3-Coder-Next-MLX-6bit",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    64.749702656,
    0.000000001,
    "LM Studio Qwen3-Coder-Next MLX 6-bit DGX resident footprint",
  );
  assertNear(
    result.alloc,
    2.535456768,
    0.000000001,
    "LM Studio Qwen3-Coder-Next MLX 6-bit DGX BF16 KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.batchWeight,
    2.909818368,
    0.000000001,
    "LM Studio Qwen3-Coder-Next MLX 6-bit DGX exact single-session decode traffic",
  );
  assertNear(
    result.single.readTraffic,
    0.864288768,
    0.000000001,
    "LM Studio Qwen3-Coder-Next MLX 6-bit DGX BF16 KV plus DeltaNet state read traffic",
  );
  assertNear(
    result.single.aggregate,
    72.33498948557671,
    0.000000001,
    "LM Studio Qwen3-Coder-Next MLX 6-bit DGX single",
  );
  assert.equal(result.bMem, 21);
  assert.equal(result.best.batch, 5);
  assertNear(
    result.best.aggregate,
    114.67103427464572,
    0.000000001,
    "LM Studio Qwen3-Coder-Next MLX 6-bit DGX aggregate",
  );
  assertNear(
    result.best.perSession,
    22.934206854929144,
    0.000000001,
    "LM Studio Qwen3-Coder-Next MLX 6-bit DGX per-session",
  );
  assertNear(
    result.dennard,
    2044.4437962156949,
    0.000000001,
    "LM Studio Qwen3-Coder-Next MLX 6-bit DGX Dennard",
  );

  const m5Result = profiled(
    "lmstudio-community/Qwen3-Coder-Next-MLX-6bit",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 14);
  assertNear(
    m5Result.single.aggregate,
    162.68748550968536,
    0.000000001,
    "LM Studio Qwen3-Coder-Next MLX 6-bit M5 single",
  );
  assertNear(
    m5Result.best.aggregate,
    297.0309426322995,
    0.000000001,
    "LM Studio Qwen3-Coder-Next MLX 6-bit M5 aggregate",
  );
  assertNear(
    m5Result.best.perSession,
    21.21649590230711,
    0.000000001,
    "LM Studio Qwen3-Coder-Next MLX 6-bit M5 per-session",
  );
  assertNear(
    m5Result.dennard,
    4598.126340206728,
    0.000000001,
    "LM Studio Qwen3-Coder-Next MLX 6-bit M5 Dennard",
  );

  const m1UltraResult = profiled(
    "lmstudio-community/Qwen3-Coder-Next-MLX-6bit",
    "apple-mac-studio-m1-ultra-128gb",
  );
  assert.equal(m1UltraResult.status_code, "ok");
  assert.equal(m1UltraResult.best.batch, 20);
  assertNear(
    m1UltraResult.best.aggregate,
    405.6321441098028,
    0.000000001,
    "LM Studio Qwen3-Coder-Next MLX 6-bit M1 Ultra aggregate",
  );
  assertNear(
    m1UltraResult.best.perSession,
    20.28160720549014,
    0.000000001,
    "LM Studio Qwen3-Coder-Next MLX 6-bit M1 Ultra per-session",
  );
}

{
  const item = profile("lmstudio-community/Qwen3-Coder-Next-MLX-8bit");
  const weightAdapter = item.architecture.weight_adapter;
  assert.equal(weightAdapter.kind, "moe_distinct_experts_exact");
  assertNear(
    weightAdapter.resident_weight_gb,
    84.655345152,
    0.000000001,
    "LM Studio Qwen3-Coder-Next MLX 8-bit resident footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    84.324732416,
    0.000000001,
    "LM Studio Qwen3-Coder-Next MLX 8-bit main resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.330612736,
    0.000000001,
    "LM Studio Qwen3-Coder-Next MLX 8-bit auxiliary resident footprint",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    2.18348288,
    0.000000001,
    "LM Studio Qwen3-Coder-Next MLX 8-bit fixed traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.160432128,
    0.000000001,
    "LM Studio Qwen3-Coder-Next MLX 8-bit routed expert traffic",
  );

  const result = profiled(
    "lmstudio-community/Qwen3-Coder-Next-MLX-8bit",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    84.655345152,
    0.000000001,
    "LM Studio Qwen3-Coder-Next MLX 8-bit DGX resident footprint",
  );
  assertNear(
    result.alloc,
    2.535456768,
    0.000000001,
    "LM Studio Qwen3-Coder-Next MLX 8-bit DGX BF16 KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.batchWeight,
    3.78780416,
    0.000000001,
    "LM Studio Qwen3-Coder-Next MLX 8-bit DGX exact single-session decode traffic",
  );
  assertNear(
    result.single.readTraffic,
    0.864288768,
    0.000000001,
    "LM Studio Qwen3-Coder-Next MLX 8-bit DGX BF16 KV plus DeltaNet state read traffic",
  );
  assertNear(
    result.single.aggregate,
    58.683264548923475,
    0.000000001,
    "LM Studio Qwen3-Coder-Next MLX 8-bit DGX single",
  );
  assert.equal(result.bMem, 13);
  assert.equal(result.best.batch, 4);
  assertNear(
    result.best.aggregate,
    91.97839938362914,
    0.000000001,
    "LM Studio Qwen3-Coder-Next MLX 8-bit DGX aggregate",
  );
  assertNear(
    result.best.perSession,
    22.994599845907285,
    0.000000001,
    "LM Studio Qwen3-Coder-Next MLX 8-bit DGX per-session",
  );
  assertNear(
    result.dennard,
    1004.7144896412233,
    0.000000001,
    "LM Studio Qwen3-Coder-Next MLX 8-bit DGX Dennard",
  );

  const m5Result = profiled(
    "lmstudio-community/Qwen3-Coder-Next-MLX-8bit",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 12);
  assertNear(
    m5Result.single.aggregate,
    131.98360598182788,
    0.000000001,
    "LM Studio Qwen3-Coder-Next MLX 8-bit M5 single",
  );
  assertNear(
    m5Result.best.aggregate,
    246.6884138232267,
    0.000000001,
    "LM Studio Qwen3-Coder-Next MLX 8-bit M5 aggregate",
  );
  assertNear(
    m5Result.best.perSession,
    20.557367818602227,
    0.000000001,
    "LM Studio Qwen3-Coder-Next MLX 8-bit M5 per-session",
  );
  assertNear(
    m5Result.dennard,
    2259.687533478795,
    0.000000001,
    "LM Studio Qwen3-Coder-Next MLX 8-bit M5 Dennard",
  );
}

{
  const item = profile("unsloth/Qwen3-Coder-Next-GGUF");
  const weightAdapter = item.architecture.weight_adapter;
  assert.equal(weightAdapter.kind, "moe_distinct_experts_exact");
  assertNear(
    weightAdapter.resident_weight_gb,
    45.13034448,
    0.000000001,
    "Unsloth Qwen3-Coder-Next GGUF resident footprint",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    44.9493248,
    0.000000001,
    "Unsloth Qwen3-Coder-Next GGUF main resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.18101968,
    0.000000001,
    "Unsloth Qwen3-Coder-Next GGUF auxiliary resident footprint",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    1.462780928,
    0.000000001,
    "Unsloth Qwen3-Coder-Next GGUF fixed traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.084934656,
    0.000000001,
    "Unsloth Qwen3-Coder-Next GGUF routed expert traffic",
  );

  const result = profiled("unsloth/Qwen3-Coder-Next-GGUF", "nvidia-dgx-spark");
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    45.13034448,
    0.000000001,
    "Unsloth Qwen3-Coder-Next GGUF DGX resident footprint",
  );
  assertNear(
    result.alloc,
    2.535456768,
    0.000000001,
    "Unsloth Qwen3-Coder-Next GGUF DGX FP16 KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.batchWeight,
    2.312127488,
    0.000000001,
    "Unsloth Qwen3-Coder-Next GGUF DGX exact single-session decode traffic",
  );
  assertNear(
    result.single.readTraffic,
    0.864288768,
    0.000000001,
    "Unsloth Qwen3-Coder-Next GGUF DGX FP16 KV plus DeltaNet state read traffic",
  );
  assertNear(
    result.single.aggregate,
    85.946,
    0.001,
    "Unsloth Qwen3-Coder-Next GGUF DGX single",
  );
  assert.equal(result.bMem, 29);
  assert.equal(result.best.batch, 7);
  assertNear(
    result.best.aggregate,
    145.645,
    0.001,
    "Unsloth Qwen3-Coder-Next GGUF DGX aggregate",
  );
  assertNear(
    result.best.perSession,
    20.806,
    0.001,
    "Unsloth Qwen3-Coder-Next GGUF DGX per-session",
  );
  assertNear(
    result.dennard,
    3486.587,
    0.001,
    "Unsloth Qwen3-Coder-Next GGUF DGX Dennard",
  );

  const m5Result = profiled(
    "unsloth/Qwen3-Coder-Next-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 18);
  assertNear(
    m5Result.single.aggregate,
    193.3,
    0.001,
    "Unsloth Qwen3-Coder-Next GGUF M5 single",
  );
  assertNear(
    m5Result.best.aggregate,
    368.202,
    0.001,
    "Unsloth Qwen3-Coder-Next GGUF M5 aggregate",
  );
  assertNear(
    m5Result.best.perSession,
    20.456,
    0.001,
    "Unsloth Qwen3-Coder-Next GGUF M5 per-session",
  );
  assertNear(
    m5Result.dennard,
    7841.628,
    0.001,
    "Unsloth Qwen3-Coder-Next GGUF M5 Dennard",
  );
}

{
  const modelProfile = profile("Qwen/Qwen3-Next-80B-A3B-Instruct");
  const result = profiled(
    "Qwen/Qwen3-Next-80B-A3B-Instruct",
    "nvidia-dgx-spark",
  );
  assert.equal(
    modelProfile.serving.runtime_format,
    "vllm-or-sglang-bf16-text-decode-memory-bound",
  );
  assert.equal(result.status_code, "resident_not_fit");
  assertNear(
    result.resident,
    162.64972544,
    0.000000001,
    "Qwen3 Next 80B A3B Instruct BF16 DGX resident footprint",
  );
  assertNear(
    result.alloc,
    2.535456768,
    0.000000001,
    "Qwen3 Next 80B A3B Instruct BF16 DGX BF16 KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.batchWeight,
    7.12752896,
    0.000000001,
    "Qwen3 Next 80B A3B Instruct BF16 exact single-session decode traffic",
  );
  assertNear(
    result.single.readTraffic,
    0.864288768,
    0.000000001,
    "Qwen3 Next 80B A3B Instruct BF16 BF16 KV plus DeltaNet state read traffic",
  );
  assert.equal(result.bMem, 0);
  assert.equal(result.best, null);

  const m2Result = profiled(
    "Qwen/Qwen3-Next-80B-A3B-Instruct",
    "apple-mac-studio-m2-ultra-192gb",
  );
  assert.equal(m2Result.status_code, "ok");
  assert.equal(m2Result.bMem, 8);
  assert.equal(m2Result.best.batch, 8);
  assertNear(
    m2Result.single.aggregate,
    100.10238311581273,
    0.000000001,
    "Qwen3 Next 80B A3B Instruct BF16 M2 Ultra single",
  );
  assertNear(
    m2Result.best.aggregate,
    190.51823243853892,
    0.000000001,
    "Qwen3 Next 80B A3B Instruct BF16 M2 Ultra aggregate",
  );
  assertNear(
    m2Result.best.perSession,
    23.814779054817365,
    0.000000001,
    "Qwen3 Next 80B A3B Instruct BF16 M2 Ultra per-session",
  );
  assertNear(
    m2Result.dennard,
    945.1445860048653,
    0.000000001,
    "Qwen3 Next 80B A3B Instruct BF16 M2 Ultra Dennard",
  );
}

{
  const result = profiled(
    "Qwen/Qwen3-Next-80B-A3B-Instruct-FP8",
    "nvidia-dgx-spark",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    82.03286912,
    0.000000001,
    "Qwen3 Next 80B A3B Instruct FP8 DGX resident footprint",
  );
  assertNear(
    result.alloc,
    2.535456768,
    0.000000001,
    "Qwen3 Next 80B A3B Instruct FP8 DGX BF16 KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.batchWeight,
    3.9322496,
    0.000000001,
    "Qwen3 Next 80B A3B Instruct FP8 DGX exact single-session decode traffic",
  );
  assertNear(
    result.single.readTraffic,
    0.864288768,
    0.000000001,
    "Qwen3 Next 80B A3B Instruct FP8 DGX BF16 KV plus DeltaNet state read traffic",
  );
  assertNear(
    result.single.aggregate,
    57,
    1,
    "Qwen3 Next 80B A3B Instruct FP8 DGX single",
  );
  assert.equal(result.bMem, 14);
  assert.equal(result.best.batch, 4);
  assertNear(
    result.best.aggregate,
    93,
    1,
    "Qwen3 Next 80B A3B Instruct FP8 DGX aggregate",
  );
  assertNear(
    result.dennard,
    1040,
    50,
    "Qwen3 Next 80B A3B Instruct FP8 DGX Dennard",
  );
}

{
  const repo = "cyankiwi/Qwen3-Next-80B-A3B-Instruct-AWQ-4bit";
  const modelProfile = profile(repo);
  const catalogRow = model(repo);
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  assert.equal(modelProfile.status, "audited");
  assert.equal(modelProfile.base_model_proof.config_compatible, true);
  assert.equal(catalogRow.hf_downloads, 195424);
  assert.equal(catalogRow.architecture.shared_experts_per_token, 1);
  assertNear(
    catalogRow.adapter.resident_weight_gb,
    49.203395072,
    0.000000001,
    "cyankiwi Qwen3 Next 80B A3B AWQ catalog resident footprint",
  );
  assertNear(
    catalogRow.adapter.active_weight_gb,
    4.95699968,
    0.000000001,
    "cyankiwi Qwen3 Next 80B A3B AWQ catalog single-session traffic",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    4.10763008,
    0.000000001,
    "cyankiwi Qwen3 Next 80B A3B AWQ fixed ordinary traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.08493696,
    0.000000001,
    "cyankiwi Qwen3 Next 80B A3B AWQ per-expert traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.608041472,
    0.000000001,
    "cyankiwi Qwen3 Next 80B A3B AWQ resident-only embedding and MTP footprint",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    49.203395072,
    0.000000001,
    "cyankiwi Qwen3 Next 80B A3B AWQ DGX resident footprint",
  );
  assertNear(
    result.alloc,
    2.535456768,
    0.000000001,
    "cyankiwi Qwen3 Next 80B A3B AWQ DGX BF16 KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.batchWeight,
    4.95699968,
    0.000000001,
    "cyankiwi Qwen3 Next 80B A3B AWQ exact single-session decode traffic",
  );
  assertNear(
    result.single.readTraffic,
    0.864288768,
    0.000000001,
    "cyankiwi Qwen3 Next 80B A3B AWQ BF16 KV plus DeltaNet state read traffic",
  );
  assert.equal(result.bMem, 27);
  assert.equal(result.best.batch, 5);
  assertNear(
    result.single.aggregate,
    46.89683434150968,
    0.000000001,
    "cyankiwi Qwen3 Next 80B A3B AWQ DGX single",
  );
  assertNear(
    result.best.aggregate,
    109.08447526452355,
    0.000000001,
    "cyankiwi Qwen3 Next 80B A3B AWQ DGX aggregate",
  );
  assertNear(
    result.dennard,
    1537.800429402919,
    0.000000001,
    "cyankiwi Qwen3 Next 80B A3B AWQ DGX Dennard",
  );
}

{
  const repo = "cyankiwi/Qwen3-Next-80B-A3B-Thinking-AWQ-4bit";
  const modelProfile = profile(repo);
  const catalogRow = model(repo);
  const weightAdapter = modelProfile.architecture.weight_adapter;
  const result = profiled(repo, "nvidia-dgx-spark");
  assert.equal(modelProfile.status, "audited");
  assert.equal(modelProfile.base_model_proof.config_compatible, true);
  assert.equal(catalogRow.hf_downloads, 105276);
  assert.ok(catalogRow.tags.includes("region:us"));
  assert.equal(catalogRow.architecture.shared_experts_per_token, 1);
  assertNear(
    catalogRow.adapter.resident_weight_gb,
    49.203395072,
    0.000000001,
    "cyankiwi Qwen3 Next 80B A3B Thinking AWQ catalog resident footprint",
  );
  assertNear(
    catalogRow.adapter.active_weight_gb,
    4.95699968,
    0.000000001,
    "cyankiwi Qwen3 Next 80B A3B Thinking AWQ catalog single-session traffic",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    4.10763008,
    0.000000001,
    "cyankiwi Qwen3 Next 80B A3B Thinking AWQ fixed ordinary traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.08493696,
    0.000000001,
    "cyankiwi Qwen3 Next 80B A3B Thinking AWQ per-expert traffic",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.608041472,
    0.000000001,
    "cyankiwi Qwen3 Next 80B A3B Thinking AWQ resident-only embedding and MTP footprint",
  );
  assert.equal(result.status_code, "ok");
  assertNear(
    result.resident,
    49.203395072,
    0.000000001,
    "cyankiwi Qwen3 Next 80B A3B Thinking AWQ DGX resident footprint",
  );
  assertNear(
    result.alloc,
    2.535456768,
    0.000000001,
    "cyankiwi Qwen3 Next 80B A3B Thinking AWQ DGX BF16 KV plus DeltaNet state allocation",
  );
  assertNear(
    result.single.batchWeight,
    4.95699968,
    0.000000001,
    "cyankiwi Qwen3 Next 80B A3B Thinking AWQ exact single-session decode traffic",
  );
  assertNear(
    result.single.readTraffic,
    0.864288768,
    0.000000001,
    "cyankiwi Qwen3 Next 80B A3B Thinking AWQ BF16 KV plus DeltaNet state read traffic",
  );
  assert.equal(result.bMem, 27);
  assert.equal(result.best.batch, 5);
  assertNear(
    result.single.aggregate,
    46.89683434150968,
    0.000000001,
    "cyankiwi Qwen3 Next 80B A3B Thinking AWQ DGX single",
  );
  assertNear(
    result.best.aggregate,
    109.08447526452355,
    0.000000001,
    "cyankiwi Qwen3 Next 80B A3B Thinking AWQ DGX aggregate",
  );
  assertNear(
    result.dennard,
    1537.800429402919,
    0.000000001,
    "cyankiwi Qwen3 Next 80B A3B Thinking AWQ DGX Dennard",
  );
}

{
  const item = profile("VLTX/VertaLily-1.2-1B-GGUF");
  const modelRow = model("VLTX/VertaLily-1.2-1B-GGUF");
  const weightAdapter = item.architecture.weight_adapter;
  assert.equal(item.status, "audited");
  assert.equal(item.architecture.max_context_tokens, 128000);
  assert.equal(modelRow.hf_downloads, 152564);
  assert.equal(modelRow.architecture.layers, 16);
  assert.equal(modelRow.architecture.max_context_tokens, 128000);
  assert.equal(modelRow.adapter.weight_precision, "GGUF Q4_K_M");
  assertNear(
    weightAdapter.resident_weight_gb,
    0.730894368,
    0.000000001,
    "VertaLily Q4_K_M resident linked artifact size",
  );
  assertNear(
    weightAdapter.swept_weight_gb,
    0.72850944,
    0.000000001,
    "VertaLily Q4_K_M swept tensor spans",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.002384928,
    0.000000001,
    "VertaLily Q4_K_M GGUF metadata/header overhead",
  );
  const [attentionKv, shortConvState] = item.architecture.kv_adapter.components;
  assert.equal(attentionKv.kind, "full_context");
  assert.equal(attentionKv.layers, 6);
  assert.equal(attentionKv.kv_heads, 8);
  assert.equal(attentionKv.head_dim, 64);
  assert.equal(shortConvState.kind, "recurrent_state");
  assertNear(
    shortConvState.alloc_gb_per_session,
    0.00012288,
    0.000000001,
    "VertaLily short-conv fixed state allocation",
  );
  const dgxResult = profiled("VLTX/VertaLily-1.2-1B-GGUF", "nvidia-dgx-spark");
  assert.equal(dgxResult.status_code, "ok");
  assertNear(
    dgxResult.alloc,
    1.22892288,
    0.000000001,
    "VertaLily DGX FP16 attention KV plus short-conv state allocation",
  );
  assertNear(
    dgxResult.single.readTraffic,
    0.39333888,
    0.000000001,
    "VertaLily DGX FP16 attention KV plus short-conv state read traffic",
  );
  assertNear(
    dgxResult.single.aggregate,
    243.34840560263976,
    0.000000001,
    "VertaLily DGX single-session throughput",
  );
  assert.equal(dgxResult.bMem, 97);
  assert.equal(dgxResult.best.batch, 32);
  assertNear(
    dgxResult.best.aggregate,
    656.0847171193411,
    0.000000001,
    "VertaLily DGX aggregate throughput at b*",
  );
  assertNear(
    dgxResult.best.perSession,
    20.50264740997941,
    0.000000001,
    "VertaLily DGX per-session throughput at b*",
  );
  assertNear(
    dgxResult.dennard,
    36368.95277616251,
    0.000000001,
    "VertaLily DGX Dennard bound",
  );
  const m5Result = profiled(
    "VLTX/VertaLily-1.2-1B-GGUF",
    "apple-macbook-pro-16-m5-max-128gb",
  );
  assert.equal(m5Result.best.batch, 76);
  assertNear(
    m5Result.single.aggregate,
    547.3110660806623,
    0.000000001,
    "VertaLily M5 Max single-session throughput",
  );
  assertNear(
    m5Result.best.aggregate,
    1523.858572715762,
    0.000000001,
    "VertaLily M5 Max aggregate throughput at b*",
  );
  assertNear(
    m5Result.best.perSession,
    20.050770693628447,
    0.000000001,
    "VertaLily M5 Max per-session throughput at b*",
  );
  assertNear(
    m5Result.dennard,
    81796.83884455597,
    0.000000001,
    "VertaLily M5 Max Dennard bound",
  );
}

{
  const repo = "Jackrong/Qwen3.5-27B-Claude-4.6-Opus-Reasoning-Distilled-GGUF";
  const item = profile(repo);
  const modelRow = model(repo);
  const weightAdapter = item.architecture.weight_adapter;
  assert.equal(item.status, "audited");
  assert.equal(item.architecture.max_context_tokens, 262144);
  assert.equal(modelRow.hf_downloads, 212029);
  assert.equal(modelRow.architecture.total_params_b, 26.895998464);
  assert.equal(modelRow.architecture.active_params_b, 25.624600064);
  assert.equal(modelRow.adapter.weight_precision, "GGUF Q4_K_M");
  assertNear(
    weightAdapter.resident_weight_gb,
    16.540267968,
    0.000000001,
    "Jackrong Qwen3.5 27B Q4_K_M resident linked artifact size",
  );
  assertNear(
    weightAdapter.swept_weight_gb,
    15.814117376,
    0.000000001,
    "Jackrong Qwen3.5 27B Q4_K_M swept tensor spans",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.726150592,
    0.000000001,
    "Jackrong Qwen3.5 27B Q4_K_M resident-only token embedding plus GGUF overhead",
  );
  const [attentionKv, deltaState] = item.architecture.kv_adapter.components;
  assert.equal(attentionKv.kind, "full_context");
  assert.equal(attentionKv.layers, 16);
  assert.equal(attentionKv.kv_heads, 4);
  assert.equal(attentionKv.head_dim, 256);
  assert.equal(deltaState.kind, "recurrent_state");
  assertNear(
    deltaState.alloc_gb_per_session,
    0.154927104,
    0.000000001,
    "Jackrong Qwen3.5 27B fixed DeltaNet state allocation",
  );
  const dgxResult = profiled(repo, "nvidia-dgx-spark");
  assert.equal(dgxResult.status_code, "no_floor");
  assertNear(
    dgxResult.resident,
    16.540267968,
    0.000000001,
    "Jackrong Qwen3.5 27B DGX resident footprint",
  );
  assertNear(
    dgxResult.alloc,
    6.708527104,
    0.000000001,
    "Jackrong Qwen3.5 27B DGX FP16 KV plus DeltaNet allocation",
  );
  assertNear(
    dgxResult.single.readTraffic,
    2.252079104,
    0.000000001,
    "Jackrong Qwen3.5 27B DGX FP16 KV plus DeltaNet read traffic",
  );
  assertNear(
    dgxResult.single.aggregate,
    15.111094374636181,
    0.000000001,
    "Jackrong Qwen3.5 27B DGX single-session throughput",
  );
  assert.equal(dgxResult.bMem, 15);
  assert.equal(dgxResult.best, null);
  assertNear(
    dgxResult.dennard,
    266.2329838344315,
    0.000000001,
    "Jackrong Qwen3.5 27B DGX Dennard bound",
  );
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  assert.equal(m5Result.status_code, "ok");
  assert.equal(m5Result.best.batch, 6);
  assertNear(
    m5Result.single.aggregate,
    33.986124344419835,
    0.000000001,
    "Jackrong Qwen3.5 27B M5 Max single-session throughput",
  );
  assertNear(
    m5Result.best.aggregate,
    125.61977880007333,
    0.000000001,
    "Jackrong Qwen3.5 27B M5 Max aggregate throughput at b*",
  );
  assertNear(
    m5Result.best.perSession,
    20.936629800012224,
    0.000000001,
    "Jackrong Qwen3.5 27B M5 Max per-session throughput at b*",
  );
  assertNear(
    m5Result.dennard,
    598.7804105287213,
    0.000000001,
    "Jackrong Qwen3.5 27B M5 Max Dennard bound",
  );
}

{
  const repo = "Qwen/Qwen2.5-3B-Instruct-GGUF";
  const item = profile(repo);
  const modelRow = model(repo);
  const weightAdapter = item.architecture.weight_adapter;
  assert.equal(item.status, "audited");
  assert.equal(item.architecture.max_context_tokens, 32768);
  assert.equal(modelRow.hf_downloads, 215418);
  assert.equal(modelRow.architecture.total_params_b, 3.397103616);
  assert.equal(modelRow.architecture.active_params_b, 3.085938688);
  assert.equal(modelRow.adapter.weight_precision, "GGUF Q5_K_M");
  assertNear(
    weightAdapter.resident_weight_gb,
    2.438740384,
    0.000000001,
    "Qwen2.5 3B Instruct Q5_K_M resident linked artifact size",
  );
  assertNear(
    weightAdapter.swept_weight_gb,
    2.218858496,
    0.000000001,
    "Qwen2.5 3B Instruct Q5_K_M swept tensor spans",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.219881888,
    0.000000001,
    "Qwen2.5 3B Instruct Q5_K_M resident-only token embedding plus GGUF overhead",
  );
  assert.equal(item.architecture.kv_adapter.kind, "full_context");
  assert.equal(item.architecture.kv_adapter.layers, 36);
  assert.equal(item.architecture.kv_adapter.kv_heads, 2);
  assert.equal(item.architecture.kv_adapter.head_dim, 128);
  const dgxResult = profiled(repo, "nvidia-dgx-spark");
  assert.equal(dgxResult.status_code, "ok");
  assertNear(
    dgxResult.resident,
    2.438740384,
    0.000000001,
    "Qwen2.5 3B Instruct GGUF DGX resident footprint",
  );
  assertNear(
    dgxResult.alloc,
    3.6864,
    0.000000001,
    "Qwen2.5 3B Instruct GGUF DGX FP16 KV allocation",
  );
  assertNear(
    dgxResult.single.readTraffic,
    1.179648,
    0.000000001,
    "Qwen2.5 3B Instruct GGUF DGX FP16 KV read traffic",
  );
  assertNear(
    dgxResult.single.aggregate,
    80.32940361341595,
    0.000000001,
    "Qwen2.5 3B Instruct GGUF DGX single-session throughput",
  );
  assert.equal(dgxResult.bMem, 31);
  assert.equal(dgxResult.best.batch, 9);
  assertNear(
    dgxResult.best.aggregate,
    191.41938649624475,
    0.000000001,
    "Qwen2.5 3B Instruct GGUF DGX aggregate throughput at b*",
  );
  assertNear(
    dgxResult.best.perSession,
    21.26882072180497,
    0.000000001,
    "Qwen2.5 3B Instruct GGUF DGX per-session throughput at b*",
  );
  assertNear(
    dgxResult.dennard,
    3923.691138132876,
    0.000000001,
    "Qwen2.5 3B Instruct GGUF DGX Dennard bound",
  );
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  assert.equal(m5Result.best.batch, 24);
  assertNear(
    m5Result.single.aggregate,
    180.66759640526516,
    0.000000001,
    "Qwen2.5 3B Instruct GGUF M5 Max single-session throughput",
  );
  assertNear(
    m5Result.best.aggregate,
    482.66629110442733,
    0.000000001,
    "Qwen2.5 3B Instruct GGUF M5 Max aggregate throughput at b*",
  );
  assertNear(
    m5Result.best.perSession,
    20.11109546268447,
    0.000000001,
    "Qwen2.5 3B Instruct GGUF M5 Max per-session throughput at b*",
  );
  assertNear(
    m5Result.dennard,
    8824.711937046102,
    0.000000001,
    "Qwen2.5 3B Instruct GGUF M5 Max Dennard bound",
  );
}

{
  const repo = "unsloth/GLM-5.2-GGUF";
  const item = profile(repo);
  const modelRow = model(repo);
  const weightAdapter = item.architecture.weight_adapter;
  assert.equal(item.status, "audited");
  assert.equal(item.architecture.max_context_tokens, 1048576);
  assert.equal(modelRow.hf_downloads, 392857);
  assert.equal(modelRow.architecture.total_params_b, 753.864139008);
  assert.equal(modelRow.architecture.active_params_b, 40.1021376);
  assert.equal(modelRow.adapter.weight_precision, "GGUF BF16");
  assertNear(
    weightAdapter.resident_weight_gb,
    1507.988023008,
    0.000000001,
    "Unsloth GLM-5.2 BF16 GGUF resident linked split size",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    1484.695550976,
    0.000000001,
    "Unsloth GLM-5.2 BF16 GGUF active-resident tensor footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    23.292472032,
    0.000000001,
    "Unsloth GLM-5.2 BF16 GGUF resident-only embedding/MTP/indexer/overhead",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    35.144088576,
    0.000000001,
    "Unsloth GLM-5.2 BF16 GGUF current llama.cpp used fixed traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    5.6623104,
    0.000000001,
    "Unsloth GLM-5.2 BF16 GGUF per-routed-expert traffic",
  );
  assert.equal(item.architecture.kv_adapter.kind, "full_context");
  assert.equal(item.architecture.kv_adapter.layers, 78);
  assert.equal(item.architecture.kv_adapter.kv_heads, 1);
  assert.equal(item.architecture.kv_adapter.head_dim, 576);
  assert.equal(item.architecture.kv_adapter.kv_scalar_multiplier, 1);
  const dgxResult = profiled(repo, "nvidia-dgx-spark");
  assert.equal(dgxResult.status_code, "resident_not_fit");
  assertNear(
    dgxResult.resident,
    1507.988023008,
    0.000000001,
    "Unsloth GLM-5.2 BF16 GGUF DGX resident footprint",
  );
  assertNear(
    dgxResult.alloc,
    8.9856,
    0.000000001,
    "Unsloth GLM-5.2 BF16 GGUF DGX compact MLA allocation",
  );
  assertNear(
    dgxResult.single.readTraffic,
    2.875392,
    0.000000001,
    "Unsloth GLM-5.2 BF16 GGUF DGX compact MLA read traffic",
  );
  assertNear(
    dgxResult.single.aggregate,
    3.2766043194953656,
    0.000000001,
    "Unsloth GLM-5.2 BF16 GGUF DGX single-session throughput",
  );
  assert.equal(dgxResult.bMem, 0);
  assert.equal(dgxResult.best, null);
  const gb300Result = profiled(
    repo,
    "nvidia-msi-xpertstation-ws300-dgx-station-gb300",
  );
  assert.equal(gb300Result.status_code, "resident_not_fit");
  assertNear(
    gb300Result.free,
    -767.988023008,
    0.000000001,
    "Unsloth GLM-5.2 BF16 GGUF GB300 resident shortfall",
  );
  assertNear(
    gb300Result.single.aggregate,
    85.21571673412856,
    0.000000001,
    "Unsloth GLM-5.2 BF16 GGUF GB300 single-session bound",
  );
}

{
  const repo = "sugoitoolkit/Sugoi-14B-Ultra-GGUF";
  const item = profile(repo);
  const modelRow = model(repo);
  const weightAdapter = item.architecture.weight_adapter;
  assert.equal(item.status, "audited");
  assert.equal(item.architecture.max_context_tokens, 32768);
  assert.equal(modelRow.hf_downloads, 187132);
  assert.equal(modelRow.architecture.total_params_b, 14.770033664);
  assert.equal(modelRow.architecture.active_params_b, 13.991465984);
  assert.equal(modelRow.adapter.weight_precision, "GGUF F16");
  assertNear(
    weightAdapter.resident_weight_gb,
    29.54771584,
    0.000000001,
    "Sugoi 14B Ultra F16 GGUF resident linked artifact size",
  );
  assertNear(
    weightAdapter.swept_weight_gb,
    27.984613376,
    0.000000001,
    "Sugoi 14B Ultra F16 GGUF swept tensor spans",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    1.563102464,
    0.000000001,
    "Sugoi 14B Ultra F16 GGUF resident-only token embedding plus overhead",
  );
  assert.equal(item.architecture.kv_adapter.kind, "full_context");
  assert.equal(item.architecture.kv_adapter.layers, 48);
  assert.equal(item.architecture.kv_adapter.kv_heads, 8);
  assert.equal(item.architecture.kv_adapter.head_dim, 128);
  const dgxResult = profiled(repo, "nvidia-dgx-spark");
  assert.equal(dgxResult.status_code, "no_floor");
  assertNear(
    dgxResult.resident,
    29.54771584,
    0.000000001,
    "Sugoi 14B Ultra F16 GGUF DGX resident footprint",
  );
  assertNear(
    dgxResult.alloc,
    19.6608,
    0.000000001,
    "Sugoi 14B Ultra F16 GGUF DGX FP16 KV allocation",
  );
  assertNear(
    dgxResult.single.readTraffic,
    6.291456,
    0.000000001,
    "Sugoi 14B Ultra F16 GGUF DGX FP16 KV read traffic",
  );
  assertNear(
    dgxResult.single.aggregate,
    7.964740560104999,
    0.000000001,
    "Sugoi 14B Ultra F16 GGUF DGX single-session throughput",
  );
  assert.equal(dgxResult.bMem, 4);
  assert.equal(dgxResult.best, null);
  assertNear(
    dgxResult.dennard,
    44.880913599335436,
    0.000000001,
    "Sugoi 14B Ultra F16 GGUF DGX Dennard bound",
  );
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  assert.equal(m5Result.status_code, "no_floor");
  assertNear(
    m5Result.single.aggregate,
    17.913372541774613,
    0.000000001,
    "Sugoi 14B Ultra F16 GGUF M5 Max single-session throughput",
  );
  const m1Result = profiled(repo, "apple-mac-studio-m1-ultra-128gb");
  assert.equal(m1Result.status_code, "ok");
  assert.equal(m1Result.best.batch, 1);
  assertNear(
    m1Result.best.aggregate,
    23.339899077230765,
    0.000000001,
    "Sugoi 14B Ultra F16 GGUF M1 Ultra aggregate throughput at b*",
  );
  assertNear(
    m1Result.dennard,
    131.51916073065328,
    0.000000001,
    "Sugoi 14B Ultra F16 GGUF M1 Ultra Dennard bound",
  );
}

{
  const repo = "Jackrong/Qwopus3.6-35B-A3B-v1-GGUF";
  const item = profile(repo);
  const modelRow = model(repo);
  const weightAdapter = item.architecture.weight_adapter;
  assert.equal(item.status, "audited");
  assert.equal(item.architecture.max_context_tokens, 262144);
  assert.equal(modelRow.hf_downloads, 178977);
  assert.equal(modelRow.architecture.total_params_b, 34.660610688);
  assert.equal(modelRow.architecture.active_params_b, 2.946429568);
  assert.equal(modelRow.architecture.shared_experts_per_token, 1);
  assert.equal(modelRow.adapter.weight_precision, "GGUF IQ4_XS");
  assertNear(
    weightAdapter.resident_weight_gb,
    18.939312512,
    0.000000001,
    "Jackrong Qwopus3.6 35B A3B v1 IQ4_XS resident linked artifact size",
  );
  assertNear(
    weightAdapter.main_resident_weight_gb,
    18.658150912,
    0.000000001,
    "Jackrong Qwopus3.6 35B A3B v1 IQ4_XS main resident footprint",
  );
  assertNear(
    weightAdapter.auxiliary_resident_weight_gb,
    0.2811616,
    0.000000001,
    "Jackrong Qwopus3.6 35B A3B v1 IQ4_XS resident-only token embedding plus header",
  );
  assertNear(
    weightAdapter.fixed_weight_gb,
    1.335675392,
    0.000000001,
    "Jackrong Qwopus3.6 35B A3B v1 IQ4_XS fixed ordinary text traffic",
  );
  assertNear(
    weightAdapter.routed_expert_weight_gb,
    0.06766592,
    0.000000001,
    "Jackrong Qwopus3.6 35B A3B v1 IQ4_XS routed expert byte group",
  );
  const dgxResult = profiled(repo, "nvidia-dgx-spark");
  assert.equal(dgxResult.status_code, "ok");
  assertNear(
    dgxResult.resident,
    18.939312512,
    0.000000001,
    "Jackrong Qwopus3.6 35B A3B v1 IQ4_XS DGX resident footprint",
  );
  assertNear(
    dgxResult.single.batchWeight,
    1.877002752,
    0.000000001,
    "Jackrong Qwopus3.6 35B A3B v1 IQ4_XS single-session weight traffic",
  );
  assertNear(
    dgxResult.alloc,
    2.11288064,
    0.000000001,
    "Jackrong Qwopus3.6 35B A3B v1 IQ4_XS hybrid KV plus DeltaNet allocation",
  );
  assertNear(
    dgxResult.single.readTraffic,
    0.72024064,
    0.000000001,
    "Jackrong Qwopus3.6 35B A3B v1 IQ4_XS hybrid KV plus DeltaNet read traffic",
  );
  assertNear(
    dgxResult.single.aggregate,
    105.11144270917832,
    0.000000001,
    "Jackrong Qwopus3.6 35B A3B v1 IQ4_XS DGX single-session throughput",
  );
  assert.equal(dgxResult.bMem, 47);
  assert.equal(dgxResult.best.batch, 10);
  assertNear(
    dgxResult.best.aggregate,
    206.03449902525483,
    0.000000001,
    "Jackrong Qwopus3.6 35B A3B v1 IQ4_XS DGX aggregate throughput at b*",
  );
  assertNear(
    dgxResult.best.perSession,
    20.603449902525483,
    0.000000001,
    "Jackrong Qwopus3.6 35B A3B v1 IQ4_XS DGX per-session throughput at b*",
  );
  assertNear(
    dgxResult.dennard,
    6956.727982907029,
    0.000000001,
    "Jackrong Qwopus3.6 35B A3B v1 IQ4_XS DGX Dennard bound",
  );
  const m5Result = profiled(repo, "apple-macbook-pro-16-m5-max-128gb");
  assert.equal(m5Result.best.batch, 26);
  assertNear(
    m5Result.best.aggregate,
    535.7652765581759,
    0.000000001,
    "Jackrong Qwopus3.6 35B A3B v1 IQ4_XS M5 Max aggregate throughput at b*",
  );
  assertNear(
    m5Result.dennard,
    15646.26733151984,
    0.000000001,
    "Jackrong Qwopus3.6 35B A3B v1 IQ4_XS M5 Max Dennard bound",
  );
}

console.log("profiled bounds regression tests passed");