diff --git a/cpu_performance.js b/cpu_performance.js
new file mode 100644
index 0000000..044a467
--- /dev/null
+++ b/cpu_performance.js
@@ -0,0 +1,344 @@
+// JavaScript reference implementation of the CPU Performance API.
+//
+// This module is a direct translation of the Chromium C++ implementation in
+// cpu_performance.cc. Its purpose is to make the classification rules
+// described informally by the specification (index.bs) easy to inspect,
+// reproduce, and test in isolation. The high-level shape of the API matches
+// the specification: `navigator.cpuPerformance` returns a non-negative
+// integer, where 0 means "unknown" and higher values mean higher tiers.
+// The specification currently defines tiers 1..4; future revisions are
+// expected to add 5, 6, and so on.
+
+'use strict';
+
+const Manufacturer = Object.freeze({
+  UNKNOWN: 'unknown',
+  AMD: 'amd',
+  APPLE: 'apple',
+  INTEL: 'intel',
+  MEDIATEK: 'mediatek',
+  MICROSOFT: 'microsoft',
+  QUALCOMM: 'qualcomm',
+  SAMSUNG: 'samsung',
+});
+
+function trimAndCollapseWhitespace(text) {
+  // \p{Z} matches unicode separators (including NBSP).
+  // \x1C\x1F match the file and unit separator characters.
+  return text
+    .replace(/^[\s\p{Z}\x1C\x1F]+/u, '')
+    .replace(/[\s\p{Z}\x1C\x1F]+$/u, '')
+    .replace(/[\s\p{Z}\x1C\x1F]+/gu, ' ');
+}
+
+function getManufacturer(cpuModel) {
+  if (/\bAMD\b/i.test(cpuModel)) return Manufacturer.AMD;
+  if (/\bApple\b/i.test(cpuModel)) return Manufacturer.APPLE;
+  if (/\b(Intel|Celeron|Pentium)\b/i.test(cpuModel)) return Manufacturer.INTEL;
+  if (/\bMediaTek\b/i.test(cpuModel)) return Manufacturer.MEDIATEK;
+  if (/\bMicrosoft\b/i.test(cpuModel)) return Manufacturer.MICROSOFT;
+  if (/\b(Qualcomm|Snapdragon)\b/i.test(cpuModel)) return Manufacturer.QUALCOMM;
+  if (/\bSamsung\b/i.test(cpuModel)) return Manufacturer.SAMSUNG;
+  return Manufacturer.UNKNOWN;
+}
+
+function splitCpuModel(cpuModel) {
+  let text = String(cpuModel == null ? '' : cpuModel);
+
+  text = trimAndCollapseWhitespace(text);
+
+  const manufacturer = getManufacturer(text);
+
+  // Remove everything between parentheses.
+  text = text.replace(/\([^)]*\)/g, ' ');
+
+  // Remove special characters.
+  text = text.replace(/\$|®|™/g, ' ');
+
+  // Remove "GHz" patterns.
+  text = text.replace(/@( )?\d[.,]\d+([~\-]\d[.,]\d+)?( )?GHz\b/gi, '');
+  text = text.replace(/\b\d[.,]\d+([~\-]\d[.,]\d+)?( )?GHz\b/gi, '');
+
+  text = trimAndCollapseWhitespace(text);
+
+  // Remove trailing special characters.
+  text = text.replace(/(^| )?[@~\-,.]$/g, '');
+
+  // Remove filler words.
+  text = text.replace(/\bCPU\b/gi, '');
+  text = text.replace(/\bMobile\b/gi, '');
+  text = text.replace(/\bProcessor\b/gi, '');
+  text = text.replace(/\bSilicon\b/gi, '');
+  text = text.replace(/\bSOC\b/gi, '');
+  text = text.replace(/\bTechnology\b/gi, '');
+
+  text = trimAndCollapseWhitespace(text);
+
+  switch (manufacturer) {
+    case Manufacturer.AMD:
+      // ReplaceFirst: strip everything up to and including the first "AMD" token.
+      text = text.replace(/.*?\bAMD\b/i, '');
+      text = trimAndCollapseWhitespace(text);
+      text = text.replace(/\bFX -/gi, 'FX-');
+      text = text.replace(/\+( )?(AMD )?Radeon.*/gi, '');
+      text = text.replace(
+        /\b(RADEON )?R\d+, \d+ COMPUTE CORES \d+C\+\d+G\b/gi,
+        '',
+      );
+      text = text.replace(/\bwith (AMD )?Radeon.*/gi, '');
+      text = text.replace(/\bw\/( )?(AMD )?Radeon.*/gi, '');
+      text = text.replace(/\bRadeon.*/gi, '');
+
+      text = text.replace(/\b\w+( |-)Core\b/gi, '');
+      text = text.replace(/\b\d+-Core(s)?\b/gi, '');
+
+      text = text.replace(/\bAPU\b/gi, '');
+      text = text.replace(/\bCreator Edition\b/gi, '');
+      text = text.replace(/\bDesktop Kit\b/gi, '');
+
+      text = text.replace(/\b(3250C) 15W\b/gi, '$1');
+      break;
+    case Manufacturer.APPLE:
+      text = text.replace(/.*?\bApple\b/i, '');
+      break;
+    case Manufacturer.INTEL:
+      text = text.replace(/.*?\bIntel\b/i, '');
+      text = trimAndCollapseWhitespace(text);
+      text = text.replace(/\b(Core)(2)\b/gi, '$1 $2');
+      text = text.replace(/\b(Core i\d+)( )?-( )?/gi, '$1-');
+      text = text.replace(/\b(Core i\d+) (M) (\d+)\b/gi, '$1-$3$2');
+      text = text.replace(/\b(Core i\d+) ([LQU]) (\d+)\b/gi, '$1-$3$2M');
+      text = text.replace(/\b(Core i\d+) (\d+)\b/gi, '$1-$2');
+      text = text.replace(/\b(Celeron|Pentium) Dual(-Core)?\b/gi, '$1');
+      text = text.replace(/\b0+$/g, '');
+      break;
+    default:
+      // For all other manufacturers including UNKNOWN, return an empty model.
+      return { manufacturer, model: '' };
+  }
+
+  text = trimAndCollapseWhitespace(text);
+  return { manufacturer, model: text };
+}
+
+function getTierFromCores(cores) {
+  if (cores >= 1 && cores <= 2) return 1;
+  if (cores >= 3 && cores <= 4) return 2;
+  if (cores >= 5 && cores <= 12) return 3;
+  if (cores >= 13) return 4;
+  return 0;
+}
+
+function getTierFromCpuInfo(cpuModel, cores) {
+  if (cores <= 0) return 0;
+  if (cores <= 1) return 1;
+
+  const { manufacturer, model } = splitCpuModel(cpuModel);
+  const m = (re) => re.test(model);
+
+  if (cores <= 4) {
+    switch (manufacturer) {
+      case Manufacturer.AMD:
+        // 2 cores, K8 + K10 + Mobile Trinity
+        if (
+          cores === 2 &&
+          (m(/^Athlon 64\b/) ||
+            m(/^Athlon II\b/) ||
+            m(/^Athlon X2\b/) ||
+            m(/^Phenom II\b/) ||
+            m(/^Sempron X2\b/) ||
+            m(/^Turion II\b/) ||
+            m(/^Turion X2\b/) ||
+            // Llano (~2011)
+            m(/^(A4|E2)-[3]\d\d\d[A-Z]*\b/) ||
+            // Trinity (~2012)
+            m(/^(A4|A6)-[4]\d\d\dM[A-Z]*\b/))
+        ) {
+          return 1;
+        }
+        // 2 cores, Bobcat + Jaguar
+        if (
+          cores === 2 &&
+          (m(/^(C|E|E1|E2|T|Z)-\w*\b/) ||
+            m(/^(A4)-[1]\d\d\d[A-Z]*\b/) ||
+            m(/^(GX)-[2]\d\d[A-Z]*\b/) ||
+            m(/^Sempron 2650\b/))
+        ) {
+          return 1;
+        }
+        // 2 cores, Entry-Level Stoney Ridge 2019 6W Re-Release
+        if (cores === 2 && m(/^A4-9120[Ce]\b/)) {
+          return 1;
+        }
+        // 4 cores, >= Zen
+        if (
+          cores === 4 &&
+          m(/^Ryzen\b/) &&
+          // not 2 cores, Zen (~2017)
+          !m(/^Ryzen 3 Pro 2100GE\b/) &&
+          !m(/^Ryzen 3 Pro 3050GE\b/) &&
+          !m(/^Ryzen 3 2200U\b/) &&
+          !m(/^Ryzen 3 3200U\b/) &&
+          !m(/^Ryzen 3 3250[UC]\b/) &&
+          !m(/^Ryzen Embedded R[1]\d\d\d[A-Z]*\b/) &&
+          // not 2 cores, Zen+ (~2018)
+          !m(/^Ryzen Embedded R2312\b/)
+        ) {
+          return 3;
+        }
+        break;
+      case Manufacturer.INTEL:
+        // 2-4 cores, E-Core, Bonnell + Saltwell
+        if (
+          cores >= 2 && cores <= 4 &&
+          (// Silverthorne (~2008)
+            m(/^Atom (Z5)\d\d[A-Z]*\b/) ||
+            // Diamondville (~2008)
+            m(/^Atom (2|3|N2)\d\d[A-Z]*\b/) ||
+            // Pineview (~2010)
+            m(/^Atom (D4|N4|D5|N5)\d\d[A-Z]*\b/) ||
+            // Tunnel Creek (~2010) / Stellarton (~2010)
+            m(/^Atom (E6)\d\d[A-Z]*\b/) ||
+            // Lincroft (~2010)
+            m(/^Atom (Z6)\d\d[A-Z]*\b/) ||
+            // Cedarview (~2011)
+            m(/^Atom (D2|N2)\d\d\d[A-Z]*\b/) ||
+            // Penwell (~2012) + Cloverview (~2012)
+            m(/^Atom (Z2)\d\d\d[A-Z]*\b/))
+        ) {
+          return 1;
+        }
+        // 2-4 cores, E-Core, Silvermont + Airmont
+        if (
+          cores >= 2 && cores <= 4 &&
+          (// Bay Trail-D (~2013)
+            m(/^Celeron (J1)\d\d\d[A-Z]*\b/) ||
+            m(/^Pentium (J2)\d\d\d[A-Z]*\b/) ||
+            // Avoton (~2013) / Rangeley (~2013)
+            m(/^Atom (C2)[35]\d\d[A-Z]*\b/) ||
+            // Bay Trail-I (~2013)
+            m(/^Atom (E3)[8]\d\d[A-Z]*\b/) ||
+            // Bay Trail-M (~2013)
+            m(/^Celeron (N2)\d\d\d[A-Z]*\b/) ||
+            m(/^Pentium (N3)[5]\d\d[A-Z]*\b/) ||
+            // Bay Trail-T (~2013) + Merrifield (~2014) + Moorefield (~2014)
+            m(/^Atom (Z3)\d\d\d[A-Z]*\b/) ||
+            // Braswell (~2016)
+            m(/^Atom x[5]-(E8)\d\d\d[A-Z]*\b/) ||
+            m(/^Celeron (J3|N3)[01]\d\d[A-Z]*\b/) ||
+            m(/^Pentium (J3|N3)[7]\d\d[A-Z]*\b/) ||
+            // Cherry Trail-T (~2015)
+            m(/^Atom x[57]-(Z8)\d\d\d[A-Z]*\b/))
+        ) {
+          return 1;
+        }
+        // 2 cores, E-Core, Goldmont
+        if (
+          cores === 2 &&
+          (// Apollo Lake (~2016)
+            m(/^Atom x[5]-(A3|E3)\d\d\d[A-Z]*\b/) ||
+            m(/^Celeron (J3|N3)[34]\d\d[A-Z]*\b/) ||
+            // Denverton (~2017)
+            m(/^Atom (C3)\d\d\d[A-Z]*\b/))
+        ) {
+          return 1;
+        }
+        // 2 cores, P-Core, Merom + Penryn
+        if (
+          cores === 2 &&
+          (// Merom (~2006) + Conroe (~2006) + Penryn (~2007)
+            m(/^Celeron (E1|SU2|T1|T3)\d\d\d[A-Z]*\b/) ||
+            m(/^Core 2 Duo\b/) ||
+            m(/^Core 2 Extreme\b/) ||
+            m(/^Pentium (E2|SU2|SU4|T2|T3|T4)\d\d\d[A-Z]*\b/) ||
+            m(/^Xeon (3|E3|L3)\d\d\d[A-Z]*\b/))
+        ) {
+          return 1;
+        }
+        // 2 cores, P-Core, Nehalem + Westmere
+        if (
+          cores === 2 &&
+          (// Arrandale (~2010)
+            m(/^Celeron (P4|U3)\d\d\d[A-Z]*\b/) ||
+            m(/^Pentium (P6|U5)\d\d\d[A-Z]*\b/))
+        ) {
+          return 1;
+        }
+        // 2 cores, P-Core, Mobile Sandy Bridge + Mobile Ivy Bridge
+        if (
+          cores === 2 &&
+          (// Sandy Bridge-M (~2011)
+            m(/^Celeron (7|8|B7|B8)\d\d[A-Z]*\b/) ||
+            m(/^Pentium (9|B9)\d\d[A-Z]*\b/) ||
+            // Ivy Bridge-M (~2012)
+            m(/^Celeron (1)\d\d\d[A-Z]*\b/) ||
+            m(/^Pentium (2|A1)\d\d\d[A-Z]*\b/))
+        ) {
+          return 1;
+        }
+        // 4 cores, E-Core, >= Gracemont
+        if (
+          cores === 4 &&
+          (m(/^N\d\d+\b/) ||
+            // Alder Lake-N (~2023)
+            m(/^Atom x7425E\b/))
+        ) {
+          return 3;
+        }
+        break;
+      default:
+        // Any other manufacturer with at most 2 cores is demoted to tier 1.
+        if (cores <= 2) return 1;
+        break;
+    }
+    return 2;
+  }
+
+  if (cores <= 10) {
+    switch (manufacturer) {
+      case Manufacturer.APPLE:
+        // 8+ cores, M-series
+        if (cores >= 8 && m(/^M\d+\b/)) return 4;
+        break;
+      case Manufacturer.INTEL:
+        // 8+ cores, >= Meteor Lake
+        if (cores >= 8 && m(/^Core Ultra\b/)) return 4;
+        break;
+      default:
+        break;
+    }
+    return 3;
+  }
+
+  return 4;
+}
+
+// Spec-shaped accessor. Returns an object that exposes a `cpuPerformance`
+// getter behaving like `navigator.cpuPerformance` as defined in index.bs:
+// a non-negative integer where 0 means "unknown" and higher values mean
+// higher tiers.
+function createNavigatorCpuPerformance({ cpuModel = '', cores = 0 } = {}) {
+  const tier = getTierFromCpuInfo(cpuModel, cores);
+  return Object.freeze({
+    get cpuPerformance() {
+      return tier;
+    },
+  });
+}
+
+const exports_ = {
+  Manufacturer,
+  trimAndCollapseWhitespace,
+  getManufacturer,
+  splitCpuModel,
+  getTierFromCores,
+  getTierFromCpuInfo,
+  createNavigatorCpuPerformance,
+};
+
+// Support both Node.js (require) and a plain browser <script> tag (global).
+if (typeof module !== 'undefined' && typeof module.exports !== 'undefined') {
+  module.exports = exports_;
+} else if (typeof globalThis !== 'undefined') {
+  globalThis.CpuPerformance = exports_;
+}
diff --git a/cpu_performance.test.js b/cpu_performance.test.js
new file mode 100644
index 0000000..ed5cb7e
--- /dev/null
+++ b/cpu_performance.test.js
@@ -0,0 +1,237 @@
+// Unit tests for the JavaScript reference implementation of the CPU
+// Performance API. Each test pins a concrete (CPU model, core count) pair
+// to the tier that the Chromium implementation in cpu_performance.cc would
+// classify it under, so the two implementations can be cross-validated.
+
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const {
+  Manufacturer,
+  splitCpuModel,
+  getTierFromCores,
+  getTierFromCpuInfo,
+  createNavigatorCpuPerformance,
+} = require('./cpu_performance');
+
+// 20 representative CPU configurations covering every tier and every
+// manufacturer-specific code path that the Chromium implementation handles.
+const CPU_CASES = [
+  // --- Tier 0 (unknown) ---
+  {
+    name: 'zero cores reports tier 0',
+    model: 'Apple M2',
+    cores: 0,
+    expected: 0,
+  },
+
+  // --- Tier 1 ---
+  {
+    name: 'single core falls into tier 1 regardless of model',
+    model: 'Some Future Mystery Chip',
+    cores: 1,
+    expected: 1,
+  },
+  {
+    name: 'two cores on an unknown manufacturer is tier 1',
+    model: 'Mystery Brand XPU 9000',
+    cores: 2,
+    expected: 1,
+  },
+  {
+    name: 'Intel Atom Z520 (Silverthorne) on 2 cores is tier 1',
+    model: 'Intel(R) Atom(TM) CPU Z520 @ 1.33GHz',
+    cores: 2,
+    expected: 1,
+  },
+  {
+    name: 'Intel Pentium N3540 (Bay Trail-M) on 4 cores is tier 1',
+    model: 'Intel(R) Pentium(R) CPU N3540 @ 2.16GHz',
+    cores: 4,
+    expected: 1,
+  },
+  {
+    name: 'Intel Core 2 Duo T7700 (Merom) on 2 cores is tier 1',
+    model: 'Intel(R) Core(TM)2 Duo CPU T7700 @ 2.40GHz',
+    cores: 2,
+    expected: 1,
+  },
+  {
+    name: 'AMD A4-9120e (Stoney Ridge re-release) on 2 cores is tier 1',
+    model: 'AMD A4-9120e',
+    cores: 2,
+    expected: 1,
+  },
+
+  // --- Tier 2 ---
+  {
+    name: 'three cores on an unknown manufacturer is tier 2',
+    model: 'Mystery Brand XPU 9000',
+    cores: 3,
+    expected: 2,
+  },
+  {
+    name: 'AMD Ryzen 3 2200U on 4 cores is excluded from tier 3, so tier 2',
+    model: 'AMD Ryzen 3 2200U',
+    cores: 4,
+    expected: 2,
+  },
+
+  // --- Tier 3 ---
+  {
+    name: 'AMD Ryzen 5 2400G on 4 cores is tier 3 (Zen-class)',
+    model: 'AMD Ryzen 5 2400G',
+    cores: 4,
+    expected: 3,
+  },
+  {
+    name: 'Intel Atom x7425E (Alder Lake-N) on 4 cores is tier 3',
+    model: 'Intel(R) Atom(TM) x7425E',
+    cores: 4,
+    expected: 3,
+  },
+  {
+    name: 'Intel N100 (Alder Lake-N) on 4 cores is tier 3',
+    model: 'Intel N100',
+    cores: 4,
+    expected: 3,
+  },
+  {
+    name: 'Intel Core i5-10400 on 6 cores is tier 3',
+    model: 'Intel(R) Core(TM) i5-10400 CPU @ 2.90GHz',
+    cores: 6,
+    expected: 3,
+  },
+  {
+    name: 'AMD Ryzen 5 5600X on 6 cores is tier 3',
+    model: 'AMD Ryzen 5 5600X 6-Core Processor',
+    cores: 6,
+    expected: 3,
+  },
+  {
+    name: 'Intel Core i7-1185G7 on 8 cores is tier 3 (not Core Ultra)',
+    model: 'Intel(R) Core(TM) i7-1185G7 CPU @ 3.00GHz',
+    cores: 8,
+    expected: 3,
+  },
+  {
+    name: 'Qualcomm Snapdragon 8cx Gen 3 on 8 cores is tier 3',
+    model: 'Qualcomm Snapdragon 8cx Gen 3',
+    cores: 8,
+    expected: 3,
+  },
+  {
+    name: 'Microsoft SQ3 on 8 cores is tier 3',
+    model: 'Microsoft SQ3',
+    cores: 8,
+    expected: 3,
+  },
+
+  // --- Tier 4 ---
+  {
+    name: 'Apple M1 on 8 cores is tier 4',
+    model: 'Apple M1',
+    cores: 8,
+    expected: 4,
+  },
+  {
+    name: 'Apple M2 Pro on 10 cores is tier 4',
+    model: 'Apple M2 Pro',
+    cores: 10,
+    expected: 4,
+  },
+  {
+    name: 'Intel Core Ultra 7 155H (Meteor Lake) on 8 cores is tier 4',
+    model: 'Intel(R) Core(TM) Ultra 7 155H',
+    cores: 8,
+    expected: 4,
+  },
+  {
+    name: 'AMD Ryzen 9 5950X on 16 cores is tier 4 (cores > 10)',
+    model: 'AMD Ryzen 9 5950X 16-Core Processor',
+    cores: 16,
+    expected: 4,
+  },
+  {
+    name: 'Intel Core i9-13900K on 24 cores is tier 4 (cores > 10)',
+    model: 'Intel(R) Core(TM) i9-13900K CPU @ 3.00GHz',
+    cores: 24,
+    expected: 4,
+  },
+];
+
+test('getTierFromCpuInfo classifies known CPU configurations', async (t) => {
+  for (const c of CPU_CASES) {
+    await t.test(c.name, () => {
+      assert.equal(getTierFromCpuInfo(c.model, c.cores), c.expected);
+    });
+  }
+});
+
+test('getTierFromCores follows the documented thresholds', () => {
+  assert.equal(getTierFromCores(0), 0);
+  assert.equal(getTierFromCores(1), 1);
+  assert.equal(getTierFromCores(2), 1);
+  assert.equal(getTierFromCores(3), 2);
+  assert.equal(getTierFromCores(4), 2);
+  assert.equal(getTierFromCores(5), 3);
+  assert.equal(getTierFromCores(12), 3);
+  assert.equal(getTierFromCores(13), 4);
+  assert.equal(getTierFromCores(64), 4);
+});
+
+test('splitCpuModel normalizes vendor strings', () => {
+  assert.deepEqual(splitCpuModel('Apple M1'), {
+    manufacturer: Manufacturer.APPLE,
+    model: 'M1',
+  });
+
+  assert.deepEqual(
+    splitCpuModel('Intel(R) Core(TM) i7-1185G7 CPU @ 3.00GHz'),
+    { manufacturer: Manufacturer.INTEL, model: 'Core i7-1185G7' },
+  );
+
+  assert.deepEqual(splitCpuModel('Intel(R) Core(TM)2 Duo CPU T7700 @ 2.40GHz'), {
+    manufacturer: Manufacturer.INTEL,
+    model: 'Core 2 Duo T7700',
+  });
+
+  assert.deepEqual(
+    splitCpuModel('AMD Ryzen 9 5950X 16-Core Processor'),
+    { manufacturer: Manufacturer.AMD, model: 'Ryzen 9 5950X' },
+  );
+
+  assert.deepEqual(
+    splitCpuModel('AMD Ryzen 5 PRO 5650U with Radeon Graphics'),
+    { manufacturer: Manufacturer.AMD, model: 'Ryzen 5 PRO 5650U' },
+  );
+
+  // Unknown manufacturers always yield an empty model.
+  assert.deepEqual(splitCpuModel('Mystery Brand XPU 9000'), {
+    manufacturer: Manufacturer.UNKNOWN,
+    model: '',
+  });
+
+  // Qualcomm is recognized but falls into the empty-model default branch.
+  assert.deepEqual(splitCpuModel('Qualcomm Snapdragon 8cx Gen 3'), {
+    manufacturer: Manufacturer.QUALCOMM,
+    model: '',
+  });
+});
+
+test('createNavigatorCpuPerformance exposes the spec-shaped attribute', () => {
+  const nav = createNavigatorCpuPerformance({
+    cpuModel: 'Apple M2',
+    cores: 8,
+  });
+  assert.equal(nav.cpuPerformance, 4);
+
+  // The returned value must always be an integer in 0..4 per the spec.
+  assert.equal(Number.isInteger(nav.cpuPerformance), true);
+  assert.ok(nav.cpuPerformance >= 0 && nav.cpuPerformance <= 4);
+
+  // Default arguments mean "no CPU info available" — unknown tier (0).
+  assert.equal(createNavigatorCpuPerformance().cpuPerformance, 0);
+});
diff --git a/demo.html b/demo.html
new file mode 100644
index 0000000..d8454f9
--- /dev/null
+++ b/demo.html
@@ -0,0 +1,507 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <!-- Origin trial tokens for `CpuPerformance`. -->
+  <!-- https://rbyers.github.io -->
+  <meta http-equiv="origin-trial" content="AufTAiLNr6iiWkWLr8sISbpxFfeZBnf/xHSkYjX4k9Bs07HOHpmCCKwAOXsfr3hLBFF3w1dr++N5NtgpIXLW8wwAAABYeyJvcmlnaW4iOiJodHRwczovL3JieWVycy5naXRodWIuaW86NDQzIiwiZmVhdHVyZSI6IkNwdVBlcmZvcm1hbmNlIiwiZXhwaXJ5IjoxNzg4ODI1NjAwfQ==">
+  <!-- https://wicg.github.io -->
+  <meta http-equiv="origin-trial" content="AuZ4GJ+Y1/kzz3iEusO6JXV0zPqgxh8wieBq49jGnUxdFW+FxkfVtDqmDyZhVWpLCXTVHh3A+SXWcn2ZkB71LQkAAABWeyJvcmlnaW4iOiJodHRwczovL3dpY2cuZ2l0aHViLmlvOjQ0MyIsImZlYXR1cmUiOiJDcHVQZXJmb3JtYW5jZSIsImV4cGlyeSI6MTc4ODgyNTYwMH0=">
+  <title>CPU Performance API — Reference Implementation Playground</title>
+  <style>
+    :root {
+      color-scheme: light dark;
+      --bg: #f6f7f9;
+      --panel: #ffffff;
+      --border: #d8dde3;
+      --text: #1e2227;
+      --muted: #5a6470;
+      --accent: #2563eb;
+      --tier-0: #6b7280;
+      --tier-1: #ef4444;
+      --tier-2: #f59e0b;
+      --tier-3: #10b981;
+      --tier-4: #2563eb;
+    }
+    @media (prefers-color-scheme: dark) {
+      :root {
+        --bg: #15181d;
+        --panel: #1d2127;
+        --border: #2d333b;
+        --text: #e6e8eb;
+        --muted: #98a1ad;
+      }
+    }
+    * { box-sizing: border-box; }
+    html, body { margin: 0; padding: 0; }
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", system-ui,
+        sans-serif;
+      background: var(--bg);
+      color: var(--text);
+      line-height: 1.5;
+      padding: 2rem 1rem;
+    }
+    main {
+      max-width: 760px;
+      margin: 0 auto;
+    }
+    h1 { font-size: 1.6rem; margin: 0 0 0.25rem; }
+    p.lede {
+      color: var(--muted);
+      margin: 0 0 1.75rem;
+    }
+    p.lede a { color: var(--accent); }
+    section.panel {
+      background: var(--panel);
+      border: 1px solid var(--border);
+      border-radius: 10px;
+      padding: 1.25rem 1.5rem;
+      margin-bottom: 1.25rem;
+    }
+    .row {
+      display: grid;
+      grid-template-columns: 1fr 140px;
+      gap: 1rem;
+    }
+    label {
+      display: block;
+      font-size: 0.85rem;
+      color: var(--muted);
+      margin-bottom: 0.25rem;
+    }
+    input[type="text"], input[type="number"] {
+      width: 100%;
+      font: inherit;
+      color: inherit;
+      background: var(--bg);
+      border: 1px solid var(--border);
+      border-radius: 6px;
+      padding: 0.5rem 0.65rem;
+    }
+    input:focus, select:focus {
+      outline: 2px solid var(--accent);
+      outline-offset: 1px;
+    }
+    .presets {
+      margin-top: 1rem;
+    }
+    select {
+      width: 100%;
+      font: inherit;
+      color: inherit;
+      background: var(--bg);
+      border: 1px solid var(--border);
+      border-radius: 6px;
+      padding: 0.5rem 0.65rem;
+    }
+    .result-grid {
+      display: grid;
+      grid-template-columns: 160px 1fr;
+      gap: 0.5rem 1.25rem;
+      align-items: baseline;
+    }
+    .result-grid dt {
+      color: var(--muted);
+      font-size: 0.85rem;
+    }
+    .result-grid dd {
+      margin: 0;
+      font-family: ui-monospace, "SF Mono", Menlo, Consolas, monospace;
+      word-break: break-word;
+    }
+    .tier-badge {
+      display: inline-flex;
+      align-items: center;
+      justify-content: center;
+      width: 1.75rem;
+      height: 1.75rem;
+      border-radius: 50%;
+      color: white;
+      font-weight: 600;
+      font-family: ui-monospace, "SF Mono", Menlo, Consolas, monospace;
+      font-size: 0.95rem;
+    }
+    .tier-0 { background: var(--tier-0); }
+    .tier-1 { background: var(--tier-1); }
+    .tier-2 { background: var(--tier-2); }
+    .tier-3 { background: var(--tier-3); }
+    .tier-4 { background: var(--tier-4); }
+    .support {
+      color: #1e2227;
+      display: flex;
+      align-items: center;
+      gap: 0.65rem;
+      flex-wrap: wrap;
+    }
+    .panel.support-yes { background: #effaee; border-color: #c8e7c4; }
+    .panel.support-no  { background: #fdeef0; border-color: #f1cdd0; }
+    .footer {
+      color: var(--muted);
+      font-size: 0.85rem;
+      text-align: center;
+      margin-top: 2rem;
+    }
+    .footer code {
+      font-family: ui-monospace, "SF Mono", Menlo, Consolas, monospace;
+    }
+  </style>
+</head>
+<body>
+  <main>
+    <h1>CPU Performance API Playground</h1>
+    <p class="lede">
+      Interactive playground for the
+      <a href="https://wicg.github.io/cpu-performance/">CPU Performance API</a>
+      JavaScript reference implementation. Enter a CPU model string and a
+      logical core count to see how the implementation would classify the
+      device.
+    </p>
+
+    <section class="panel">
+      <div class="row">
+        <div>
+          <label for="model">CPU model</label>
+          <input id="model" type="text" autocomplete="off" spellcheck="false"
+            placeholder="e.g. Intel(R) Core(TM) i7-1185G7 CPU @ 3.00GHz">
+        </div>
+        <div>
+          <label for="cores">Logical cores</label>
+          <input id="cores" type="number" min="0" max="256" step="1" value="8">
+        </div>
+      </div>
+
+      <div class="presets">
+        <label for="preset">Load a preset</label>
+        <select id="preset">
+          <!-- Filled by script. -->
+        </select>
+      </div>
+    </section>
+
+    <section class="panel">
+      <dl class="result-grid">
+        <dt>navigator.cpuPerformance</dt>
+        <dd>
+          <span id="tier-badge" class="tier-badge tier-0">0</span>
+        </dd>
+        <dt>Manufacturer</dt>
+        <dd id="manufacturer">unknown</dd>
+        <dt>Normalized model</dt>
+        <dd id="normalized">(empty)</dd>
+        <dt>Cores-only tier</dt>
+        <dd>
+          <span id="cores-tier-badge" class="tier-badge tier-0">0</span>
+        </dd>
+      </dl>
+    </section>
+
+    <section id="browser-support" class="panel support">
+      <span>Your browser&rsquo;s <code>navigator.cpuPerformance</code>:</span>
+      <span id="browser-support-text">Checking&hellip;</span>
+    </section>
+  </main>
+
+  <script src="cpu_performance.js"></script>
+  <script>
+    (function () {
+      'use strict';
+
+      const {
+        splitCpuModel,
+        getTierFromCores,
+        getTierFromCpuInfo,
+      } = globalThis.CpuPerformance;
+
+      // Grouped presets — used to populate <optgroup> elements.
+      // Device groups (real-world phones, tablets, laptops) come first; the
+      // CPU-family groups below are useful for poking at individual edge
+      // cases in the classifier.
+      const PRESET_GROUPS = [
+        {
+          group: 'Phones — flagship',
+          items: [
+            { device: 'iPhone 16 Pro (2024)', model: 'Apple A18 Pro', cores: 6 },
+            { device: 'iPhone 15 Pro (2023)', model: 'Apple A17 Pro', cores: 6 },
+            { device: 'iPhone 14 Pro (2022)', model: 'Apple A16 Bionic', cores: 6 },
+            { device: 'iPhone 13 (2021)', model: 'Apple A15 Bionic', cores: 6 },
+            { device: 'Samsung Galaxy S24 Ultra (US, 2024)', model: 'Qualcomm Snapdragon 8 Gen 3 for Galaxy', cores: 8 },
+            { device: 'Samsung Galaxy S24 (International, 2024)', model: 'Samsung Exynos 2400', cores: 10 },
+            { device: 'Samsung Galaxy S23 Ultra (2023)', model: 'Qualcomm Snapdragon 8 Gen 2 for Galaxy', cores: 8 },
+            { device: 'Samsung Galaxy S22 (US, 2022)', model: 'Qualcomm Snapdragon 8 Gen 1', cores: 8 },
+            { device: 'Google Pixel 8 Pro (2023)', model: 'Google Tensor G3', cores: 9 },
+            { device: 'OnePlus 12 (2024)', model: 'Qualcomm Snapdragon 8 Gen 3', cores: 8 },
+            { device: 'Xiaomi 14 (2024)', model: 'Qualcomm Snapdragon 8 Gen 3', cores: 8 },
+            { device: 'Vivo X100 Pro (India, 2023)', model: 'MediaTek Dimensity 9300', cores: 8 },
+            { device: 'iQOO 12 (India, 2023)', model: 'Qualcomm Snapdragon 8 Gen 3', cores: 8 },
+            { device: 'Realme GT Neo 5 (2023)', model: 'Qualcomm Snapdragon 8+ Gen 1', cores: 8 },
+          ],
+        },
+        {
+          group: 'Phones — mid-range / budget',
+          items: [
+            { device: 'iPhone SE 3rd gen (2022)', model: 'Apple A15 Bionic', cores: 6 },
+            { device: 'Samsung Galaxy A54 5G (2023)', model: 'Samsung Exynos 1380', cores: 8 },
+            { device: 'Samsung Galaxy A14 (2023)', model: 'MediaTek Helio G80', cores: 8 },
+            { device: 'Google Pixel 6a (2022)', model: 'Google Tensor', cores: 8 },
+            { device: 'Redmi Note 13 Pro (India, 2024)', model: 'Qualcomm Snapdragon 7s Gen 2', cores: 8 },
+            { device: 'Redmi 9 (India, 2020)', model: 'MediaTek Helio G80', cores: 8 },
+            { device: 'Redmi 9A (India, 2020)', model: 'MediaTek Helio G25', cores: 8 },
+            { device: 'Oppo Reno 11 (India, 2024)', model: 'MediaTek Dimensity 7050', cores: 8 },
+            { device: 'Motorola Edge 50 (2024)', model: 'MediaTek Dimensity 7300', cores: 8 },
+            { device: 'Moto G Power (2022)', model: 'MediaTek Helio G37', cores: 8 },
+            { device: 'Nokia G42 5G (2023)', model: 'Qualcomm Snapdragon 480+', cores: 8 },
+          ],
+        },
+        {
+          group: 'Phones — older / legacy',
+          items: [
+            { device: 'iPhone 6s (2015)', model: 'Apple A9', cores: 2 },
+            { device: 'iPhone 7 (2016)', model: 'Apple A10 Fusion', cores: 4 },
+            { device: 'iPhone X (2017)', model: 'Apple A11 Bionic', cores: 6 },
+            { device: 'iPhone XS (2018)', model: 'Apple A12 Bionic', cores: 6 },
+            { device: 'iPhone 11 (2019)', model: 'Apple A13 Bionic', cores: 6 },
+            { device: 'Samsung Galaxy S8 (US, 2017)', model: 'Qualcomm Snapdragon 835', cores: 8 },
+            { device: 'Samsung Galaxy S8 (International, 2017)', model: 'Samsung Exynos 8895', cores: 8 },
+            { device: 'Samsung Galaxy S10 (2019)', model: 'Qualcomm Snapdragon 855', cores: 8 },
+            { device: 'Samsung Galaxy Note 8 (2017)', model: 'Qualcomm Snapdragon 835', cores: 8 },
+            { device: 'Samsung Galaxy J7 (2016)', model: 'Samsung Exynos 7580', cores: 8 },
+            { device: 'OnePlus 6 (2018)', model: 'Qualcomm Snapdragon 845', cores: 8 },
+            { device: 'Google Nexus 5 (2013)', model: 'Qualcomm Snapdragon 800', cores: 4 },
+          ],
+        },
+        {
+          group: 'Tablets',
+          items: [
+            { device: 'iPad Pro M4 (2024, 1TB+)', model: 'Apple M4', cores: 10 },
+            { device: 'iPad Air M2 (2024)', model: 'Apple M2', cores: 8 },
+            { device: 'iPad (10th gen, 2022)', model: 'Apple A14 Bionic', cores: 6 },
+            { device: 'iPad mini 6 (2021)', model: 'Apple A15 Bionic', cores: 6 },
+            { device: 'iPad (9th gen, 2021)', model: 'Apple A13 Bionic', cores: 6 },
+            { device: 'Samsung Galaxy Tab S9 (2023)', model: 'Qualcomm Snapdragon 8 Gen 2 for Galaxy', cores: 8 },
+            { device: 'Samsung Galaxy Tab A9+ (2023)', model: 'Qualcomm Snapdragon 695', cores: 8 },
+            { device: 'Amazon Fire HD 10 (2023)', model: 'MediaTek Helio P60T', cores: 8 },
+          ],
+        },
+        {
+          group: 'Laptops — Apple',
+          items: [
+            { device: 'MacBook Pro 16" M3 Max (2023)', model: 'Apple M3 Max', cores: 16 },
+            { device: 'MacBook Pro 14" M3 Pro (2023)', model: 'Apple M3 Pro', cores: 12 },
+            { device: 'MacBook Air M2 (2022)', model: 'Apple M2', cores: 8 },
+            { device: 'MacBook Air M1 (2020)', model: 'Apple M1', cores: 8 },
+            { device: 'MacBook Pro 13" Intel (2020)', model: 'Intel(R) Core(TM) i5-1038NG7 CPU @ 2.00GHz', cores: 8 },
+          ],
+        },
+        {
+          group: 'Laptops — Windows / Chromebook',
+          items: [
+            { device: 'Dell XPS 15 (2023)', model: 'Intel(R) Core(TM) i7-13700H', cores: 20 },
+            { device: 'Dell XPS 13 (2023)', model: 'Intel(R) Core(TM) i7-1360P', cores: 16 },
+            { device: 'HP Spectre x360 14 (2024)', model: 'Intel(R) Core(TM) Ultra 7 155H', cores: 16 },
+            { device: 'Lenovo ThinkPad X1 Carbon Gen 11 (2023)', model: 'Intel(R) Core(TM) i7-1365U', cores: 12 },
+            { device: 'Lenovo Legion Pro 7i (2023)', model: 'Intel(R) Core(TM) i9-13900HX', cores: 24 },
+            { device: 'ASUS ROG Zephyrus G14 (2023)', model: 'AMD Ryzen 9 7940HS with Radeon Graphics', cores: 16 },
+            { device: 'Framework Laptop 13 (AMD, 2023)', model: 'AMD Ryzen 7 7840U with Radeon Graphics', cores: 16 },
+            { device: 'Microsoft Surface Pro 9 (2022)', model: 'Intel(R) Core(TM) i7-1255U', cores: 10 },
+            { device: 'Microsoft Surface Laptop 7 (2024, Copilot+)', model: 'Qualcomm Snapdragon X Elite', cores: 12 },
+            { device: 'Microsoft Surface Pro X (2019)', model: 'Microsoft SQ1', cores: 8 },
+            { device: 'Acer Chromebook 314 (2023)', model: 'Intel N100', cores: 4 },
+            { device: 'HP Chromebook 11 G4 (2015)', model: 'Intel(R) Celeron(R) CPU N2840 @ 2.16GHz', cores: 2 },
+            { device: 'Lenovo IdeaPad 1 (2022)', model: 'AMD Athlon Silver 3050U with Radeon Graphics', cores: 2 },
+          ],
+        },
+        {
+          group: 'Apple Silicon (Macs)',
+          items: [
+            { model: 'Apple M1', cores: 8 },
+            { model: 'Apple M1 Pro', cores: 10 },
+            { model: 'Apple M2', cores: 8 },
+            { model: 'Apple M2 Pro', cores: 10 },
+            { model: 'Apple M3', cores: 8 },
+            { model: 'Apple M3 Max', cores: 14 },
+            { model: 'Apple M4 Max', cores: 16 },
+          ],
+        },
+        {
+          group: 'Intel — Core Ultra',
+          items: [
+            { model: 'Intel(R) Core(TM) Ultra 5 125H', cores: 8 },
+            { model: 'Intel(R) Core(TM) Ultra 7 155H', cores: 8 },
+            { model: 'Intel(R) Core(TM) Ultra 9 285K', cores: 24 },
+          ],
+        },
+        {
+          group: 'Intel — Core i',
+          items: [
+            { model: 'Intel(R) Core(TM) i3-1115G4 CPU @ 3.00GHz', cores: 2 },
+            { model: 'Intel(R) Core(TM) i5-10400 CPU @ 2.90GHz', cores: 6 },
+            { model: 'Intel(R) Core(TM) i7-1185G7 CPU @ 3.00GHz', cores: 8 },
+            { model: 'Intel(R) Core(TM) i7-10750H CPU @ 2.60GHz', cores: 12 },
+            { model: 'Intel(R) Core(TM) i9-13900K CPU @ 3.00GHz', cores: 24 },
+            { model: 'Intel(R) Core(TM)2 Duo CPU T7700 @ 2.40GHz', cores: 2 },
+            { model: 'Intel(R) Core(TM)2 Quad CPU Q9400 @ 2.66GHz', cores: 4 },
+          ],
+        },
+        {
+          group: 'Intel — Atom / Pentium / Celeron',
+          items: [
+            { model: 'Intel(R) Atom(TM) CPU Z520 @ 1.33GHz', cores: 2 },
+            { model: 'Intel(R) Atom(TM) CPU N270 @ 1.60GHz', cores: 2 },
+            { model: 'Intel(R) Atom(TM) CPU D525 @ 1.80GHz', cores: 4 },
+            { model: 'Intel(R) Atom(TM) x5-Z8350 CPU @ 1.44GHz', cores: 4 },
+            { model: 'Intel(R) Atom(TM) x7425E', cores: 4 },
+            { model: 'Intel(R) Celeron(R) CPU N2840 @ 2.16GHz', cores: 2 },
+            { model: 'Intel(R) Celeron(R) CPU J3455 @ 1.50GHz', cores: 4 },
+            { model: 'Intel(R) Pentium(R) CPU N3540 @ 2.16GHz', cores: 4 },
+            { model: 'Intel(R) Pentium(R) Silver N6005', cores: 4 },
+            { model: 'Intel N100', cores: 4 },
+            { model: 'Intel N305', cores: 8 },
+          ],
+        },
+        {
+          group: 'AMD — Ryzen',
+          items: [
+            { model: 'AMD Ryzen 3 2200U', cores: 4 },
+            { model: 'AMD Ryzen 3 3250U', cores: 4 },
+            { model: 'AMD Ryzen 5 2400G', cores: 4 },
+            { model: 'AMD Ryzen 5 5600X 6-Core Processor', cores: 6 },
+            { model: 'AMD Ryzen 7 5800H with Radeon Graphics', cores: 8 },
+            { model: 'AMD Ryzen 9 5950X 16-Core Processor', cores: 16 },
+            { model: 'AMD Ryzen 9 7950X3D 16-Core Processor', cores: 16 },
+            { model: 'AMD Ryzen Threadripper PRO 5995WX', cores: 64 },
+          ],
+        },
+        {
+          group: 'AMD — legacy / low-power',
+          items: [
+            { model: 'AMD A4-9120e', cores: 2 },
+            { model: 'AMD A6-4400M APU with Radeon HD Graphics', cores: 2 },
+            { model: 'AMD E1-2500 APU with Radeon HD Graphics', cores: 2 },
+            { model: 'AMD Athlon 64 X2', cores: 2 },
+            { model: 'AMD FX-8350 Eight-Core Processor', cores: 8 },
+          ],
+        },
+        {
+          group: 'Qualcomm / Microsoft / MediaTek / Samsung',
+          items: [
+            { model: 'Qualcomm Snapdragon 7c Gen 2', cores: 8 },
+            { model: 'Qualcomm Snapdragon 8cx Gen 3', cores: 8 },
+            { model: 'Qualcomm Snapdragon X Elite', cores: 12 },
+            { model: 'Microsoft SQ1', cores: 8 },
+            { model: 'Microsoft SQ3', cores: 8 },
+            { model: 'MediaTek Kompanio 1200', cores: 8 },
+            { model: 'Samsung Exynos 2200', cores: 8 },
+          ],
+        },
+        {
+          group: 'Cores-only fallback (unknown manufacturer)',
+          items: [
+            { model: 'Generic CPU', cores: 1 },
+            { model: 'Generic CPU', cores: 2 },
+            { model: 'Generic CPU', cores: 4 },
+            { model: 'Generic CPU', cores: 8 },
+            { model: 'Generic CPU', cores: 16 },
+            { model: '', cores: 0 },
+          ],
+        },
+      ];
+
+      const modelInput = document.getElementById('model');
+      const coresInput = document.getElementById('cores');
+      const tierBadge = document.getElementById('tier-badge');
+      const coresTierBadge = document.getElementById('cores-tier-badge');
+      const manufacturerEl = document.getElementById('manufacturer');
+      const normalizedEl = document.getElementById('normalized');
+      const presetSelect = document.getElementById('preset');
+
+      function paintBadge(el, tier) {
+        el.textContent = String(tier);
+        el.className =
+          'tier-badge tier-' + (tier >= 0 && tier <= 4 ? tier : 0);
+      }
+
+      function update() {
+        const model = modelInput.value;
+        const cores = Math.max(0, Math.floor(Number(coresInput.value) || 0));
+
+        paintBadge(tierBadge, getTierFromCpuInfo(model, cores));
+        paintBadge(coresTierBadge, getTierFromCores(cores));
+
+        const split = splitCpuModel(model);
+        manufacturerEl.textContent = split.manufacturer;
+        normalizedEl.textContent = split.model === '' ? '(empty)' : split.model;
+      }
+
+      const placeholder = document.createElement('option');
+      placeholder.value = '';
+      placeholder.textContent = 'Select an example…';
+      presetSelect.appendChild(placeholder);
+
+      const presetIndex = [];
+      for (const { group, items } of PRESET_GROUPS) {
+        const og = document.createElement('optgroup');
+        og.label = group;
+        for (const preset of items) {
+          const opt = document.createElement('option');
+          opt.value = String(presetIndex.length);
+          const cpuLabel =
+            (preset.model || '(empty)') + ' · ' + preset.cores + 'c';
+          opt.textContent = preset.device
+            ? preset.device + ' — ' + cpuLabel
+            : cpuLabel;
+          og.appendChild(opt);
+          presetIndex.push(preset);
+        }
+        presetSelect.appendChild(og);
+      }
+
+      presetSelect.addEventListener('change', () => {
+        const idx = Number(presetSelect.value);
+        if (!Number.isInteger(idx) || idx < 0 || idx >= presetIndex.length) {
+          return;
+        }
+        const preset = presetIndex[idx];
+        modelInput.value = preset.model;
+        coresInput.value = String(preset.cores);
+        update();
+      });
+
+      function clearPresetSelection() {
+        presetSelect.value = '';
+      }
+      modelInput.addEventListener('input', () => {
+        clearPresetSelection();
+        update();
+      });
+      coresInput.addEventListener('input', () => {
+        clearPresetSelection();
+        update();
+      });
+
+      // Initialise with a reasonable default so the page isn't empty.
+      modelInput.value = 'Intel(R) Core(TM) Ultra 7 155H';
+      coresInput.value = '8';
+      update();
+
+      // Probe for the real navigator.cpuPerformance attribute.
+      const supportEl = document.getElementById('browser-support');
+      const supportText = document.getElementById('browser-support-text');
+      if (typeof navigator !== 'undefined' && 'cpuPerformance' in navigator) {
+        const value = navigator.cpuPerformance;
+        supportEl.classList.add('support-yes');
+        supportText.replaceChildren();
+        const badge = document.createElement('span');
+        badge.className =
+          'tier-badge tier-' + (value >= 0 && value <= 4 ? value : 0);
+        badge.textContent = String(value);
+        supportText.append(badge);
+      } else {
+        supportEl.classList.add('support-no');
+        supportText.textContent = 'Not supported by your browser';
+      }
+    })();
+  </script>
+</body>
+</html>
diff --git a/index.bs b/index.bs
index aa599dc..545ff33 100644
--- a/index.bs
+++ b/index.bs
@@ -120,14 +120,44 @@ returned in case the API's implementation is unable to classify the user device.
 
 ## Computing Performance Tier Value ## {#computing-performance-tier-value}
 
-Classification of user devices to [=performance tiers=] is
-[=implementation-defined=] and should be interpreted by web applications
-according to their particular needs. However, implementations of this API should
-adhere to the following rules:
-
-1.  **Consistency**: The mapping of devices to [=performance tiers=] should
-    reflect the [=CPU=] [=performance=] that can be measured with specific
-    benchmarks, ideally using programming tools provided by a browser
+<div algorithm>
+  To <dfn>compute the performance tier</dfn> of a user device's [=CPU=]:
+
+    1.  Let |cores| be the number of [=cores=] of the [=CPU=] as reported by
+        the operating system, or null if the operating system does not report a
+        [=core=] count.
+    2.  If |cores| is null or 0, return 0.
+    3.  If |cores| is 1, return 1.
+    4.  If |cores| is between 2 and 4 (inclusive), return 2.
+    5.  If |cores| is between 5 and 10 (inclusive), return 3.
+    6.  Return 4.
+</div>
+
+NOTE: Implementations are permitted to adjust the returned [=performance
+tier=] when the [=CPU=] model is known to perform substantially better or
+worse than is typical for its [=core=] count. Such adjustments typically
+shift the [=performance tier=] by no more than a single tier level (i.e., by
++1 or &minus;1), and require reliable information about the [=CPU=] model
+from the operating system. The set of [=CPU=] models for which such
+adjustments are applied is implementation-defined.
+
+NOTE: A JavaScript [reference
+implementation](https://wicg.github.io/cpu-performance/cpu_performance.js) of
+this algorithm — including a representative set of model-based adjustments
+derived from the implementation in the Chromium browser engine — is available
+in the [cpu-performance repository](https://github.com/WICG/cpu-performance),
+along with an [interactive demo
+page](https://wicg.github.io/cpu-performance/demo.html) that illustrates how
+the algorithm and its model-based heuristics classify a wide range of
+real-world devices. These are not normative; they represent a suggested
+implementation of this section's algorithm with model-based adjustments
+applied.
+
+Implementations of this API should also adhere to the following rules:
+
+1.  **Consistency**: Any model-based adjustments to the [=performance tier=]
+    should reflect the [=CPU=] [=performance=] that can be measured with
+    specific benchmarks, ideally using programming tools provided by a browser
     (JavaScript, WebAssembly, etc.) and measured in ideal conditions. More
     powerful devices should not be classified in lower [=performance tiers=]
     than less powerful devices.
@@ -151,21 +181,12 @@ adhere to the following rules:
     break the behavior of obsolete machines running obsolete applications.
 
 3.  **User privacy**: To avoid user fingerprinting, implementations should
-    classify a fairly large number of user devices in each [=performance tier=]
-    (see also [[#security-privacy]]). In particular, implementations that are
-    based on some [=CPU=] model database should not return the special value 0
-    for new user devices that are not contained in the database. The special
-    value should be returned only when the implementation cannot obtain
-    information about the [=CPU=] from the operating system.
-
-Implementations may (but are not required to) compute the [=performance tier=]
-value for a given user device based on the following characteristics:
-
--   the [=CPU=] model;
--   the number of [=cores=], [=physical core|physical=] and/or [=logical
-    core|logical=];
--   the [=frequency=]; and
--   other available [=CPU=] characteristics.
+    ensure that a fairly large number of user devices fall into each
+    [=performance tier=] (see also [[#security-privacy]]). In particular,
+    model-based adjustments should be coarse enough that each [=performance
+    tier=] still contains many distinct [=CPU=] models, and the special value
+    0 should be returned only when the implementation cannot obtain
+    information about the number of [=cores=] from the operating system.
 
 
 Javascript API {#js-api}
@@ -183,10 +204,10 @@ Javascript API {#js-api}
   The <dfn attribute for=Navigator><code>cpuPerformance</code></dfn> getter
   steps are:
 
-    1.  Let |tier| be an {{unsigned short}} representing the [=performance
-        tier=] of the device's [=CPU=], generated in an
-        [=implementation-defined=] way, considering the recommendations
-        and constraints described in [[#computing-performance-tier-value]].
+    1.  Let |tier| be the result of [=compute the performance tier|computing
+        the performance tier=] of the device's [=CPU=], possibly with
+        model-based adjustments as described in
+        [[#computing-performance-tier-value]].
     2.  [=Assert=]: 0 &le; |tier| &le; 4.
     3.  Return |tier|.
 </div>