From 0bc3092f8fdbc1d71bcb47291eb81e8169b68b00 Mon Sep 17 00:00:00 2001
From: nichinichisou <nichinichisou0609@outlook.com>
Date: Wed, 30 Sep 2026 03:23:17 +0800
Subject: [PATCH 1/8] feat(examples): the chart detail shows the rank measure
 of every Gekisou range
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Each Gekisou range ranks the room by its mission's measure (combo: max combo, luck: luck points, Just: Just count).
The detail lists the three measures per range (seed means, min–max) with the compared one marked, in Gekisou Live;
a measure older data lacks shows as "–". ranking.js rangeMeasures, MISSION_MEASURE, MEASURES; catalog.js
gekisouSkill looks up Gekisou skill names in gekisouCatalog with fallbacks, for the aptitude table to come.
---
 examples/songs/catalog.js      | 26 +++++++++++++++
 examples/songs/index.html      |  5 +++
 examples/songs/ranking.js      | 28 ++++++++++++++++
 examples/songs/songs.js        | 32 +++++++++++++++++--
 examples/songs/text.js         | 10 ++++--
 tests/unit/songs-page.test.mjs | 58 +++++++++++++++++++++++++++++++---
 6 files changed, 150 insertions(+), 9 deletions(-)

diff --git a/examples/songs/catalog.js b/examples/songs/catalog.js
index cb04f23..c62871b 100644
--- a/examples/songs/catalog.js
+++ b/examples/songs/catalog.js
@@ -84,6 +84,32 @@ export const refigure = (rows, data, scenario) => {
   return rows;
 };
 
+// music-data.json's `gekisouCatalog` tables by id, built once per file.
+const CATALOGS = new WeakMap();
+const catalogOf = (data) => {
+  if (data && CATALOGS.has(data)) return CATALOGS.get(data);
+  const cat = (data && data.gekisouCatalog) || {};
+  const out = {};
+  for (const [k, list] of Object.entries(cat)) {
+    if (Array.isArray(list)) out[k] = new Map(list.filter((x) => x && x.id !== undefined).map((x) => [x.id, x]));
+  }
+  if (data && typeof data === "object") CATALOGS.set(data, out);
+  return out;
+};
+
+// A Gekisou skill (`table` "skills") or Gekisou support skill ("supportSkills") of `gekisouCatalog` by id: its name in
+// a language (pickText: else Japanese, else any language; "#id" without one), mission and maxLevel (null when the
+// catalog lacks them, as in older data).
+export const gekisouSkill = (data, table, id, lang) => {
+  const e = (catalogOf(data)[table] || new Map()).get(id);
+  return {
+    id,
+    name: pickText(e && e.name, lang) || `#${id}`,
+    mission: e ? e.mission ?? null : null,
+    maxLevel: e ? e.maxLevel ?? null : null,
+  };
+};
+
 // Whether a row matches a search text: any language of the title, reading, credits, or the music id.
 export const matches = (row, text) => {
   const t = String(text || "").trim().toLowerCase();
diff --git a/examples/songs/index.html b/examples/songs/index.html
index 3e62f5c..634ab0b 100644
--- a/examples/songs/index.html
+++ b/examples/songs/index.html
@@ -399,6 +399,11 @@
   .rk { display: inline-block; min-width: 32px; padding: 0 8px; border-radius: 4px; text-align: center; font-weight: 600; font-size: 12px; border: 1px solid var(--mn-border); color: var(--mn-ink-soft); }
   .rk-SS { color: var(--mn-orbit-light); background: var(--mn-orbit-night); border-color: var(--mn-orbit-edge); }
   .rk-S { color: var(--mn-accent-deep); background: var(--mn-accent-soft); border-color: color-mix(in srgb, var(--mn-accent) 40%, transparent); }
+  /* the rank measures of the Gekisou ranges */
+  .tbl-scroll { overflow-x: auto; }
+  .ranks td.hi { font-weight: 600; color: var(--mn-text); }
+  .measures th:nth-child(2), .measures td:nth-child(2) { text-align: left; }
+  .measures td { white-space: nowrap; }
 
   .boot { display: flex; align-items: center; justify-content: center; gap: 12px; min-height: 60vh; color: var(--mn-text-muted); }
   .boot.error { color: var(--mn-rose); }
diff --git a/examples/songs/ranking.js b/examples/songs/ranking.js
index 075561d..5fbce94 100644
--- a/examples/songs/ranking.js
+++ b/examples/songs/ranking.js
@@ -38,6 +38,11 @@
 // combo breaks: a Great share q scales every score by 1 - 0.2 q; a Just rate j (battle only) interpolates between the
 // all-Just seeds and the all-Perfect run of the Just ranges (`scorePerfect`, `rangeScorePerfect`), with the rank
 // bonuses recomputed on the interpolated range scores and the skill weights inside a range scaled by the same ratio.
+//
+// Gekisou skills (the member cards' Gekisou skills and their snaps' Gekisou support skills) count in Gekisou Live's
+// score with Gekisou (battleLiveScore) only, never in Free Live or in the score without Gekisou (soloScore). The page's
+// decks carry none: every figure here is without them. Every Gekisou range ranks the room by its mission's measure
+// (rangeMeasures).
 
 export const DIFFICULTIES = ["easy", "normal", "hard", "expert"];
 export const EPS = 1e-12;
@@ -79,6 +84,29 @@ const JUST_MISSION = 3;
 // mode "battle" | "free"; ranks[i] the rank in range i; just and great as fractions (0..1)
 export const DEFAULT_SCENARIO = Object.freeze({ mode: "battle", ranks: Object.freeze([1, 1, 1]), just: 1, great: 0 });
 
+// The measure a Gekisou range ranks the room by, per mission (1 combo, 2 luck, 3 Just), and the measures the seeds
+// carry per range (music-data.json deck `seeds[].ranges[j]`: maxCombo, justCount, luckPoints).
+export const MISSION_MEASURE = Object.freeze({ 1: "maxCombo", 2: "luckPoints", 3: "justCount" });
+export const MEASURES = ["maxCombo", "justCount", "luckPoints"];
+
+// Per Gekisou range of a chart's deck statistics (Gekisou on, no skills): its mission, the measure it ranks by (null
+// for an unknown mission) and `values`, every measure as {mean, min, max} over the seeds; a measure some seed lacks
+// (older data) is null. [] without seeds or for a chart unplayable with Gekisou on.
+export const rangeMeasures = (deck) => {
+  if (!deck || deck.unplayable) return [];
+  const seeds = deck.seeds || [];
+  const stat = (i, key) => {
+    const v = seeds.map((s) => (s && s.ranges && s.ranges[i] ? s.ranges[i][key] : undefined));
+    return v.length && v.every(Number.isFinite) ? { mean: mean(v), min: Math.min(...v), max: Math.max(...v) } : null;
+  };
+  return (deck.ranges || []).map((r, i) => ({
+    index: i,
+    mission: r.mission ?? null,
+    measure: MISSION_MEASURE[r.mission] ?? null,
+    values: Object.fromEntries(MEASURES.map((k) => [k, stat(i, k)])),
+  }));
+};
+
 // The score factor of a Great share q (0..1) over every note: 1 - 0.2 q.
 export const greatFactor = (q) => 1 - (1 - GREAT_SCORE) * (Number.isFinite(q) ? Math.min(1, Math.max(0, q)) : 0);
 
diff --git a/examples/songs/songs.js b/examples/songs/songs.js
index 6f45819..c558d31 100644
--- a/examples/songs/songs.js
+++ b/examples/songs/songs.js
@@ -23,9 +23,9 @@ import {
   ticks,
 } from "./catalog.js";
 import {
-  RANGES, RANK_MAX, SCORE_RANKS, X_MAX, chartFigures, eventDominance, formatLength, formatRanks, lengthMs, meanSkill,
-  modelPower, orderRates, parseRanks, perMinute, plainKind, quantile, rank, rankThreshold, reachChance, requiredPower,
-  scenarioData, scoreRate, weightSum,
+  MEASURES, RANGES, RANK_MAX, SCORE_RANKS, X_MAX, chartFigures, eventDominance, formatLength, formatRanks, lengthMs,
+  meanSkill, modelPower, orderRates, parseRanks, perMinute, plainKind, quantile, rangeMeasures, rank, rankThreshold,
+  reachChance, requiredPower, scenarioData, scoreRate, weightSum,
 } from "./ranking.js";
 import { GUIDE, UI } from "./text.js";
 
@@ -721,6 +721,29 @@ const main = async () => {
       })));
   };
 
+  // the rank measure of every Gekisou range (ranking.js rangeMeasures, no skills): Gekisou Live only; null when the
+  // data has none of them
+  const measuresBox = (r) => {
+    const t = u();
+    const D = t.detail;
+    const measures = rangeMeasures(r.stats);
+    if (!measures.some((m) => MEASURES.some((k) => m.values[k]))) return null;
+    // a measure as its seed mean, with the seeds' min–max when they differ
+    const stat = (m) => {
+      if (!m) return "–";
+      const v = Number.isInteger(m.mean) ? fmtInt(m.mean) : fmt(m.mean, 1);
+      return m.min === m.max ? v : `${v} (${fmtInt(m.min)}–${fmtInt(m.max)})`;
+    };
+    return h("section", {}, heading("h3", "sec-head", D.measures),
+      h("div", { class: "tbl-scroll" }, h("table", { class: "ranks measures" },
+        h("thead", {}, h("tr", {}, h("th", {}, D.mRange), h("th", {}, D.mCompared), MEASURES.map((k) => h("th", {}, D.measure[k])))),
+        h("tbody", {}, measures.map((m) => h("tr", {},
+          h("td", {}, t.scen.range(m.index + 1, t.missions[m.mission] || null)),
+          h("td", {}, m.measure ? D.measure[m.measure] : "–"),
+          MEASURES.map((k) => h("td", { class: k === m.measure ? "num hi" : "num dim" }, stat(m.values[k])))))))),
+      h("p", { class: "hint" }, D.measuresHint));
+  };
+
   // a scenario changed in the detail: the view behind it redraws when the detail closes
   let behindStale = false;
   const openChart = (scoreId) => { S.chart = scoreId; renderDrawer(); save(); };
@@ -743,10 +766,12 @@ const main = async () => {
     const line = h("div", { class: "tl-scroll" });
     const weights = h("section", {});
     const ranks = h("div", {});
+    const measures = measuresBox(r);
     const draw = () => {
       const e = eff(r);
       const battle = S.mode === "battle";
       const solo = battle && r.weights ? freeRate(r) : null;
+      if (measures) measures.hidden = !battle;
       put(scores, h("div", { class: "tiles" },
         r.weights ? tile(t.col.rate, fmt(e.rate, 3), (() => {
           const v = orderRates(r, skills());
@@ -795,6 +820,7 @@ const main = async () => {
           h("section", {}, heading("h3", "sec-head", t.detail.composition), composition(r)),
           weights),
         ranks,
+        measures,
         h("p", { class: "ids" }, `${t.detail.musicId} ${r.musicId} · ${t.detail.scoreId} ${r.scoreId} · ${t.detail.musicType} ${r.song.musicType}`)));
     drawer.replaceChildren(panel);
     drawer.classList.add("open");
diff --git a/examples/songs/text.js b/examples/songs/text.js
index 60d74a9..00182b3 100644
--- a/examples/songs/text.js
+++ b/examples/songs/text.js
@@ -66,7 +66,10 @@ export const UI = {
       seeds: (n) => `${n} 个种子`, unplayable: "撃奏ライブ无法游玩", unplayableHint: "Fever 超过 3 个：从反编译代码看，游戏只保留 3 个激走区间，第 4 个 Fever 开始时会出错",
       unplayableFree: "；自由 Live 不开激走，可以照常游玩，切到自由 Live 可看它的数值",
       score: "得分（当前场景）", noFigures: "得分", twoScores: "撃奏ライブ的两套分数（每点综合力）",
-      twoScoresHint: "撃奏ライブ同时上报两套分数：前者含激走，即本场景的数值；后者不含激走，存为歌曲最高分，约等于自由 Live 的分数",
+      twoScoresHint: "撃奏ライブ同时上报两套分数：前者含激走，即本场景的数值（本页的卡组不带激走技能）；后者不含任何激走效果，卡上的激走技能也不计，存为歌曲最高分，约等于自由 Live 的分数",
+      measures: "各区间的名次指标", mRange: "区间", mCompared: "比的指标",
+      measure: { maxCombo: "最大连击", justCount: "Just 数", luckPoints: "幸运点数" },
+      measuresHint: "撃奏ライブ的每个区间按该区间任务的指标与房间内其他人比名次：连击任务比最大连击，幸运任务比幸运点数，Just 任务比 Just 数（加粗的一格）。按本模型，理论最佳打法、不带激走技能，取种子平均，括号内为种子间的最小–最大；“–”表示数据里没有这一项。本页不模拟对手，名次由你选定。",
       orders: "顺序区间", sameOrder: "技能相同，顺序不影响得分", ranks: "评级门槛", rank: "评级", required: "所需分数", needPower: "所需综合力（期望）",
       needRange: "所需综合力（顺序区间）", chanceAt: (p) => `综合力 ${p} 达成率`, requiredRoom: (n) => `所需分数（${n} 人房间，每人）`,
       ranksHint: "门槛按歌定义，各难度共用；自由 Live 用单人门槛。所需综合力 = 门槛 ÷ 每点综合力的期望得分（已含准率）。",
@@ -143,7 +146,10 @@ export const UI = {
       seeds: (n) => `${n} seeds`, unplayable: "Unplayable in Gekisou Live", unplayableHint: "More than 3 fevers: by the decompiled code the game keeps three Gekisou ranges and fails when a fourth fever starts",
       unplayableFree: "; Free Live has no Gekisou and plays it as usual: switch to Free Live for its figures",
       score: "Score (current scenario)", noFigures: "Score", twoScores: "Gekisou Live's two scores (per point of power)",
-      twoScoresHint: "Gekisou Live reports two scores: the first with Gekisou, this scenario's figure; the second without, kept as the song's best score, about the Free Live score",
+      twoScoresHint: "Gekisou Live reports two scores: the first with Gekisou, this scenario's figure (the page's decks have no Gekisou skills); the second without any Gekisou effect, the cards' Gekisou skills included, kept as the song's best score, about the Free Live score",
+      measures: "Rank measures per range", mRange: "Range", mCompared: "Ranked by",
+      measure: { maxCombo: "Max combo", justCount: "Just count", luckPoints: "Luck points" },
+      measuresHint: "Every Gekisou Live range ranks the room by its mission's measure: combo missions by the max combo, luck missions by the luck points, Just missions by the Just count (the bold cell). By this model, in the theoretical best play without Gekisou skills: seed means, with the seeds' min–max in brackets; “–” where the data lacks the measure. The page does not model opponents and takes the ranks you pick.",
       orders: "Order range", sameOrder: "Equal skills: the order does not matter", ranks: "Score ranks", rank: "Rank", required: "Score", needPower: "Power (expected)",
       needRange: "Power (order range)", chanceAt: (p) => `Chance at ${p}`, requiredRoom: (n) => `Score (room of ${n}, each)`,
       ranksHint: "Thresholds are the song's, shared by every difficulty; Free Live uses the solo thresholds. Power needed = threshold ÷ expected score per power (accuracy included).",
diff --git a/tests/unit/songs-page.test.mjs b/tests/unit/songs-page.test.mjs
index a506483..a82011f 100644
--- a/tests/unit/songs-page.test.mjs
+++ b/tests/unit/songs-page.test.mjs
@@ -2,12 +2,13 @@ import test from "node:test";
 import assert from "node:assert/strict";
 
 import {
-  DEFAULT_SCENARIO, X_MAX, chartFigures, dominance, dominates, eventDominates, formatLength, formatRanks, greatFactor,
-  joinCharts, lengthMs, meanSkill, orderRates, parseRanks, perMinute, pickText, plainKind, quantile, rank, rankPercent,
-  rankThreshold, reachChance, requiredPower, roomThreshold, scenarioData, scoreRate, weightSum,
+  DEFAULT_SCENARIO, MEASURES, MISSION_MEASURE, X_MAX, chartFigures, dominance, dominates, eventDominates, formatLength,
+  formatRanks, greatFactor, joinCharts, lengthMs, meanSkill, orderRates, parseRanks, perMinute, pickText, plainKind,
+  quantile, rangeMeasures, rank, rankPercent, rankThreshold, reachChance, requiredPower, roomThreshold, scenarioData,
+  scoreRate, weightSum,
 } from "../../examples/songs/ranking.js";
 import {
-  chartRows, density, extent, histogram, matches, moenotesUrl, noteKinds, refigure, sortBy, ticks,
+  chartRows, density, extent, gekisouSkill, histogram, matches, moenotesUrl, noteKinds, refigure, sortBy, ticks,
 } from "../../examples/songs/catalog.js";
 
 // music-data.json: kind 0 is a judgement score up, kind 1 the plain score up the page models
@@ -379,6 +380,55 @@ test("Gekisou Live rates the room: every player at sqrt(5 / n) of the battle thr
   for (const n of [0, 1, 3, 5]) assert.equal(eventDominates(a, b, "chart", X_MAX, n), n !== 0);
 });
 
+// ---------------------------------------------------------------- Gekisou ranges and skills
+
+test("the rank measures per Gekisou range: the mission's measure, seed means and ranges", () => {
+  assert.deepEqual(MEASURES, ["maxCombo", "justCount", "luckPoints"]);
+  assert.deepEqual([1, 2, 3, 4].map((m) => MISSION_MEASURE[m]), ["maxCombo", "luckPoints", "justCount", undefined]);
+  // deck3: two seeds; range 1 has Just counts, the luck points and max combos are missing (older data)
+  const m = rangeMeasures(deck3());
+  assert.deepEqual(m.map((x) => [x.index, x.mission, x.measure]), [[0, 1, "maxCombo"], [1, 3, "justCount"], [2, 2, "luckPoints"]]);
+  assert.deepEqual(m[1].values.justCount, { mean: 40, min: 40, max: 40 });
+  assert.equal(m[0].values.maxCombo, null);
+  assert.equal(m[2].values.luckPoints, null);
+  const d = deck3();
+  d.seeds = d.seeds.map((s, k) => ({ ...s, ranges: s.ranges.map((x, i) => ({ ...x, maxCombo: 100 + i + k, luckPoints: i === 2 ? 50 + 10 * k : 0 })) }));
+  const n = rangeMeasures(d);
+  assert.deepEqual(n[0].values.maxCombo, { mean: 100.5, min: 100, max: 101 });
+  assert.deepEqual(n[2].values.luckPoints, { mean: 55, min: 50, max: 60 });
+  assert.deepEqual(n[0].values.luckPoints, { mean: 0, min: 0, max: 0 });
+  // an unknown mission ranks by nothing; no seeds or unplayable: nothing
+  assert.equal(rangeMeasures({ ...d, ranges: d.ranges.map((r) => ({ ...r, mission: 4 })) })[0].measure, null);
+  assert.deepEqual(rangeMeasures(null), []);
+  assert.deepEqual(rangeMeasures(deck3({ unplayable: "4 fevers", seeds: [] })), []);
+  assert.ok(rangeMeasures(deck3({ seeds: [] })).every((x) => MEASURES.every((k) => x.values[k] === null)));
+});
+
+test("fields of other formats (the dropped best formation deck.gekisou) leave the figures alone", () => {
+  const extra = { gekisou: { formation: [], objective: 1, evaluations: 1, seeds: deck3().seeds.map((s) => ({ ...s, score: s.score * 2 })) } };
+  for (const sc of [null, { ranks: [2, 5, 3], just: 0.5, great: 0.25 }, { mode: "free" }]) {
+    assert.deepEqual(chartFigures(deck3(extra), 1, 1000, sc), chartFigures(deck3(), 1, 1000, sc));
+  }
+  assert.deepEqual(scenarioData({ songs: [{ id: 1, charts: [{ scoreId: 1, deck: deck3(extra) }] }] }), { free: true, ranks: true, just: true });
+});
+
+test("Gekisou skill names come from gekisouCatalog in the page language, with fallbacks", () => {
+  const data = {
+    gekisouCatalog: {
+      skills: [{ id: 7, mission: 1, maxLevel: 5, name: { ja: "連撃", en: "Combo" } }, { id: 8, mission: 3, maxLevel: 5, name: null }],
+      supportSkills: [{ id: 31, mission: 3, maxLevel: 5, name: { "zh-Hans": "JUST 得分" } }],
+    },
+  };
+  assert.deepEqual(gekisouSkill(data, "skills", 7, "en"), { id: 7, name: "Combo", mission: 1, maxLevel: 5 });
+  assert.equal(gekisouSkill(data, "skills", 7, "ko").name, "連撃");              // else Japanese
+  assert.equal(gekisouSkill(data, "supportSkills", 31, "en").name, "JUST 得分");  // else any language
+  assert.deepEqual(gekisouSkill(data, "skills", 8, "ja"), { id: 8, name: "#8", mission: 3, maxLevel: 5 });   // no name
+  assert.deepEqual(gekisouSkill(data, "skills", 99, "ja"), { id: 99, name: "#99", mission: null, maxLevel: null });
+  assert.deepEqual(gekisouSkill(data, "members", 7, "ja"), { id: 7, name: "#7", mission: null, maxLevel: null });
+  assert.equal(gekisouSkill(songs, "skills", 7, "ja").name, "#7");                // older data: no catalog
+  assert.equal(gekisouSkill(null, "skills", 7, "ja").name, "#7");
+});
+
 // ---------------------------------------------------------------- catalog.js
 
 test("note kinds count the judged notes only", () => {

From 486ed40c3791b413df5281548084227ba6b8f943 Mon Sep 17 00:00:00 2001
From: nichinichisou <nichinichisou0609@outlook.com>
Date: Wed, 30 Sep 2026 03:23:17 +0800
Subject: [PATCH 2/8] docs(examples): chart data guide: how Gekisou skills work

A section on the Gekisou skills: battleLiveScore only, mission-gated, the band condition of support skills, what stays
exact and what is approximate with them, the skills that do nothing in the theoretical best play or only raise a rank
measure, the seed mean, and the state of the checks (audited, native whole-live comparison under way). The page's
figures are without Gekisou skills; the aptitude data is pending.
---
 README.en.md           |  2 +-
 README.md              |  2 +-
 examples/songs/text.js | 68 ++++++++++++++++++++++++++++++++++--------
 3 files changed, 58 insertions(+), 14 deletions(-)

diff --git a/README.en.md b/README.en.md
index efcbdcd..1b2f48a 100644
--- a/README.en.md
+++ b/README.en.md
@@ -86,7 +86,7 @@ Example pages. Open them with any static server at the repository root:
 | [examples/basic.html](examples/basic.html) | one `<ournotes-player>` |
 | [examples/iframe.html](examples/iframe.html) | a page holding one player, ready to embed with an `<iframe>` (`?src=`) |
 | [examples/chart-list](examples/chart-list) | lists a site's `charts.json` and plays the chosen chart; a site of several regions or languages switches with `?region=&lang=` |
-| [examples/songs](examples/songs) | chart data: reads a site's `music-data.json` (nnnotes music-data, with ournotes-deck's whole-live statistics, Gekisou on) and `jackets/` (optional); rankings by efficiency (expectation and range over the random skill order), event rank (power needed, chance), speed, level, notes, length and skip score, a scatter plot and level distribution, chart details (BPM, density, fevers with their Gekisou missions, skill timeline, notes by kind, skill position weights, score ranks) and a guide to the model; styled after moenotes' Sirius theme (light / dark), song pages link to moenotes |
+| [examples/songs](examples/songs) | chart data: reads a site's `music-data.json` (nnnotes music-data, with ournotes-deck's whole-live statistics, Gekisou on) and `jackets/` (optional); rankings by efficiency (expectation and range over the random skill order), event rank (power needed, chance), speed, level, notes, length and skip score, a scatter plot and level distribution, chart details (BPM, density, fevers with their Gekisou missions, skill timeline, notes by kind, skill position weights, score ranks, the rank measures of the Gekisou ranges) and a guide to the model; styled after moenotes' Sirius theme (light / dark), song pages link to moenotes |
 | [examples/story-list](examples/story-list) | lists a site's `stories.json` and plays the chosen episode |
 | [examples/story](examples/story) | plays one episode (`?story=` or `?src=`). Live2D's two files come from `?core=` and `?motionsync=`, the Spine runtime for home talks from `?spine=` |
 | [examples/live2d](examples/live2d) | lists a site's `models.json`, shows the chosen model and plays its motions and expressions |
diff --git a/README.md b/README.md
index 3577bfc..0d85e4b 100644
--- a/README.md
+++ b/README.md
@@ -72,7 +72,7 @@ button.onclick = () => player.play();   // 浏览器要求在用户操作中开
 | [examples/basic.html](examples/basic.html) | 一个 `<ournotes-player>` |
 | [examples/iframe.html](examples/iframe.html) | 只含一个播放器的页面，可用 `<iframe>` 嵌入（`?src=`） |
 | [examples/chart-list](examples/chart-list) | 列出站点的 `charts.json` 并播放所选谱面；多区服或多语言的站点用 `?region=&lang=` 切换 |
-| [examples/songs](examples/songs) | 谱面数据：读站点的 `music-data.json`（nnnotes music-data，含 ournotes-deck 的激走整局统计）和 `jackets/`（可选），按效率（随机技能顺序下的期望与区间）、活动评级（所需综合力、达成率）、速度、等级、Notes、时长、跳过得分排行，散点图和等级分布，谱面详情（BPM、密度、Fever 与激走任务、技能时间轴、音符构成、技能位权重、评级门槛）和模型说明；外观沿用 moenotes 的 Sirius 主题（浅色 / 深色），歌曲资料页跳转 moenotes |
+| [examples/songs](examples/songs) | 谱面数据：读站点的 `music-data.json`（nnnotes music-data，含 ournotes-deck 的激走整局统计）和 `jackets/`（可选），按效率（随机技能顺序下的期望与区间）、活动评级（所需综合力、达成率）、速度、等级、Notes、时长、跳过得分排行，散点图和等级分布，谱面详情（BPM、密度、Fever 与激走任务、技能时间轴、音符构成、技能位权重、评级门槛、各激走区间的名次指标）和模型说明；外观沿用 moenotes 的 Sirius 主题（浅色 / 深色），歌曲资料页跳转 moenotes |
 | [examples/story-list](examples/story-list) | 列出站点的 `stories.json` 并播放所选剧情 |
 | [examples/story](examples/story) | 播放一集剧情（`?story=` 或 `?src=`；Live2D 的两个文件用 `?core=`、`?motionsync=`，据点对话的 Spine 运行时用 `?spine=`） |
 | [examples/live2d](examples/live2d) | 列出站点的 `models.json`，显示所选模型并播放其动作与表情 |
diff --git a/examples/songs/text.js b/examples/songs/text.js
index 00182b3..8dc9b7f 100644
--- a/examples/songs/text.js
+++ b/examples/songs/text.js
@@ -187,6 +187,7 @@ export const GUIDE = {
           "score 是模型算出的无技能得分（撃奏ライブ场景含区间排名加成），w_k 是第 k 位成员带一个因子 1（技能值 10000，即 +100%）的普通加分技能时整局多得的分数；两者都除以测量综合力 P₀。"
             + "技能值换算成因子时有取整（⌊值/10000 × 10⁵⌋/10⁵），各音符得分也有取整，所以上式在取整范围内成立：deck 对每个种子用一副真实技能值的随机卡组、在另一个综合力（1000003）下整局重算，偏差超过上界的谱面直接报错；现有 340 张全部通过。"
             + "这项核对只说明上式与模拟自洽，不能说明模拟与游戏一致。",
+          "本页的卡组只有普通技能，不含成员卡的激走技能和小卡的激走支援技能，得分数值都按不带它们计算；它们的机制见第 7 节。",
           "每首歌有三个激走任务（连击、幸运或 Just，按歌定义，各难度共用），依次对应谱面的三个 Fever 区间。Just 判定只在 Just 任务区间内开启，所以三个任务里没有 Just 的歌（85 首中 41 首：21 首全是连击、20 首全是幸运）整局都没有 Just；"
             + "三个任务全是 Just 的有 27 首，另有 17 首连击、幸运、Just 各一个。",
           "按本模型，激走的影响很大：与激走关闭相比，Expert 谱面的无技能得分高 1.6–4.7 倍（中位 2.4 倍）。主要来源是区间排名加成（MasterLiveGekisouRankingScoreBonus）：每个完成的区间再加上该区间得分的一个百分比，按名次查表，默认按第 1 名计；"
@@ -213,7 +214,7 @@ export const GUIDE = {
             + "按本模型，三个区间全是第 1 名时的无技能得分是全是第 5 名时的 1.25–1.65 倍（340 张谱面，中位 1.46 倍）。",
           "自由 Live 场景的数值来自另一次激走关闭的整局模拟，不是从撃奏ライブ减去加成得到的：关闭激走时也没有 Just、激走连击系数和幸运冲刺。关闭激走时没有幸运抽签，本页用到的技能也没有概率条件，所以每张谱面只有一个种子；"
             + "Fever 超过 3 个、撃奏ライブ无法游玩的谱面，在自由 Live 场景照常计算。",
-          "从反编译代码看，撃奏ライブ同时上报两套分数：一套含全部激走效果（Just、幸运、激走连击和排名加成），本页撃奏ライブ场景的数值对应这一套；另一套不含激走效果，存为歌曲的最高分，按本模型约等于自由 Live 的分数。谱面详情里两个数字都列出。"
+          "从反编译代码看，撃奏ライブ同时上报两套分数：一套含全部激走效果（Just、幸运、激走连击、排名加成和卡上的激走技能），本页撃奏ライブ场景的数值对应这一套（卡组不带激走技能时）；另一套不含任何激走效果（激走技能也不计），存为歌曲的最高分，按本模型约等于自由 Live 的分数。谱面详情里两个数字都列出。"
             + "服务器怎样使用这两套分数（例如计算活动积分），客户端代码里看不到。",
         ],
       },
@@ -286,22 +287,43 @@ export const GUIDE = {
           "Just 率 j 只作用于撃奏ライブ的 Just 任务区间：deck 另做一次 Just 区间内全打 Perfect 的无技能模拟（X_P），页面在它与全 Just 的模拟（X_J）之间按 j 线性插值，名次加成按插值后的区间得分重算（第 2 节的截断公式），再乘 g(q)。"
             + "技能位权重在各区间内的部分按同一比例 ρ_i 缩放，这也是近似。j = 100%、q = 0 时回到第 1、2 节的数值；自由 Live 没有 Just，只有 Great 比例。",
           "断连不满足上述条件：连击系数和激走连击系数取决于当前连击数，连击任务区间还会因断连失败，断在不同位置损失不同（deck 统计尚未导出每张谱面的断连损失分布）。"
-            + "判定转换技能（12006、13005）把 Great 转为 Perfect，相当于降低 q；回复和护盾只在生命归零之后才影响得分（此后每个音符 × 0.3）。",
+            + "判定转换技能（12006 把 Great 转为 Perfect，13005 转为 Just）相当于降低 q；回复和护盾只在生命归零之后才影响得分（此后每个音符 × 0.3）。",
+        ],
+      },
+      {
+        title: "激走技能",
+        body: [
+          "成员卡带激走技能，与它配对的小卡带激走支援技能。从反编译代码看，它们只在激走开启时建立，只加进含激走的那套分数（battleLiveScore），不进不含激走的那套（soloScore），自由 Live 里也没有。"
+            + "每个技能属于一种激走任务（连击、幸运或 Just），只在同任务的区间里触发，与演奏位置和洗牌无关；支援技能可以带乐队条件（条件 5000），看配对的成员是否属于指定乐队。"
+            + "ournotes-deck 的整局模拟可以带上激走技能，它们的效果（激走连击加成、幸运槽与幸运点、Just 数加成、支援技能的加分等）都逐帧计算。",
+          "本页现有的得分数值都不带激走技能。谱面对各激走技能的适性（每个激走技能或支援技能单独带上时的得分增量与区间指标变化）数据待更新。",
+        ],
+        after: [
+          "精确与近似。带上激走技能再按第 1、2、6 节的式子计算时：名次 1、全 Just、无 Great 的得分是整局模拟的结果，普通技能那部分沿用第 1 节的线性式，与不带激走技能时是同一个近似。"
+            + "名次沿用第 2 节的线性式：从反编译代码看，名次加成是区间结束时记入的一笔固定分，不改变任何得分系数，所以换名次时无普通技能的部分仍然精确。"
+            + "Just 率低于 100% 时沿用第 6 节的插值，带激走技能时这是近似：转 Just（13005）、每个 Just 加分的支援技能（2001）和累计 Just（13002）对 Just 数都不是线性的。Great 比例沿用 1 − 0.2 q，同样是近似。",
+          "理论最佳打法下不起作用的技能。连击保护（12004）和 Great 转 Perfect（12006）只在出现 Great 或 Miss 时起作用，理论最佳打法下为 0，Great 比例的近似里也没有计入它们；每个音符都在准确时刻命中时，放宽 Just 判定（4004）也不起作用。"
+            + "另有一些激走技能只提高名次指标，不直接加分（Just 数加成 13000、累计 Just 13002、加幸运点 11002）：本页不模拟对手，名次由你选定，所以它们不改变本页的得分；实际对局里它们可能帮你拿到更好的名次。"
+            + "以上是按反编译代码的阅读得出的，这些技能的得分增量为 0 还在用整局实跑逐一确认。",
+          "种子。带激走技能的整局模拟与第 1 节用同一组种子（含幸运区间的谱面是前 8 个公开种子），取的是这组种子的平均，不是游戏里的期望，游戏的种子规律未知；带激走技能时幸运区间的种子间差别可能更大。"
+            + "演奏位置每局洗牌，但激走技能与位置无关；洗牌只改变单个种子里概率判定的抽取次序，不改变期望。",
+          "核对现状。激走技能这一层按反编译代码逐项审计，与重写一致；整局与游戏原生代码的对照正在做，结果出来之前，这一层的数值尚在核对。按本模型得出的结论也都以此为前提。",
         ],
       },
       {
         title: "尚未纳入的机制",
         defs: [
           ["其它技能类型", "music-data.json 的 deck.kinds 列出主数据里所有与因子线性相关的加分类别（效果 2000、2002、2004、2005，按持续时间、目标和条件区分），每张谱面都给出了各类别的位置权重；"
-            + "本页只用普通加分这一类。判定加分（2004，目标判定 41/46）和带条件的 2000（条件组 14、15）权重不同，需要按具体卡组逐类求和；累计加分（2001、2003）、判定转换、激走技能与 Snap 技能不是线性的，只能整局模拟。"],
+            + "本页只用普通加分这一类。判定加分（2004，目标判定 41/46）和带条件的 2000（条件组 14、15）权重不同，需要按具体卡组逐类求和；累计加分（2001、2003）和判定转换不是线性的，只能整局模拟，激走技能与激走支援技能也是这样（第 7 节）。"],
           ["撃奏ライブ的对手", "名次由房间里其他玩家在各区间的任务指标决定。本页不模拟对手，而是让你直接选名次（名次 1 为最佳情况）；同值时加成表按哪一种名次查尚未完全核实，直接选名次时不受影响。房间不满 5 人时服务器是否补位，客户端代码里看不到。游戏没有协力模式。"],
-          ["Snap 技能", "跟随所属成员一起被洗牌；效果多由条件触发（成员乐队、生命、判定数等），取决于具体卡组，本页不计入。条件在整局都满足的加分，相当于在 base 上乘 (1 + y)。"],
+          ["Snap 技能（普通支援技能）", "跟随所属成员一起被洗牌；效果多由条件触发（成员乐队、生命、判定数等），取决于具体卡组，本页不计入。条件在整局都满足的加分，相当于在 base 上乘 (1 + y)。小卡的激走支援技能另算，见第 7 节。"],
           ["概率发动（条件 4011）", "若发动概率 p 与其它量独立，它的期望贡献等于把该技能值换成 p · x，可以直接填进技能输入；方差会比表中给出的更大。"],
           ["实机一局耗时", "进入结算的时刻、加载时间都依赖设备和网络，由每局额外耗时 c 表示；支配关系对所有 c ≥ 0 成立。"],
           ["核对范围", "本页的数值不是直接运行游戏代码得到的：ournotes-deck 是我们照反编译代码重写的模拟，每张谱面的整局都由它计算。"
             + "游戏自己的函数只用来分块核对这份重写：在 ARM64 模拟器里单独运行客户端的相关函数（计分、技能的发动与结束、激走连击等），和重写的实现逐例比较，已核对的部分没有发现差异。"
             + "没有核对过的部分可能有错；整局从没有用游戏代码跑过，也还没有拿实机成绩逐局核对。"
-            + "判定窗口类技能（4000–4003、13001）尚未接入整局模拟，另有少数激走条件只有合成测试；本页只用普通加分技能，不受这两项影响。游戏更新或热更新补丁也可能改变这些规则。"],
+            + "激走技能这一层（第 7 节）：按反编译代码逐项审计，与重写一致；整局与原生代码的对照正在做，结果出来之前尚在核对。"
+            + "判定窗口类技能（4000–4003、13001）尚未接入整局模拟，另有少数激走条件只有合成测试；本页只用普通加分技能，不受这两项影响，激走技能可能用到这些条件，这也在上面的“尚在核对”之内。游戏更新或热更新补丁也可能改变这些规则。"],
         ],
       },
       {
@@ -312,7 +334,7 @@ export const GUIDE = {
           ["主 BPM、密度", "主 BPM 是第一个到最后一个判定音符之间持续时间最长的 BPM；密度 = 判定音符数 ÷ 这段区间的秒数。"],
           ["基础系数、W、跳过系数", "base 与 W 定义见第 1、3 节：撃奏ライブ场景下 base 含所选名次的激走区间排名加成，自由 Live 场景没有；两者都按准率缩放。跳过系数是跳过时每点综合力的得分（全部按 Great、连击为 0、无技能），与时长无关，本页不随场景变化。"],
           ["与其它资料不一致时", "本页的数值来自我们对反编译代码的理解，没有官方资料可以对照，可能有错；和其它站点、工具或实机结果不一致时，请优先相信它们。"
-            + "口径不同（时长的取法、游玩场景与名次、准率、卡组设定）也会带来差别，可以先把页面上的参数调成对方的设定再比较。"],
+            + "口径不同（时长的取法、游玩场景与名次、准率、卡组设定、是否带激走技能）也会带来差别，可以先把页面上的参数调成对方的设定再比较。"],
         ],
       },
     ],
@@ -339,6 +361,7 @@ export const GUIDE = {
           "score is the model's no-skill score (in Gekisou Live with the range rank bonuses), w_k the score a factor-1 plain skill (value 10000, +100 %) on the member at position k adds over the whole live; both per point of the measurement power P₀. "
             + "The value becomes a factor with a floor (⌊value/10000 × 10⁵⌋/10⁵) and every note score is floored, so the formula holds up to the floors: for every seed deck plays a random deck of real skill values at another power (1000003) through the whole live, and a chart whose deviation exceeds the bound fails. All 340 current charts pass. "
             + "This check only shows that the formula agrees with the simulation, not that the simulation agrees with the game.",
+          "The page's decks have plain skills only, no member Gekisou skills and no snap Gekisou support skills, and every score figure is without them; section 7 has how they work.",
           "Every song has three Gekisou missions (combo, luck or Just, set per song and shared by every difficulty), one for each of the chart's three fevers in order. Just judgements are only on inside Just mission ranges, so the songs without a Just mission (41 of 85: 21 all combo, 20 all luck) have no Just all live; "
             + "27 songs have three Just missions, and 17 have one each of combo, luck and Just.",
           "By this model Gekisou weighs a lot: against Gekisou off, an Expert chart's no-skill score is 1.6–4.7 times higher (median 2.4). Most of it is the range rank bonus (MasterLiveGekisouRankingScoreBonus): every completed range adds a percentage of its own score, looked up by rank, rank 1 by default; "
@@ -365,7 +388,7 @@ export const GUIDE = {
             + "By this model the no-skill score at rank 1 in all three ranges is 1.25–1.65 times that at rank 5 (340 charts, median 1.46).",
           "The Free Live figures come from a separate whole-live simulation with Gekisou off, not from Gekisou Live minus the bonuses: without Gekisou there are no Just judgements, Gekisou combo factor or luck rushes either. Without Gekisou there is no luck lottery, and the page's skill has no probability condition, so every chart has one seed; "
             + "charts with more than 3 fevers, unplayable in Gekisou Live, are computed as usual in Free Live.",
-          "By the decompiled code, Gekisou Live reports two scores: one with every Gekisou effect (Just, luck, the Gekisou combo and the rank bonuses), which the page's Gekisou Live figures stand for; the other without any Gekisou effect, kept as the song's best score, by this model about the Free Live score. The chart details show both. "
+          "By the decompiled code, Gekisou Live reports two scores: one with every Gekisou effect (Just, luck, the Gekisou combo, the rank bonuses and the cards' Gekisou skills), which the page's Gekisou Live figures stand for (with a deck without Gekisou skills); the other without any Gekisou effect (no Gekisou skills either), kept as the song's best score, by this model about the Free Live score. The chart details show both. "
             + "How the server uses the two (for event points, say) is not in the client code.",
         ],
       },
@@ -438,22 +461,43 @@ export const GUIDE = {
           "The Just rate j applies to the Just mission ranges of Gekisou Live only: deck runs the live once more with Perfects instead of Justs in those ranges and no skills (X_P), the page interpolates linearly by j between it and the all-Just run (X_J), recomputes the rank bonuses on the interpolated range scores (the floor formula of section 2) and applies g(q). "
             + "The skill position weights are scaled by the same ratio ρ_i inside every range, again an approximation. At j = 100 % and q = 0 the figures are those of sections 1 and 2; Free Live has no Just, only the Great share.",
           "Breaks do not meet the condition: the combo and Gekisou combo factors depend on the running combo and a break fails a combo mission range, so a break costs differently at different notes (the deck statistics do not export a chart's break-cost distribution yet). "
-            + "Judgement conversion (12006, 13005) turns Greats into Perfects, lowering q; recovery and guard skills change the score only once life reaches zero (every note × 0.3 after that).",
+            + "Judgement conversion (12006 turns Greats into Perfects, 13005 into Justs) lowers q; recovery and guard skills change the score only once life reaches zero (every note × 0.3 after that).",
+        ],
+      },
+      {
+        title: "Gekisou skills",
+        body: [
+          "Member cards carry a Gekisou skill and the snap paired with them a Gekisou support skill. By the decompiled code they exist only with Gekisou on and add to the score with Gekisou (battleLiveScore) only, never to the score without it (soloScore), and Free Live has none. "
+            + "Every skill belongs to one Gekisou mission (combo, luck or Just) and fires only in ranges of that mission, whatever the performance position and the shuffle; a support skill may carry a band condition (condition 5000) on the member it is paired with. "
+            + "ournotes-deck's whole-live simulation can take Gekisou skills, and computes their effects (the Gekisou combo boost, the luck gauge and luck points, Just count boosts, the support skills' score ups and others) frame by frame.",
+          "The page's current score figures are all without Gekisou skills. A chart's aptitude for each Gekisou skill (the score gain and the range measure changes of one Gekisou skill or support skill taken alone) is pending in the data.",
+        ],
+        after: [
+          "Exact and approximate. With Gekisou skills taken and the formulas of sections 1, 2 and 6 applied: at rank 1, all Just and no Great the score is the whole-live simulation's, and the plain skills' part keeps the linear formula of section 1, the same approximation as without Gekisou skills. "
+            + "The ranks keep the linear formula of section 2: by the decompiled code the rank bonus is a fixed amount added at the range's end that changes no score factor, so the part without plain skills stays exact at other ranks. "
+            + "A Just rate below 100 % keeps the interpolation of section 6, an approximation with Gekisou skills: Just conversion (13005), the per-Just support score up (2001) and cumulative Just (13002) are not linear in the Just count. The Great share keeps 1 − 0.2 q, an approximation too.",
+          "Skills that do nothing in the theoretical best play. The combo guard (12004) and Great to Perfect (12006) act only on Greats or Misses: 0 in the theoretical best play, and the Great share approximation leaves them out; with every note hit at its exact time, the wider Just window (4004) does nothing either. "
+            + "Some Gekisou skills raise a rank measure only and add no score (Just count boost 13000, cumulative Just 13002, luck points 11002): the page does not model opponents and takes the ranks you pick, so they leave the page's scores alone; in a real room they may win you a better rank. "
+            + "This follows from our reading of the decompiled code; whole-live runs confirming a zero score gain for each of these skills are under way.",
+          "Seeds. Whole lives with Gekisou skills use the seeds of section 1 (the first 8 published seeds on charts with a luck range), and their mean is not the game's expectation, its seed law being unknown; with Gekisou skills the seeds of luck ranges may spread further apart. "
+            + "The performance positions are shuffled every live, but the Gekisou skills do not depend on the position; the shuffle changes only the order of the chance draws within a seed, not the expectation.",
+          "State of the checks. This layer has been audited item by item against the decompiled code and agrees with the rewrite; the whole-live comparison with the game's native code is in progress, and until it is done the figures of this layer are still being checked. The conclusions “by this model” rest on that too.",
         ],
       },
       {
         title: "Mechanisms not modelled yet",
         defs: [
           ["Other skill types", "music-data.json's deck.kinds lists every score-up kind of the master data whose score is linear in the factor (effects 2000, 2002, 2004, 2005, told apart by duration, targets and conditions), with each chart's position weights per kind; "
-            + "the page uses the plain score-up kind only. Judgement score up (2004, target judgements 41/46) and conditional 2000s (condition groups 14, 15) weigh differently and need a deck's own kinds summed; cumulative score up (2001, 2003), judgement conversion, Gekisou skills and snap skills are not linear and need the simulation itself."],
+            + "the page uses the plain score-up kind only. Judgement score up (2004, target judgements 41/46) and conditional 2000s (condition groups 14, 15) weigh differently and need a deck's own kinds summed; cumulative score up (2001, 2003) and judgement conversion are not linear and need the simulation itself, and so do Gekisou skills and Gekisou support skills (section 7)."],
           ["Gekisou Live opponents", "The ranks depend on the other players' mission measures in every range. The page does not model opponents and lets you pick the ranks instead (rank 1 is the best case); which kind of rank the bonus table takes on equal values is not fully checked, and picking the ranks directly does not depend on it. Whether the server fills a room of fewer than 5 is not in the client code. The game has no co-op mode."],
-          ["Snap skills", "Shuffled with their member; mostly conditional (the member's band, life, judgement counts), so deck-specific and left out here. A score up whose condition holds all live multiplies base by (1 + y)."],
+          ["Snap skills (plain support skills)", "Shuffled with their member; mostly conditional (the member's band, life, judgement counts), so deck-specific and left out here. A score up whose condition holds all live multiplies base by (1 + y). A snap's Gekisou support skill is another matter, see section 7."],
           ["Probability skills (condition 4011)", "With an activation chance p independent of the rest, the expected contribution is that of the value p · x, which can be entered as the skill value; the spread is larger than shown."],
           ["Real play time", "When the results start and how long loading takes depend on the device and the network; the overhead c stands for them, and dominance holds for every c ≥ 0."],
           ["Scope of the checks", "The figures on this page do not come from running the game's code: ournotes-deck is our simulation, rewritten after the decompiled code, and it computes every chart's whole live. "
             + "The game's own functions only check the rewrite piece by piece: the client's relevant functions (scoring, skill execute and finish, the Gekisou combo and others) run alone in an ARM64 emulator and are compared case by case with the rewrite; the parts checked so far show no difference. "
             + "Parts not checked may be wrong; no whole live has been run with the game's code, and none has been checked against real play results yet. "
-            + "Judgement window skills (4000–4003, 13001) are not in the whole-live simulation yet, and a few Gekisou conditions only have synthetic tests; the page uses the plain score-up skill only and is affected by neither. A game update or hotfix patch may also change these rules."],
+            + "The Gekisou skill layer (section 7) has been audited item by item against the decompiled code and agrees with the rewrite; the whole-live comparison with the native code is in progress, and until it is done the layer is still being checked. "
+            + "Judgement window skills (4000–4003, 13001) are not in the whole-live simulation yet, and a few Gekisou conditions only have synthetic tests; the page uses the plain score-up skill only and is affected by neither, the Gekisou skills may use those conditions, and that is part of the check still under way. A game update or hotfix patch may also change these rules."],
         ],
       },
       {
@@ -464,7 +508,7 @@ export const GUIDE = {
           ["Main BPM, density", "The main BPM holds longest from the first to the last judged note; density = judged notes ÷ that span in seconds."],
           ["Base, W, skip", "Base and W as in sections 1 and 3: in Gekisou Live base includes the range rank bonuses of the ranks chosen, in Free Live it has none; both scale with the accuracy. Skip: score per point of power of a skipped live (every note Great, combo 0, no skills), independent of the length, and the same in every scenario on this page."],
           ["Where other sources disagree", "The figures come from our reading of the decompiled code, with no official data to check them against, and may be wrong; where other sites, tools or real plays disagree, trust them first. "
-            + "Different conventions (how the length is taken, the play scenario and ranks, the accuracy, the deck) also make differences; set the page's parameters to theirs before comparing."],
+            + "Different conventions (how the length is taken, the play scenario and ranks, the accuracy, the deck, Gekisou skills or none) also make differences; set the page's parameters to theirs before comparing."],
         ],
       },
     ],

From 1522c24ed6a5b1a8b1bca5dada215e5ace99ea3c Mon Sep 17 00:00:00 2001
From: nichinichisou <nichinichisou0609@outlook.com>
Date: Wed, 30 Sep 2026 04:18:58 +0800
Subject: [PATCH 3/8] feat(examples): add single-skill aptitude functions and
 master factor conversion

Keep baseline scores unchanged. Compute aptitude rank and accuracy changes, withhold complete gains below full Just when ordinary skills need unmeasured Perfect cross weights, and expose SE only for original sampled statistics. Add catalog shape names and synthetic tests. Master integer effect values use float32 conversion; user percentages do not.

Co-Authored-By: Claude Code <noreply@anthropic.com>
---
 examples/songs/catalog.js      |  23 ++++++
 examples/songs/ranking.js      | 134 ++++++++++++++++++++++++++++++++-
 tests/unit/songs-page.test.mjs | 105 ++++++++++++++++++++++++--
 3 files changed, 252 insertions(+), 10 deletions(-)

diff --git a/examples/songs/catalog.js b/examples/songs/catalog.js
index c62871b..bbfae52 100644
--- a/examples/songs/catalog.js
+++ b/examples/songs/catalog.js
@@ -110,6 +110,29 @@ export const gekisouSkill = (data, table, id, lang) => {
   };
 };
 
+// The skills of an aptitude shape (music-data.json deck.gekisouAptitude.shapes[]: member Gekisou skills or snap
+// Gekisou support skills with the same score effects) with their names (gekisouSkill, "#id" without one) and levels,
+// each skill once.
+export const shapeSkills = (data, shape, lang) => {
+  const table = shape && shape.source === "support" ? "supportSkills" : "skills";
+  const seen = new Set();
+  const out = [];
+  for (const s of (shape && Array.isArray(shape.skills) ? shape.skills : [])) {
+    const key = `${s.id}:${s.level}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push({ ...gekisouSkill(data, table, s.id, lang), level: s.level ?? null });
+  }
+  return out;
+};
+
+// The bands a shape's band condition names (skills[].bandIds), by music-data.json's `bands` ("#id" without one).
+export const shapeBands = (data, shape, lang) => {
+  const bands = new Map(((data && data.bands) || []).map((b) => [b.id, b]));
+  const ids = [...new Set((shape && Array.isArray(shape.skills) ? shape.skills : []).flatMap((s) => s.bandIds || []))].sort((a, b) => a - b);
+  return ids.map((id) => pickText(bands.get(id) && bands.get(id).name, lang) || `#${id}`);
+};
+
 // Whether a row matches a search text: any language of the title, reading, credits, or the music id.
 export const matches = (row, text) => {
   const t = String(text || "").trim().toLowerCase();
diff --git a/examples/songs/ranking.js b/examples/songs/ranking.js
index 5fbce94..87f3fa6 100644
--- a/examples/songs/ranking.js
+++ b/examples/songs/ranking.js
@@ -91,7 +91,7 @@ export const MEASURES = ["maxCombo", "justCount", "luckPoints"];
 
 // Per Gekisou range of a chart's deck statistics (Gekisou on, no skills): its mission, the measure it ranks by (null
 // for an unknown mission) and `values`, every measure as {mean, min, max} over the seeds; a measure some seed lacks
-// (older data) is null. [] without seeds or for a chart unplayable with Gekisou on.
+// (older data) is null. [] for a chart unplayable with Gekisou on.
 export const rangeMeasures = (deck) => {
   if (!deck || deck.unplayable) return [];
   const seeds = deck.seeds || [];
@@ -134,9 +134,11 @@ export const rankPercent = (range, r) => {
 };
 
 // Which scenarios music-data.json can show: free (offSeeds), ranks other than 1 (rankBonusPercents and
-// rangeWeights), a Just rate below 100 % (scorePerfect, with rangeWeights for the skill weights).
+// rangeWeights), a Just rate below 100 % (scorePerfect, with rangeWeights for the skill weights), and whether it has
+// Gekisou skill aptitudes (the shapes of deck.gekisouAptitude and a chart with variants).
 export const scenarioData = (data) => {
-  const has = { free: false, ranks: false, just: false };
+  const has = { free: false, ranks: false, just: false, aptitude: false };
+  const shapes = aptitudeShapes(data).size > 0;
   for (const song of (data && data.songs) || []) {
     for (const chart of song.charts || []) {
       const d = chart.deck;
@@ -146,6 +148,7 @@ export const scenarioData = (data) => {
       if ((d.ranges || []).length && d.ranges.every((r) => Array.isArray(r.rankBonusPercents) && r.rankBonusPercents.length >= RANK_MAX)
         && seeds.some((s) => s.rangeWeights)) has.ranks = true;
       if (seeds.some((s) => Number.isFinite(s.scorePerfect) && s.rangeWeights)) has.just = true;
+      if (shapes && chartVariants(d).length) has.aptitude = true;
     }
   }
   return has;
@@ -210,6 +213,126 @@ export const chartFigures = (deck, kind, power = POWER, scenario = null) => {
   };
 };
 
+// ---------------------------------------------------------------- Gekisou skill aptitude
+// A chart's aptitude for a Gekisou skill is what taking that one skill changes (music-data.json: the file's
+// `deck.gekisouAptitude.shapes`, the chart's `deck.gekisouAptitude.variants`). A shape is the class of member Gekisou
+// skills (at their highest level) or snap Gekisou support skills (at the level of the highest rank) with the same score
+// effects; a support skill with a band condition has two variants, the condition met (bandMatch true) or not (false).
+// Every figure of a variant is a gain Δ over deck.seeds (same seeds, same play, rank 1) as [mean, standard error] over
+// its own seeds; a deterministic variant ran one seed, with se 0. For a scenario (SCHEMA 1.6, P₀ the measurement power):
+//   rank 1 everywhere:  Δscore = score                       (Just play; scorePerfect in the Perfect play)
+//   ranks r:            Δscore = tail + Σ_i rangeScore_i · (1 + p_i(r_i) / 100)      (±1 point per range)
+//   plain skill cross:  Δw[k](r) = weights[k] + Σ_i (p_i(r_i) − p_i(1)) / 100 · rangeWeights[k][i]
+//                       (without rangeWeights: weights[k], the rank-1 cross terms)
+//   Just rate j:        every Just-play figure X becomes j · X + (1 − j) · X_Perfect (approximate); the cross terms
+//                       are unavailable below full Just: Perfect cross weights were not measured
+//   Great share q:      everything × (1 − 0.2 q) (approximate)
+// and a deck of power P and skills x gains P · (Δscore / P₀ + Σ_k x_π(k) · Δw[k]), in expectation over the skill order
+// P · (Δscore / P₀ + x̄ · Σ_k Δw[k]): aptitudeFigures has the shape of chartFigures, so scoreRate applies. Free Live has
+// no Gekisou: no aptitude. The gains of several skills do not add up (combo boosts saturate, rush support and luck
+// gauge skills reinforce each other, Just count skills move per-Just support): one skill at a time.
+
+const CACHE = new WeakMap();
+const cached = (data, key, make) => {
+  if (!data || typeof data !== "object") return make();
+  if (!CACHE.has(data)) CACHE.set(data, {});
+  const c = CACHE.get(data);
+  if (!(key in c)) c[key] = make();
+  return c[key];
+};
+
+// The shapes of music-data.json's `deck.gekisouAptitude` by id (an empty map without them).
+export const aptitudeShapes = (data) => cached(data, "shapes", () => {
+  const list = data && data.deck && data.deck.gekisouAptitude && data.deck.gekisouAptitude.shapes;
+  return new Map((Array.isArray(list) ? list : []).filter((s) => s && Number.isInteger(s.id)).map((s) => [s.id, s]));
+});
+
+// A chart's variants (deck.gekisouAptitude.variants); [] for a chart without them, unplayable or in older data.
+export const chartVariants = (deck) => {
+  const a = deck && !deck.unplayable && deck.gekisouAptitude;
+  return a && Array.isArray(a.variants) ? a.variants : [];
+};
+
+const mOf = (x) => (Array.isArray(x) && Number.isFinite(x[0]) ? x[0] : null);
+const seOf = (x) => (Array.isArray(x) && Number.isFinite(x[1]) ? x[1] : 0);
+
+// A variant's gain in a scenario (see above; `ranges` the chart's deck ranges, default power P₀ 300000): `base` the
+// score gain per unit of power, `baseSe` its raw standard error only (null after transformations),
+// `weights[k]` the gain of position k's plain skill weight (null when the data has no cross terms), `crossAtRank1` true
+// when the cross terms stay at rank 1 (no rangeWeights) while the ranks are not, and the variant's seed facts. null in
+// Free Live or without the scenario's fields.
+export const aptitudeFigures = (variant, ranges, power = POWER, scenario = null) => {
+  const sc = { ...DEFAULT_SCENARIO, ...(scenario || {}) };
+  if (!variant || sc.mode === "free" || mOf(variant.score) === null) return null;
+  const rs = Array.isArray(variant.ranges) ? variant.ranges : [];
+  const ranks = rs.map((_, i) => clampRank((sc.ranks || [])[i]));
+  const j = Number.isFinite(sc.just) ? Math.min(1, Math.max(0, sc.just)) : 1;
+  const partial = j < 1;
+  const lerp = (p, just) => (partial ? p + j * (just - p) : just);
+  const g = greatFactor(sc.great);
+  const pick = (x, xp) => {                                  // a Just-play figure at the Just rate
+    const a = mOf(x);
+    if (a === null) return null;
+    if (!partial) return a;
+    const b = mOf(xp);
+    return b === null ? null : lerp(b, a);
+  };
+  const rank1 = ranks.every((r) => r === 1);
+  let score;
+  if (rank1) {
+    score = pick(variant.score, variant.scorePerfect);
+  } else {
+    const tail = pick(variant.tail, variant.tailPerfect);
+    const pr = rs.map((_, i) => rankPercent(ranges[i], ranks[i]));
+    const p1 = rs.map((_, i) => rankPercent(ranges[i], 1));
+    const rsj = rs.map((x) => pick(x.rangeScore, x.rangeScorePerfect));
+    if (tail === null || [...pr, ...p1].some((p) => p === null) || rsj.some((v) => v === null)) return null;
+    score = tail + rsj.reduce((a, v, i) => a + v * (1 + pr[i] / 100), 0);
+  }
+  if (score === null) return null;
+  let weights = null;
+  let crossAtRank1 = false;
+  if (!partial && Array.isArray(variant.weights)) {
+    const rw = variant.rangeWeights;
+    crossAtRank1 = !rank1 && !Array.isArray(rw);
+    const shift = rs.map((_, i) => (rank1 || !Array.isArray(rw) ? 0 : (rankPercent(ranges[i], ranks[i]) - rankPercent(ranges[i], 1)) / 100));
+    weights = variant.weights.map((w, k) => ((mOf(w) ?? 0)
+      + shift.reduce((a, d, i) => a + (d ? d * (mOf(rw[k] && rw[k][i]) ?? 0) : 0), 0)) * g);
+  }
+  return {
+    base: (score * g) / power,
+    // Only the original sampled statistic has an SE; aggregate transformed means have no covariance data.
+    baseSe: rank1 && !partial && sc.great === 0 ? seOf(variant.score) / power : null,
+    weights,
+    missingPerfectCross: partial,
+    crossAtRank1,
+    seeds: variant.seeds ?? null,
+    deterministic: Boolean(variant.deterministic),
+    seTargetMet: variant.seTargetMet !== false,
+  };
+};
+
+// The score gain per power follows the page's random ordinary-skill order: only the mean skill value matters.
+// Missing cross terms cannot silently stand in for zero when ordinary skills are enabled.
+export const aptitudeRate = (fig, skills) => {
+  if (!fig) return null;
+  if (!fig.weights) return skillValues(skills).some((x) => x > 0) ? null : fig.base;
+  return scoreRate(fig, skills);
+};
+
+// Only the raw all-Just, rank-1, no-Great, no-ordinary-skill gain has an exported SE.
+// No SE is assigned to transformed or combined results: joint samples/covariances are absent.
+export const aptitudeSe = (fig, skills) => (fig && !skillValues(skills).some((x) => x > 0) ? fig.baseSe : null);
+
+// A variant that adds no score: "measures" when it still moves a range measure (or converts judgements), "none" when
+// it changes nothing in the theoretical best play; null for a variant with a score gain or cross term.
+export const zeroGain = (variant) => {
+  if (!variant || mOf(variant.score) !== 0 || seOf(variant.score) !== 0) return null;
+  if ((variant.weights || []).some((w) => (mOf(w) ?? 0) !== 0)) return null;
+  const moves = (variant.ranges || []).some((x) => MEASURES.some((k) => (mOf(x[k]) ?? 0) !== 0)) || (mOf(variant.converted) ?? 0) !== 0;
+  return moves ? "measures" : "none";
+};
+
 // ournotes-deck's measurement power of music-data.json.
 export const modelPower = (data) => (data && data.deck && data.deck.model && data.deck.model.power) || POWER;
 
@@ -254,6 +377,11 @@ export const lengthMs = (row, source) => {
   return typeof v === "number" && v > 0 ? v : null;
 };
 
+// Master integer effect value -> factor used by check.deck predictions. The game first computes value/10000
+// and its ×100000 in float32, then truncates to five decimals: e.g. 13000 becomes 1.29999, not 1.3.
+// This is ONLY for master integer values, not the page's user-entered percentages (which stay percent/100).
+export const masterSkillFactor = (value) => Math.trunc(Math.fround(Math.fround(value / 10000) * 100000)) / 100000;
+
 // Skill values (fractions: 1 = +100 %) as numbers; missing, negative or non-numeric values count as 0.
 export const skillValues = (skills) => [...(skills || [])].map((x) => {
   const v = Number(x);
diff --git a/tests/unit/songs-page.test.mjs b/tests/unit/songs-page.test.mjs
index a82011f..ef3e078 100644
--- a/tests/unit/songs-page.test.mjs
+++ b/tests/unit/songs-page.test.mjs
@@ -2,13 +2,13 @@ import test from "node:test";
 import assert from "node:assert/strict";
 
 import {
-  DEFAULT_SCENARIO, MEASURES, MISSION_MEASURE, X_MAX, chartFigures, dominance, dominates, eventDominates, formatLength,
-  formatRanks, greatFactor, joinCharts, lengthMs, meanSkill, orderRates, parseRanks, perMinute, pickText, plainKind,
+  DEFAULT_SCENARIO, MEASURES, MISSION_MEASURE, X_MAX, aptitudeFigures, aptitudeRate, aptitudeSe, aptitudeShapes, chartVariants, zeroGain, chartFigures, dominance, dominates, eventDominates, formatLength,
+  formatRanks, greatFactor, joinCharts, lengthMs, meanSkill, masterSkillFactor, orderRates, parseRanks, perMinute, pickText, plainKind,
   quantile, rangeMeasures, rank, rankPercent, rankThreshold, reachChance, requiredPower, roomThreshold, scenarioData,
   scoreRate, weightSum,
 } from "../../examples/songs/ranking.js";
 import {
-  chartRows, density, extent, gekisouSkill, histogram, matches, moenotesUrl, noteKinds, refigure, sortBy, ticks,
+  chartRows, density, extent, gekisouSkill, histogram, matches, moenotesUrl, noteKinds, refigure, shapeSkills, shapeBands, sortBy, ticks,
 } from "../../examples/songs/catalog.js";
 
 // music-data.json: kind 0 is a judgement score up, kind 1 the plain score up the page models
@@ -342,10 +342,10 @@ test("Free Live reads offSeeds, also on charts unplayable with Gekisou", () => {
 
 test("what the data can show, the ranks in the query", () => {
   const data = (d) => ({ songs: [{ id: 1, charts: [{ scoreId: 1, deck: d }] }] });
-  assert.deepEqual(scenarioData(data(deck3())), { free: true, ranks: true, just: true });
-  assert.deepEqual(scenarioData(songs), { free: false, ranks: false, just: false });   // the current data
+  assert.deepEqual(scenarioData(data(deck3())), { free: true, ranks: true, just: true, aptitude: false });
+  assert.deepEqual(scenarioData(songs), { free: false, ranks: false, just: false, aptitude: false });   // the current data
   assert.deepEqual(scenarioData(data(deck3({ offSeeds: [], ranges: RANGES3.map(({ rankBonusPercents, ...r }) => r) }))),
-    { free: false, ranks: false, just: true });
+    { free: false, ranks: false, just: true, aptitude: false });
   assert.deepEqual(parseRanks(null), [1, 1, 1]);
   assert.deepEqual(parseRanks("5"), [5, 5, 5]);
   assert.deepEqual(parseRanks("2,5,3"), [2, 5, 3]);
@@ -409,7 +409,7 @@ test("fields of other formats (the dropped best formation deck.gekisou) leave th
   for (const sc of [null, { ranks: [2, 5, 3], just: 0.5, great: 0.25 }, { mode: "free" }]) {
     assert.deepEqual(chartFigures(deck3(extra), 1, 1000, sc), chartFigures(deck3(), 1, 1000, sc));
   }
-  assert.deepEqual(scenarioData({ songs: [{ id: 1, charts: [{ scoreId: 1, deck: deck3(extra) }] }] }), { free: true, ranks: true, just: true });
+  assert.deepEqual(scenarioData({ songs: [{ id: 1, charts: [{ scoreId: 1, deck: deck3(extra) }] }] }), { free: true, ranks: true, just: true, aptitude: false });
 });
 
 test("Gekisou skill names come from gekisouCatalog in the page language, with fallbacks", () => {
@@ -486,3 +486,94 @@ test("sorting, ticks, extents and histograms", () => {
   const hist = histogram([{ difficulty: "hard", level: 20 }, { difficulty: "expert", level: 26 }, { difficulty: "expert", level: 26.5 }], (r) => r.level);
   assert.deepEqual(hist.map(([b, c]) => [b, c.hard, c.expert]), [[20, 1, 0], [26, 0, 2]]);
 });
+
+// Synthetic aptitude samples: score gain 36 at rank 1; tail 1 + range gain 10 × 3.5.
+const aptitudeVariant = (extra = {}) => ({
+  shape: 0, bandMatch: null, deterministic: false, seeds: 128, crossSeeds: 64, seTargetMet: false,
+  score: [36, 2], scorePerfect: [19.5, 1], tail: [1, 0.1], tailPerfect: [2, 0.1], converted: [3, 0],
+  ranges: [{ rangeScore: [10, 0.5], rankBonus: [25, 1.25], rangeScorePerfect: [5, 0.25], maxCombo: [0, 0], justCount: [4, 0], luckPoints: [0, 0] }],
+  weights: [[0.1, 0.01], [0.2, 0.02]], rangeWeights: [[[0.04, 0.004]], [[0.08, 0.008]]],
+  ...extra,
+});
+const aptitudeRanges = [{ mission: 3, rankBonusPercent: 250, rankBonusPercents: [250, 200, 150, 100, 50] }];
+
+test("single-skill aptitude: baseline is unchanged, default gain, ranks, accuracy and cross terms", () => {
+  const v = aptitudeVariant();
+  const f = aptitudeFigures(v, aptitudeRanges, 1000);
+  near(f.base, 0.036, "raw gain");
+  near(aptitudeRate(f, [1, 1]), 0.336, "plain skills");
+  near(aptitudeRate(f, [2, 0]), 0.336, "random skill order uses the mean");
+  near(aptitudeSe(f, [0, 0]), 0.002, "score-only SE");
+  assert.equal(aptitudeSe(f, [1, 1]), null); // no covariance for the combined estimate
+  assert.equal(f.seTargetMet, false);
+  const r = aptitudeFigures(v, aptitudeRanges, 1000, { ranks: [5] });
+  near(r.base, 0.016, "tail + delta range times rank factor");
+  nearAll(r.weights, [0.02, 0.04], "rank cross terms");
+  assert.equal(aptitudeSe(r, [0, 0]), null); // no SE after rank changes
+  assert.equal(r.crossAtRank1, false);
+  const j = aptitudeFigures(v, aptitudeRanges, 1000, { just: 0.5 });
+  near(j.base, 0.02775, "Just/Perfect delta interpolation");
+  assert.equal(j.weights, null);
+  assert.equal(j.missingPerfectCross, true);
+  assert.equal(aptitudeRate(j, [1, 1]), null);
+  near(aptitudeRate(j, [0, 0]), 0.02775, "base-only interpolation remains available");
+  assert.equal(aptitudeSe(j, [0, 0]), null);
+  const both = aptitudeFigures(v, aptitudeRanges, 1000, { ranks: [5], just: 0.5, great: 0.5 });
+  near(both.base, (1.5 + 7.5 * 1.5) * 0.9 / 1000, "tail and ranges interpolate then Great scale");
+  assert.equal(both.weights, null);
+  const great = aptitudeFigures(v, aptitudeRanges, 1000, { great: 0.5 });
+  nearAll(great.weights, [0.09, 0.18], "Great scales measured Just cross terms");
+  assert.equal(aptitudeSe(great, [0, 0]), null);
+  const d = deck3({ gekisouAptitude: { variants: [v], factors: [] } });
+  assert.deepEqual(chartFigures(d, 1, 1000), chartFigures(deck3(), 1, 1000));
+  assert.equal(aptitudeFigures(v, aptitudeRanges, 1000, { mode: "free" }), null);
+  assert.deepEqual(chartFigures(d, 1, 1000, { mode: "free" }), chartFigures(deck3(), 1, 1000, { mode: "free" }));
+});
+
+test("aptitude missing fields never silently become a measured ordinary-skill gain", () => {
+  assert.equal(aptitudeFigures(null, []), null);
+  assert.equal(aptitudeFigures(aptitudeVariant({ score: null }), aptitudeRanges), null);
+  assert.equal(aptitudeFigures(aptitudeVariant({ scorePerfect: null }), aptitudeRanges, 1000, { just: 0 }), null);
+  assert.equal(aptitudeFigures(aptitudeVariant(), [], 1000, { ranks: [5] }), null);
+  const v = aptitudeVariant({ weights: null, rangeWeights: null });
+  const f = aptitudeFigures(v, aptitudeRanges, 1000);
+  near(aptitudeRate(f, [0, 0]), 0.036, "base without a plain kind");
+  assert.equal(aptitudeRate(f, [1, 0]), null);
+  assert.equal(aptitudeSe(f, [1, 0]), null);
+  const noRange = aptitudeFigures(aptitudeVariant({ rangeWeights: null }), aptitudeRanges, 1000, { ranks: [5] });
+  assert.equal(noRange.crossAtRank1, true);
+  nearAll(noRange.weights, [0.1, 0.2], "fallback retains rank-1 cross terms");
+  assert.deepEqual(chartVariants(null), []);
+  assert.deepEqual(chartVariants(deck3()), []);
+  assert.deepEqual(chartVariants(deck3({ unplayable: "4 fevers", gekisouAptitude: { variants: [v] } })), []);
+});
+
+test("aptitude shape names, band variants, zero effects and availability", () => {
+  const shape = { id: 0, source: "support", bandCondition: true, mission: 3, skills: [
+    { id: 1, level: 5, bandIds: [2] }, { id: 1, level: 4, bandIds: [2] }, { id: 9, level: 5, bandIds: [3] },
+  ] };
+  const data = { deck: { gekisouAptitude: { shapes: [shape] } }, bands: [{ id: 2, name: { en: "Band" } }],
+    gekisouCatalog: { supportSkills: [{ id: 1, mission: 3, maxLevel: 5, name: { ja: "支援", en: "Support" } }] },
+    songs: [{ charts: [{ deck: deck3({ gekisouAptitude: { variants: [aptitudeVariant({ bandMatch: true }), aptitudeVariant({ bandMatch: false })] } }) }] }],
+  };
+  assert.equal(aptitudeShapes(data).get(0), shape);
+  assert.equal(aptitudeShapes(null).size, 0);
+  assert.equal(scenarioData(data).aptitude, true);
+  assert.equal(scenarioData(songs).aptitude, false);
+  assert.deepEqual(shapeSkills(data, shape, "en").map((s) => [s.name, s.level]), [["Support", 5], ["Support", 4], ["#9", 5]]);
+  assert.equal(shapeSkills(data, shape, "ko")[0].name, "支援");
+  assert.deepEqual(shapeBands(data, shape, "ja"), ["Band", "#3"]);
+  assert.deepEqual(shapeSkills(null, null, "en"), []);
+  assert.equal(zeroGain(aptitudeVariant()), null);
+  assert.equal(zeroGain(aptitudeVariant({ score: [0, 0], weights: [[0, 0]], converted: [0, 0] })), "measures");
+  assert.equal(zeroGain(aptitudeVariant({ score: [0, 0], weights: null, converted: [0, 0], ranges: [] })), "none");
+});
+
+test("master skill factor uses float32 before truncation, unlike user percentages", () => {
+  assert.equal(masterSkillFactor(0), 0);
+  assert.equal(masterSkillFactor(1000), 0.1);
+  assert.equal(masterSkillFactor(10000), 1);
+  assert.equal(masterSkillFactor(13000), 1.29999);
+  assert.equal(masterSkillFactor(15000), 1.5);
+  assert.equal(meanSkill([130 / 100], 1), 1.3); // UI percent conversion must not use masterSkillFactor
+});

From 02796bb2c2e91d4778aecd508a098feb24468096 Mon Sep 17 00:00:00 2001
From: nichinichisou <nichinichisou0609@outlook.com>
Date: Wed, 30 Sep 2026 04:26:19 +0800
Subject: [PATCH 4/8] feat(examples): show Gekisou skill aptitude and chart
 factors in details

List single-skill variants, equivalent skill names, band conditions, score gains, raw sampling errors and range-measure changes. Keep baseline rankings unchanged. Explain non-additivity, measurement hosts, sampling and missing Perfect cross weights in both languages. Update only numeric cells during slider changes.

Co-Authored-By: Claude Code <noreply@anthropic.com>
---
 README.en.md              |  2 +-
 README.md                 |  2 +-
 examples/songs/index.html | 12 ++++++
 examples/songs/songs.js   | 90 +++++++++++++++++++++++++++++++++++++--
 examples/songs/text.js    | 70 +++++++++++++++++++++++++-----
 5 files changed, 160 insertions(+), 16 deletions(-)

diff --git a/README.en.md b/README.en.md
index 1b2f48a..acf3e43 100644
--- a/README.en.md
+++ b/README.en.md
@@ -86,7 +86,7 @@ Example pages. Open them with any static server at the repository root:
 | [examples/basic.html](examples/basic.html) | one `<ournotes-player>` |
 | [examples/iframe.html](examples/iframe.html) | a page holding one player, ready to embed with an `<iframe>` (`?src=`) |
 | [examples/chart-list](examples/chart-list) | lists a site's `charts.json` and plays the chosen chart; a site of several regions or languages switches with `?region=&lang=` |
-| [examples/songs](examples/songs) | chart data: reads a site's `music-data.json` (nnnotes music-data, with ournotes-deck's whole-live statistics, Gekisou on) and `jackets/` (optional); rankings by efficiency (expectation and range over the random skill order), event rank (power needed, chance), speed, level, notes, length and skip score, a scatter plot and level distribution, chart details (BPM, density, fevers with their Gekisou missions, skill timeline, notes by kind, skill position weights, score ranks, the rank measures of the Gekisou ranges) and a guide to the model; styled after moenotes' Sirius theme (light / dark), song pages link to moenotes |
+| [examples/songs](examples/songs) | chart data: reads a site's `music-data.json` (nnnotes music-data, with ournotes-deck's whole-live statistics, Gekisou on) and `jackets/` (optional); rankings by efficiency (expectation and range over the random skill order), event rank (power needed, chance), speed, level, notes, length and skip score, a scatter plot and level distribution, chart details (BPM, density, fevers with their Gekisou missions, skill timeline, notes by kind, skill position weights, score ranks, the rank measures of the Gekisou ranges, single-skill aptitude and chart factors; aptitude gains cannot be added) and a guide to the model; styled after moenotes' Sirius theme (light / dark), song pages link to moenotes |
 | [examples/story-list](examples/story-list) | lists a site's `stories.json` and plays the chosen episode |
 | [examples/story](examples/story) | plays one episode (`?story=` or `?src=`). Live2D's two files come from `?core=` and `?motionsync=`, the Spine runtime for home talks from `?spine=` |
 | [examples/live2d](examples/live2d) | lists a site's `models.json`, shows the chosen model and plays its motions and expressions |
diff --git a/README.md b/README.md
index 0d85e4b..8299bb2 100644
--- a/README.md
+++ b/README.md
@@ -72,7 +72,7 @@ button.onclick = () => player.play();   // 浏览器要求在用户操作中开
 | [examples/basic.html](examples/basic.html) | 一个 `<ournotes-player>` |
 | [examples/iframe.html](examples/iframe.html) | 只含一个播放器的页面，可用 `<iframe>` 嵌入（`?src=`） |
 | [examples/chart-list](examples/chart-list) | 列出站点的 `charts.json` 并播放所选谱面；多区服或多语言的站点用 `?region=&lang=` 切换 |
-| [examples/songs](examples/songs) | 谱面数据：读站点的 `music-data.json`（nnnotes music-data，含 ournotes-deck 的激走整局统计）和 `jackets/`（可选），按效率（随机技能顺序下的期望与区间）、活动评级（所需综合力、达成率）、速度、等级、Notes、时长、跳过得分排行，散点图和等级分布，谱面详情（BPM、密度、Fever 与激走任务、技能时间轴、音符构成、技能位权重、评级门槛、各激走区间的名次指标）和模型说明；外观沿用 moenotes 的 Sirius 主题（浅色 / 深色），歌曲资料页跳转 moenotes |
+| [examples/songs](examples/songs) | 谱面数据：读站点的 `music-data.json`（nnnotes music-data，含 ournotes-deck 的激走整局统计）和 `jackets/`（可选），按效率（随机技能顺序下的期望与区间）、活动评级（所需综合力、达成率）、速度、等级、Notes、时长、跳过得分排行，散点图和等级分布，谱面详情（BPM、密度、Fever 与激走任务、技能时间轴、音符构成、技能位权重、评级门槛、各激走区间的名次指标、单个激走技能的适性与谱面因子；适性不可相加）和模型说明；外观沿用 moenotes 的 Sirius 主题（浅色 / 深色），歌曲资料页跳转 moenotes |
 | [examples/story-list](examples/story-list) | 列出站点的 `stories.json` 并播放所选剧情 |
 | [examples/story](examples/story) | 播放一集剧情（`?story=` 或 `?src=`；Live2D 的两个文件用 `?core=`、`?motionsync=`，据点对话的 Spine 运行时用 `?spine=`） |
 | [examples/live2d](examples/live2d) | 列出站点的 `models.json`，显示所选模型并播放其动作与表情 |
diff --git a/examples/songs/index.html b/examples/songs/index.html
index 634ab0b..925663b 100644
--- a/examples/songs/index.html
+++ b/examples/songs/index.html
@@ -399,6 +399,18 @@
   .rk { display: inline-block; min-width: 32px; padding: 0 8px; border-radius: 4px; text-align: center; font-weight: 600; font-size: 12px; border: 1px solid var(--mn-border); color: var(--mn-ink-soft); }
   .rk-SS { color: var(--mn-orbit-light); background: var(--mn-orbit-night); border-color: var(--mn-orbit-edge); }
   .rk-S { color: var(--mn-accent-deep); background: var(--mn-accent-soft); border-color: color-mix(in srgb, var(--mn-accent) 40%, transparent); }
+  /* Single-skill aptitude: numeric cells update without rebuilding the expanded details. */
+  .apt-table { min-width: 680px; }
+  .apt-table > thead > tr > th, .apt-table > tbody > tr > td { vertical-align: top; }
+  .apt-table > tbody > tr > td:first-child { min-width: 220px; max-width: 380px; overflow-wrap: anywhere; }
+  .apt-table small { display: block; color: var(--mn-text-muted); font-size: 11px; white-space: normal; }
+  .apt-table small.warn { color: var(--mn-rose); }
+  .apt-table details { margin-top: 6px; }
+  .apt-table summary { cursor: pointer; color: var(--mn-accent-deep); font-size: 12px; }
+  .apt-table details table { margin-top: 8px; }
+  .apt-table .num { white-space: nowrap; }
+  .aptitude .panel { margin-top: 10px; }
+  .factors { min-width: 640px; }
   /* the rank measures of the Gekisou ranges */
   .tbl-scroll { overflow-x: auto; }
   .ranks td.hi { font-weight: 600; color: var(--mn-text); }
diff --git a/examples/songs/songs.js b/examples/songs/songs.js
index c558d31..3d361cc 100644
--- a/examples/songs/songs.js
+++ b/examples/songs/songs.js
@@ -19,13 +19,13 @@
 //   &theme=light|dark                                                       (default: the system's)
 // The site root is this page's directory unless ?site=<URL> names another one.
 import {
-  DIFFICULTIES, MOENOTES, NOTE_KINDS, chartRows, extent, histogram, matches, moenotesUrl, pickText, refigure, sortBy,
+  DIFFICULTIES, MOENOTES, NOTE_KINDS, chartRows, extent, histogram, matches, moenotesUrl, pickText, refigure, shapeBands, shapeSkills, sortBy,
   ticks,
 } from "./catalog.js";
 import {
-  MEASURES, RANGES, RANK_MAX, SCORE_RANKS, X_MAX, chartFigures, eventDominance, formatLength, formatRanks, lengthMs,
+  MEASURES, RANGES, RANK_MAX, SCORE_RANKS, X_MAX, aptitudeFigures, aptitudeRate, aptitudeSe, aptitudeShapes, chartVariants, chartFigures, eventDominance, formatLength, formatRanks, lengthMs,
   meanSkill, modelPower, orderRates, parseRanks, perMinute, plainKind, quantile, rangeMeasures, rank, rankThreshold,
-  reachChance, requiredPower, scenarioData, scoreRate, weightSum,
+  reachChance, requiredPower, scenarioData, scoreRate, weightSum, zeroGain,
 } from "./ranking.js";
 import { GUIDE, UI } from "./text.js";
 
@@ -744,6 +744,85 @@ const main = async () => {
       h("p", { class: "hint" }, D.measuresHint));
   };
 
+  // Aptitude only describes taking one skill; it never changes the baseline rows used by rankings.
+  // Build names and raw measure tables once. Slider updates only replace the numerical cells.
+  const aptitudeBox = (r, changed) => {
+    const A = u().aptitude, D = u().detail;
+    const element = h("section", { class: "aptitude" }, heading("h3", "sec-head", A.title));
+    const header = songs.deck && songs.deck.gekisouAptitude;
+    const data = r.stats && r.stats.gekisouAptitude;
+    if (!header || !data || r.unplayable) {
+      element.append(h("p", { class: "hint" }, A.pending));
+      return { element, update() {} };
+    }
+    const shapes = aptitudeShapes(songs);
+    const pair = (x) => Array.isArray(x) && Number.isFinite(x[0])
+      ? `${fmt(x[0], Number.isInteger(x[0]) ? 0 : 2)}${x[1] > 0 ? ` ± ${fmt(x[1], 2)}` : ""}` : "–";
+    const input = h("input", { type: "number", class: "num-in power", min: 0, step: 1000, value: S.power || "", "aria-label": A.power });
+    input.addEventListener("input", () => { S.power = Math.max(0, Math.round(Number(input.value) || 0)); changed(); });
+    const xs = S.skills.map((x, k) => {
+      const inp = h("input", { type: "number", class: "num-in skill", min: 0, max: 100 * X_MAX, step: 5, value: x, "aria-label": `${u().skills} ${k + 1}` });
+      inp.addEventListener("input", () => { S.skills[k] = Math.min(100 * X_MAX, Math.max(0, Number(inp.value) || 0)); changed(); });
+      inp.addEventListener("change", () => { inp.value = S.skills[k]; });
+      return inp;
+    });
+    element.append(h("p", { class: "hint" }, A.note),
+      h("div", { class: "panel" }, h("label", { class: "field" }, A.power, input),
+        h("small", { class: "note" }, A.defaultPower(fmtInt(power))),
+        h("div", { class: "field" }, u().skills, xs)),
+      h("p", { class: "hint" }, A.accuracy), h("p", { class: "hint" }, A.se));
+    const items = chartVariants(r.stats).map((v) => {
+      const shape = shapes.get(v.shape);
+      const names = shapeSkills(songs, shape, S.lang);
+      const label = (x) => `${x.name} · Lv.${x.level ?? "?"} (#${x.id})`;
+      const name = names.length ? [label(names[0]), names.length > 1 ? h("details", {},
+        h("summary", {}, A.more(names.length - 1)), h("ul", {}, names.slice(1).map((x) => h("li", {}, label(x))))) : null]
+        : [`${A.unknown} #${v.shape}`];
+      const gain = h("td", { class: "num" }), ratio = h("td", { class: "num" }), hint = h("small", {});
+      const raw = h("details", {}, h("summary", {}, A.changes), h("p", { class: "note" }, A.raw),
+        h("table", { class: "ranks measures" }, h("thead", {}, h("tr", {}, h("th", {}, D.mRange), MEASURES.map((k) => h("th", {}, `Δ ${D.measure[k]}`)))),
+          h("tbody", {}, (v.ranges || []).map((x, i) => h("tr", {}, h("td", {}, String(i + 1)), MEASURES.map((k) => h("td", {}, pair(x[k]))))))),
+        h("p", {}, A.rawScore, " ", pair(v.score)), h("p", {}, A.rawPerfect, " ", pair(v.scorePerfect)),
+        h("p", {}, A.converted, " ", pair(v.converted)));
+      const zero = zeroGain(v);
+      const row = h("tr", {}, h("td", {}, name, hint, raw),
+        h("td", {}, shape ? A[shape.source] || shape.source : "–"),
+        h("td", { title: shapeBands(songs, shape, S.lang).join(" / ") }, v.bandMatch === true ? A.match : v.bandMatch === false ? A.mismatch : A.noBand),
+        gain, ratio,
+        h("td", {}, `${v.seeds ?? "–"} / ${v.crossSeeds ?? "–"}`,
+          !v.deterministic ? h("small", {}, A.rawScore, ": ", pair(v.score)) : null,
+          v.seTargetMet === false ? h("small", { class: "warn" }, A.warning) : null,
+          v.deterministic ? h("small", {}, A.deterministic) : null,
+          zero ? h("small", {}, zero === "none" ? A.zero : A.onlyMeasures) : null));
+      return { v, gain, ratio, hint, row };
+    });
+    if (!items.length) element.append(h("p", { class: "hint" }, A.empty));
+    else element.append(h("div", { class: "tbl-scroll" }, h("table", { class: "ranks apt-table" },
+      h("thead", {}, h("tr", {}, [A.skill, A.source, A.band, A.gain, A.ratio, A.seeds].map((x) => h("th", {}, x)))),
+      h("tbody", {}, items.map((x) => x.row)))));
+    const factors = data.factors || [];
+    const keys = ["judgedNotes", "justNotes", "perfectNotes", "tailNotes", "comboAtStart", "lotteries"];
+    if (factors.length) element.append(heading("h3", "sec-head", A.factors), h("div", { class: "tbl-scroll" },
+      h("table", { class: "ranks measures factors" }, h("thead", {}, h("tr", {}, h("th", {}, D.mRange), keys.map((k) => h("th", {}, A[k])))),
+        h("tbody", {}, factors.map((x, i) => h("tr", {}, h("td", {}, String(i + 1)), keys.map((k) => h("td", {}, k === "lotteries" ? pair(x[k]) : fmtInt(x[k])))))))),
+      h("p", { class: "hint" }, A.factorNote));
+    return { element, update() {
+      const sc = scenario();
+      const P = S.power || power;
+      for (const { v, gain, ratio, hint } of items) {
+        // A missing/mismatched plain kind must not be mistaken for measured zero cross terms.
+        const usable = header.plainKind === kind && kind !== null ? v : { ...v, weights: null, rangeWeights: null };
+        const f = aptitudeFigures(usable, r.stats.ranges || [], power, sc);
+        const rate = aptitudeRate(f, skills());
+        const se = aptitudeSe(f, skills());
+        put(gain, rate === null ? "–" : `${fmt(P * rate, 1)}${se === null ? "" : ` ± ${fmt(P * se, 1)}`}`);
+        put(ratio, rate !== null && r.base > 0 ? `${fmt(100 * rate / r.base, 2)}%` : "–");
+        put(hint, rate === null ? [f && f.missingPerfectCross ? A.missingPerfect : A.missingCross,
+          f ? ` ${A.baseOnly}: ${fmt(P * f.base, 1)}` : ""] : f.crossAtRank1 ? A.rank1 : "");
+      }
+    } };
+  };
+
   // a scenario changed in the detail: the view behind it redraws when the detail closes
   let behindStale = false;
   const openChart = (scoreId) => { S.chart = scoreId; renderDrawer(); save(); };
@@ -767,11 +846,14 @@ const main = async () => {
     const weights = h("section", {});
     const ranks = h("div", {});
     const measures = measuresBox(r);
+    const aptitude = aptitudeBox(r, () => { draw(); behindStale = true; save(); });
     const draw = () => {
       const e = eff(r);
       const battle = S.mode === "battle";
       const solo = battle && r.weights ? freeRate(r) : null;
       if (measures) measures.hidden = !battle;
+      aptitude.element.hidden = !battle;
+      if (battle) aptitude.update();
       put(scores, h("div", { class: "tiles" },
         r.weights ? tile(t.col.rate, fmt(e.rate, 3), (() => {
           const v = orderRates(r, skills());
@@ -820,7 +902,7 @@ const main = async () => {
           h("section", {}, heading("h3", "sec-head", t.detail.composition), composition(r)),
           weights),
         ranks,
-        measures,
+        measures, aptitude.element,
         h("p", { class: "ids" }, `${t.detail.musicId} ${r.musicId} · ${t.detail.scoreId} ${r.scoreId} · ${t.detail.musicType} ${r.song.musicType}`)));
     drawer.replaceChildren(panel);
     drawer.classList.add("open");
diff --git a/examples/songs/text.js b/examples/songs/text.js
index 8dc9b7f..b973295 100644
--- a/examples/songs/text.js
+++ b/examples/songs/text.js
@@ -40,6 +40,25 @@ export const UI = {
       pending: "数据待更新", room: "房间人数",
       roomHint: "按全员得分之和评级；假设全员与你同分，你的所需分数 = √(5/n) × 撃奏ライブ门槛", soloRanks: "自由 Live 用单人评级门槛",
     },
+    aptitude: {
+      title: "激走技能适性", pending: "适性数据待更新；排行和得分仍按不带激走技能计算。",
+      empty: "没有适用于本谱任务的技能变体。", skill: "技能 / 等级", source: "来源", member: "成员", support: "支援",
+      band: "乐队条件", match: "匹配", mismatch: "不匹配", noBand: "无条件", unknown: "未知形状",
+      gain: "Δ得分", ratio: "占无技能得分", seeds: "种子 / 交叉项", changes: "区间指标变化", converted: "转换数 Δ",
+      more: (n) => `同形状的其他 ${n} 个技能`,
+      warning: "标准误未达目标", deterministic: "确定性检验通过", zero: "理论最佳打法下无增量", onlyMeasures: "只改变指标",
+      power: "换算综合力", defaultPower: (p) => `未填综合力时按测量综合力 ${p} 显示`,
+      note: "单个技能，不可相加。下表不会加进排行或本场景得分；普通技能按本页随机发动顺序取平均倍率。百分比的分母是同名次、同准率且不带普通技能或激走技能的基线分数。",
+      accuracy: "Just 率插值、Great 比例缩放都是近似。Just < 100% 且普通技能非零时，缺少 Perfect 交叉权重，不提供完整增量。",
+      missingPerfect: "缺少 Perfect 交叉权重；完整增量不可用。", baseOnly: "无普通技能增量（近似）", rawScore: "原始无普通技能 Δ分（P₀、全 Just、第 1 名）", rawPerfect: "原始全 Perfect Δ分（测量综合力）",
+      se: "± 仅附在原始采样统计量上，表示标准误，不是置信区间。名次、准率或普通技能改变后的合成结果没有协方差，不附 ±。展开区间指标可看原始 Δscore ± 标准误；未达目标针对原始 Δscore，调整参数不会重测。",
+      rank1: "此项缺少区间交叉权重，交叉项仍按名次 1，不能精确跟随当前名次。",
+      missingCross: "没有可用的普通技能交叉项；将普通技能倍率设为 0 可看基础增量。",
+      raw: "以下指标及转换数是全 Just、无 Great 的原始增量，不随准率滑块变化；名次由你指定，指标增量不直接换算成更高名次。",
+      factors: "谱面因子（不带技能）", judgedNotes: "区间判定数", justNotes: "Just 音符", perfectNotes: "Just 区间 Perfect 音符",
+      tailNotes: "尾部音符", comboAtStart: "进入时连击", lotteries: "抽签次数",
+      factorNote: "区间计数为 Start 帧之后至 End 帧；尾部为 End 至 Complete，受技能影响但不计入区间分。抽签次数取基线种子均值 ± 标准误。",
+    },
     frontier: "只看前沿", col: {
       rank: "#", song: "曲目", level: "等级", time: "时长", bpm: "BPM", notes: "Notes", density: "N/s",
       rate: "分/综合力", perMinute: "分/综合力/分钟", relative: "相对", dom: "支配", skip: "跳过系数", base: "基础系数",
@@ -121,6 +140,25 @@ export const UI = {
       roomHint: "the room's summed score is rated; with every player scoring the same as you, you need √(5/n) × the Gekisou Live threshold",
       soloRanks: "Free Live uses the solo rank thresholds",
     },
+    aptitude: {
+      title: "Gekisou skill aptitude", pending: "Aptitude data pending; rankings and scores still have no Gekisou skills.",
+      empty: "No skill variants apply to this chart's missions.", skill: "Skill / level", source: "Source", member: "Member", support: "Support",
+      band: "Band condition", match: "matched", mismatch: "unmatched", noBand: "none", unknown: "Unknown shape",
+      gain: "Score Δ", ratio: "Share of no-skill score", seeds: "Seeds / cross terms", changes: "Range measure changes", converted: "Conversions Δ",
+      more: (n) => `${n} other skills of this shape`,
+      warning: "SE target not met", deterministic: "Passed determinism test", zero: "No gain in best play", onlyMeasures: "Measures only",
+      power: "Power for conversion", defaultPower: (p) => `Empty power uses the measurement power ${p}`,
+      note: "One skill at a time; gains cannot be added. This table does not change rankings or scenario scores. Ordinary skills use their mean value over the page's random activation order. The percentage divides by the baseline at the same ranks and accuracy, without ordinary or Gekisou skills.",
+      accuracy: "Just interpolation and Great scaling are approximate. Below 100% Just with nonzero ordinary skills, Perfect cross weights are missing: no complete gain is provided.",
+      missingPerfect: "Perfect cross weights missing; complete gain unavailable.", baseOnly: "No-ordinary-skill gain (approximate)", rawScore: "Raw no-ordinary-skill score Δ (P₀, all Just, rank 1)", rawPerfect: "Raw all-Perfect score Δ (measurement power)",
+      se: "± labels raw sampled statistics only: standard error, not a confidence interval. Combined results after ranks, accuracy or ordinary skills change have no covariance data and no ±. Expand range measures for raw score gain ± SE. The target flag concerns original score gain; changing settings does not resample it.",
+      rank1: "No range cross weights: cross terms stay at rank 1, not exactly at the chosen ranks.",
+      missingCross: "Ordinary-skill cross terms unavailable; set ordinary skills to 0 to see the base gain.",
+      raw: "Measures and conversions below are raw all-Just, no-Great gains, unchanged by accuracy sliders. Ranks are chosen by you; higher measures do not directly become higher ranks.",
+      factors: "Chart factors (no skills)", judgedNotes: "Range judged notes", justNotes: "Just notes", perfectNotes: "Perfects in Just ranges",
+      tailNotes: "Tail notes", comboAtStart: "Entry combo", lotteries: "Lotteries",
+      factorNote: "Range counts cover after Start through End; the tail covers after End through Complete, affected by skills but outside the range score. Lottery counts are the baseline seed mean ± standard error.",
+    },
     frontier: "Frontier only", col: {
       rank: "#", song: "Song", level: "Level", time: "Time", bpm: "BPM", notes: "Notes", density: "N/s",
       rate: "Score/power", perMinute: "Score/power/min", relative: "Rel.", dom: "Beaten", skip: "Skip", base: "Base",
@@ -294,19 +332,25 @@ export const GUIDE = {
         title: "激走技能",
         body: [
           "成员卡带激走技能，与它配对的小卡带激走支援技能。从反编译代码看，它们只在激走开启时建立，只加进含激走的那套分数（battleLiveScore），不进不含激走的那套（soloScore），自由 Live 里也没有。"
-            + "每个技能属于一种激走任务（连击、幸运或 Just），只在同任务的区间里触发，与演奏位置和洗牌无关；支援技能可以带乐队条件（条件 5000），看配对的成员是否属于指定乐队。"
+            + "技能按激走任务（连击、幸运、Just，或全部）门控，只在适用任务的区间里触发，与演奏位置和洗牌无关；支援技能可以带乐队条件（条件 5000），看配对的成员是否属于指定乐队。"
             + "ournotes-deck 的整局模拟可以带上激走技能，它们的效果（激走连击加成、幸运槽与幸运点、Just 数加成、支援技能的加分等）都逐帧计算。",
-          "本页现有的得分数值都不带激走技能。谱面对各激走技能的适性（每个激走技能或支援技能单独带上时的得分增量与区间指标变化）数据待更新。",
+          "本页的排行和场景得分仍不带激走技能。适性表单独显示每个激走技能或支援技能带上时的得分增量与区间指标变化，不是推荐编成。成员技能取最高等级，支援技能取小卡最高突破时的等级；计分效果参数相同的技能归为同一形状，名字合列。成员技能只给一名演奏者装备，其余位置空。支援技能挂在合成的空激走技能宿主上（负 id、没有效果行，任务与支援技能相同），不借用真卡。有乐队条件的支援技能分匹配和不匹配两种变体：宿主设为目标乐队或乐队 0。",
+        ],
+        math: [
+          "Δ(x) = P · ( Δscore / P₀ + x̄ · Σ_k Δw_k )",
+          "Δscore(r) = Δtail + Σ_i ΔrangeScore_i · (1 + p_i(r_i)/100)",
+          "Δw_k(r) = Δw_k + Σ_i (p_i(r_i) − p_i(1))/100 · ΔrangeWeights_k,i",
         ],
         after: [
           "精确与近似。带上激走技能再按第 1、2、6 节的式子计算时：名次 1、全 Just、无 Great 的得分是整局模拟的结果，普通技能那部分沿用第 1 节的线性式，与不带激走技能时是同一个近似。"
-            + "名次沿用第 2 节的线性式：从反编译代码看，名次加成是区间结束时记入的一笔固定分，不改变任何得分系数，所以换名次时无普通技能的部分仍然精确。"
+            + "名次沿用第 2 节的线性式：从反编译代码看，名次加成是区间结束时记入的一笔固定分，不改变任何得分系数，所以适性名次增量可按尾部加各区间增量乘名次系数得到，每区间有约 ±1 分的两次取整差；若没有区间交叉权重，交叉项只能按名次 1 显示并注明。"
             + "Just 率低于 100% 时沿用第 6 节的插值，带激走技能时这是近似：转 Just（13005）、每个 Just 加分的支援技能（2001）和累计 Just（13002）对 Just 数都不是线性的。Great 比例沿用 1 − 0.2 q，同样是近似。",
           "理论最佳打法下不起作用的技能。连击保护（12004）和 Great 转 Perfect（12006）只在出现 Great 或 Miss 时起作用，理论最佳打法下为 0，Great 比例的近似里也没有计入它们；每个音符都在准确时刻命中时，放宽 Just 判定（4004）也不起作用。"
             + "另有一些激走技能只提高名次指标，不直接加分（Just 数加成 13000、累计 Just 13002、加幸运点 11002）：本页不模拟对手，名次由你选定，所以它们不改变本页的得分；实际对局里它们可能帮你拿到更好的名次。"
-            + "以上是按反编译代码的阅读得出的，这些技能的得分增量为 0 还在用整局实跑逐一确认。",
-          "种子。带激走技能的整局模拟与第 1 节用同一组种子（含幸运区间的谱面是前 8 个公开种子），取的是这组种子的平均，不是游戏里的期望，游戏的种子规律未知；带激走技能时幸运区间的种子间差别可能更大。"
+            + "以上零效果类型已按适性数据的核对记录在全部谱面整局实跑确认；这仍是模型内部核对，不等于与游戏原生实现一致。",
+          "种子。先用 4 个种子检验确定性，各项增量完全相同则只报 1 个种子、标准误为 0。其余按 32、64、128、256、512、1024 逐级增加，直到 Δscore 标准误不超过“增量均值绝对值的 1%”与“同种子基线均值的 0.1%”中较宽的目标；到上限仍未达到就标注。普通技能交叉项至多用前 64 个种子。不同形状可用不同种子数；均值不是游戏期望，真实种子分布未知。表中 ± 仅表示原始统计量的标准误；组合后的值没有协方差数据，不显示标准误。表内 Δscore 是按相同种子、相同打法得到的差值；每位置另带单位普通技能测交叉项，随机名次与随机普通技能卡组再做 check 核对。Just 率低于 100% 且普通技能非零时，因缺少 Perfect 交叉权重，不提供完整适性增量。"
             + "演奏位置每局洗牌，但激走技能与位置无关；洗牌只改变单个种子里概率判定的抽取次序，不改变期望。",
+          "不可相加。连击加成存在饱和，多技能增量直接相加会高估；rush 支援与幸运槽技能（11001、11003、11005）会互相放大；13000/13002 改变 Just 数，又会影响按 Just 数触发的支援（7000）。单技能适性不能用于推算多技能编成，两个乐队变体也不能相加。",
           "核对现状。激走技能这一层按反编译代码逐项审计，与重写一致；整局与游戏原生代码的对照正在做，结果出来之前，这一层的数值尚在核对。按本模型得出的结论也都以此为前提。",
         ],
       },
@@ -468,19 +512,25 @@ export const GUIDE = {
         title: "Gekisou skills",
         body: [
           "Member cards carry a Gekisou skill and the snap paired with them a Gekisou support skill. By the decompiled code they exist only with Gekisou on and add to the score with Gekisou (battleLiveScore) only, never to the score without it (soloScore), and Free Live has none. "
-            + "Every skill belongs to one Gekisou mission (combo, luck or Just) and fires only in ranges of that mission, whatever the performance position and the shuffle; a support skill may carry a band condition (condition 5000) on the member it is paired with. "
+            + "Skills are gated by their Gekisou mission (combo, luck, Just or all) and fire only in applicable ranges, whatever the performance position and the shuffle; a support skill may carry a band condition (condition 5000) on the member it is paired with. "
             + "ournotes-deck's whole-live simulation can take Gekisou skills, and computes their effects (the Gekisou combo boost, the luck gauge and luck points, Just count boosts, the support skills' score ups and others) frame by frame.",
-          "The page's current score figures are all without Gekisou skills. A chart's aptitude for each Gekisou skill (the score gain and the range measure changes of one Gekisou skill or support skill taken alone) is pending in the data.",
+          "The rankings and scenario scores still have no Gekisou skills. The aptitude table separately shows the score and range-measure gains of one Gekisou or support skill, not a recommended formation. Member skills use their highest level; support skills use their snap’s highest-rank level. Equal scoring-effect parameters form one shape whose skill names are listed together. A member skill is equipped on one performer, leaving the others empty. A support skill uses a synthetic empty Gekisou-skill host (negative id, no effect rows, the same mission), never a real card. Band conditions have matched and unmatched variants, using the target band or band 0.",
+        ],
+        math: [
+          "Δ(x) = P · ( Δscore / P₀ + x̄ · Σ_k Δw_k )",
+          "Δscore(r) = Δtail + Σ_i ΔrangeScore_i · (1 + p_i(r_i)/100)",
+          "Δw_k(r) = Δw_k + Σ_i (p_i(r_i) − p_i(1))/100 · ΔrangeWeights_k,i",
         ],
         after: [
           "Exact and approximate. With Gekisou skills taken and the formulas of sections 1, 2 and 6 applied: at rank 1, all Just and no Great the score is the whole-live simulation's, and the plain skills' part keeps the linear formula of section 1, the same approximation as without Gekisou skills. "
-            + "The ranks keep the linear formula of section 2: by the decompiled code the rank bonus is a fixed amount added at the range's end that changes no score factor, so the part without plain skills stays exact at other ranks. "
+            + "The ranks keep the linear formula of section 2: by the decompiled code the rank bonus is a fixed amount added at the range's end that changes no score factor, so aptitude gains at other ranks follow from the tail plus range gains times rank factors, with about ±1 point per range from the two floors. Without range cross weights, cross terms remain at rank 1 and are labelled accordingly. "
             + "A Just rate below 100 % keeps the interpolation of section 6, an approximation with Gekisou skills: Just conversion (13005), the per-Just support score up (2001) and cumulative Just (13002) are not linear in the Just count. The Great share keeps 1 − 0.2 q, an approximation too.",
           "Skills that do nothing in the theoretical best play. The combo guard (12004) and Great to Perfect (12006) act only on Greats or Misses: 0 in the theoretical best play, and the Great share approximation leaves them out; with every note hit at its exact time, the wider Just window (4004) does nothing either. "
             + "Some Gekisou skills raise a rank measure only and add no score (Just count boost 13000, cumulative Just 13002, luck points 11002): the page does not model opponents and takes the ranks you pick, so they leave the page's scores alone; in a real room they may win you a better rank. "
-            + "This follows from our reading of the decompiled code; whole-live runs confirming a zero score gain for each of these skills are under way.",
-          "Seeds. Whole lives with Gekisou skills use the seeds of section 1 (the first 8 published seeds on charts with a luck range), and their mean is not the game's expectation, its seed law being unknown; with Gekisou skills the seeds of luck ranges may spread further apart. "
+            + "The aptitude verification records report whole-live confirmation of these zero-effect types on all charts. This is still an internal model check, not proof of agreement with the native game.",
+          "Seeds. Four seeds first test determinism; identical gains in every field are reported with one seed and zero SE. Otherwise batches of 32, 64, 128, 256, 512 and 1024 stop when score-gain SE is within the larger of 1% of the absolute mean gain or 0.1% of the baseline mean on the same seeds. A flag warns when the cap still misses the target. Cross terms use at most the first 64 seeds. Shapes can use different counts. Seed means are not the game’s expectation; its seed distribution is unknown. ± denotes SE on raw statistics only; combined values have no SE because covariances are unavailable. Deltas compare the same seeds and play; unit ordinary skills at each position measure cross terms, checked with random ranks and a random ordinary-skill deck. Below full Just with nonzero ordinary skills, missing Perfect cross weights prevent a complete aptitude gain. "
             + "The performance positions are shuffled every live, but the Gekisou skills do not depend on the position; the shuffle changes only the order of the chance draws within a seed, not the expectation.",
+          "Gains cannot be added. Combo boosts saturate, so adding single-skill gains can overestimate a combination. Rush support and luck-gauge skills (11001, 11003, 11005) reinforce each other; 13000/13002 change Just counts and therefore support triggered by those counts (7000). Single-skill aptitude cannot predict a multi-skill formation; the two band variants cannot be added either.",
           "State of the checks. This layer has been audited item by item against the decompiled code and agrees with the rewrite; the whole-live comparison with the game's native code is in progress, and until it is done the figures of this layer are still being checked. The conclusions “by this model” rest on that too.",
         ],
       },

From 46ac74f5ea08c801efcffe7c671b5119b4641e64 Mon Sep 17 00:00:00 2001
From: nichinichisou <nichinichisou0609@outlook.com>
Date: Wed, 30 Sep 2026 04:40:25 +0800
Subject: [PATCH 5/8] docs(examples): correct the Just-count support
 interaction claim

Remove the unverified implication from increased Just counters to support score gains. Keep combo saturation, luck-rush interaction and judgement conversion as non-additivity examples without generalizing the isolated no-interaction result.

Co-Authored-By: Claude Code <noreply@anthropic.com>
---
 examples/songs/ranking.js | 2 +-
 examples/songs/text.js    | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/examples/songs/ranking.js b/examples/songs/ranking.js
index 87f3fa6..0016ca1 100644
--- a/examples/songs/ranking.js
+++ b/examples/songs/ranking.js
@@ -230,7 +230,7 @@ export const chartFigures = (deck, kind, power = POWER, scenario = null) => {
 // and a deck of power P and skills x gains P · (Δscore / P₀ + Σ_k x_π(k) · Δw[k]), in expectation over the skill order
 // P · (Δscore / P₀ + x̄ · Σ_k Δw[k]): aptitudeFigures has the shape of chartFigures, so scoreRate applies. Free Live has
 // no Gekisou: no aptitude. The gains of several skills do not add up (combo boosts saturate, rush support and luck
-// gauge skills reinforce each other, Just count skills move per-Just support): one skill at a time.
+// gauge skills reinforce each other, 13005 conversion may change other skills’ triggers): one skill at a time.
 
 const CACHE = new WeakMap();
 const cached = (data, key, make) => {
diff --git a/examples/songs/text.js b/examples/songs/text.js
index b973295..7fec6f0 100644
--- a/examples/songs/text.js
+++ b/examples/songs/text.js
@@ -350,7 +350,7 @@ export const GUIDE = {
             + "以上零效果类型已按适性数据的核对记录在全部谱面整局实跑确认；这仍是模型内部核对，不等于与游戏原生实现一致。",
           "种子。先用 4 个种子检验确定性，各项增量完全相同则只报 1 个种子、标准误为 0。其余按 32、64、128、256、512、1024 逐级增加，直到 Δscore 标准误不超过“增量均值绝对值的 1%”与“同种子基线均值的 0.1%”中较宽的目标；到上限仍未达到就标注。普通技能交叉项至多用前 64 个种子。不同形状可用不同种子数；均值不是游戏期望，真实种子分布未知。表中 ± 仅表示原始统计量的标准误；组合后的值没有协方差数据，不显示标准误。表内 Δscore 是按相同种子、相同打法得到的差值；每位置另带单位普通技能测交叉项，随机名次与随机普通技能卡组再做 check 核对。Just 率低于 100% 且普通技能非零时，因缺少 Perfect 交叉权重，不提供完整适性增量。"
             + "演奏位置每局洗牌，但激走技能与位置无关；洗牌只改变单个种子里概率判定的抽取次序，不改变期望。",
-          "不可相加。连击加成存在饱和，多技能增量直接相加会高估；rush 支援与幸运槽技能（11001、11003、11005）会互相放大；13000/13002 改变 Just 数，又会影响按 Just 数触发的支援（7000）。单技能适性不能用于推算多技能编成，两个乐队变体也不能相加。",
+          "不可相加。连击加成存在饱和，多技能增量直接相加会高估；rush 支援与幸运槽技能（11001、11003、11005）会互相放大；13005 的判定转换也可能改变其它技能的触发与收益。不能只因 13000/13002 增加 Just 计数，就认定它们会改变按 Just 判定触发的支援得分；已有一组整局实跑未见这种交互，但也不能据此推广所有组合都无交互。单技能适性不能用于推算多技能编成，两个乐队变体也不能相加。",
           "核对现状。激走技能这一层按反编译代码逐项审计，与重写一致；整局与游戏原生代码的对照正在做，结果出来之前，这一层的数值尚在核对。按本模型得出的结论也都以此为前提。",
         ],
       },
@@ -530,7 +530,7 @@ export const GUIDE = {
             + "The aptitude verification records report whole-live confirmation of these zero-effect types on all charts. This is still an internal model check, not proof of agreement with the native game.",
           "Seeds. Four seeds first test determinism; identical gains in every field are reported with one seed and zero SE. Otherwise batches of 32, 64, 128, 256, 512 and 1024 stop when score-gain SE is within the larger of 1% of the absolute mean gain or 0.1% of the baseline mean on the same seeds. A flag warns when the cap still misses the target. Cross terms use at most the first 64 seeds. Shapes can use different counts. Seed means are not the game’s expectation; its seed distribution is unknown. ± denotes SE on raw statistics only; combined values have no SE because covariances are unavailable. Deltas compare the same seeds and play; unit ordinary skills at each position measure cross terms, checked with random ranks and a random ordinary-skill deck. Below full Just with nonzero ordinary skills, missing Perfect cross weights prevent a complete aptitude gain. "
             + "The performance positions are shuffled every live, but the Gekisou skills do not depend on the position; the shuffle changes only the order of the chance draws within a seed, not the expectation.",
-          "Gains cannot be added. Combo boosts saturate, so adding single-skill gains can overestimate a combination. Rush support and luck-gauge skills (11001, 11003, 11005) reinforce each other; 13000/13002 change Just counts and therefore support triggered by those counts (7000). Single-skill aptitude cannot predict a multi-skill formation; the two band variants cannot be added either.",
+          "Gains cannot be added. Combo boosts saturate, so adding single-skill gains can overestimate a combination. Rush support and luck-gauge skills (11001, 11003, 11005) reinforce each other; judgement conversion by 13005 may also change other skills’ triggers and gains. Raising the Just counter with 13000/13002 does not by itself establish an effect on support triggered by Just judgements. One set of whole-live runs found no such interaction, but this does not establish independence for every combination. Single-skill aptitude cannot predict a multi-skill formation; the two band variants cannot be added either.",
           "State of the checks. This layer has been audited item by item against the decompiled code and agrees with the rewrite; the whole-live comparison with the game's native code is in progress, and until it is done the figures of this layer are still being checked. The conclusions “by this model” rest on that too.",
         ],
       },

From ab89d23eacb099021cd3a41d65bbd6ee6758c31c Mon Sep 17 00:00:00 2001
From: nichinichisou <nichinichisou0609@outlook.com>
Date: Wed, 30 Sep 2026 04:50:15 +0800
Subject: [PATCH 6/8] feat(examples): label chart data and Gekisou aptitude as
 Beta

Add visible Beta badges next to the page and aptitude headings, linked to Chinese/English descriptions through aria-describedby. State that figures may change, luck results have sampling error and native whole-live checks are incomplete. Reuse existing theme tokens without adding feedback links.

Co-Authored-By: Claude Code <noreply@anthropic.com>
---
 examples/songs/index.html      |  5 +++++
 examples/songs/songs.js        | 12 +++++++++---
 examples/songs/text.js         |  2 ++
 tests/unit/songs-page.test.mjs |  9 +++++++++
 4 files changed, 25 insertions(+), 3 deletions(-)

diff --git a/examples/songs/index.html b/examples/songs/index.html
index 925663b..19b8d03 100644
--- a/examples/songs/index.html
+++ b/examples/songs/index.html
@@ -114,6 +114,11 @@
 
   /* route heading: moenotes .mn-page-heading */
   .page-head { margin: 26px 0 20px; padding: 0 2px 18px; border-bottom: 1px solid var(--mn-glass-border); }
+  .beta-badge {
+    display: inline-block; flex: none; padding: 1px 8px; border-radius: var(--cut-sm);
+    border: 1px solid var(--mn-accent); background: var(--mn-accent-soft); color: var(--mn-accent-deep);
+    font: 500 11px/1.6 var(--mn-font); letter-spacing: .03em; vertical-align: middle; white-space: nowrap;
+  }
   .page-head-title { display: flex; align-items: center; gap: 13px; }
   .page-head h1 { margin: 0; min-width: 0; font-size: clamp(26px, 2.8vw, 36px); font-weight: 500; line-height: 1.25; letter-spacing: -.035em; }
   .page-head .star { width: 23px; height: 23px; color: var(--mn-accent-deep); flex: none; }
diff --git a/examples/songs/songs.js b/examples/songs/songs.js
index 3d361cc..3e50424 100644
--- a/examples/songs/songs.js
+++ b/examples/songs/songs.js
@@ -272,13 +272,17 @@ const main = async () => {
           langs.map((l) => h("option", { value: l, selected: l === S.lang }, l))))));
   };
 
+  // Visible text plus an explicit description: the beta state does not rely on color or a hover tooltip.
+  const betaBadge = (descriptionId) => h("span", { class: "beta-badge", lang: "en", "aria-describedby": descriptionId }, u().beta);
+
   // the route heading: the view's title and what it answers
   const renderHead = () => {
     const t = u();
     const [title, lead] = S.view === "guide" ? [g().title, g().lead]
       : [t.heads[S.view], t.lead[S.view](songs.songs.length, rows.length)];
-    put(head, h("div", { class: "page-head" }, h("div", { class: "page-head-title" }, icon("star", "ic star"), h("h1", {}, title),
-      h("span", { class: "track", "aria-hidden": "true" })), h("p", {}, lead)));
+    put(head, h("div", { class: "page-head" }, h("div", { class: "page-head-title" }, icon("star", "ic star"), h("h1", {}, title), betaBadge("page-beta-note"),
+      h("span", { class: "track", "aria-hidden": "true" })), h("p", {}, lead),
+    h("p", { id: "page-beta-note", class: "beta-note" }, t.betaNote)));
   };
 
   const renderFilters = () => {
@@ -748,7 +752,9 @@ const main = async () => {
   // Build names and raw measure tables once. Slider updates only replace the numerical cells.
   const aptitudeBox = (r, changed) => {
     const A = u().aptitude, D = u().detail;
-    const element = h("section", { class: "aptitude" }, heading("h3", "sec-head", A.title));
+    const element = h("section", { class: "aptitude" },
+      heading("h3", "sec-head", [A.title, " ", betaBadge("aptitude-beta-note")]),
+      h("p", { id: "aptitude-beta-note", class: "hint beta-note" }, u().betaNote));
     const header = songs.deck && songs.deck.gekisouAptitude;
     const data = r.stats && r.stats.gekisouAptitude;
     if (!header || !data || r.unplayable) {
diff --git a/examples/songs/text.js b/examples/songs/text.js
index 7fec6f0..f682ff7 100644
--- a/examples/songs/text.js
+++ b/examples/songs/text.js
@@ -3,6 +3,7 @@
 
 export const UI = {
   zh: {
+    beta: "Beta", betaNote: "测试中，数值可能调整。幸运结果有采样误差，原生整局核对尚未完成。",
     app: "谱面数据", views: { rank: "排行", charts: "图表", guide: "说明" },
     all: "全部", search: "搜索曲名、读音、作者…", songs: (n) => `${n} 首`, chartsN: (n) => `${n} 张谱面`,
     jackets: "封面", jacketsHint: "显示或隐藏封面", theme: "切换浅色 / 深色", swap: "交换横纵轴",
@@ -101,6 +102,7 @@ export const UI = {
     caveat: "数值以游戏反编译为来源，尽量准确但不保证正确；与其它资料有出入时请以它们为准",
   },
   en: {
+    beta: "Beta", betaNote: "In testing; figures may change. Luck results have sampling error, and whole-live checks against the native game are not yet complete.",
     app: "Chart data", views: { rank: "Rankings", charts: "Charts", guide: "Guide" },
     all: "All", search: "Search title, reading, credits…", songs: (n) => `${n} songs`, chartsN: (n) => `${n} charts`,
     jackets: "Jackets", jacketsHint: "Show or hide the jackets", theme: "Light / dark", swap: "Swap the axes",
diff --git a/tests/unit/songs-page.test.mjs b/tests/unit/songs-page.test.mjs
index ef3e078..c0e9b43 100644
--- a/tests/unit/songs-page.test.mjs
+++ b/tests/unit/songs-page.test.mjs
@@ -1,5 +1,6 @@
 import test from "node:test";
 import assert from "node:assert/strict";
+import { UI } from "../../examples/songs/text.js";
 
 import {
   DEFAULT_SCENARIO, MEASURES, MISSION_MEASURE, X_MAX, aptitudeFigures, aptitudeRate, aptitudeSe, aptitudeShapes, chartVariants, zeroGain, chartFigures, dominance, dominates, eventDominates, formatLength,
@@ -577,3 +578,11 @@ test("master skill factor uses float32 before truncation, unlike user percentage
   assert.equal(masterSkillFactor(15000), 1.5);
   assert.equal(meanSkill([130 / 100], 1), 1.3); // UI percent conversion must not use masterSkillFactor
 });
+
+test("Beta notice explains testing, sampling error and unfinished native checks in both languages", () => {
+  assert.equal(UI.zh.beta, "Beta");
+  assert.equal(UI.en.beta, "Beta");
+  for (const term of ["测试中", "数值可能调整", "采样误差", "原生整局核对尚未完成"]) assert.ok(UI.zh.betaNote.includes(term));
+  for (const term of ["In testing", "figures may change", "sampling error", "native game", "not yet complete"]) assert.ok(UI.en.betaNote.includes(term));
+  for (const locale of [UI.zh, UI.en]) assert.ok(!/https?:|反馈|feedback/i.test(locale.betaNote));
+});

From d2996b9b1daac0226ed2ff750fd350f2c6d8b58f Mon Sep 17 00:00:00 2001
From: nichinichisou <nichinichisou0609@outlook.com>
Date: Wed, 30 Sep 2026 05:11:04 +0800
Subject: [PATCH 7/8] docs(examples): record the scoped native whole-live
 verification

Record chart 10000201 at power 300000 with no skills and Gekisou off: 364 Perfect inputs match by note ID, time and frame; final score 1063422 matches deck. Limit the evidence to this input and final score, with per-frame scoring, skills and Gekisou still unchecked and Unity/external dependency substitutes still present. Keep Beta.

Co-Authored-By: Claude Code <noreply@anthropic.com>
---
 examples/songs/text.js         | 12 ++++++------
 tests/unit/songs-page.test.mjs | 12 +++++++++++-
 2 files changed, 17 insertions(+), 7 deletions(-)

diff --git a/examples/songs/text.js b/examples/songs/text.js
index f682ff7..6eaeb23 100644
--- a/examples/songs/text.js
+++ b/examples/songs/text.js
@@ -208,7 +208,7 @@ export const GUIDE = {
   zh: {
     title: "定义、推导与成立条件",
     lead: "本页的数值以游戏客户端的反编译代码为来源：ournotes-deck 按反编译得到的得分逻辑对每张谱面做整局模拟（激走开启与关闭各一次），结果就是 music-data.json 的 deck 统计。"
-      + "这里的模拟是我们照反编译代码重写的程序，不是在模拟器里直接运行游戏本身的代码；游戏自己的函数只用来分块核对这份重写（见“尚未纳入的机制”一节的“核对范围”）。"
+      + "这里的模拟是我们照反编译代码重写的程序，不是在模拟器里直接运行游戏本身的代码；游戏自己的函数用于核对这份重写，目前包含分块核对与一张谱面的整局输入、终分核对（见“尚未纳入的机制”一节的“核对范围”）。"
       + "我们尽量保证正确，但对反编译代码的理解、模型的简化和数据版本都可能出错，所以不能保证。如果本页和其它站点、工具或实机结果有出入，多半是我们这边有误，请以它们为准。"
       + "下文给出每个量的定义、推导和成立条件；模型没有覆盖的机制单列一节。",
     sections: [
@@ -366,8 +366,8 @@ export const GUIDE = {
           ["概率发动（条件 4011）", "若发动概率 p 与其它量独立，它的期望贡献等于把该技能值换成 p · x，可以直接填进技能输入；方差会比表中给出的更大。"],
           ["实机一局耗时", "进入结算的时刻、加载时间都依赖设备和网络，由每局额外耗时 c 表示；支配关系对所有 c ≥ 0 成立。"],
           ["核对范围", "本页的数值不是直接运行游戏代码得到的：ournotes-deck 是我们照反编译代码重写的模拟，每张谱面的整局都由它计算。"
-            + "游戏自己的函数只用来分块核对这份重写：在 ARM64 模拟器里单独运行客户端的相关函数（计分、技能的发动与结束、激走连击等），和重写的实现逐例比较，已核对的部分没有发现差异。"
-            + "没有核对过的部分可能有错；整局从没有用游戏代码跑过，也还没有拿实机成绩逐局核对。"
+            + "游戏自己的函数用于分块核对这份重写：在 ARM64 模拟器里单独运行客户端的相关函数（计分、技能的发动与结束、激走连击等），和重写的实现逐例比较，已核对的部分没有发现差异。"
+            + "原生整局已跑通谱面 10000201：综合力 300000、无技能、激走关闭，364 次 Perfect 的音符 ID、时刻与帧均与理论输入一致，终分 1063422 与 deck 一致。这只核对了一张谱面的输入与终分；逐帧分数、技能与激走尚未完成核对，环境仍有 Unity 及外部依赖替身，不能据此认定模型与游戏全面等价。未核对的部分可能有错，也尚未与实机成绩逐局核对。"
             + "激走技能这一层（第 7 节）：按反编译代码逐项审计，与重写一致；整局与原生代码的对照正在做，结果出来之前尚在核对。"
             + "判定窗口类技能（4000–4003、13001）尚未接入整局模拟，另有少数激走条件只有合成测试；本页只用普通加分技能，不受这两项影响，激走技能可能用到这些条件，这也在上面的“尚在核对”之内。游戏更新或热更新补丁也可能改变这些规则。"],
         ],
@@ -388,7 +388,7 @@ export const GUIDE = {
   en: {
     title: "Definitions, derivations and conditions",
     lead: "The figures on this page are sourced from the game client's decompiled code: ournotes-deck simulates every chart's whole live (once with Gekisou on, once off) after the score logic read from it, and the results are music-data.json's deck statistics. "
-      + "The simulation is our own program, rewritten after the decompiled code; it does not run the game's code in an emulator. The game's own functions are used only to check the rewrite piece by piece (see Scope of the checks under the mechanisms left out). "
+      + "The simulation is our own program, rewritten after the decompiled code; it does not run the game's code in an emulator. The game's own functions check the rewrite piece by piece, with an additional whole-live input and final-score check for one chart (see Scope of the checks under the mechanisms left out). "
       + "We aim for them to be correct but cannot guarantee it: our reading of the decompiled code, the model's simplifications and the data version can all be wrong. Where this page disagrees with other sites, tools or real plays, the mistake is most likely ours; trust them. "
       + "Below: each quantity's definition, derivation and conditions; the mechanisms the model leaves out have their own section.",
     sections: [
@@ -546,8 +546,8 @@ export const GUIDE = {
           ["Probability skills (condition 4011)", "With an activation chance p independent of the rest, the expected contribution is that of the value p · x, which can be entered as the skill value; the spread is larger than shown."],
           ["Real play time", "When the results start and how long loading takes depend on the device and the network; the overhead c stands for them, and dominance holds for every c ≥ 0."],
           ["Scope of the checks", "The figures on this page do not come from running the game's code: ournotes-deck is our simulation, rewritten after the decompiled code, and it computes every chart's whole live. "
-            + "The game's own functions only check the rewrite piece by piece: the client's relevant functions (scoring, skill execute and finish, the Gekisou combo and others) run alone in an ARM64 emulator and are compared case by case with the rewrite; the parts checked so far show no difference. "
-            + "Parts not checked may be wrong; no whole live has been run with the game's code, and none has been checked against real play results yet. "
+            + "The game's own functions check the rewrite piece by piece: the client's relevant functions (scoring, skill execute and finish, the Gekisou combo and others) run alone in an ARM64 emulator and are compared case by case with the rewrite; the parts checked so far show no difference. "
+            + "A native whole-live run now covers chart 10000201 at power 300000, without skills and with Gekisou off: the note IDs, times and frames of 364 Perfects match the theoretical input, and the final score 1063422 matches deck. This checks only one chart’s input and final score. Per-frame scores, skills and Gekisou remain unchecked; the environment still substitutes for Unity and external dependencies. This does not establish full equivalence with the game. Unchecked parts may be wrong, and comparisons against real device results are still pending. "
             + "The Gekisou skill layer (section 7) has been audited item by item against the decompiled code and agrees with the rewrite; the whole-live comparison with the native code is in progress, and until it is done the layer is still being checked. "
             + "Judgement window skills (4000–4003, 13001) are not in the whole-live simulation yet, and a few Gekisou conditions only have synthetic tests; the page uses the plain score-up skill only and is affected by neither, the Gekisou skills may use those conditions, and that is part of the check still under way. A game update or hotfix patch may also change these rules."],
         ],
diff --git a/tests/unit/songs-page.test.mjs b/tests/unit/songs-page.test.mjs
index c0e9b43..91922a4 100644
--- a/tests/unit/songs-page.test.mjs
+++ b/tests/unit/songs-page.test.mjs
@@ -1,6 +1,6 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { UI } from "../../examples/songs/text.js";
+import { GUIDE, UI } from "../../examples/songs/text.js";
 
 import {
   DEFAULT_SCENARIO, MEASURES, MISSION_MEASURE, X_MAX, aptitudeFigures, aptitudeRate, aptitudeSe, aptitudeShapes, chartVariants, zeroGain, chartFigures, dominance, dominates, eventDominates, formatLength,
@@ -586,3 +586,13 @@ test("Beta notice explains testing, sampling error and unfinished native checks
   for (const term of ["In testing", "figures may change", "sampling error", "native game", "not yet complete"]) assert.ok(UI.en.betaNote.includes(term));
   for (const locale of [UI.zh, UI.en]) assert.ok(!/https?:|反馈|feedback/i.test(locale.betaNote));
 });
+
+test("native evidence is limited to one chart input and final score, not full equivalence", () => {
+  const zh = GUIDE.zh.sections.find(s => s.title === "尚未纳入的机制").defs.find(([key]) => key === "核对范围")[1];
+  const en = GUIDE.en.sections.find(s => s.title === "Mechanisms not modelled yet").defs.find(([key]) => key === "Scope of the checks")[1];
+  for (const text of [zh, en]) for (const value of ["10000201", "300000", "364", "1063422", "Unity"]) assert.ok(text.includes(value));
+  assert.ok(zh.includes("逐帧分数、技能与激走尚未完成核对"));
+  assert.ok(en.includes("Per-frame scores, skills and Gekisou remain unchecked"));
+  assert.ok(!zh.includes("整局从没有用游戏代码跑过"));
+  assert.ok(!en.includes("no whole live has been run"));
+});

From 0e2c2352b01fa0fad26cd8365d09be00737d63eb Mon Sep 17 00:00:00 2001
From: nichinichisou <nichinichisou0609@outlook.com>
Date: Wed, 30 Sep 2026 13:53:27 +0800
Subject: [PATCH 8/8] feat(songs): refine chart data and add optional replay
 controls

Keep aligned responsive tables, a Pareto frontier and one detailed tooltip.
Restore lookup-based accuracy estimates and update rankings after dragging.
Place common chart facts first and Gekisou aptitude last. Share the optional
Rust replay editor with per-segment probabilities and reproducible inputs.

Co-Authored-By: Claude Code <noreply@anthropic.com>
---
 examples/songs/catalog.js         |   6 +
 examples/songs/index.html         | 132 ++++-
 examples/songs/pareto.js          |  12 +
 examples/songs/replay-panel.js    | 170 ++++++
 examples/songs/replay-preset.js   | 151 +++++
 examples/songs/replay-worker.js   |  40 ++
 examples/songs/songs.js           | 154 ++---
 examples/songs/text.js            | 919 ++++++++++++++++++++----------
 tests/unit/replay-preset.test.mjs | 222 ++++++++
 tests/unit/songs-page.test.mjs    |  26 +-
 tests/unit/songs-pareto.test.mjs  |  22 +
 11 files changed, 1483 insertions(+), 371 deletions(-)
 create mode 100644 examples/songs/pareto.js
 create mode 100644 examples/songs/replay-panel.js
 create mode 100644 examples/songs/replay-preset.js
 create mode 100644 examples/songs/replay-worker.js
 create mode 100644 tests/unit/replay-preset.test.mjs
 create mode 100644 tests/unit/songs-pareto.test.mjs

diff --git a/examples/songs/catalog.js b/examples/songs/catalog.js
index bbfae52..f8c010b 100644
--- a/examples/songs/catalog.js
+++ b/examples/songs/catalog.js
@@ -190,6 +190,12 @@ export const histogram = (rows, get, step = 1) => {
 
 // moenotes (bdon.moe) has the song pages (credits, vocals, audio, jacket, chart previews); this page links to them.
 export const MOENOTES = "https://bdon.moe/";
+/** Same published path as MoeNotes' getMusicJacketUrl; independent of a local --jackets export. */
+export function moenotesJacketUrl(assetName, assetBase = "https://assets.bdon.moe") {
+  if (!assetName) return null;
+  const key = `Image/Jacket/${assetName}`;
+  return `${assetBase.replace(/\/+$/, "")}/${["zh-Hans", ...key.split("/"), `${key.split("/").at(-1)}.webp`].map(encodeURIComponent).join("/")}`;
+}
 const MOENOTES_PREFIX = { "zh-Hans": "", "zh-Hant": "zh-tw", ja: "ja", en: "en", ko: "ko" };
 
 // The moenotes page of a song in the language nearest to `lang` (default: Simplified Chinese, its root).
diff --git a/examples/songs/index.html b/examples/songs/index.html
index 19b8d03..89d9533 100644
--- a/examples/songs/index.html
+++ b/examples/songs/index.html
@@ -297,14 +297,19 @@
   .hbar-fill { display: block; height: 100%; border-radius: 5px; }
   .hbar b { text-align: right; font-weight: 500; font-variant-numeric: tabular-nums; }
   .tip {
-    position: fixed; left: 0; top: 0; z-index: 60; min-width: 190px; max-width: 280px; padding: 10px 12px; pointer-events: none;
+    position: fixed; left: 0; top: 0; z-index: 60; min-width: min(190px, calc(100vw - 16px)); max-width: min(280px, calc(100vw - 16px)); padding: 10px 12px; pointer-events: none;
     border: 1px solid var(--mn-border); border-radius: 14px; background: var(--mn-paper); box-shadow: 0 14px 44px #06112a30; font-size: 12px;
   }
   .tip-head { display: flex; align-items: center; gap: 8px; margin-bottom: 6px; }
-  .tip-title { font-weight: 500; font-size: 13px; }
+  .tip-head > div { min-width: 0; }
+  .tip-title { font-weight: 500; font-size: 13px; overflow-wrap: anywhere; }
   .tip-sub { display: flex; align-items: center; gap: 6px; color: var(--mn-text-muted); }
   .tip-row { display: flex; justify-content: space-between; gap: 12px; color: var(--mn-text-muted); }
   .tip-row b { color: var(--mn-text); font-weight: 500; font-variant-numeric: tabular-nums; }
+  .replay { margin: 18px 0; min-width: 0; }
+  .replay > summary { cursor: pointer; font-weight: 500; }
+  .guide-method h2 { margin: 18px 0 6px; font-size: 16px; font-weight: 500; }
+  .guide-method p { margin: 0 0 22px; font-size: 13px; line-height: 1.85; color: var(--mn-text-muted); }
 
   /* guide */
   .guide { display: grid; grid-template-columns: 220px minmax(0, 1fr); gap: 32px; align-items: start; }
@@ -437,8 +442,6 @@
   }
   @media (max-width: 860px) {
     .grid2 { grid-template-columns: 1fr; }
-    .rank-table .c-bpm, .rank-table .c-notes, .rank-table .c-rate, .rank-table .c-relative, .rank-table .c-dom, .rank-table .c-perHour { display: none; }
-    .rank-table .c-bpm.hi, .rank-table .c-notes.hi { display: table-cell; }
     .defs { grid-template-columns: 1fr; }
     .defs dt { border-top: 1px solid var(--mn-glass-border); }
     .defs dd { border-top: 0; }
@@ -461,8 +464,6 @@
     .page-head p { margin-left: 0; font-size: 12px; }
     .filters { padding: 12px 14px; }
     .group-label { display: none; }
-    .rank-table .c-density, .rank-table .c-time { display: none; }
-    .rank-table .c-density.hi, .rank-table .c-time.hi { display: table-cell; }
     .rank-table td, .rank-table th { padding: 7px 5px; }
     .rank-table th { white-space: normal; }
     .bar { min-width: 52px; padding: 1px 4px; }
@@ -482,6 +483,125 @@
     .hbar { grid-template-columns: 96px 1fr 28px; }
     input[type=range] { width: 110px; }
   }
+/* Rankings stay a column-aligned list at every width. Breakpoints follow the content, including sidebars. */
+.main { container: chart-view / inline-size; min-width: 0; }
+.table-box { container: chart-ranking / inline-size; min-width: 0; }
+.panel { container: chart-settings / inline-size; min-width: 0; max-width: 100%; }
+.field, .skills { min-width: 0; max-width: 100%; }
+.table-toolbar { display: flex; flex-wrap: wrap; justify-content: space-between; align-items: center; gap: 8px; margin-bottom: 8px; }
+.table-toolbar .count { margin: 0; }
+.columns-toggle { display: none; }
+.columns-toggle small { color: var(--mn-text-muted); font-size: 11px; }
+.table-scroll { max-width: 100%; overflow: auto; scrollbar-width: thin; scrollbar-color: var(--mn-accent) var(--mn-cream-deep); }
+.table-box > .table-scroll { max-height: 70vh; }
+.rank-table th { position: sticky; top: 0; z-index: 2; background: var(--mn-paper); }
+.rank-table .spread { display: block; }
+.rank-table .c-song { width: 23%; }
+.rank-table .song-title .t { max-width: clamp(110px, 17cqw, 230px); }
+@container chart-view (max-width: 1200px) {
+  .tabs { flex-wrap: wrap; overflow: visible; }
+  .tabs button { padding: 7px 12px; }
+}
+@container chart-settings (max-width: 680px) {
+  .panel > .field { flex: 1 1 100%; }
+  .field > .note { flex-basis: 100%; white-space: normal; }
+  .skills { gap: 6px; }
+  .num-in.skill { width: 54px; }
+}
+@container chart-ranking (max-width: 1200px) {
+  .columns-toggle { display: inline-flex; }
+  .rank-table { font-size: 12px; }
+  .rank-table :is(th, td) { padding: 7px 6px; }
+  .rank-table th { white-space: normal; font-size: 11px; line-height: 1.4; }
+  .rank-table .song { gap: 7px; }
+  .rank-table .jk { width: 32px; height: 32px; }
+  .rank-table .song-title .t { max-width: 150px; }
+  .rank-table .song-band { font-size: 11px; }
+  .rank-table .bar { min-width: 66px; padding: 1px 4px; }
+  .rank-table[data-columns="auto"] :is(.c-relative, .c-dom) { display: none; }
+  .rank-table[data-columns="all"] { min-width: 1000px; }
+  .rank-table[data-columns="all"] :is(.c-rank, .c-song) { position: sticky; background: var(--mn-paper); z-index: 1; }
+  .rank-table[data-columns="all"] .c-rank { left: 0; min-width: 40px; width: 40px; }
+  .rank-table[data-columns="all"] .c-song { left: 40px; width: 180px; }
+  .rank-table[data-columns="all"] th:is(.c-rank, .c-song) { z-index: 3; }
+}
+@container chart-ranking (max-width: 860px) {
+  .rank-table[data-columns="auto"][data-rank-by="efficiency"] :is(.c-bpm, .c-notes, .c-density) { display: none; }
+  .rank-table[data-columns="auto"][data-rank-by="event"] .c-perHour { display: none; }
+  .rank-table .song-title .t { max-width: 130px; white-space: normal; overflow-wrap: anywhere; }
+}
+@container chart-ranking (max-width: 500px) {
+  .rank-table :is(th, td) { padding: 7px 4px; }
+  .rank-table .song-title .t { max-width: 110px; }
+  .rank-table .song-band { display: none; }
+  .rank-table .lv small { display: none; }
+  .rank-table .no { min-width: 22px; padding: 0 2px; }
+  .rank-table[data-columns="auto"] :is(.c-time, .c-bpm, .c-notes, .c-density, .c-rate, .c-chance) { display: none; }
+  .rank-table[data-columns="auto"] :is(.c-time, .c-bpm, .c-notes, .c-density).hi { display: table-cell; }
+}
+.verification-scroll { max-width: 100%; overflow-x: auto; margin: 16px 0; border: 1px solid var(--mn-glass-border); border-radius: 10px; }
+.verification { width: 100%; min-width: 640px; border-collapse: collapse; table-layout: fixed; font-size: 12px; }
+.verification :is(th, td) { padding: 10px 12px; text-align: left; vertical-align: top; border-bottom: 1px solid var(--mn-glass-border); overflow-wrap: anywhere; line-height: 1.65; }
+.verification th { background: var(--mn-accent-soft); font-weight: 500; }
+.verification tr:last-child td { border-bottom: 0; }
+.g-section :is(p, dd) { overflow-wrap: anywhere; }
+.card, .grid2 > *, .plot-box, .scatter-canvas { min-width: 0; max-width: 100%; }
+.pareto-controls { display: flex; align-items: center; flex-wrap: wrap; gap: 10px 20px; padding: 12px 0 16px; }
+.pareto-controls .field { gap: 8px; }
+.frontier-key { display: inline-flex; align-items: center; gap: 7px; color: var(--mn-accent-deep); font-size: 12px; font-weight: 600; }
+.frontier-key::before { content: ""; width: 22px; height: 3px; border-radius: 2px; background: linear-gradient(90deg, var(--mn-accent-deep), var(--mn-pink)); }
+.plot-summary { display: flex; justify-content: space-between; gap: 12px; flex-wrap: wrap; padding: 8px 8px 0; color: var(--mn-text-muted); font-size: 12px; }
+.scatter .plot-surface { fill: var(--mn-accent-soft); fill-opacity: .35; }
+.scatter .grid line { stroke-dasharray: 3 5; }
+.scatter .frontier-line { fill: none; stroke-width: 2.5; stroke-linecap: round; stroke-linejoin: round; pointer-events: none; }
+.scatter .frontier-glow { fill: none; stroke: var(--mn-accent); stroke-width: 9; opacity: .15; stroke-linecap: round; stroke-linejoin: round; pointer-events: none; }
+.scatter .dots .regular-point { fill-opacity: .55; stroke-width: 1.5; }
+.scatter .dots .pareto-point { fill-opacity: 1; stroke-width: 3; filter: drop-shadow(0 1px 3px var(--mn-accent)); }
+.pareto-note { margin: 2px 8px 12px; color: var(--mn-text-muted); font-size: 12px; line-height: 1.8; }
+.guide-reminder { margin: 12px 0 20px; padding: 16px 20px; border: 1px solid var(--mn-glass-border); border-left: 3px solid var(--mn-accent-deep); border-radius: var(--cut-md); background: var(--mn-accent-soft); font-size: 13px; line-height: 1.85; }
+.guide-reminder strong { color: var(--mn-accent-deep); font-weight: 600; }
+.page-head .guide-reminder p { margin: 6px 0 0; max-width: none; color: var(--mn-text); }
+.model-link { color: var(--mn-accent-deep); text-decoration: underline; text-underline-offset: 3px; }
+.sr-only { position: absolute; width: 1px; height: 1px; padding: 0; margin: -1px; overflow: hidden; clip: rect(0,0,0,0); white-space: nowrap; border: 0; }
+.pareto-note summary { cursor: pointer; }
+
+/* The reading layout uses the actual available width, including the site's sidebar. */
+.guide { grid-template-columns: minmax(0, 1fr) 190px; gap: clamp(24px, 3cqw, 44px); }
+.toc { grid-column: 2; grid-row: 1; padding: 8px 0 8px 14px; border-left: 1px solid var(--mn-glass-border); border-radius: 0; background: none; box-shadow: none; }
+.toc a { padding: 7px 8px; font-size: 12px; }
+.toc-mobile { display: none; margin-bottom: 24px; padding: 12px 16px; border: 1px solid var(--mn-glass-border); border-radius: 12px; background: var(--mn-paper); }
+.toc-mobile summary, .guide-methods summary { cursor: pointer; color: var(--mn-accent-deep); font-weight: 500; }
+.toc-mobile nav { display: grid; grid-template-columns: repeat(auto-fit, minmax(180px, 1fr)); gap: 4px 12px; margin-top: 12px; }
+.toc-mobile a { display: flex; gap: 10px; padding: 6px 0; text-decoration: none; font-size: 13px; }
+.toc-mobile a span { color: var(--mn-text-muted); }
+.g-body { grid-column: 1; grid-row: 1; width: 100%; max-width: none; min-width: 0; font-size: 14px; }
+.g-section { margin: 0; padding: 30px 0; border-top: 1px solid var(--mn-glass-border); }
+.g-section:first-child { border-top: 0; padding-top: 8px; }
+.guide-section-head { display: flex; align-items: baseline; gap: 12px; margin: 0 0 16px; }
+.guide-section-head h2 { margin: 0; color: var(--mn-text); font-size: 20px; font-weight: 600; letter-spacing: -.02em; }
+.guide-section-head .g-no { font-size: 12px; flex: none; }
+.g-section p { margin: 14px 0; line-height: 1.95; }
+.defs { grid-template-columns: minmax(120px, 160px) minmax(0, 1fr); }
+.guide-methods { margin-top: 16px; padding: 14px 18px; border: 1px solid var(--mn-glass-border); border-radius: 12px; background: var(--mn-paper); }
+.verification { min-width: 720px; font-size: 13px; }
+.verification caption { padding: 12px 16px; text-align: left; color: var(--mn-text-muted); background: var(--mn-paper); font-size: 12px; }
+.verification th:nth-child(1) { width: 23%; }
+.verification th:nth-child(2) { width: 28%; }
+.verification th:nth-child(3) { width: 17%; }
+.verification th:nth-child(4) { width: 32%; }
+@container chart-view (max-width: 1050px) {
+  .guide { display: block; }
+  .toc { display: none; }
+  .toc-mobile { display: block; }
+}
+@container chart-view (max-width: 640px) {
+  .g-body { font-size: 13px; }
+  .guide-section-head h2 { font-size: 18px; }
+  .defs { grid-template-columns: 1fr; }
+  .defs dt { border-top: 1px solid var(--mn-glass-border); }
+  .defs dd { border-top: 0; }
+}
+
 </style>
 <script type="module" src="songs.js"></script>
 </head>
diff --git a/examples/songs/pareto.js b/examples/songs/pareto.js
new file mode 100644
index 0000000..104bea5
--- /dev/null
+++ b/examples/songs/pareto.js
@@ -0,0 +1,12 @@
+// A two-objective frontier for the currently plotted candidates. Equal coordinates remain equal candidates;
+// a point dominates another only when it is no worse on both chosen axes and strictly better on at least one.
+// This is separate from ranking.js's dominance for every skill mean and overhead.
+export const axisGoal = (axis) => axis === "displayLevel" || axis === "bgmMs" ? "min" : "max";
+
+export function paretoPoints(points, xGoal = "min", yGoal = "max") {
+  const finite = points.filter(([x, y]) => Number.isFinite(x) && Number.isFinite(y));
+  const dx = xGoal === "min" ? 1 : -1, dy = yGoal === "min" ? 1 : -1;
+  return finite.filter(([x, y]) => !finite.some(([a, b]) =>
+    dx * a <= dx * x && dy * b <= dy * y && (dx * a < dx * x || dy * b < dy * y)))
+    .sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+}
diff --git a/examples/songs/replay-panel.js b/examples/songs/replay-panel.js
new file mode 100644
index 0000000..084996c
--- /dev/null
+++ b/examples/songs/replay-panel.js
@@ -0,0 +1,170 @@
+// Both the standalone page and MoeNotes mount this editor. Rust owns templates, validation and calculation.
+import { NOTE_KINDS } from "./catalog.js";
+import { applySegmentPreset } from "./replay-preset.js";
+const NOTE_KIND=new Map(NOTE_KINDS.flatMap(([kind,types])=>types.map(type=>[type,kind])));
+const GRADE_NAMES=["","Miss","Bad","Good","Great","Perfect","Just","Pass"];
+const el=(tag,props={},...children)=>{
+  const node=document.createElement(tag);
+  for(const [key,value]of Object.entries(props)){
+    if(key.startsWith("on"))node.addEventListener(key.slice(2),value);
+    else if(key in node)node[key]=value;
+    else node.setAttribute(key,String(value));
+  }
+  node.append(...children.flat());return node;
+};
+export function mountReplayPanel(host,options){
+  const {text:t,site,reference,scoreId,power:initialPower=300000,mode:initialMode={kind:"normal"}}=options;
+  const root=host.shadowRoot??host.attachShadow({mode:"open"});root.replaceChildren();
+  const styles=el("style",{},`
+    :host{display:block;color:var(--mn-text);font:inherit;min-width:0}*{box-sizing:border-box}
+    .controls{display:flex;flex-wrap:wrap;gap:10px;align-items:end;margin:12px 0}label{display:grid;gap:5px;font-size:12px}
+    button,input,select{font:inherit;color:inherit;background:var(--mn-paper);border:1px solid var(--mn-border);border-radius:8px;padding:6px 9px}
+    button{cursor:pointer}button:disabled{opacity:.5;cursor:default}input[type=number]{width:110px}input[type=file]{max-width:220px}
+    .note{color:var(--mn-text-muted);font-size:12px;line-height:1.6}.scroll{max-height:350px;overflow:auto;border:1px solid var(--mn-border);border-radius:10px}
+    table{width:100%;border-collapse:collapse;font-size:12px;font-variant-numeric:tabular-nums}th,td{padding:7px 10px;text-align:left;border-bottom:1px solid var(--mn-border)}
+    th{position:sticky;top:0;background:var(--mn-paper)}.stats{display:flex;gap:15px;flex-wrap:wrap;margin:12px 0}.stats strong{display:block;font-size:20px}
+    details{margin:10px 0}summary{cursor:pointer;font-size:13px}.status{overflow-wrap:anywhere}output{display:block}
+    .accuracy{display:flex;flex-wrap:wrap;gap:12px 22px;padding:12px;border:1px solid var(--mn-border);border-radius:10px;align-items:center}
+    .accuracy label{display:flex;align-items:center;gap:8px}.accuracy input{width:130px;padding:0;accent-color:var(--mn-accent,#8bbde5)}.accuracy output{min-width:4ch;font-variant-numeric:tabular-nums}.plan{margin:7px 0}
+    .accuracy input[type=number]{width:65px;padding:6px}.segments{overflow:auto;max-width:100%;margin:10px 0}.segments:empty{display:none}.segments table{min-width:660px}.segments input[type=number]{width:58px;padding:5px}.segments .time-input{width:65px}.segments th{position:static;white-space:nowrap}.segments td{padding:6px}.segment-actions{display:flex;flex-wrap:wrap;gap:7px;align-items:center;margin:10px 0}.segment-actions button{font-size:12px}.segment-actions label{display:flex;align-items:center;gap:6px}.segment-actions input{width:90px}.segments small{white-space:nowrap}
+  `);
+  const status=el("p",{className:"note status",role:"status"},t.loading),results=el("output",{}),notes=el("div",{className:"scroll"});
+  const power=el("input",{type:"number",min:0,step:1000,value:String(initialPower||300000)});
+  const seed=el("input",{type:"number",step:1,value:"0"});
+  const fps=el("select",{},...[30,60,120].map(n=>el("option",{value:String(n),selected:n===60},`${n} fps`)));
+  const mode=el("select",{},el("option",{value:"normal",selected:initialMode.kind==="normal"},t.free),el("option",{value:"fixedSoloGekisou",selected:initialMode.kind!=="normal"},t.fixedRanks));
+  const label=(name,input)=>el("label",{},name,input);
+  const reset=el("button",{type:"button",disabled:true},t.reset),run=el("button",{type:"button",disabled:true},t.run);
+  const importFile=el("input",{type:"file",accept:"application/json,.json",disabled:true}),download=el("button",{type:"button",disabled:true},t.export);
+  const great=el("input",{type:"range",min:0,max:100,step:1,value:"0",disabled:true,"aria-label":t.greatShare}),just=el("input",{type:"range",min:0,max:100,step:1,value:"100",disabled:true,"aria-label":t.justShare});
+  const greatValue=el("output",{},"0%"),justValue=el("output",{},"100%"),plan=el("p",{className:"note plan"});
+  const good=el("input",{type:"number",min:0,max:100,step:1,value:"0",disabled:true,"aria-label":"Good %"}),bad=el("input",{type:"number",min:0,max:100,step:1,value:"0",disabled:true,"aria-label":"Bad %"}),miss=el("input",{type:"number",min:0,max:100,step:1,value:"0",disabled:true,"aria-label":"Miss %"});
+  const planSeed=el("input",{type:"number",min:0,max:4294967295,step:1,value:"0",disabled:true}),generate=el("button",{type:"button",disabled:true},t.generate);
+  const segmentTable=el("div",{className:"segments"}),segmentActions=el("div",{className:"segment-actions"});
+  const notesDetail=el("details",{ontoggle:()=>{if(notesDetail.open&&request)renderNotes();}},el("summary",{},t.editNotes),notes);
+  root.append(styles,el("p",{className:"note"},t.hint),el("div",{className:"controls"},label(t.power,power),label(t.seed,seed),label(t.clock,fps),label(t.mode,mode),reset,run),el("div",{className:"accuracy"},el("span",{className:"note"},t.wholeSong),el("label",{},t.greatShare,great,greatValue),el("label",{},t.justShare,just,justValue),label("Good %",good),label("Bad %",bad),label("Miss %",miss)),segmentActions,segmentTable,el("p",{className:"note"},t.presetHint),plan,status,results,notesDetail,el("details",{},el("summary",{},t.advanced),el("p",{className:"note"},t.advancedHint),el("div",{className:"controls"},label(t.import,importFile),download)));
+  let request,description,justTypes=[],presetActive=true,disposed=false,nextId=0,ready=false,templateFps=60,fatal=false;
+  let segments=[],planValid=true,busy=false;
+  const savedModes=new Map([["normal",{kind:"normal"}],["fixedSoloGekisou",{kind:"fixedSoloGekisou",ranks:initialMode.ranks??[1,1,1]}]]);
+  const pending=new Map();
+  const workerUrl=URL.createObjectURL(new Blob([`import ${JSON.stringify(new URL("./replay-worker.js",import.meta.url).href)};`],{type:"text/javascript"}));
+  const worker=new Worker(workerUrl,{type:"module"});URL.revokeObjectURL(workerUrl);
+  worker.onmessage=({data})=>{const task=pending.get(data.id);if(!task)return;pending.delete(data.id);data.error?task.reject(new Error(data.error)):task.resolve(data.result);};
+  const fail=error=>{if(!disposed){status.textContent=`${t.error}: ${String(error?.message??error)}`;if(!busy){run.disabled=!request||!planValid;reset.disabled=false;}}};
+  worker.onerror=error=>{
+    fatal=true;ready=false;for(const task of pending.values())task.reject(new Error(error.message));pending.clear();
+    fail(error);request=undefined;run.disabled=reset.disabled=importFile.disabled=download.disabled=great.disabled=just.disabled=true;
+  };
+  const call=(op,...args)=>new Promise((resolve,reject)=>{if(fatal){reject(new Error(t.error));return;}const id=++nextId;pending.set(id,{resolve,reject});worker.postMessage({id,op,args});});
+  const controlsToRequest=()=>{
+    request.power=Number(power.value);request.seed=Number(seed.value);
+    return request;
+  };
+  const invalidate=()=>{results.replaceChildren();if(request)status.textContent=t.ready;};
+  power.oninput=seed.oninput=invalidate;
+  function beginWork(){if(busy||fatal||disposed)return false;busy=true;for(const input of root.querySelectorAll("input,select,button"))input.disabled=true;return true;}
+  function endWork(){
+    busy=false;if(disposed||fatal)return;
+    power.disabled=seed.disabled=mode.disabled=false;fps.disabled=fps.value==="imported";
+    reset.disabled=false;run.disabled=!request||!planValid;importFile.disabled=!ready;download.disabled=!request;
+    renderNotes();
+  }
+  function updatePlan(){
+    if(!request)return;
+    const counts={};for(const frame of request.frames)for(const note of frame.judgements)counts[note.judgement]=(counts[note.judgement]??0)+1;
+    plan.textContent=[5,6,4,3,2,1].map(grade=>`${GRADE_NAMES[grade]} ${counts[grade]??0}`).join(" · ");
+    if(busy)return;
+    const raw=request.rawRuntime!=null||request.frames.some(frame=>frame.judgements.some(note=>note.rawResult!=null));
+    for(const input of [great,just,good,bad,miss,planSeed,generate,...segmentActions.querySelectorAll("button"),...segmentTable.querySelectorAll("input,button")])input.disabled=!ready||raw;
+    just.disabled=!ready||raw||request.mode.kind==="normal"||!description.missions.includes(3);
+    for(const input of segmentTable.querySelectorAll('[data-grade="just"]'))input.disabled=just.disabled;
+    if(raw)plan.append(` · ${t.rawPreset}`);
+  }
+  function applyPreset(){
+    if(!request||fatal||busy)return;
+    try{
+      const base={startMs:null,endMs:null,great:Number(great.value)/100,good:Number(good.value)/100,bad:Number(bad.value)/100,miss:Number(miss.value)/100,just:Number(just.value)/100};
+      if([base,...segments].some(s=>s.great+s.good+s.bad+s.miss>1+1e-12))throw new Error(t.probabilityTotal);
+      applySegmentPreset(request,description,justTypes,[base,...segments],Number(planSeed.value));
+      planValid=true;presetActive=true;greatValue.textContent=`${great.value}%`;justValue.textContent=`${just.value}%`;renderNotes();invalidate();run.disabled=false;
+    }catch(error){planValid=false;fail(error);run.disabled=true;results.replaceChildren();}
+  }
+  great.oninput=()=>{greatValue.textContent=`${great.value}%`;};just.oninput=()=>{justValue.textContent=`${just.value}%`;};
+  great.onchange=just.onchange=applyPreset;
+  good.oninput=bad.oninput=miss.oninput=planSeed.oninput=applyPreset;generate.onclick=applyPreset;
+  function renderSegments(){
+    const probability=(segment,key)=>{
+      const input=el("input",{type:"number",min:0,max:100,step:1,value:String(Math.round(segment[key]*100)),"data-grade":key,"aria-label":`${segment.name} ${key} %`,oninput:()=>{segment[key]=Number(input.value)/100;applyPreset();}});return input;
+    };
+    const time=(segment,key)=>{const input=el("input",{type:"number",className:"time-input",min:0,step:.1,value:String(segment[key]/1000),"aria-label":`${segment.name} ${key==="startMs"?t.start:t.end}`,onchange:()=>{segment[key]=Math.round(Number(input.value)*1000);applyPreset();}});return input;};
+    segmentTable.replaceChildren(...(segments.length?[el("table",{},el("thead",{},el("tr",{},...[t.segment,t.start,t.end,"Great %","Good %","Bad %","Miss %","Just %",""].map(name=>el("th",{},name)))),el("tbody",{},...segments.map(segment=>el("tr",{},el("td",{},el("small",{},segment.name)),el("td",{},time(segment,"startMs")),el("td",{},time(segment,"endMs")),...["great","good","bad","miss","just"].map(key=>el("td",{},probability(segment,key))),el("td",{},el("button",{type:"button","aria-label":`${t.remove} ${segment.name}`,onclick:()=>{segments=segments.filter(s=>s!==segment);renderSegments();applyPreset();}},"×"))))))]:[]));
+    updatePlan();
+  }
+  function addSegment(name,startMs,endMs){
+    segments.push({name,startMs,endMs,great:Number(great.value)/100,good:Number(good.value)/100,bad:Number(bad.value)/100,miss:Number(miss.value)/100,just:Number(just.value)/100});renderSegments();applyPreset();
+  }
+  function setupSegments(){
+    segmentActions.replaceChildren(label(t.planSeed,planSeed),generate,...description.fevers.map(([start,end],i)=>el("button",{type:"button",onclick:()=>addSegment(`${t.range} ${i+1}`,start,end)},`+ ${t.range} ${i+1}`)),el("button",{type:"button",onclick:()=>addSegment(`${t.segment} ${segments.length+1}`,0,Math.min(30000,request.musicLengthMs))},`+ ${t.customSegment}`));
+    renderSegments();
+  }
+  mode.onchange=()=>{if(request&&savedModes.has(mode.value)){request.mode=structuredClone(savedModes.get(mode.value));presetActive?applyPreset():updatePlan();invalidate();}};
+  function renderNotes(){
+    updatePlan();if(!notesDetail.open){notes.replaceChildren();return;}
+    const byId=new Map(description.notes.map(n=>[n.noteId,n]));
+    const body=el("tbody",{});
+    for(const frame of request.frames)for(const judgement of frame.judgements){
+      const note=byId.get(judgement.noteId);if(!note)continue;
+      if(note.defaultJudgement===7)continue;
+      const select=el("select",{disabled:busy||judgement.rawResult!=null,"aria-label":`${t.judgement} ${judgement.noteId}`,onchange:()=>{if(busy)return;judgement.judgement=Number(select.value);presetActive=false;planValid=true;run.disabled=false;updatePlan();invalidate();}});
+      for(const grade of note.defaultJudgement===7?[7]:[5,6,4,3,2,1])select.append(el("option",{value:String(grade),selected:judgement.judgement===grade},GRADE_NAMES[grade]));
+      body.append(el("tr",{},el("td",{},String(judgement.noteId)),el("td",{},`${note.noteMs} ms`),el("td",{},options.noteKindLabels?.[NOTE_KIND.get(note.opType)]??String(note.opType)),el("td",{},select)));
+    }
+    notes.replaceChildren(el("table",{},el("thead",{},el("tr",{},...[t.note,t.time,t.type,t.judgement].map(name=>el("th",{},name)))),body));
+    updatePlan();
+  }
+  async function restore(){
+    if(!beginWork())return;
+    reset.disabled=run.disabled=importFile.disabled=great.disabled=just.disabled=true;ready=false;status.textContent=t.loading;results.replaceChildren();
+    if(fps.value!=="imported")templateFps=Number(fps.value);fps.value=String(templateFps);fps.disabled=false;
+    if(!["normal","fixedSoloGekisou"].includes(mode.value))mode.value=initialMode.kind==="normal"?"normal":"fixedSoloGekisou";
+    try{request=await call("template",scoreId,Number(power.value),templateFps);if(disposed)return;request.mode=structuredClone(savedModes.get(mode.value));controlsToRequest();ready=true;setupSegments();busy=false;applyPreset();download.disabled=false;}
+    catch(error){fail(error);}finally{endWork();}
+  }
+  reset.onclick=restore;fps.onchange=restore;
+  run.onclick=async()=>{
+    if(!beginWork())return;
+    run.disabled=importFile.disabled=true;ready=false;updatePlan();status.textContent=t.calculating;
+    try{
+      const result=await call("run",JSON.stringify(controlsToRequest()));if(disposed)return;
+      if(!result.complete)throw new Error(t.incomplete);
+      const stat=(name,value)=>el("div",{},el("span",{className:"note"},name),el("strong",{},Number(value).toLocaleString()));
+      results.replaceChildren(el("div",{className:"stats"},stat(t.score,result.score),stat(t.frameScore,result.frameScore),stat(t.life,result.life),stat(t.combo,result.combo)),el("p",{className:"note"},["just","perfect","great","good","bad","miss"].map(k=>`${k.toUpperCase()} ${result.judgements[k]}`).join(" · ")));
+      if(result.ranges.length)results.append(el("table",{},el("thead",{},el("tr",{},...[t.range,t.combo,t.just,t.luck].map(x=>el("th",{},x)))),el("tbody",{},...result.ranges.map((range,i)=>el("tr",{},...[i+1,range.maxCombo,range.justCount,range.luckPoints].map(x=>el("td",{},String(x))))))));
+      status.textContent=t.complete;
+    }catch(error){fail(error);}finally{ready=true;endWork();}
+  };
+  importFile.onchange=async()=>{
+    if(!beginWork())return;
+    try{
+      const file=importFile.files?.[0];if(!file)return;
+      const imported=JSON.parse(await file.text());
+      if(imported.format!=="ournotes.replay/1"||imported.scoreId!==scoreId)throw new Error(t.wrongChart);
+      if(imported.complete===false)throw new Error(t.incomplete);
+      const known=new Set(description.notes.map(note=>note.noteId));
+      if(!["normal","soloGekisou","fixedSoloGekisou","externalGekisou"].includes(imported.mode?.kind)||!Number.isFinite(imported.power)||!Number.isInteger(imported.seed)||!Number.isInteger(imported.musicLengthMs)||!Number.isInteger(imported.scoreMusicLengthMs)||!Array.isArray(imported.frames)||!imported.frames.length||imported.frames.some(frame=>!Number.isInteger(frame?.timeMs)||!Number.isFinite(frame.deltaSeconds)||!Array.isArray(frame.judgements)||frame.judgements.some(note=>!known.has(note?.noteId)||!Number.isInteger(note.judgement)||note.judgement<1||note.judgement>7||!Number.isInteger(note.judgementTimeMs))))throw new Error(t.wrongChart);
+      request=imported;presetActive=false;planValid=true;power.value=String(request.power);seed.value=String(request.seed);
+      savedModes.set(request.mode.kind,structuredClone(request.mode));
+      if(![...mode.options].some(option=>option.value===request.mode.kind))mode.append(el("option",{value:request.mode.kind},t.importedMode));
+      mode.value=request.mode.kind;
+      if(![...fps.options].some(option=>option.value==="imported"))fps.append(el("option",{value:"imported"},t.importedClock));
+      fps.value="imported";fps.disabled=true;
+      renderNotes();status.textContent=t.ready;results.replaceChildren();run.disabled=false;download.disabled=false;
+    }catch(error){fail(error);}finally{endWork();}
+  };
+  download.onclick=()=>{
+    const url=URL.createObjectURL(new Blob([JSON.stringify(controlsToRequest(),null,2)],{type:"application/json"}));
+    const link=el("a",{href:url,download:`live-${scoreId}.json`});link.click();URL.revokeObjectURL(url);
+  };
+  (async()=>{try{const metadata=await call("init",site,reference);justTypes=metadata.justJudgementTypes;description=await call("describeChart",scoreId);await restore();}catch(error){fail(error);}})();
+  return()=>{disposed=true;worker.terminate();for(const task of pending.values())task.reject(new Error(t.error));pending.clear();root.replaceChildren();};
+}
diff --git a/examples/songs/replay-preset.js b/examples/songs/replay-preset.js
new file mode 100644
index 0000000..d4b99b0
--- /dev/null
+++ b/examples/songs/replay-preset.js
@@ -0,0 +1,151 @@
+// Declared input plans only. Rust owns conversion, state updates and scoring.
+
+/** Read Just capability from a caller-verified nnnotes.deck-data/1 document. */
+export function parseJustJudgementTypes(deckDataJSON) {
+  const data = typeof deckDataJSON === "string" ? JSON.parse(deckDataJSON) : deckDataJSON;
+  if (data?.format !== "nnnotes.deck-data/1") throw new Error("Unsupported replay data format");
+  const table = data.master?.MasterLiveJudgementTiming;
+  if (!Array.isArray(table?.columns) || !Array.isArray(table.rows)) throw new Error("Missing judgement timing table");
+  const type = table.columns.indexOf("_noteJudgementType");
+  const grade = table.columns.indexOf("_noteSimulateJudgement");
+  if (type < 0 || grade < 0) throw new Error("Missing judgement timing columns");
+  const found = new Set();
+  for (const row of table.rows) {
+    if (!Array.isArray(row) || !Number.isInteger(row[type]) || !Number.isInteger(row[grade])) {
+      throw new Error("Invalid judgement timing row");
+    }
+    if (row[grade] === 6) found.add(row[type]);
+  }
+  return [...found];
+}
+
+// Exactly count positions, spread evenly over the existing order. The prefix count differs
+// from prefixLength * count / length by less than one. No shuffle or scoring formula.
+function chooseEvenly(items, count, set) {
+  let remainder = 0;
+  for (const item of items) {
+    remainder += count;
+    if (remainder >= items.length) {
+      remainder -= items.length;
+      set(item);
+    }
+  }
+}
+
+/**
+ * Replace only input grades, after validating the entire plan. Pass and frame/note order stay intact.
+ * Great covers all judged inputs; Just covers the remaining Just-capable inputs in enabled frames.
+ * Fractions choose rounded counts in one deterministic plan, not an expectation over plans.
+ */
+function preparePlan(request, description, justTypes) {
+  if (request?.format !== "ournotes.replay/1" || !Array.isArray(request.frames) || !Array.isArray(description?.notes)) {
+    throw new Error("Invalid replay plan");
+  }
+  if (request.rawRuntime != null) throw new Error("Accuracy presets require a judgement template without raw results");
+  if (!Array.isArray(justTypes) && !(justTypes instanceof Set)) throw new Error("Missing Just judgement types");
+  const types = new Set(justTypes);
+  if ([...types].some(n => !Number.isInteger(n))) throw new Error("Invalid Just judgement type");
+  const mode = request.mode?.kind;
+  if (!["normal", "soloGekisou", "fixedSoloGekisou", "externalGekisou"].includes(mode)) {
+    throw new Error("Unsupported replay mode");
+  }
+  const byId = new Map(description.notes.map(note => [note.noteId, note]));
+  if (byId.size !== description.notes.length) throw new Error("Duplicate chart note id");
+  const inputs = [], seen = new Set();
+  for (let f = 0; f < request.frames.length; f++) {
+    const frame = request.frames[f];
+    if (!Number.isInteger(frame.timeMs) || !Array.isArray(frame.judgements)) throw new Error("Invalid replay frame");
+    for (const judgement of frame.judgements) {
+      if (judgement.rawResult != null) throw new Error("Accuracy presets require a judgement template without raw results");
+      const note = byId.get(judgement.noteId);
+      if (!note || seen.has(judgement.noteId)) throw new Error("Unknown or duplicate replay note");
+      seen.add(judgement.noteId);
+      if (note.defaultJudgement === 7 || judgement.judgement === 7) continue;
+      inputs.push({ judgement, note, frame: f, grade: 5 });
+    }
+  }
+  const windows = [];
+  if (mode !== "normal") {
+    if (!Array.isArray(description.fevers) || !Array.isArray(description.missions)) throw new Error("Missing Gekisou ranges");
+    for (let i = 0; i < description.fevers.length; i++) {
+      const fever = description.fevers[i];
+      if (!Array.isArray(fever) || fever.length !== 2 || !fever.every(Number.isInteger)) throw new Error("Invalid fever range");
+      if (description.missions[i] !== 3) continue;
+      const first = request.frames.findIndex(frame => frame.timeMs >= fever[0]);
+      if (first < 0) continue;
+      let stop = first + 1;
+      while (stop < request.frames.length && request.frames[stop].timeMs < fever[1]) stop++;
+      windows.push([first, stop]);
+    }
+  }
+  return { inputs, canJust: input => types.has(input.note.judgementType)
+    && windows.some(([first, stop]) => first <= input.frame && input.frame < stop) };
+}
+
+export function applyAccuracyPreset(request, description, justTypes, greatFraction, justFraction) {
+  if (![greatFraction, justFraction].every(n => typeof n === "number" && Number.isFinite(n) && n >= 0 && n <= 1)) {
+    throw new Error("Accuracy fractions must be between 0 and 1");
+  }
+  const { inputs, canJust } = preparePlan(request, description, justTypes);
+  const great = Math.round(inputs.length * greatFraction);
+  chooseEvenly(inputs, great, input => { input.grade = 4; });
+  const eligible = inputs.filter(input => input.grade !== 4 && canJust(input));
+  const just = Math.round(eligible.length * justFraction);
+  chooseEvenly(eligible, just, input => { input.grade = 6; });
+  // No validation or operation that can throw remains after the first input write.
+  for (const input of inputs) input.judgement.judgement = input.grade;
+  return { great, just, perfect: inputs.length - great - just, total: inputs.length, justEligible: eligible.length };
+}
+
+/**
+ * Generate one seeded, explicit input stream. The first segment is the whole-song default;
+ * later [startMs,endMs) segments override earlier ones by chart noteMs.
+ * Input PRNG: LCG32, x <- 1664525*x + 1013904223 modulo 2^32; uniform x/2^32.
+ * Exactly two draws per judged input, including inputs outside Just windows. Pass consumes none.
+ * This plan seed is independent of request.seed, the game's skill/luck seed.
+ */
+export function applySegmentPreset(request, description, justTypes, segments, planSeed) {
+  if (!Number.isInteger(planSeed) || planSeed < 0 || planSeed > 0xffffffff) throw new Error("Plan seed must be a uint32 integer");
+  if (!Array.isArray(segments) || segments.length === 0) throw new Error("A whole-song default segment is required");
+  const rules = segments.map((segment, i) => {
+    if (!segment || (i === 0 ? segment.startMs !== null || segment.endMs !== null
+      : !Number.isInteger(segment.startMs) || !Number.isInteger(segment.endMs) || segment.startMs >= segment.endMs)) {
+      throw new Error("Segment zero must cover the song; later segments need integer startMs < endMs");
+    }
+    const p = [segment.great, segment.good, segment.bad, segment.miss, segment.just];
+    if (!p.every(n => typeof n === "number" && Number.isFinite(n) && n >= 0 && n <= 1)) {
+      throw new Error("Segment probabilities must be between 0 and 1");
+    }
+    if (p.slice(0, 4).reduce((a, b) => a + b, 0) > 1 + 4 * Number.EPSILON) {
+      throw new Error("Great + Good + Bad + Miss probabilities must not exceed 1");
+    }
+    return { ...segment };
+  });
+  const { inputs, canJust } = preparePlan(request, description, justTypes);
+  if (inputs.some(input => !Number.isInteger(input.note.noteMs))) throw new Error("Segment plans require chart noteMs");
+  let state = planSeed >>> 0;
+  const random = () => {
+    state = (Math.imul(state, 1664525) + 1013904223) >>> 0;
+    return state / 0x100000000;
+  };
+  const counts = { great: 0, good: 0, bad: 0, miss: 0, just: 0, perfect: 0, total: inputs.length };
+  for (const input of inputs) {
+    let rule = rules[0];
+    for (let i = 1; i < rules.length; i++) {
+      if (rules[i].startMs <= input.note.noteMs && input.note.noteMs < rules[i].endMs) rule = rules[i];
+    }
+    const gradeDraw = random(), justDraw = random();
+    let limit = 0, selected = "perfect";
+    for (const [name, grade] of [["great", 4], ["good", 3], ["bad", 2], ["miss", 1]]) {
+      limit += rule[name];
+      if (gradeDraw < limit) { selected = name; input.grade = grade; break; }
+    }
+    if (selected === "perfect" && canJust(input) && justDraw < rule.just) {
+      selected = "just"; input.grade = 6;
+    }
+    counts[selected]++;
+  }
+  // Everything is validated and all draws resolved before mutating the caller's stream.
+  for (const input of inputs) input.judgement.judgement = input.grade;
+  return counts;
+}
diff --git a/examples/songs/replay-worker.js b/examples/songs/replay-worker.js
new file mode 100644
index 0000000..85f0288
--- /dev/null
+++ b/examples/songs/replay-worker.js
@@ -0,0 +1,40 @@
+// The worker transports JSON to Rust. It contains no grading or scoring rules.
+import { parseJustJudgementTypes } from "./replay-preset.js";
+let session;
+const decode = new TextDecoder();
+async function verified(url, identity) {
+  const response = await fetch(url, { credentials: "omit" });
+  if (!response.ok) throw new Error(`HTTP ${response.status}: ${url}`);
+  const bytes = await response.arrayBuffer();
+  const hash = [...new Uint8Array(await crypto.subtle.digest("SHA-256", bytes))].map(x => x.toString(16).padStart(2, "0")).join("");
+  if (!/^[0-9a-f]{64}$/i.test(identity.sha256 ?? "") || hash !== identity.sha256.toLowerCase()) throw new Error(`SHA-256 mismatch: ${url}`);
+  if (identity.bytes !== undefined && identity.bytes !== bytes.byteLength) throw new Error(`Size mismatch: ${url}`);
+  return bytes;
+}
+self.onmessage = async ({data:message}) => {
+  const {id,op,args=[]}=message;
+  try {
+    if (op === "init") {
+      const [site,reference]=args;
+      if (reference.format !== "nnnotes.replay-manifest/1") throw new Error("Unsupported replay manifest");
+      const manifestUrl = new URL(reference.manifestUrl,site).href;
+      const manifest = JSON.parse(decode.decode(await verified(manifestUrl,reference)));
+      if (manifest.format !== reference.format || manifest.engine?.requestFormat !== "ournotes.replay/1") throw new Error("Unsupported replay engine");
+      const resolve = item => new URL(item.url,manifestUrl).href;
+      const [data,js,wasm]=await Promise.all([verified(resolve(manifest.deckData),manifest.deckData),verified(resolve(manifest.engine.js),manifest.engine.js),verified(resolve(manifest.engine.wasm),manifest.engine.wasm)]);
+      const moduleUrl=URL.createObjectURL(new Blob([js],{type:"text/javascript"}));
+      const dataJson=decode.decode(data);
+      const justJudgementTypes=parseJustJudgementTypes(JSON.parse(dataJson));
+      try {
+        const engine=await import(moduleUrl);
+        await engine.default({module_or_path:wasm});
+        session=new engine.ReplaySession(dataJson);
+      } finally { URL.revokeObjectURL(moduleUrl); }
+      self.postMessage({id,result:{model:manifest.engine.model,justJudgementTypes}});
+      return;
+    }
+    if (!session) throw new Error("Replay engine is not loaded");
+    if (!["describeChart","template","run"].includes(op)) throw new Error("Unsupported replay operation");
+    self.postMessage({id,result:JSON.parse(session[op](...args))});
+  } catch(error) { self.postMessage({id,error:String(error?.message??error)}); }
+};
diff --git a/examples/songs/songs.js b/examples/songs/songs.js
index 3e50424..b8504e5 100644
--- a/examples/songs/songs.js
+++ b/examples/songs/songs.js
@@ -8,29 +8,28 @@
 //   &gk=free &rk=<r>[,<r>,<r>]                                              (play scenario: Free Live, else Gekisou
 //                                                                           Live with a rank 1-5 per range; default
 //                                                                           Gekisou Live at rank 1 everywhere)
-//   &gr=<Great percent> &jr=<Just percent>                                  (accuracy: Great share, default 0; Just
-//                                                                           rate in Just ranges, default 100)
 //   &p=<power> &tr=<rank> &n=<players>                                      (event: rank chance; Gekisou Live room
 //                                                                           size, default 5)
-//   &jk=off                                                                 (no jackets)
 //   &ax=<figure> &ay=<figure>                                               (scatter axes)
 //   &c=<scoreId>                                                            (the chart detail open)
 //   &moenotes=<base URL>|off                                                (song links; default https://bdon.moe/)
 //   &theme=light|dark                                                       (default: the system's)
-// The site root is this page's directory unless ?site=<URL> names another one.
+// Published beside the music-data directory; ?site=<URL> can name another data root.
 import {
   DIFFICULTIES, MOENOTES, NOTE_KINDS, chartRows, extent, histogram, matches, moenotesUrl, pickText, refigure, shapeBands, shapeSkills, sortBy,
-  ticks,
+  ticks, moenotesJacketUrl,
 } from "./catalog.js";
 import {
   MEASURES, RANGES, RANK_MAX, SCORE_RANKS, X_MAX, aptitudeFigures, aptitudeRate, aptitudeSe, aptitudeShapes, chartVariants, chartFigures, eventDominance, formatLength, formatRanks, lengthMs,
   meanSkill, modelPower, orderRates, parseRanks, perMinute, plainKind, quantile, rangeMeasures, rank, rankThreshold,
   reachChance, requiredPower, scenarioData, scoreRate, weightSum, zeroGain,
 } from "./ranking.js";
-import { GUIDE, UI } from "./text.js";
+import { GUIDE, UI, REPLAY_UI } from "./text.js";
+import { axisGoal, paretoPoints } from "./pareto.js";
+import { mountReplayPanel } from "./replay-panel.js";
 
 const q = new URLSearchParams(location.search);
-const site = new URL(q.get("site") || "./", location.href);
+const site = new URL(q.get("site") || "../music-data/", location.href);
 const moeBase = q.get("moenotes") === "off" ? null : q.get("moenotes") || MOENOTES;
 const SVG = "http://www.w3.org/2000/svg";
 // difficulty accents are CSS variables (index.html), so both themes restyle the charts too
@@ -88,6 +87,10 @@ const heading = (tag, cls, title, ...tail) => h("div", { class: cls }, icon("sta
   h("span", { class: "track", "aria-hidden": "true" }), tail.flat().filter(Boolean).length ? h("div", { class: "tail" }, tail) : null);
 const fmt = (v, d = 2) => (v === null || v === undefined || !Number.isFinite(v) ? "–" : v.toFixed(d));
 const fmtInt = (v) => (Number.isFinite(v) ? Math.round(v).toLocaleString() : "–");
+const modelText = (text) => {
+  const name = text.includes("ournotes-deck") ? "ournotes-deck" : "Rust", index = text.indexOf(name);
+  return index < 0 ? text : [text.slice(0,index), h("a",{class:"model-link",href:"https://github.com/empty-sekai/ournotes-deck",target:"_blank",rel:"noopener",title:"ournotes-deck (GitHub)"},name),text.slice(index+name.length)];
+};
 const lv = (r) => (Number.isInteger(r.displayLevel) ? String(r.displayLevel) : String(r.displayLevel));
 
 const load = async (name, optional) => {
@@ -114,10 +117,9 @@ const main = async () => {
   const boot = h("div", { class: "boot" }, h("div", { class: "spinner" }), UI.zh.loading);
   document.body.append(boot);
   const songs = await load("music-data.json");
-  // jackets are optional (nnnotes songs --jackets): one probe decides whether the site has them
-  const probe = ((songs && songs.songs) || []).find((x) => x.jacket);
-  const hasJackets = probe ? await fetch(new URL(`jackets/${probe.jacket}.webp`, site), { method: "HEAD" })
-    .then((r) => r.ok).catch(() => false) : false;
+  // Use MoeNotes' published jackets by default; a local chart site need not export another copy.
+  const hasJackets = ((songs && songs.songs) || []).some((x) => x.jacket);
+  const jacketUrl = (r) => moenotesJacketUrl(r.song.jacket, q.get("jacket-api") || "https://assets.bdon.moe");
   boot.remove();
 
   const langs = Array.isArray(songs.languages) && songs.languages.length ? songs.languages : ["ja"];
@@ -127,9 +129,9 @@ const main = async () => {
   const hasStats = rows.some((r) => r.weights);
   // what the data can show besides Gekisou Live at rank 1 (ranking.js scenarioData)
   const has = scenarioData(songs);
+  const pct = (value,fallback) => value===null||!Number.isFinite(Number(value)) ? fallback : Math.min(100,Math.max(0,Math.round(Number(value))));
   const kind = plainKind(songs);
   const power = modelPower(songs);
-  const pct = (v, def) => (v === null || !Number.isFinite(Number(v)) ? def : Math.min(100, Math.max(0, Math.round(Number(v)))));
   const S = {
     view: ["rank", "charts", "guide"].includes(q.get("v")) ? q.get("v") : "rank",
     lang: defaultLanguage(langs),
@@ -147,18 +149,19 @@ const main = async () => {
     // the play scenario (ranking.js chartFigures) and the accuracy
     mode: q.get("gk") === "free" && has.free ? "free" : "battle",
     ranks: has.ranks ? parseRanks(q.get("rk")) : Array(RANGES).fill(1),
-    great: pct(q.get("gr"), 0),
-    just: has.just ? pct(q.get("jr"), 100) : 100,
+    great: pct(q.get("gr"),0),
+    just: has.just ? pct(q.get("jr"),100) : 100,
     room: Math.min(RANK_MAX, Math.max(1, Math.round(Number(q.get("n")) || 5))),
-    jackets: q.get("jk") !== "off",
     ax: AXES.includes(q.get("ax")) ? q.get("ax") : "displayLevel",
     ay: AXES.includes(q.get("ay")) ? q.get("ay") : hasStats ? "perMinute" : "density",
+    xGoal: q.get("xg") === "max" ? "max" : q.get("xg") === "min" ? "min" : axisGoal(AXES.includes(q.get("ax")) ? q.get("ax") : "displayLevel"),
+    yGoal: q.get("yg") === "min" ? "min" : q.get("yg") === "max" ? "max" : axisGoal(AXES.includes(q.get("ay")) ? q.get("ay") : hasStats ? "perMinute" : "density"),
     chart: Number(q.get("c")) || null,
   };
   while (S.skills.length < 5) S.skills.push(0);
   if (!hasStats && EFF_RANKS.has(S.rankBy)) S.rankBy = "speed";
   const u = () => (S.lang.startsWith("zh") ? UI.zh : UI.en);
-  const showJackets = () => hasJackets && S.jackets;
+  const showJackets = () => hasJackets;
   const g = () => (S.lang.startsWith("zh") ? GUIDE.zh : GUIDE.en);
   const skills = () => S.skills.map((x) => x / 100);
   const scenario = () => ({ mode: S.mode, ranks: S.ranks, just: S.just / 100, great: S.great / 100 });
@@ -208,9 +211,10 @@ const main = async () => {
     put("gr", S.great, 0);
     put("jr", S.just, 100);
     put("n", S.room, 5);
-    put("jk", S.jackets ? null : "off", null);
     put("ax", S.ax, "displayLevel");
     put("ay", S.ay, hasStats ? "perMinute" : "density");
+    put("xg", S.xGoal, axisGoal(S.ax));
+    put("yg", S.yGoal, axisGoal(S.ay));
     put("c", S.chart, null);
     put("theme", theme, null);
     let t = p.toString();
@@ -222,7 +226,7 @@ const main = async () => {
   const jacket = (r, cls = "jk") => {
     const box = h("span", { class: cls, style: `--band:${bandColor(r)}` }, h("span", { class: "jk-fallback" }, title(r).slice(0, 1)));
     if (showJackets() && r.song.jacket) {
-      const img = h("img", { src: new URL(`jackets/${r.song.jacket}.webp`, site).href, alt: "", loading: "lazy", decoding: "async" });
+      const img = h("img", { src: jacketUrl(r), alt: "", loading: "lazy", decoding: "async" });
       img.addEventListener("error", () => img.remove());
       box.append(img);
     }
@@ -264,8 +268,6 @@ const main = async () => {
         "aria-current": S.view === v ? "page" : null, onclick: () => { S.view = v; renderAll(); scrollTo({ top: 0 }); },
       }, t.views[v]))),
       h("div", { class: "tools" },
-        hasJackets ? h("button", { class: "toggle", "aria-pressed": S.jackets ? "true" : "false", title: t.jacketsHint,
-          onclick: () => { S.jackets = !S.jackets; renderAll(); } }, icon("image"), h("span", {}, t.jackets)) : null,
         h("button", { class: "icon-btn", "aria-label": t.theme, title: t.theme,
           onclick: () => { theme = shown === "dark" ? "light" : "dark"; applyTheme(); renderHeader(); save(); } }, icon(shown === "dark" ? "sun" : "moon")),
         h("select", { class: "lang", "aria-label": "Language", onchange: (e) => { S.lang = e.target.value; renderAll(); } },
@@ -273,7 +275,7 @@ const main = async () => {
   };
 
   // Visible text plus an explicit description: the beta state does not rely on color or a hover tooltip.
-  const betaBadge = (descriptionId) => h("span", { class: "beta-badge", lang: "en", "aria-describedby": descriptionId }, u().beta);
+  const betaBadge = (descriptionId) => h("button", { class: "beta-badge", lang: "en", title:u().betaNote, "aria-describedby": descriptionId, onclick:()=>{S.view="guide";renderAll();} }, u().beta);
 
   // the route heading: the view's title and what it answers
   const renderHead = () => {
@@ -281,8 +283,7 @@ const main = async () => {
     const [title, lead] = S.view === "guide" ? [g().title, g().lead]
       : [t.heads[S.view], t.lead[S.view](songs.songs.length, rows.length)];
     put(head, h("div", { class: "page-head" }, h("div", { class: "page-head-title" }, icon("star", "ic star"), h("h1", {}, title), betaBadge("page-beta-note"),
-      h("span", { class: "track", "aria-hidden": "true" })), h("p", {}, lead),
-    h("p", { id: "page-beta-note", class: "beta-note" }, t.betaNote)));
+      h("span", { class: "track", "aria-hidden": "true" })), S.view === "guide" && g().reminder ? h("aside", {id:"page-beta-note",class:"guide-reminder",role:"note"}, h("strong",{},g().reminder.title),g().reminder.priority ? h("p",{},h("strong",{},g().reminder.priority)) : null, h("p",{},modelText(g().reminder.text))) : h("span", {id:"page-beta-note",class:"sr-only"},t.betaNote)));
   };
 
   const renderFilters = () => {
@@ -327,29 +328,17 @@ const main = async () => {
       h("small", {}, T.range(i + 1, missions ? t.missions[missions[i]] : null)),
       seg([...Array(RANK_MAX).keys()].map((k) => [k + 1, String(k + 1), k > 0 && !has.ranks]), S.ranks[i],
         (v) => { setScenario(() => { S.ranks = S.ranks.map((x, j) => (j === i ? v : x)); }); redo(); }, "seg mini")));
-    const slider = (label, value, set, off) => {
-      const out = h("output", {}, off ? T.pending : `${value}%`);
-      const inp = h("input", { type: "range", min: 0, max: 100, step: 1, value, disabled: off, "aria-label": label });
-      inp.addEventListener("input", () => {
-        const v = Number(inp.value);
-        out.textContent = `${v}%`;
-        setScenario(() => set(v));
-        live();
-        save();
-      });
-      return h("label", { class: "field" }, h("span", {}, label), inp, out);
+    const accuracySlider = (label,value,set,disabled=false) => {
+      const output=h("output",{},`${value}%`),input=h("input",{type:"range",min:0,max:100,step:1,value,disabled,"aria-label":label,oninput:()=>{output.textContent=`${input.value}%`;},onchange:()=>{setScenario(()=>set(Number(input.value)));live();save();}});
+      return h("label",{class:"field"},h("span",{},label),input,output);
     };
     return h("div", { class: "panel scen glass" },
-      h("div", { class: "field" }, h("span", {}, T.mode), modes, note(battle ? T.battleHint : T.freeHint)),
-      battle ? h("div", { class: "field" }, h("span", {}, T.ranks), ranks, note(has.ranks ? T.rankBest : `${T.rankBest} · ${T.ranksPending}`)) : null,
-      h("div", { class: "field" }, h("span", {}, T.accuracy),
-        slider(T.great, S.great, (v) => { S.great = v; }, false),
-        battle ? slider(T.just, S.just, (v) => { S.just = v; }, !has.just) : null,
-        note(battle ? T.accNote : T.accNoteFree)),
+      h("div", { class: "field" }, h("span", {}, T.mode), modes),
+      battle ? h("div", { class: "field" }, h("span", {}, T.ranks), ranks, !has.ranks ? note(T.ranksPending) : null) : null,
+      h("div",{class:"field"},h("span",{},T.accuracy),accuracySlider(T.great,S.great,value=>{S.great=value;}),battle?accuracySlider(T.just,S.just,value=>{S.just=value;},!has.just):null,h("abbr",{class:"note",title:battle?T.accNote:T.accNoteFree},t.referenceEstimate)),
       rooms && battle ? h("div", { class: "field" }, h("span", {}, T.room),
         seg([...Array(RANK_MAX).keys()].map((k) => [k + 1, String(k + 1)]), S.room, (v) => { S.room = v; redo(); }, "seg mini"),
-        note(T.roomHint)) : null,
-      rooms && !battle ? note(T.soloRanks) : null);
+        null) : null);
   };
   const redoMain = () => { renderMain(); save(); };
 
@@ -359,7 +348,8 @@ const main = async () => {
     const t = u();
     const ohOut = h("output", {}, `${S.overhead} s`);
     const oh = h("input", { type: "range", min: 0, max: 180, step: 5, value: S.overhead, "aria-label": t.overhead });
-    oh.addEventListener("input", () => { S.overhead = Number(oh.value); ohOut.textContent = `${S.overhead} s`; live(); save(); });
+    oh.addEventListener("input", () => { ohOut.textContent = `${oh.value} s`; });
+    oh.addEventListener("change", () => { S.overhead = Number(oh.value); live(); save(); });
     const mean = h("output", { class: "mean" });
     const showMean = () => { mean.textContent = t.meanSkill(Math.round(100 * meanSkill(skills(), 5))); };
     showMean();
@@ -383,6 +373,7 @@ const main = async () => {
   };
 
   let tableBox = null;
+  let allColumns = false;
   const renderRank = () => {
     const t = u();
     const tabs = seg(RANKS.filter((k) => hasStats || !EFF_RANKS.has(k)).map((k) => [k, t.rankBy[k]]), S.rankBy,
@@ -393,7 +384,7 @@ const main = async () => {
     tableBox = h("div", { class: "table-box" });
     put(main, 
       h("div", { class: "rank-head" }, tabs),
-      h("p", { class: "hint" }, t.rankHint[S.rankBy], sub),
+      sub ? h("div", { class: "hint" }, sub) : null,
       S.rankBy === "efficiency" || S.rankBy === "event"
         ? [scenarioPanel({ redo: redoMain, live: renderTable, rooms: S.rankBy === "event" }), effPanel(renderTable)] : null,
       !hasStats ? h("p", { class: "hint warn" }, t.noStats) : null,
@@ -487,57 +478,69 @@ const main = async () => {
       if (hi === "level") cell.level = h("td", { class: "num" }, bar(r.displayLevel, level(r)));
       return h("tr", { class: `${r.frontier && unsorted ? "on-front" : ""}`, tabindex: 0,
         onclick: () => openChart(r.scoreId), onkeydown: (e) => { if (e.key === "Enter") openChart(r.scoreId); } },
-      cols.map((k) => { const c = cell[k]; if (k === hi) c.classList.add("hi"); c.classList.add(`c-${k}`); return c; }));
+      cols.map((k) => { const c = cell[k]; if (k === hi) c.classList.add("hi"); c.classList.add(`c-${k}`); c.dataset.label = k === "bpm" && S.rankBy === "speed" && S.speedBy === "bpmMax" ? t.speedBy.bpmMax : t.col[k]; return c; }));
     });
     tableBox.replaceChildren(
-      h("div", { class: "count" }, `${u().chartsN(list.length)}${list.length !== all ? ` / ${all}` : ""}`),
-      h("div", { class: "table-card glass" }, list.length ? h("div", { class: "table-scroll" }, h("table", { class: "rank-table" },
+      h("div", { class: "table-toolbar" }, h("div", { class: "count" }, `${u().chartsN(list.length)}${list.length !== all ? ` / ${all}` : ""}`),
+        h("label", { class: "check columns-toggle" }, h("input", { type: "checkbox", checked: allColumns, onchange: (e) => { allColumns = e.target.checked; renderTable(); } }), t.allColumns, allColumns ? h("small", {}, t.allColumnsHint) : null)),
+      h("div", { class: "table-card glass" }, list.length ? h("div", { class: "table-scroll" }, h("table", { class: "rank-table", "data-rank-by": S.rankBy, "data-columns": allColumns ? "all" : "auto" },
         h("thead", {}, h("tr", {}, cols.map((k) => { const c = th(k); c.classList.add(`c-${k}`); return c; }))),
         h("tbody", {}, body))) : h("div", { class: "empty" }, h("b", {}, t.empty), t.emptyHint, " ",
         h("button", { class: "ghost", onclick: clearFilters }, t.clear))));
   };
 
   // ------------------------------------------------------------ charts
-  const tooltip = h("div", { class: "tip", hidden: true });
+  const tooltip = h("div", { class: "tip", role: "tooltip", hidden: true });
   document.body.append(tooltip);
   const showTip = (e, r, lines) => {
     tooltip.replaceChildren(h("div", { class: "tip-head" }, jacket(r, "jk sm"), h("div", {},
       h("div", { class: "tip-title" }, title(r)), h("div", { class: "tip-sub" }, level(r), " ", bandName(r)))),
     lines.map(([k, v]) => h("div", { class: "tip-row" }, h("span", {}, k), h("b", {}, v))));
     tooltip.hidden = false;
-    const x = Math.min(e.clientX + 14, innerWidth - tooltip.offsetWidth - 8);
-    const y = Math.min(e.clientY + 14, innerHeight - tooltip.offsetHeight - 8);
+    const x = Math.max(8, Math.min(e.clientX + 14, innerWidth - tooltip.offsetWidth - 8));
+    const y = Math.max(8, Math.min(e.clientY + 14, innerHeight - tooltip.offsetHeight - 8));
     tooltip.style.transform = `translate(${x}px, ${y}px)`;
   };
   const hideTip = () => { tooltip.hidden = true; };
 
   const scatter = () => {
     const t = u();
-    const W = 860, H = 460, m = { l: 58, r: 18, t: 16, b: 46 };
+    const W = Math.max(280, Math.min(1000, main.clientWidth - 40)), H = Math.max(320, Math.min(480, W * .55)), m = { l: 58, r: 22, t: 24, b: 50 };
     const list = pool().filter((r) => matches(r, S.search));
     const pts = list.map((r) => [figure(r, S.ax), figure(r, S.ay), r]).filter(([x, y]) => Number.isFinite(x) && Number.isFinite(y));
     const ex = extent(pts.map((p) => p[0])), ey = extent(pts.map((p) => p[1]));
     const svg = s("svg", { viewBox: `0 0 ${W} ${H}`, class: "plot", role: "img", "aria-label": `${t.axes[S.ax]} × ${t.axes[S.ay]}` });
     if (!ex || !ey) return svg;
+    const frontier = paretoPoints(pts, S.xGoal, S.yGoal);
+    const frontierIds = new Set(frontier.map((p) => p[2].scoreId));
     const sx = (v) => m.l + ((v - ex[0]) / (ex[1] - ex[0])) * (W - m.l - m.r);
     const sy = (v) => H - m.b - ((v - ey[0]) / (ey[1] - ey[0])) * (H - m.t - m.b);
+    svg.classList.add("scatter");
+    const defs = s("defs", {}), gradient = s("linearGradient", { id: "scatter-frontier-gradient", x1: 0, x2: 1, y1: 0, y2: 1 });
+    gradient.append(s("stop", { "stop-color": "var(--mn-accent-deep)" }), s("stop", { offset: 1, "stop-color": "var(--mn-pink)" }));
+    defs.append(gradient);
+    svg.append(defs, s("rect", { class: "plot-surface", x: m.l, y: m.t, width: W-m.l-m.r, height: H-m.t-m.b, rx: 12 }));
     const grid = s("g", { class: "grid" });
-    for (const v of ticks(ex[0], ex[1], 8)) grid.append(s("line", { x1: sx(v), x2: sx(v), y1: m.t, y2: H - m.b }), s("text", { x: sx(v), y: H - m.b + 18, "text-anchor": "middle" }, String(+v.toFixed(2))));
+    for (const v of ticks(ex[0], ex[1], W < 500 ? 4 : 8)) grid.append(s("line", { x1: sx(v), x2: sx(v), y1: m.t, y2: H - m.b }), s("text", { x: sx(v), y: H - m.b + 18, "text-anchor": "middle" }, String(+v.toFixed(2))));
     for (const v of ticks(ey[0], ey[1], 6)) grid.append(s("line", { x1: m.l, x2: W - m.r, y1: sy(v), y2: sy(v) }), s("text", { x: m.l - 8, y: sy(v) + 4, "text-anchor": "end" }, String(+v.toFixed(3))));
-    svg.append(grid,
+    const path = frontier.map(([x, y], i) => `${i ? "L" : "M"}${sx(x)},${sy(y)}`).join(" ");
+    svg.append(grid, s("path", { class: "frontier-glow", d: path }), s("path", { class: "frontier-line", d: path, style: "stroke:url(#scatter-frontier-gradient)" }),
       s("text", { class: "axis-label", x: (m.l + W - m.r) / 2, y: H - 8, "text-anchor": "middle" }, t.axes[S.ax]),
       s("text", { class: "axis-label", x: 14, y: (m.t + H - m.b) / 2, transform: `rotate(-90 14 ${(m.t + H - m.b) / 2})`, "text-anchor": "middle" }, t.axes[S.ay]));
-    const jitter = (id) => (S.ax === "displayLevel" ? (((id * 2654435761) % 1000) / 1000 - 0.5) * 0.3 : 0);
     const dots = s("g", { class: "dots" });
+    // The detailed popup replaces SVG titles, which would display a second native tooltip.
     for (const [x, y, r] of pts) {
-      const c = s("circle", { cx: sx(x + jitter(r.scoreId)), cy: sy(y), r: 5.5, style: `fill:${bandColor(r)};stroke:${DIFF_COLOR[r.difficulty]}`, tabindex: 0 });
+      const c = s("circle", { cx: sx(x), cy: sy(y), r: frontierIds.has(r.scoreId) ? 6.5 : 4.5, class: frontierIds.has(r.scoreId) ? "pareto-point" : "regular-point", style: `fill:${bandColor(r)};stroke:${DIFF_COLOR[r.difficulty]}`, tabindex: 0, "aria-label": `${title(r)} · ${t.axes[S.ax]} ${fmt(x, 3)} · ${t.axes[S.ay]} ${fmt(y, 3)}` });
       c.addEventListener("mousemove", (e) => showTip(e, r, [[t.axes[S.ax], fmt(x, S.ax === "displayLevel" ? 1 : 3)], [t.axes[S.ay], fmt(y, 3)]]));
       c.addEventListener("mouseleave", hideTip);
+      c.addEventListener("focus", () => { const box=c.getBoundingClientRect();showTip({clientX:box.left+box.width/2,clientY:box.top+box.height/2},r,[[t.axes[S.ax],fmt(x,3)],[t.axes[S.ay],fmt(y,3)]]); });
+      c.addEventListener("blur", hideTip);
       c.addEventListener("click", () => { hideTip(); openChart(r.scoreId); });
+      c.addEventListener("keydown", (e) => { if (e.key === "Enter") openChart(r.scoreId); });
       dots.append(c);
     }
     svg.append(dots);
-    return svg;
+    return h("div", { class: "scatter-canvas" }, h("div", { class: "plot-summary" }, h("span", {}, t.plotted(pts.length)), h("span", { class: "frontier-key" }, t.paretoCount(frontier.length))), svg, h("details", { class: "pareto-note" }, h("summary",{},t.paretoHelp),h("p",{},t.paretoHint)));
   };
 
   const levelChart = () => {
@@ -591,6 +594,7 @@ const main = async () => {
     const axes = AXES.filter((k) => hasStats || !EFF_AXES.has(k));
     const pick = (label, value, set) => h("label", { class: "field" }, h("span", {}, label), h("select", { onchange: (e) => { set(e.target.value); renderMain(); save(); } },
       axes.map((k) => h("option", { value: k, selected: k === value }, t.axes[k]))));
+    const goal = (label, value, set) => h("label", { class: "field" }, h("span", {}, label), h("select", { onchange: (e) => { set(e.target.value); renderMain(); save(); } }, ["min", "max"].map(v=>h("option", {value:v, selected:v===value}, v==="min"?t.lowerBetter:t.higherBetter))));
     const plot = h("div", { class: "plot-box" }, scatter());
     const legend = h("div", { class: "legend" },
       [...bands].map(([, b]) => h("span", {}, h("i", { class: "dot", style: `background:${b.mainColor}` }), pickText(b.name, S.lang))),
@@ -599,7 +603,8 @@ const main = async () => {
     put(main, 
       h("section", { class: "card glass" },
         heading("h2", "sec-head", t.scatter,
-          h("div", { class: "axes" }, pick(t.x, S.ax, (v) => { S.ax = v; }), h("button", { class: "ghost", "aria-label": t.swap, title: t.swap, onclick: () => { [S.ax, S.ay] = [S.ay, S.ax]; renderMain(); save(); } }, icon("swap")), pick(t.y, S.ay, (v) => { S.ay = v; }))),
+          h("div", { class: "axes" }, pick(t.x, S.ax, (v) => { S.ax = v; S.xGoal = axisGoal(v); }), h("button", { class: "ghost", "aria-label": t.swap, title: t.swap, onclick: () => { [S.ax, S.ay] = [S.ay, S.ax]; [S.xGoal,S.yGoal]=[S.yGoal,S.xGoal]; renderMain(); save(); } }, icon("swap")), pick(t.y, S.ay, (v) => { S.ay = v; S.yGoal = axisGoal(v); }))),
+        h("div", { class: "pareto-controls" }, h("span", {class:"frontier-key"}, t.pareto), goal(t.xGoal,S.xGoal,v=>{S.xGoal=v;}), goal(t.yGoal,S.yGoal,v=>{S.yGoal=v;})),
         EFF_AXES.has(S.ax) || EFF_AXES.has(S.ay)
           ? [scenarioPanel({ redo: redoMain, live: () => plot.replaceChildren(scatter()) }), effPanel(() => plot.replaceChildren(scatter()))] : null,
         plot, legend),
@@ -615,12 +620,17 @@ const main = async () => {
     const G = g();
     const no = (i) => String(i + 1).padStart(2, "0");
     const links = G.sections.map((x, i) => h("a", { href: `#g${i}` }, h("span", {}, no(i)), x.title));
-    put(main, h("div", { class: "guide" },
-      h("nav", { class: "toc glass", "aria-label": G.title }, links),
+    put(main, G.method ? h("section", {class:"guide-method",id:"sources"}, h("h2",{},G.method.title), h("p",{},modelText(G.method.text))) : null, h("div", { class: "guide" },
+      h("nav", { class: "toc", "aria-label": G.title }, links),
+      h("details",{class:"toc-mobile"},h("summary",{},G.contentsLabel),h("nav",{"aria-label":G.title},G.sections.map((x,i)=>h("a",{href:`#g${i}`,onclick:e=>e.currentTarget.closest("details")?.removeAttribute("open")},h("span",{},no(i)),x.title)))),
       h("article", { class: "g-body" }, G.sections.map((x, i) => h("section", { id: `g${i}`, class: "g-section" },
-        heading("h2", "sec-head", [h("span", { class: "g-no" }, no(i)), " ", x.title]),
-        (x.body || []).map((p) => h("p", {}, p)),
+        h("header",{class:"guide-section-head"},h("span",{class:"g-no"},no(i)),h("h2",{},x.title)),
+        !x.table ? (x.body || []).map((p) => h("p", {}, p)) : null,
         x.math && x.math.length ? h("div", { class: "formula" }, x.math.map((m) => h("code", {}, m))) : null,
+        x.table ? h("div", { class: "verification-scroll",tabindex:0,role:"region","aria-label":x.title }, h("table", { class: "verification" },
+          x.table.caption ? h("caption",{},x.table.caption) : null,
+          h("thead", {}, h("tr", {}, x.table.headers.map((heading) => h("th", { scope: "col" }, heading)))),
+          h("tbody", {}, x.table.rows.map((row) => h("tr", {}, row.map((cell) => h("td", {}, cell))))))) : null,
         (x.after || []).map((p) => h("p", {}, p)),
         x.defs && x.defs.length ? h("dl", { class: "defs" }, x.defs.flatMap(([term, def]) => [h("dt", {}, term), h("dd", {}, def)])) : null)))));
     // the contents follow the reading: the first section in the band from under the header to 45% of the window
@@ -831,6 +841,7 @@ const main = async () => {
 
   // a scenario changed in the detail: the view behind it redraws when the detail closes
   let behindStale = false;
+  let disposeReplay = null;
   const openChart = (scoreId) => { S.chart = scoreId; renderDrawer(); save(); };
   const closeChart = () => {
     S.chart = null;
@@ -839,6 +850,7 @@ const main = async () => {
     save();
   };
   const renderDrawer = () => {
+    disposeReplay?.(); disposeReplay = null;
     const r = S.chart && byScore.get(S.chart);
     if (!r) { drawer.classList.remove("open"); drawer.replaceChildren(); document.body.classList.remove("locked"); return; }
     const t = u();
@@ -853,6 +865,11 @@ const main = async () => {
     const ranks = h("div", {});
     const measures = measuresBox(r);
     const aptitude = aptitudeBox(r, () => { draw(); behindStale = true; save(); });
+    const replayHost = h("div", {});
+    const replayText = REPLAY_UI[S.lang.startsWith("zh") ? "zh" : "en"];
+    const replay = songs.replay ? h("details", { class: "replay", ontoggle: (event) => {
+      if (event.currentTarget.open && !disposeReplay) disposeReplay = mountReplayPanel(replayHost, {site:site.href,reference:songs.replay,scoreId:r.scoreId,power:S.power||300000,mode:S.mode==="free"?{kind:"normal"}:{kind:"fixedSoloGekisou",ranks:S.ranks},text:replayText,noteKindLabels:t.kinds});
+    } }, h("summary", {}, replayText.title), replayHost) : null;
     const draw = () => {
       const e = eff(r);
       const battle = S.mode === "battle";
@@ -887,7 +904,7 @@ const main = async () => {
     draw();
     const panel = h("div", { class: "drawer", role: "dialog", "aria-modal": "true", "aria-label": title(r) },
       h("div", { class: "d-hero", style: `--band:${bandColor(r)}` },
-        showJackets() && r.song.jacket ? h("div", { class: "d-bg", style: `background-image:url("${new URL(`jackets/${r.song.jacket}.webp`, site).href}")` }) : null,
+        showJackets() && r.song.jacket ? h("div", { class: "d-bg", style: `background-image:url("${jacketUrl(r)}")` }) : null,
         jacket(r, "jk xl"),
         h("div", { class: "d-title" },
           h("div", { class: "d-band" }, h("i", { class: "dot", style: `background:${bandColor(r)}` }), bandName(r)),
@@ -908,8 +925,9 @@ const main = async () => {
           h("section", {}, heading("h3", "sec-head", t.detail.composition), composition(r)),
           weights),
         ranks,
-        measures, aptitude.element,
-        h("p", { class: "ids" }, `${t.detail.musicId} ${r.musicId} · ${t.detail.scoreId} ${r.scoreId} · ${t.detail.musicType} ${r.song.musicType}`)));
+        measures,
+        h("p", { class: "ids" }, `${t.detail.musicId} ${r.musicId} · ${t.detail.scoreId} ${r.scoreId} · ${t.detail.musicType} ${r.song.musicType}`),
+        replay, aptitude.element));
     drawer.replaceChildren(panel);
     drawer.classList.add("open");
     document.body.classList.add("locked");
@@ -936,11 +954,17 @@ const main = async () => {
     put(foot, h("footer", { class: "foot" }, h("span", {},
       h("span", { title: u().sourceHint(p.region ?? "?", master, client) }, u().source(/^[0-9a-f]{32}$/i.test(master) ? master.slice(0, 8) : master)),
       deckLink ? [` · ${u().deckModel} `, deckLink] : null),
-      h("span", {}, u().caveat),
+      p.developmentSample ? h("span", {title:`${p.developmentSample}${p.localModel?.sourceTreeSha256 ? ` · SHA-256 ${p.localModel.sourceTreeSha256}` : ""}`}, u().developmentData, p.localModel?.workingTreeDirty ? ` · ${u().uncommittedModel}` : "") : null,
       moeBase ? h("span", {}, h("a", { href: moeBase, target: "_blank", rel: "noopener" }, "moenotes", icon("out")), ` · ${u().moenotesHint}`) : null));
   };
   const renderAll = () => { renderHeader(); renderHead(); renderFilters(); renderMain(); renderFoot(); renderDrawer(); save(); };
   renderAll();
+  let observedWidth = main.clientWidth;
+  new ResizeObserver(() => {
+    if (main.clientWidth === observedWidth) return;
+    observedWidth = main.clientWidth;
+    if (S.view === "charts") main.querySelector(".plot-box")?.replaceChildren(scatter());
+  }).observe(main);
 };
 
 main().catch((e) => {
diff --git a/examples/songs/text.js b/examples/songs/text.js
index 6eaeb23..5022b5e 100644
--- a/examples/songs/text.js
+++ b/examples/songs/text.js
@@ -3,7 +3,10 @@
 
 export const UI = {
   zh: {
-    beta: "Beta", betaNote: "测试中，数值可能调整。幸运结果有采样误差，原生整局核对尚未完成。",
+    beta: "Beta", betaNote: "Rust 模型计算；ARM64 原生核对与逐音符单局计算见说明。",
+    referenceEstimate: "参考估算",
+    developmentData: "本地开发数据",
+    uncommittedModel: "模型含未提交修改",
     app: "谱面数据", views: { rank: "排行", charts: "图表", guide: "说明" },
     all: "全部", search: "搜索曲名、读音、作者…", songs: (n) => `${n} 首`, chartsN: (n) => `${n} 张谱面`,
     jackets: "封面", jacketsHint: "显示或隐藏封面", theme: "切换浅色 / 深色", swap: "交换横纵轴",
@@ -60,6 +63,7 @@ export const UI = {
       tailNotes: "尾部音符", comboAtStart: "进入时连击", lotteries: "抽签次数",
       factorNote: "区间计数为 Start 帧之后至 End 帧；尾部为 End 至 Complete，受技能影响但不计入区间分。抽签次数取基线种子均值 ± 标准误。",
     },
+    allColumns: "全部列", allColumnsHint: "可左右滚动对比",
     frontier: "只看前沿", col: {
       rank: "#", song: "曲目", level: "等级", time: "时长", bpm: "BPM", notes: "Notes", density: "N/s",
       rate: "分/综合力", perMinute: "分/综合力/分钟", relative: "相对", dom: "支配", skip: "跳过系数", base: "基础系数",
@@ -75,6 +79,16 @@ export const UI = {
       perMinute: "分/综合力/分钟", rate: "分/综合力", base: "基础系数", skip: "跳过系数",
     },
     scatter: "散点图", x: "横轴", y: "纵轴", levelDist: "等级分布", bandShare: "各乐队曲目数",
+    pareto: "帕累托前沿",
+    approximateShort: "近似",
+    paretoHelp: "前沿说明",
+    lowerBetter: "越低越好",
+    higherBetter: "越高越好",
+    xGoal: "横轴目标",
+    yGoal: "纵轴目标",
+    plotted: (n) => "{n} 张候选谱面".replace("{n}", n),
+    paretoCount: (n) => "{n} 张在前沿".replace("{n}", n),
+    paretoHint: "前沿按当前筛选、参数与两轴目标计算。连线连接离散候选，不表示中间存在谱面；它不同于排行中跨技能均值、跨额外耗时的支配关系。",
     moenotes: "在 moenotes 查看", moenotesHint: "作词作曲、演唱、音频、封面和谱面预览见 moenotes 歌曲页",
     missions: { 1: "连击", 2: "幸运", 3: "Just" },
     detail: {
@@ -102,7 +116,10 @@ export const UI = {
     caveat: "数值以游戏反编译为来源，尽量准确但不保证正确；与其它资料有出入时请以它们为准",
   },
   en: {
-    beta: "Beta", betaNote: "In testing; figures may change. Luck results have sampling error, and whole-live checks against the native game are not yet complete.",
+    beta: "Beta", betaNote: "Rust model calculations; see the guide for native ARM64 checks and per-note replay.",
+    referenceEstimate: "Reference estimate",
+    developmentData: "Local development data",
+    uncommittedModel: "Uncommitted model changes",
     app: "Chart data", views: { rank: "Rankings", charts: "Charts", guide: "Guide" },
     all: "All", search: "Search title, reading, credits…", songs: (n) => `${n} songs`, chartsN: (n) => `${n} charts`,
     jackets: "Jackets", jacketsHint: "Show or hide the jackets", theme: "Light / dark", swap: "Swap the axes",
@@ -161,6 +178,7 @@ export const UI = {
       tailNotes: "Tail notes", comboAtStart: "Entry combo", lotteries: "Lotteries",
       factorNote: "Range counts cover after Start through End; the tail covers after End through Complete, affected by skills but outside the range score. Lottery counts are the baseline seed mean ± standard error.",
     },
+    allColumns: "All columns", allColumnsHint: "Scroll sideways to compare",
     frontier: "Frontier only", col: {
       rank: "#", song: "Song", level: "Level", time: "Time", bpm: "BPM", notes: "Notes", density: "N/s",
       rate: "Score/power", perMinute: "Score/power/min", relative: "Rel.", dom: "Beaten", skip: "Skip", base: "Base",
@@ -176,6 +194,16 @@ export const UI = {
       bgmMs: "BGM length (s)", perMinute: "Score/power/min", rate: "Score/power", base: "Base", skip: "Skip",
     },
     scatter: "Scatter", x: "X", y: "Y", levelDist: "Levels", bandShare: "Songs per band",
+    pareto: "Pareto frontier",
+    approximateShort: "Approximate",
+    paretoHelp: "About this frontier",
+    lowerBetter: "Lower is better",
+    higherBetter: "Higher is better",
+    xGoal: "X objective",
+    yGoal: "Y objective",
+    plotted: (n) => "{n} candidate charts".replace("{n}", n),
+    paretoCount: (n) => "{n} on the frontier".replace("{n}", n),
+    paretoHint: "The frontier uses the current filters, parameters and two objectives. Lines connect discrete candidates; they do not imply intermediate charts. This differs from ranking dominance across every skill mean and overhead.",
     moenotes: "Open in moenotes", moenotesHint: "Credits, vocals, audio, jacket and chart previews on the moenotes song page",
     missions: { 1: "Combo", 2: "Luck", 3: "Just" },
     detail: {
@@ -204,365 +232,674 @@ export const UI = {
 };
 
 // The guide: sections of {title, body: [paragraph], math: [formula], after: [paragraph], defs: [[term, text]]}.
+export const REPLAY_UI = {
+  "zh": {
+    "title": "单局计算",
+    "loading": "正在载入模型…",
+    "hint": "设置技能转换前的判定，再计算这一局。默认无技能；结果列出转换后的判定数量。",
+    "power": "综合力",
+    "seed": "随机种子",
+    "clock": "帧率",
+    "mode": "场景",
+    "free": "自由 Live",
+    "fixedRanks": "撃奏 · 固定名次",
+    "reset": "重置判定",
+    "run": "计算",
+    "export": "导出 JSON",
+    "advanced": "导入 / 导出",
+    "advancedHint": "JSON 保留音符时刻、帧内顺序、技能和名次确认。导入的输入由 Rust 检查。",
+    "import": "导入 JSON",
+    "error": "计算失败",
+    "ready": "可计算",
+    "calculating": "正在计算…",
+    "score": "最终得分",
+    "frameScore": "最后一帧显示分",
+    "life": "生命",
+    "combo": "连击",
+    "note": "音符",
+    "time": "时刻",
+    "type": "类型",
+    "judgement": "判定",
+    "range": "区间",
+    "just": "Just",
+    "luck": "幸运点数",
+    "complete": "已计算",
+    "wrongChart": "文件的谱面或格式不匹配。",
+    "importedMode": "导入的场景",
+    "incomplete": "输入未完成，不能作为整局结果。",
+    "importedClock": "导入的时钟",
+    "exactPlan": "逐音符计算",
+    "greatShare": "Great 概率",
+    "justShare": "Just 率",
+    "presetHint": "剩余概率为 Perfect，Just 仅用于可判为 Just 的音符。段落覆盖全曲设定，后面的段落优先。种子生成一局可复现的判定，结果不是平均得分。",
+    "rawPreset": "原始输入请先重置再用滑块。",
+    "wholeSong": "全曲默认",
+    "planSeed": "判定种子",
+    "generate": "生成判定",
+    "editNotes": "查看／逐音符修改",
+    "segment": "段落",
+    "customSegment": "自定义段落",
+    "start": "开始（秒）",
+    "end": "结束（秒）",
+    "remove": "删除",
+    "probabilityTotal": "Great、Good、Bad、Miss 概率之和不能超过 100%。"
+  },
+  "en": {
+    "title": "One live",
+    "loading": "Loading model…",
+    "hint": "Set judgements before skill conversion. No skills by default; result counts include conversion.",
+    "power": "Power",
+    "seed": "Seed",
+    "clock": "Frame rate",
+    "mode": "Mode",
+    "free": "Free Live",
+    "fixedRanks": "Gekisou · fixed ranks",
+    "reset": "Reset notes",
+    "run": "Calculate",
+    "export": "Export JSON",
+    "advanced": "Import / export",
+    "advancedHint": "JSON preserves note times, frame order, skills and rank confirmations. Imported inputs are validated by Rust.",
+    "import": "Import JSON",
+    "error": "Calculation failed",
+    "ready": "Ready",
+    "calculating": "Calculating…",
+    "score": "Final score",
+    "frameScore": "Last frame display",
+    "life": "Life",
+    "combo": "Combo",
+    "note": "Note",
+    "time": "Time",
+    "type": "Type",
+    "judgement": "Judgement",
+    "range": "Range",
+    "just": "Just",
+    "luck": "Luck points",
+    "complete": "Calculated",
+    "wrongChart": "The file has another chart or an unsupported format.",
+    "importedMode": "Imported mode",
+    "incomplete": "Incomplete inputs cannot be shown as a whole-live result.",
+    "importedClock": "Imported clock",
+    "exactPlan": "Per-note calculation",
+    "greatShare": "Great probability",
+    "justShare": "Just rate",
+    "presetHint": "Perfect takes the remaining probability; Just applies only where eligible. Segments override the whole-song settings; later rows take priority. The seed generates one reproducible play, not an average score.",
+    "rawPreset": "Reset the raw input before using these sliders.",
+    "wholeSong": "Whole song",
+    "planSeed": "Judgement seed",
+    "generate": "Generate judgements",
+    "editNotes": "View / edit individual notes",
+    "segment": "Segment",
+    "customSegment": "Custom segment",
+    "start": "Start (s)",
+    "end": "End (s)",
+    "remove": "Remove",
+    "probabilityTotal": "Great, Good, Bad and Miss probabilities must add up to at most 100%."
+  }
+};
+
 export const GUIDE = {
-  zh: {
-    title: "定义、推导与成立条件",
-    lead: "本页的数值以游戏客户端的反编译代码为来源：ournotes-deck 按反编译得到的得分逻辑对每张谱面做整局模拟（激走开启与关闭各一次），结果就是 music-data.json 的 deck 统计。"
-      + "这里的模拟是我们照反编译代码重写的程序，不是在模拟器里直接运行游戏本身的代码；游戏自己的函数用于核对这份重写，目前包含分块核对与一张谱面的整局输入、终分核对（见“尚未纳入的机制”一节的“核对范围”）。"
-      + "我们尽量保证正确，但对反编译代码的理解、模型的简化和数据版本都可能出错，所以不能保证。如果本页和其它站点、工具或实机结果有出入，多半是我们这边有误，请以它们为准。"
-      + "下文给出每个量的定义、推导和成立条件；模型没有覆盖的机制单列一节。",
-    sections: [
+  "zh": {
+    "title": "定义、推导与成立条件",
+    "lead": "排行与适性展示理论最佳打法的统计参考；谱面详情还可逐音符计算给定输入的一局。两者使用同一套 ournotes-deck Rust 模型，原生逐帧核对的案例见下表。",
+    "sections": [
       {
-        title: "得分模型",
-        body: [
-          "本页的得分数值按所选的游玩场景计算（第 2 节）。默认是撃奏ライブ（最多 5 人的多人模式）的最佳情况：激走开启，Fever 区间与歌曲的激走任务一起构成激走区间，三个区间都拿第 1 名的排名加成。另一个场景是自由 Live：从反编译代码看，自由 Live 和挑战 Live 不开激走（单人激走只有调试开关，发布版没有入口），按本模型单人游玩的得分会低很多。"
-            + "两个场景都按理论最佳打法模拟：每个判定音符都在准确时刻命中，全连，生命不归零；撃奏ライブ的激走 Just 任务区间内为 Just，其它音符为 Perfect。准率的近似见第 6 节。"
-            + "整局按反编译代码中的帧、得分帧（40 ms）、连击与激走连击系数、技能的发动与结束帧逐步模拟（ournotes-deck live::full）。本页的卡组模型是普通加分技能：效果 2000、持续 5 秒、作用于全体、无条件，卡组得分为",
+        "title": "得分模型",
+        "body": [
+          "排行与图表按所选场景计算理论最佳基线：激走开启时，Just 任务区间内为 Just，其余为 Perfect，三个区间默认第 1 名；自由 Live 则关闭激走，全部为 Perfect。基线全连、生命不归零，不带卡上激走技能。详情中的单局计算按你给出的逐音符判定、技能顺序与种子重新运行，第 6 节说明输入方法。整局使用 ournotes-deck live::full 逐帧处理，计分帧为 40 ms。统计表的普通技能模型为效果 2000、持续 5 秒、作用于全体、无条件，卡组得分为"
         ],
-        math: [
+        "math": [
           "S = P · ( base + Σ_k x_{π(k)} · w_k )",
-          "base = score / P₀,   w_k = (位置 k 带因子 1 的技能时的得分 − score) / P₀,   P₀ = 300000",
-        ],
-        after: [
-          "score 是模型算出的无技能得分（撃奏ライブ场景含区间排名加成），w_k 是第 k 位成员带一个因子 1（技能值 10000，即 +100%）的普通加分技能时整局多得的分数；两者都除以测量综合力 P₀。"
-            + "技能值换算成因子时有取整（⌊值/10000 × 10⁵⌋/10⁵），各音符得分也有取整，所以上式在取整范围内成立：deck 对每个种子用一副真实技能值的随机卡组、在另一个综合力（1000003）下整局重算，偏差超过上界的谱面直接报错；现有 340 张全部通过。"
-            + "这项核对只说明上式与模拟自洽，不能说明模拟与游戏一致。",
-          "本页的卡组只有普通技能，不含成员卡的激走技能和小卡的激走支援技能，得分数值都按不带它们计算；它们的机制见第 7 节。",
-          "每首歌有三个激走任务（连击、幸运或 Just，按歌定义，各难度共用），依次对应谱面的三个 Fever 区间。Just 判定只在 Just 任务区间内开启，所以三个任务里没有 Just 的歌（85 首中 41 首：21 首全是连击、20 首全是幸运）整局都没有 Just；"
-            + "三个任务全是 Just 的有 27 首，另有 17 首连击、幸运、Just 各一个。",
-          "按本模型，激走的影响很大：与激走关闭相比，Expert 谱面的无技能得分高 1.6–4.7 倍（中位 2.4 倍）。主要来源是区间排名加成（MasterLiveGekisouRankingScoreBonus）：每个完成的区间再加上该区间得分的一个百分比，按名次查表，默认按第 1 名计；"
-            + "三个激走任务相同的歌（85 首中 68 首）为 250%，三个任务各不相同的（17 首）为 370%，多人游玩时即使是第 5 名也有 100%。按第 1 名计，Expert 谱面的 base 中有 36%–69%（中位 53%）来自它。"
-            + "其次是 Just 任务区间内的 Just 判定（230%，Perfect 为 100%）：区间长、Just 音符多的谱面倍数最高，4.7 倍的那张三个 Just 区间共约 52 秒、233 个 Just 音符；连击任务区间的激走连击系数在没有激走技能时影响很小（约 1%）。"
-            + "技能落在激走区间内时，排名加成随之放大，所以区间内的技能位权重明显更高。",
-          "幸运任务区间的抽签与幸运冲刺取自本局的随机种子。含幸运区间的谱面（340 张中 148 张）给出前 8 个公开种子的结果，本页取种子平均，并在详情里给出种子间 base 的区间（中位相差 1.3%，最大 4.2%）。"
-            + "游戏的种子规律未知，所以种子平均未必等于游戏内的真实期望。",
-        ],
+          "base = score / P₀,   w_k = (位置 k 带因子 1 的技能时的得分 − score) / P₀,   P₀ = 300000"
+        ],
+        "after": [
+          "score 是模型算出的无技能得分（撃奏ライブ场景含区间排名加成），w_k 是第 k 位成员带一个因子 1（技能值 10000，即 +100%）的普通加分技能时整局多得的分数；两者都除以测量综合力 P₀。技能值换算成因子时有取整（⌊值/10000 × 10⁵⌋/10⁵），各音符得分也有取整，所以上式在取整范围内成立：deck 对每个种子用一副真实技能值的随机卡组、在另一个综合力（1000003）下整局重算，偏差超过上界的谱面直接报错；现有 340 张全部通过。这项核对只说明上式与模拟自洽，不能说明模拟与游戏一致。",
+          "每首歌有三个激走任务（连击、幸运或 Just，按歌定义，各难度共用），依次对应谱面的三个 Fever 区间。Just 判定只在 Just 任务区间内开启，所以三个任务里没有 Just 的歌（85 首中 41 首：21 首全是连击、20 首全是幸运）整局都没有 Just；三个任务全是 Just 的有 27 首，另有 17 首连击、幸运、Just 各一个。",
+          "按本模型，激走的影响很大：与激走关闭相比，Expert 谱面的无技能得分高 1.6–4.7 倍（中位 2.4 倍）。主要来源是区间排名加成（MasterLiveGekisouRankingScoreBonus）：每个完成的区间再加上该区间得分的一个百分比，按名次查表，默认按第 1 名计；三个激走任务相同的歌（85 首中 68 首）为 250%，三个任务各不相同的（17 首）为 370%，多人游玩时即使是第 5 名也有 100%。按第 1 名计，Expert 谱面的 base 中有 36%–69%（中位 53%）来自它。其次是 Just 任务区间内的 Just 判定（230%，Perfect 为 100%）：区间长、Just 音符多的谱面倍数最高，4.7 倍的那张三个 Just 区间共约 52 秒、233 个 Just 音符；连击任务区间的激走连击系数在没有激走技能时影响很小（约 1%）。技能落在激走区间内时，排名加成随之放大，所以区间内的技能位权重明显更高。",
+          "幸运任务区间的抽签与幸运冲刺取自本局的随机种子。含幸运区间的谱面（340 张中 148 张）给出前 8 个公开种子的结果，本页取种子平均，并在详情里给出种子间 base 的区间（中位相差 1.3%，最大 4.2%）。游戏的种子规律未知，所以种子平均未必等于游戏内的真实期望。"
+        ]
       },
       {
-        title: "游玩场景与名次",
-        body: [
-          "撃奏ライブ中，每个激走区间按该区间的任务指标（连击、幸运点数或 Just 数）与房间内的其他玩家比名次，同值同名次；区间完成时，再加上该区间得分的一个百分比作为排名加成（MasterLiveGekisouRankingScoreBonus，按任务模式和名次查表，名次越靠后越少）。"
-            + "页面上三个区间的名次可以分别选 1–5，默认都是 1，即最佳情况。名次不重新模拟，而是由名次 1 的模拟线性推出：",
+        "title": "游玩场景与名次",
+        "body": [
+          "每个激走区间按任务指标（连击、幸运点数或 Just 数）决定名次，再按任务模式与名次查表加入区间得分的百分比。排行和适性允许三个区间各选 1–5 名，默认均为第 1 名；这些固定名次参考由原 Solo 区间计分方法得出，名次调整使用下式：",
+          "单局 JSON 可给出固定 Solo 名次，由完整引擎结算；外部排名输入则明确给出确认帧、区间、名次与加成百分比，采用客户端的帧快照计分。两种方式不同。本页不模拟对手、网络延迟或服务器裁定。"
         ],
-        math: [
+        "math": [
           "base_r = ( score − Σ_i B_i + Σ_i trunc( RS_i · p_i(r_i) / 100 ) ) / P₀",
-          "w_r[k] = w[k] + Σ_i ( p_i(r_i) − p_i(1) ) / 100 · u_i[k]",
-        ],
-        after: [
-          "RS_i 是区间 i 的得分，p_i(r) 是区间 i 在名次 r 时的加成百分比，B_i = trunc(RS_i · p_i(1) / 100) 是名次 1 的加成（现有数据的每个种子、每个区间都满足这个等式），u_i[k] 是位置 k 的技能让区间 i 多得的分数 ÷ P₀。"
-            + "依据：从反编译代码看，加成在区间结束时一次性记入，不改变之后音符的得分系数；名次只影响一种技能条件（7012），现有主数据里没有技能用到它。所以按本模型，换名次只改变加成这一项，w_r 的误差来自技能加成的取整，小于 3/P₀。deck 另用随机名次整局实跑核对了这组线性式，现有数据全部落在误差上界内。"
-            + "按本模型，三个区间全是第 1 名时的无技能得分是全是第 5 名时的 1.25–1.65 倍（340 张谱面，中位 1.46 倍）。",
-          "自由 Live 场景的数值来自另一次激走关闭的整局模拟，不是从撃奏ライブ减去加成得到的：关闭激走时也没有 Just、激走连击系数和幸运冲刺。关闭激走时没有幸运抽签，本页用到的技能也没有概率条件，所以每张谱面只有一个种子；"
-            + "Fever 超过 3 个、撃奏ライブ无法游玩的谱面，在自由 Live 场景照常计算。",
-          "从反编译代码看，撃奏ライブ同时上报两套分数：一套含全部激走效果（Just、幸运、激走连击、排名加成和卡上的激走技能），本页撃奏ライブ场景的数值对应这一套（卡组不带激走技能时）；另一套不含任何激走效果（激走技能也不计），存为歌曲的最高分，按本模型约等于自由 Live 的分数。谱面详情里两个数字都列出。"
-            + "服务器怎样使用这两套分数（例如计算活动积分），客户端代码里看不到。",
+          "w_r[k] = w[k] + Σ_i ( p_i(r_i) − p_i(1) ) / 100 · u_i[k]"
         ],
+        "after": [
+          "RS_i 是区间 i 的得分，p_i(r) 是区间 i 在名次 r 时的加成百分比，B_i = trunc(RS_i · p_i(1) / 100) 是名次 1 的加成（现有数据的每个种子、每个区间都满足这个等式），u_i[k] 是位置 k 的技能让区间 i 多得的分数 ÷ P₀。依据：从反编译代码看，加成在区间结束时一次性记入，不改变之后音符的得分系数；名次只影响一种技能条件（7012），现有主数据里没有技能用到它。所以按本模型，换名次只改变加成这一项，w_r 的误差来自技能加成的取整，小于 3/P₀。deck 另用随机名次整局实跑核对了这组线性式，现有数据全部落在误差上界内。按本模型，三个区间全是第 1 名时的无技能得分是全是第 5 名时的 1.25–1.65 倍（340 张谱面，中位 1.46 倍）。",
+          "自由 Live 场景的数值来自另一次激走关闭的整局模拟，不是从撃奏ライブ减去加成得到的：关闭激走时也没有 Just、激走连击系数和幸运冲刺。关闭激走时没有幸运抽签，本页用到的技能也没有概率条件，所以每张谱面只有一个种子；Fever 超过 3 个、撃奏ライブ无法游玩的谱面，在自由 Live 场景照常计算。",
+          "从反编译代码看，撃奏ライブ同时上报两套分数：一套含全部激走效果（Just、幸运、激走连击、排名加成和激走技能），本页撃奏ライブ场景的数值对应这一套（暂不含激走技能，第 7 节）；另一套不含任何激走效果（激走技能也不计），存为歌曲的最高分，按本模型约等于自由 Live 的分数。谱面详情里两个数字都列出。服务器怎样使用这两套分数（例如计算活动积分），客户端代码里看不到。"
+        ]
       },
       {
-        title: "技能顺序是随机变量",
-        body: [
-          "从反编译代码看，客户端在每局开始时构造 MemberDataContainer：先把技能顺序置为 0…n−1，再用 MemberShuffle 随机流做 Fisher–Yates 洗牌；种子取自客户端时钟，单人重试沿用同一种子（顺序也不变）。"
-            + "第 e 个技能事件触发洗牌后第 e 位成员的技能，Snap 技能的列表按同一顺序构建。因此本页把 π 当作在 5! = 120 种排列上均匀分布，卡组里的站位不是可选变量。",
+        "title": "技能顺序是随机变量",
+        "body": [
+          "从反编译代码看，客户端在每局开始时构造 MemberDataContainer：先把技能顺序置为 0…n−1，再用 MemberShuffle 随机流做 Fisher–Yates 洗牌；种子取自客户端时钟，单人重试沿用同一种子（顺序也不变）。第 e 个技能事件触发洗牌后第 e 位成员的技能，Snap 技能的列表按同一顺序构建。因此本页把 π 当作在 5! = 120 种排列上均匀分布，卡组里的站位不是可选变量。"
         ],
-        math: [
+        "math": [
           "E[S] / P = base + x̄ · W,   x̄ = (1/n) Σ_i x_i,   W = Σ_k W_k",
-          "Var[S / P] = (1/(n−1)) · Σ_i (x_i − x̄)² · Σ_k (W_k − W̄)²",
+          "Var[S / P] = (1/(n−1)) · Σ_i (x_i − x̄)² · Σ_k (W_k − W̄)²"
         ],
-        after: [
+        "after": [
           "推论一：期望只取决于技能平均值 x̄，与技能在成员间如何分配、谁在第几位无关。“最强技能放在权重最高的位置”只是 120 种排列中最好的一种，是上界，不是期望。",
-          "推论二：离散度等于技能离散度与位置权重离散度的乘积；5 个技能相同时，每一局得分都相同。按本模型，以技能 [140, 100, 60, 30, 0]% 为例，在全部 Expert 谱面上，最好与最差排列相差中位 15.4%、最大 29.2%，最佳排列比期望高中位 7.6%；激走区间让位置权重差距拉大，顺序的影响远大于不计激走时。"
-            + "页面给出期望、120 种排列的区间和 P10。",
-        ],
+          "推论二：离散度等于技能离散度与位置权重离散度的乘积；5 个技能相同时，每一局得分都相同。按本模型，以技能 [140, 100, 60, 30, 0]% 为例，在全部 Expert 谱面上，最好与最差排列相差中位 15.4%、最大 29.2%，最佳排列比期望高中位 7.6%；激走区间让位置权重差距拉大，顺序的影响远大于不计激走时。页面给出期望、120 种排列的区间和 P10。",
+          "单局计算不取 120 种顺序的平均。JSON 明确列出成员、skillOrder 与 seed；技能事件依次映射到该顺序，成员属性与配对支援仍随成员记录。相同数据与输入可以重放同一局。"
+        ]
       },
       {
-        title: "效率与支配",
-        body: ["一局耗时 T = L + c。L 有两种取法：BGM 时长（ACB cue 长度，未解码音频），或谱面长度（末音 + 1 s，也就是得分代码使用的乐曲长度）；c 是打歌以外的时间。"
-          + "实机上一局从哪一刻进入结算尚未测定，所以两种 L 都提供，结论分别成立。"],
-        math: [
-          "效率 = E[S] / (P · T) = (base + x̄ W) / (L + c)",
-          "a ≻ b  ⇔  ∀ x̄ ∈ [0, x_max], ∀ c ≥ 0:  S_a(x̄)/(L_a + c) ≥ S_b(x̄)/(L_b + c)，且至少一处严格",
+        "title": "效率与支配",
+        "body": [
+          "一局耗时 T = L + c。L 有两种取法：BGM 时长（ACB cue 长度，未解码音频），或谱面长度（末音 + 1 s，也就是得分代码使用的乐曲长度）；c 是打歌以外的时间。实机上一局从哪一刻进入结算尚未测定，所以两种 L 都提供，结论分别成立。"
         ],
-        after: [
-          "固定 x̄ 时，两边之差乘以 (L_a + c)(L_b + c) 后对 c 是线性的；固定 c 时对 x̄ 也是线性的。所以只需检查四个角点：S_a ≥ S_b 与 S_a/L_a ≥ S_b/L_b 在 x̄ = 0 和 x̄ = x_max 处成立。"
-            + "x_max = 150%，取自主数据中单个技能的最大值（MasterLiveSkillEffect，满级）。不设上界时，一些 Easy 谱面只能靠不存在的 500% 以上技能值留在前沿上。",
-          "在本模型内，前沿（不被任何谱面支配的集合）与 x̄ 和 c 无关：无论它们取何值，最优谱面都在前沿上；给定参数时的名次只是其中一种排序。"
-            + "换游玩场景、名次或 Just 率会改变各谱面的数值，前沿也可能随之变化；Great 比例对所有谱面是同一个系数，不改变前沿。现有数据中，撃奏ライブ名次 1 时两种 L 下前沿都只有 340 张里的 2 张。",
-          "比较的前提是同一卡组在两首歌上综合力相同。卡牌的曲种加成（musicType）和标签加成会使 P 随歌曲变化，这时应比较 P_a S_a 与 P_b S_b。",
+        "math": [
+          "效率 = E[S] / (P · T) = (base + x̄ W) / (L + c)",
+          "a ≻ b  ⇔  ∀ x̄ ∈ [0, x_max], ∀ c ≥ 0:  S_a(x̄)/(L_a + c) ≥ S_b(x̄)/(L_b + c)，且至少一处严格"
         ],
+        "after": [
+          "固定 x̄ 时，两边之差乘以 (L_a + c)(L_b + c) 后对 c 是线性的；固定 c 时对 x̄ 也是线性的。所以只需检查四个角点：S_a ≥ S_b 与 S_a/L_a ≥ S_b/L_b 在 x̄ = 0 和 x̄ = x_max 处成立。x_max = 150%，取自主数据中单个技能的最大值（MasterLiveSkillEffect，满级）。不设上界时，一些 Easy 谱面只能靠不存在的 500% 以上技能值留在前沿上。",
+          "上述前沿结论适用于同一理论最佳统计基线。更换场景或固定名次须重新比较；任意混合判定、断连与技能组合的单局结果不能套用同一个准率系数。",
+          "比较的前提是同一卡组在两首歌上综合力相同。卡牌的曲种加成（musicType）和标签加成会使 P 随歌曲变化，这时应比较 P_a S_a 与 P_b S_b。"
+        ]
       },
       {
-        title: "评级与活动",
-        body: [
-          "评级门槛按歌定义：MasterLiveMusic._liveScoreRankGroup 指向 MasterLiveScoreRank 的一组行，同一首歌的所有难度共用；得分达到的最高门槛就是评级。"
-            + "自由 Live 用单人门槛 R（_requiredScore）。撃奏ライブ用另一组门槛 R_battle（_battleLiveRequiredScore），按房间内全员得分之和评级：总分对比 trunc(√(5/n) · R_battle · n)（n 为未断线人数），E 计作 D。"
-            + "页面在撃奏ライブ场景下假设房间 n 人（默认 5，可选 1–5）且全员与你同分，于是你的所需分数约为 √(5/n) · R_battle；队友得分高于或低于你时，你实际需要的分数会随之变低或变高。",
-          "反编译代码中的活动积分计算如下，其中 v 由（活动，评级）查表，加成来自卡组，倍率在消耗 k 个 boost 时为 5k、不消耗时为 1：",
+        "title": "评级与活动",
+        "body": [
+          "评级门槛按歌定义：MasterLiveMusic._liveScoreRankGroup 指向 MasterLiveScoreRank 的一组行，同一首歌的所有难度共用；得分达到的最高门槛就是评级。自由 Live 用单人门槛 R（_requiredScore）。撃奏ライブ用另一组门槛 R_battle（_battleLiveRequiredScore），按房间内全员得分之和评级：总分对比 trunc(√(5/n) · R_battle · n)（n 为未断线人数），E 计作 D。页面在撃奏ライブ场景下假设房间 n 人（默认 5，可选 1–5）且全员与你同分，于是你的所需分数约为 √(5/n) · R_battle；队友得分高于或低于你时，你实际需要的分数会随之变低或变高。",
+          "反编译代码中的活动积分计算如下，其中 v 由（活动，评级）查表，加成来自卡组，倍率在消耗 k 个 boost 时为 5k、不消耗时为 1："
         ],
-        math: [
+        "math": [
           "积分 = trunc( (10000 + 加成) · 倍率 · v(活动, 评级) / 10000 )",
           "按时间:  max_s  Σ_r v(r) · Pr_s(评级 = r) / (L_s + c)",
-          "a ≻_活动 b  ⇔  L_a ≤ L_b  且  ∀ r, ∀ x̄ ∈ [0, x_max]:  S_a(x̄)/R_a(r) ≥ S_b(x̄)/R_b(r)",
+          "a ≻_活动 b  ⇔  L_a ≤ L_b  且  ∀ r, ∀ x̄ ∈ [0, x_max]:  S_a(x̄)/R_a(r) ≥ S_b(x̄)/R_b(r)"
         ],
-        after: [
-          "歌曲只通过评级进入积分，所以每个 boost 换到的积分与选哪首歌无关；歌曲的差别只在于各评级的达成概率和一局的时长。"
-            + "活动支配只要求 v 随评级不减，不需要知道积分表：满足上式时，任何卡组达成任何评级在 a 上所需的综合力都不高于 b，而 a 不更长。",
+        "after": [
+          "歌曲只通过评级进入积分，所以每个 boost 换到的积分与选哪首歌无关；歌曲的差别只在于各评级的达成概率和一局的时长。活动支配只要求 v 随评级不减，不需要知道积分表：满足上式时，任何卡组达成任何评级在 a 上所需的综合力都不高于 b，而 a 不更长。",
           "积分表可以反推，不必等主数据：一局的加成和倍率已知，所以 v = 积分 × 10000 / ((10000 + 加成) × 倍率)，截断带来的误差小于 1/倍率；每个评级一条样本就能唯一确定 v。",
-          "达成率是在 120 种技能顺序上 P · S_π ≥ R 成立的比例（S 已含第 6 节的准率近似）；所需综合力取期望，区间取最好与最差排列。"
-            + "按本模型，技能全 140%、撃奏ライブ名次 1、5 人房间时，Expert 达到 SS 所需综合力从 27 万到 205 万，相差 7.5 倍。SS 门槛对本模型的得分容量做过原点的最小二乘拟合，中位相对残差约 32%：门槛看来不是按容量定的，所以活动选曲最好逐曲计算，不宜直接拿效率排行代替。"
-            + "85 首歌里有 20 首的 Hard 比 Expert 更容易拿到 SS。",
-        ],
+          "达成率是在 120 种技能顺序上 P · S_π ≥ R 成立的比例（S 为所选场景的理论最佳基线）；所需综合力取期望，区间取最好与最差排列。按本模型，技能全 140%、撃奏ライブ名次 1、5 人房间时，Expert 达到 SS 所需综合力从 27 万到 205 万，相差 7.5 倍。SS 门槛对本模型的得分容量做过原点的最小二乘拟合，中位相对残差约 32%：门槛看来不是按容量定的，所以活动选曲最好逐曲计算，不宜直接拿效率排行代替。85 首歌里有 20 首的 Hard 比 Expert 更容易拿到 SS。"
+        ]
       },
       {
-        title: "判定与准率",
-        body: ["判定系数：Perfect 100%，Great 80%，Good 50%，Bad 与 Miss 为 0 且断连；Just 为 230%，只在撃奏ライブ的 Just 任务区间内可能出现。页面上的两个准率滑块都是近似，都不含断连："],
-        math: [
-          "g(q) = 1 − 0.2 q",
-          "X(j) = X_P + j · (X_J − X_P),   X ∈ { 不含名次加成的整局得分 N,  区间得分 RS_i }",
-          "S ≈ g(q) · [ N(j) + Σ_i trunc( RS_i(j) · p_i(r_i) / 100 ) ]",
-          "w_k ≈ g(q) · [ w_r[k] + Σ_i ( ρ_i − 1 ) · ( 1 + p_i(r_i) / 100 ) · u_i[k] ],   ρ_i = RS_i(j) / RS_i",
-        ],
-        after: [
-          "Great 比例 q 作用于所有音符：若只出现 Perfect 与 Great（不断连），且每个音符为 Great 的概率 q 与位置无关，那么普通音符与排名加成都按 g(q) 缩放，页面把这个系数乘进所有得分数值（效率、所需综合力、达成率和详情）。"
-            + "Just 区间内的音符不完全是这样：一个 Great 从 230% 降到 80%，按比例损失远大于 20%，所以 Just 区间多的谱面上这个系数偏乐观。",
-          "Just 率 j 只作用于撃奏ライブ的 Just 任务区间：deck 另做一次 Just 区间内全打 Perfect 的无技能模拟（X_P），页面在它与全 Just 的模拟（X_J）之间按 j 线性插值，名次加成按插值后的区间得分重算（第 2 节的截断公式），再乘 g(q)。"
-            + "技能位权重在各区间内的部分按同一比例 ρ_i 缩放，这也是近似。j = 100%、q = 0 时回到第 1、2 节的数值；自由 Live 没有 Just，只有 Great 比例。",
-          "断连不满足上述条件：连击系数和激走连击系数取决于当前连击数，连击任务区间还会因断连失败，断在不同位置损失不同（deck 统计尚未导出每张谱面的断连损失分布）。"
-            + "判定转换技能（12006 把 Great 转为 Perfect，13005 转为 Just）相当于降低 q；回复和护盾只在生命归零之后才影响得分（此后每个音符 × 0.3）。",
-        ],
+        "title": "判定与单局计算",
+        "body": [
+          "判定倍率为 Perfect 100%、Great 80%、Good 50%、Bad 与 Miss 0；Bad 与 Miss 断连。Just 为 230%，客户端通常在 Just 任务区间开启，判定转换技能也可能改变结果。相同比例的判定落在不同音符上，得分可能不同。",
+          "排行的准度滑块用于参考估算：Great 比例按整体得分缩放，Just 率在两种基线之间插值，不处理断连，也不能完整反映判定转换和累计技能。详情中的单局计算使用具体的逐音符判定，由 Rust 完整模拟；同一准率在不同音符位置出现，结果也可能不同。"
+        ],
+        "math": [
+          "Perfect 100% · Great 80% · Good 50% · Bad / Miss 0% · Just 230%"
+        ],
+        "after": [
+          "谱面详情的单局计算默认无技能、判定音符全 Perfect，不计分的节点保留 Pass。可逐音符修改判定；要指定普通／支援／激走技能、技能顺序、种子、名次或逐帧时间，可导出模板 JSON 后编辑并导入。未知音符、重复结果、缺失音符及非法时钟会报错，不会默补 Miss。",
+          "浏览器的 WASM 直接调用与数据工具相同的 Rust 引擎，逐帧处理判定转换、连击、生命、技能与激走结算。音频长度与计分表长度分别传入；默认模板为 60 Hz，也支持 30／120 Hz，时钟会影响发动与结算时机。结果给出同帧分数与结算计算器分数、生命、当前连击、逐帧连击峰值、转换后各判定数量及区间任务指标。",
+          "这是按明确判定流得到的该局结果。它不从触控动作推导判定，也不保证与设备上的真实触控相同。带窗口效果时须提供原始判定元数据；引擎不支持的输入或效果会报错。排行与适性仍用理论最佳统计基线，不再用 Great／Just 比例或两端插值替代这一局。"
+        ]
       },
       {
-        title: "激走技能",
-        body: [
-          "成员卡带激走技能，与它配对的小卡带激走支援技能。从反编译代码看，它们只在激走开启时建立，只加进含激走的那套分数（battleLiveScore），不进不含激走的那套（soloScore），自由 Live 里也没有。"
-            + "技能按激走任务（连击、幸运、Just，或全部）门控，只在适用任务的区间里触发，与演奏位置和洗牌无关；支援技能可以带乐队条件（条件 5000），看配对的成员是否属于指定乐队。"
-            + "ournotes-deck 的整局模拟可以带上激走技能，它们的效果（激走连击加成、幸运槽与幸运点、Just 数加成、支援技能的加分等）都逐帧计算。",
-          "本页的排行和场景得分仍不带激走技能。适性表单独显示每个激走技能或支援技能带上时的得分增量与区间指标变化，不是推荐编成。成员技能取最高等级，支援技能取小卡最高突破时的等级；计分效果参数相同的技能归为同一形状，名字合列。成员技能只给一名演奏者装备，其余位置空。支援技能挂在合成的空激走技能宿主上（负 id、没有效果行，任务与支援技能相同），不借用真卡。有乐队条件的支援技能分匹配和不匹配两种变体：宿主设为目标乐队或乐队 0。",
-        ],
-        math: [
-          "Δ(x) = P · ( Δscore / P₀ + x̄ · Σ_k Δw_k )",
-          "Δscore(r) = Δtail + Σ_i ΔrangeScore_i · (1 + p_i(r_i)/100)",
-          "Δw_k(r) = Δw_k + Σ_i (p_i(r_i) − p_i(1))/100 · ΔrangeWeights_k,i",
-        ],
-        after: [
-          "精确与近似。带上激走技能再按第 1、2、6 节的式子计算时：名次 1、全 Just、无 Great 的得分是整局模拟的结果，普通技能那部分沿用第 1 节的线性式，与不带激走技能时是同一个近似。"
-            + "名次沿用第 2 节的线性式：从反编译代码看，名次加成是区间结束时记入的一笔固定分，不改变任何得分系数，所以适性名次增量可按尾部加各区间增量乘名次系数得到，每区间有约 ±1 分的两次取整差；若没有区间交叉权重，交叉项只能按名次 1 显示并注明。"
-            + "Just 率低于 100% 时沿用第 6 节的插值，带激走技能时这是近似：转 Just（13005）、每个 Just 加分的支援技能（2001）和累计 Just（13002）对 Just 数都不是线性的。Great 比例沿用 1 − 0.2 q，同样是近似。",
-          "理论最佳打法下不起作用的技能。连击保护（12004）和 Great 转 Perfect（12006）只在出现 Great 或 Miss 时起作用，理论最佳打法下为 0，Great 比例的近似里也没有计入它们；每个音符都在准确时刻命中时，放宽 Just 判定（4004）也不起作用。"
-            + "另有一些激走技能只提高名次指标，不直接加分（Just 数加成 13000、累计 Just 13002、加幸运点 11002）：本页不模拟对手，名次由你选定，所以它们不改变本页的得分；实际对局里它们可能帮你拿到更好的名次。"
-            + "以上零效果类型已按适性数据的核对记录在全部谱面整局实跑确认；这仍是模型内部核对，不等于与游戏原生实现一致。",
-          "种子。先用 4 个种子检验确定性，各项增量完全相同则只报 1 个种子、标准误为 0。其余按 32、64、128、256、512、1024 逐级增加，直到 Δscore 标准误不超过“增量均值绝对值的 1%”与“同种子基线均值的 0.1%”中较宽的目标；到上限仍未达到就标注。普通技能交叉项至多用前 64 个种子。不同形状可用不同种子数；均值不是游戏期望，真实种子分布未知。表中 ± 仅表示原始统计量的标准误；组合后的值没有协方差数据，不显示标准误。表内 Δscore 是按相同种子、相同打法得到的差值；每位置另带单位普通技能测交叉项，随机名次与随机普通技能卡组再做 check 核对。Just 率低于 100% 且普通技能非零时，因缺少 Perfect 交叉权重，不提供完整适性增量。"
-            + "演奏位置每局洗牌，但激走技能与位置无关；洗牌只改变单个种子里概率判定的抽取次序，不改变期望。",
-          "不可相加。连击加成存在饱和，多技能增量直接相加会高估；rush 支援与幸运槽技能（11001、11003、11005）会互相放大；13005 的判定转换也可能改变其它技能的触发与收益。不能只因 13000/13002 增加 Just 计数，就认定它们会改变按 Just 判定触发的支援得分；已有一组整局实跑未见这种交互，但也不能据此推广所有组合都无交互。单技能适性不能用于推算多技能编成，两个乐队变体也不能相加。",
-          "核对现状。激走技能这一层按反编译代码逐项审计，与重写一致；整局与游戏原生代码的对照正在做，结果出来之前，这一层的数值尚在核对。按本模型得出的结论也都以此为前提。",
-        ],
+        "title": "激走技能",
+        "body": [
+          "建模了什么。成员卡带激走技能，与它配对的支援卡带激走支援技能。从反编译代码看，它们只在激走开启时建立，只加进含激走的那套分数（battleLiveScore），不进不含激走的那套（soloScore），自由 Live 里也没有。每个技能属于一种激走任务（连击、幸运或 Just），只在同任务的区间里触发，与演奏位置和洗牌无关；支援技能可以带乐队条件（条件 5000），看配对的成员是否属于指定乐队。效果按类型有激走连击加成、幸运槽倍率、加幸运点、加满槽、Just 数加成与累计 Just、幸运冲刺期间的得分加成、每 10 连击或每个 Just 的加分，以及连击保护、Great 转 Perfect、转 Just、放宽 Just 判定等，ournotes-deck 在整局模拟里逐帧计算这些效果。",
+          "名次与判定。固定名次的统计参考使用第 2 节的区间加成公式；实际单局按给定判定流运行。判定转换、每个 Just 加分与累计 Just 可能改变后续状态，不能用平均准率缩放这些效果。",
+          "理论最佳基线不能体现所有技能的收益。连击保护与判定转换需要对应的断连或判定输入，窗口放宽需要原始判定元数据；只提高任务指标的技能可能帮助真实对局取得更高名次，但固定名次参考不会自动改变名次。可用单局 JSON 核对具体输入下的效果。",
+          "种子。幸运区间的抽签取自本局的随机种子，幸运类激走技能的效果也随种子变化，所以带激走技能时幸运区间的种子间差别可能更大。页面取所给种子的平均，这不是游戏里的期望，游戏的种子规律未知。演奏位置每局洗牌，但激走技能与位置无关；洗牌只改变单个种子里概率判定的抽取次序，不改变期望。",
+          "原生覆盖按场景记录在验证表中。普通技能和不带卡上激走技能的更新链已有逐帧证据；这不代表每种卡上激走技能及所有组合都已验证。未核对的效果和条件仍是未核对。",
+          "适性只测单个技能。每个成员卡激走技能取最高等级，每个支援卡激走支援技能取最高突破时的等级；计分参数相同的技能合并成形状，乐队条件分匹配与不匹配。成员技能由一名演奏者单独携带；支援技能搭配同任务、无效果的合成空激走技能，统一测量，不借用真卡。数据缺失时显示“数据待更新”，不会当作零。排行与图表的默认基线仍不带卡上激走技能。",
+          "适性增量由同一随机种子下带与不带单个技能的整局相减得到。理论最佳、名次 1 使用 score 增量均值；普通技能倍率与名次调整使用已导出的权重和区间增量，是受取整与线性假设限制的参考。具体技能与混合判定的一局使用第 6 节的完整引擎。",
+          "多个技能的增量不能相加：激走连击系数会饱和，幸运冲刺支援与幸运槽技能存在交互，判定转换也可能改变其它效果的触发；这些不能用单技能增量拼出整副编成。适性是单个技能的响应，不是组卡结果。谱面因子列出区间判定音符、Just 音符、Just 区间只能 Perfect 的音符、End 至 Complete 的尾部音符、开始时连击及无技能抽签次数，用来解释差异。",
+          "每项 [均值, 标准误] 的标准误是样本标准差除以种子数的平方根，不是模型误差。先检查随机依赖，再做四种子探测；四次相等不能单独证明确定性。随机变体从 32 个种子逐批加倍，护栏为 65536；理论最佳与全 Perfect 两端的 score 增量都须达到目标：增量绝对值的 1% 与同种子无技能基线的 0.1% 中较宽者。可能只满足基线目标，不表示增量达到 1%。正式产物要求两端都达标，护栏内未收敛就拒绝生成。交叉项最多取前 64 个种子，缺少协方差，不能当作独立误差合成。",
+          "适性没有全 Perfect 打法的普通技能交叉权重。缺少对应权重的统计调整只能作有限精度参考；任意判定与多技能组合须交给单局计算，不能拼接端点增量。"
+        ],
+        "defs": [
+          [
+            "概率发动（条件 4011）",
+            "模型按技能随机流抽取 float32 值，再与发动门槛比较。当前主数据的条件 4011 用于幸运激走成员技能 11003 与支援技能 11005。两组真实卡与支援的原生整局核对已通过，包含发动、未发动及 5% 概率成功分支，结果见下表。给定种子的单局结果由完整模型计算；种子平均与标准误用于描述适性。普通技能输入表示无条件加分，不能用 p × 技能值替代概率效果。"
+          ]
+        ]
       },
       {
-        title: "尚未纳入的机制",
-        defs: [
-          ["其它技能类型", "music-data.json 的 deck.kinds 列出主数据里所有与因子线性相关的加分类别（效果 2000、2002、2004、2005，按持续时间、目标和条件区分），每张谱面都给出了各类别的位置权重；"
-            + "本页只用普通加分这一类。判定加分（2004，目标判定 41/46）和带条件的 2000（条件组 14、15）权重不同，需要按具体卡组逐类求和；累计加分（2001、2003）和判定转换不是线性的，只能整局模拟，激走技能与激走支援技能也是这样（第 7 节）。"],
-          ["撃奏ライブ的对手", "名次由房间里其他玩家在各区间的任务指标决定。本页不模拟对手，而是让你直接选名次（名次 1 为最佳情况）；同值时加成表按哪一种名次查尚未完全核实，直接选名次时不受影响。房间不满 5 人时服务器是否补位，客户端代码里看不到。游戏没有协力模式。"],
-          ["Snap 技能（普通支援技能）", "跟随所属成员一起被洗牌；效果多由条件触发（成员乐队、生命、判定数等），取决于具体卡组，本页不计入。条件在整局都满足的加分，相当于在 base 上乘 (1 + y)。小卡的激走支援技能另算，见第 7 节。"],
-          ["概率发动（条件 4011）", "若发动概率 p 与其它量独立，它的期望贡献等于把该技能值换成 p · x，可以直接填进技能输入；方差会比表中给出的更大。"],
-          ["实机一局耗时", "进入结算的时刻、加载时间都依赖设备和网络，由每局额外耗时 c 表示；支配关系对所有 c ≥ 0 成立。"],
-          ["核对范围", "本页的数值不是直接运行游戏代码得到的：ournotes-deck 是我们照反编译代码重写的模拟，每张谱面的整局都由它计算。"
-            + "游戏自己的函数用于分块核对这份重写：在 ARM64 模拟器里单独运行客户端的相关函数（计分、技能的发动与结束、激走连击等），和重写的实现逐例比较，已核对的部分没有发现差异。"
-            + "原生整局已跑通谱面 10000201：综合力 300000、无技能、激走关闭，364 次 Perfect 的音符 ID、时刻与帧均与理论输入一致，终分 1063422 与 deck 一致。这只核对了一张谱面的输入与终分；逐帧分数、技能与激走尚未完成核对，环境仍有 Unity 及外部依赖替身，不能据此认定模型与游戏全面等价。未核对的部分可能有错，也尚未与实机成绩逐局核对。"
-            + "激走技能这一层（第 7 节）：按反编译代码逐项审计，与重写一致；整局与原生代码的对照正在做，结果出来之前尚在核对。"
-            + "判定窗口类技能（4000–4003、13001）尚未接入整局模拟，另有少数激走条件只有合成测试；本页只用普通加分技能，不受这两项影响，激走技能可能用到这些条件，这也在上面的“尚在核对”之内。游戏更新或热更新补丁也可能改变这些规则。"],
-        ],
+        "title": "统计表的范围",
+        "defs": [
+          [
+            "其它技能类型",
+            "统计表的 deck.kinds 列出与因子线性相关的加分类别（2000、2002、2004、2005），本页倍率输入只用普通加分。累计加分、判定转换、支援与激走技能的具体组合需完整模拟，可在单局 JSON 中提供模型支持的技能 ID、等级及成员属性；未知 ID 或不支持的效果会报错。"
+          ],
+          [
+            "撃奏ライブ的对手",
+            "本页不推演房间内其他玩家的任务指标。统计参考直接选择固定名次；单局的外部排名必须显式输入确认。线上同分顺序、掉线、补位与服务器结算不能由固定名次结果推断。"
+          ],
+          [
+            "Snap 技能",
+            "统计表不计 Snap 技能的具体条件组合。单局可明确提供配对支援技能与成员属性，完整引擎按生命、判定数、乐队等条件逐帧处理。"
+          ],
+          [
+            "实机一局耗时",
+            "进入结算的时刻、加载时间都依赖设备和网络，由每局额外耗时 c 表示；支配关系对所有 c ≥ 0 成立。"
+          ]
+        ]
       },
       {
-        title: "谱面事实的口径",
-        defs: [
-          ["等级", "显示等级（_musicScoreDisplayLevel，可带小数）；得分使用整数等级（_musicScoreLevel）。"],
-          ["Notes", "判定音符数，也就是全连连击数；不含隐藏音符、导引终点和不判定的长条节点。音符构成按 NoteOperateType 归类：点击 {1, 101}、划键 {40, 41, 42, 102}、长条 {20, 21, 22}、追踪 {60–63, 104, 105}、连击节点 {120}。"],
-          ["主 BPM、密度", "主 BPM 是第一个到最后一个判定音符之间持续时间最长的 BPM；密度 = 判定音符数 ÷ 这段区间的秒数。"],
-          ["基础系数、W、跳过系数", "base 与 W 定义见第 1、3 节：撃奏ライブ场景下 base 含所选名次的激走区间排名加成，自由 Live 场景没有；两者都按准率缩放。跳过系数是跳过时每点综合力的得分（全部按 Great、连击为 0、无技能），与时长无关，本页不随场景变化。"],
-          ["与其它资料不一致时", "本页的数值来自我们对反编译代码的理解，没有官方资料可以对照，可能有错；和其它站点、工具或实机结果不一致时，请优先相信它们。"
-            + "口径不同（时长的取法、游玩场景与名次、准率、卡组设定、是否带激走技能）也会带来差别，可以先把页面上的参数调成对方的设定再比较。"],
-        ],
+        "title": "谱面事实的口径",
+        "defs": [
+          [
+            "等级",
+            "显示等级（_musicScoreDisplayLevel，可带小数）；得分使用整数等级（_musicScoreLevel）。"
+          ],
+          [
+            "Notes",
+            "判定音符数，也就是全连连击数；不含隐藏音符、导引终点和不判定的长条节点。音符构成按 NoteOperateType 归类：点击 {1, 101}、划键 {40, 41, 42, 102}、长条 {20, 21, 22}、追踪 {60–63, 104, 105}、连击节点 {120}。"
+          ],
+          [
+            "主 BPM、密度",
+            "主 BPM 是第一个到最后一个判定音符之间持续时间最长的 BPM；密度 = 判定音符数 ÷ 这段区间的秒数。"
+          ],
+          [
+            "基础系数、W、跳过系数",
+            "base 与 W 定义见第 1、3 节，均属于所选场景的理论最佳统计基线：激走开启时含固定名次的区间加成，自由 Live 没有。跳过系数是每点综合力的跳过得分（全部 Great、连击为 0、无技能），与时长无关，本页不随场景变化。"
+          ]
+        ]
       },
+      {
+        "title": "原生代码核对",
+        "body": [],
+        "table": {
+          "headers": [
+            "场景 / 输入",
+            "实际核对内容",
+            "结果",
+            "尚未核对的情况"
+          ],
+          "rows": [
+            [
+              "10000201；综合力 300000；无技能；激走关闭",
+              "5500 帧、13 字段、71500 项比较；364 次判定事件",
+              "零差异；六项 float32 因子逐位相等",
+              "全新无回退流程；模拟器最大连击不等于受保护的 live 最大连击"
+            ],
+            [
+              "五成员普通技能 1；全 Perfect 与混合 P/Great/Good/Bad/Miss",
+              "每例 5500 帧、253000 项核心比较；原生 SkillExecutor 触发、池、阶段与应用分派",
+              "零差异；float32 最大 ULP 为 0",
+              "只覆盖无条件 2000 家族；排除 elapsed 镜像；并非完整游戏生命周期"
+            ],
+            [
+              "真实技能 1/4/6/7/5；高/中/低准度 × 30/60/120 fps",
+              "九组共 57750 帧；35 个效果池实例；18826500 项核心比较；谱面事件与转换判定同序",
+              "零差异；float32 最大 ULP 为 0",
+              "覆盖指定目标与生命条件，未覆盖全部技能或输入窗口"
+            ],
+            [
+              "非零逐音符击打偏移",
+              "原生实际 P274 / Great58 / Good32；5500 帧、1793000 项核心比较",
+              "零差异；float32 最大 ULP 为 0",
+              "原生自动输入窗口分类；Rust 仍消费原生判定，不是独立触摸重放"
+            ],
+            [
+              "生命条件边界 700→600",
+              "5500 帧；45 个效果池实例；2288000 项核心比较",
+              "零差异；float32 最大 ULP 为 0",
+              "700 时选择高生命效果；降至 600 后已有效果继续，不切换低生命效果"
+            ],
+            [
+              "真实高等级技能 3/5/1/2/7，等级 5",
+              "5500 帧、1545500 项核心比较；覆盖实际 float32 技能因子",
+              "零差异；已比较 float32 最大 ULP 为 0",
+              "限定此技能组合；13000 的转换结果为 1.29999…，不能手填成 1.3"
+            ],
+            [
+              "真实卡上激走与支援；八组高中低准度及 30/60/120 fps",
+              "48750 帧、35777250 项比较；效果池、转换判定、连击保护、累计 Just、幸运槽与 rush",
+              "声明字段零差异；float32 逐位一致",
+              "指定卡与支援配置；成员综合力相关效果、完整失败与结算转场另需核对"
+            ],
+            [
+              "Just 动态窗口；发布模型的公共 API",
+              " 1600 帧原生捕获；9 类窗口、39 个 unit；388800 项窗口及 62400 项核心比较",
+              "451200 项零差异；启闭与窗口宽度均相同",
+              "窗口状态与宽度、计分、生命和当前连击；输入为已分类判定"
+            ],
+            [
+              "概率发动 4011；真实成员卡 43 / 支援 66；高生命与生命 600 + 4 Miss",
+              "两组共 15000 帧、10680000 项核心比较；72 项随机值、门槛与布尔结果核对",
+              "零差异；终分分别 2835163 / 2760861",
+              "seed 14 定向覆盖 5% 成功分支；这是固定输入核对，不是概率分布测量"
+            ],
+            [
+              "单人激走：连击 / Just / 幸运；无卡上技能",
+              "10000103 / 10000201 / 10000303；19000 帧、646000 项整数比较",
+              "所列双分数、生命、连击、随机次数及区间状态零差异",
+              "部分区间计数与 float32 字段尚缺同义对应；帧分数观察与 score() 分开"
+            ],
+            [
+              "离线多人：连击 / Just / 幸运；实际混判及生命归零",
+              "19000 帧、646000 项核心比较；76000 项排名推导比较另列",
+              "零差异；幸运场景实际原生随机抽取 431 次",
+              "无卡上技能、独立触摸窗口、完整失败转场或服务器奖励；排名推导字段不是生产观察接口"
+            ],
+            [
+              "原生多人排名",
+              "572 组调用案例，含同分、次指标、缺输入与错误边界",
+              "15259 项精确比较，零差异",
+              "是子系统测试，不是 572 局；同分组内原始成员顺序不属 Rust API 承诺"
+            ],
+            [
+              "挑战 Live：无辅助 / FullCombo / AllPerfect；实际混判",
+              "三组 5858 帧、1382503 项核心比较；原生进入、更新与退出",
+              "声明字段零差异；另核对 Bad / Good 导致的原生重试分支",
+              "重试条件为原生端观察；动画采用零延迟完成，未核对完整结算页或服务器"
+            ],
+            [
+              "Mission / SoloGekisou；混判、断连与生命归零",
+              "5502 帧、1469049 项核心比较；22008 项排名推导比较另列",
+              "零差异；终分 439015；同帧显示分与计分器分数分别核对",
+              "未核对完整结果页/服务器；派生排名不是独立的生产观察字段"
+            ],
+            [
+              "自由 / 单人激走 / 挑战 / 任务 / 多人 / Arena / 教程",
+              "执行七种原生设置入口及谱面、启动分支",
+              "仅入口证据；全模式覆盖仍待完成",
+              "进入模式不等于整局通过；真实活动、Arena master 与服务器生命周期另需验证"
+            ]
+          ],
+          "caption": "客户端 1.0.1-25 · 核对记录 2026-09-30"
+        },
+        "after": [
+          "表中核对的整数全部相等，float32 按位一致。模型通过 272 项回归测试，逐音符计算的 Rust 与 WASM 结果也已在全部 340 张谱面核对一致。"
+        ]
+      }
     ],
+    "reminder": {
+      "title": "与其它资料不一致时",
+      "text": "比较时请对齐版本、谱面、场景、综合力、判定流、技能、顺序、种子和帧时钟；反馈差异时请附输入 JSON 与结果。统计采样误差、有限精度参考与原生核对范围各见上文。",
+      "priority": "当你发现和其他资料不一致时，那就是其他资料是对的。"
+    },
+    "contentsLabel": "目录",
+    "methodsLabel": "核对方法与尚未覆盖的情况",
+    "method": {
+      "title": "来源与核对方法",
+      "text": "谱面与主数据来自游戏资源，经 nnnotes 提取；数值由 ournotes-deck 的 Rust 模型计算。我们在离线 ARM64 模拟器 Unicorn 中直接运行游戏客户端的 libil2cpp 二进制，固定谱面、技能、种子和帧时钟，与 Rust 模型逐帧核对计分、生命、连击、技能与排名。文件、音频、显示和 Unity JSON 对象装配使用替身，计分运算仍执行原生指令。表中核对的整数完全相等、float32 按位一致，说明模型在这些条件下重现了客户端的计算；范围不包含真实设备或服务器结算。"
+    }
   },
-  en: {
-    title: "Definitions, derivations and conditions",
-    lead: "The figures on this page are sourced from the game client's decompiled code: ournotes-deck simulates every chart's whole live (once with Gekisou on, once off) after the score logic read from it, and the results are music-data.json's deck statistics. "
-      + "The simulation is our own program, rewritten after the decompiled code; it does not run the game's code in an emulator. The game's own functions check the rewrite piece by piece, with an additional whole-live input and final-score check for one chart (see Scope of the checks under the mechanisms left out). "
-      + "We aim for them to be correct but cannot guarantee it: our reading of the decompiled code, the model's simplifications and the data version can all be wrong. Where this page disagrees with other sites, tools or real plays, the mistake is most likely ours; trust them. "
-      + "Below: each quantity's definition, derivation and conditions; the mechanisms the model leaves out have their own section.",
-    sections: [
+  "en": {
+    "title": "Definitions, derivations and conditions",
+    "lead": "Rankings and aptitude show statistical references for theoretical best play. Chart details can also calculate one play from per-note inputs. Both use the same ournotes-deck Rust model; the native frame checks are listed below.",
+    "sections": [
       {
-        title: "Score model",
-        body: [
-          "The page's score figures follow the play scenario chosen (section 2). The default is the best case of Gekisou Live (撃奏ライブ, the multiplayer mode of up to 5 players): Gekisou on, the fevers with the song's Gekisou missions make the Gekisou ranges, and all three ranges take the rank-1 bonus. The other scenario is Free Live: by the decompiled code, Free Live and Challenge Live play without Gekisou (solo Gekisou is a debug switch with no way in in the release), and by this model solo scores are much lower. "
-            + "Both are simulated in theoretical best play: every judged note hit at its exact time, a full combo, life never at zero; in Gekisou Live Just inside the Gekisou Just mission ranges and Perfect elsewhere. Section 6 has the accuracy approximations. "
-            + "The live is simulated frame by frame after the decompiled code (ournotes-deck live::full): frames, score frames (40 ms), combo and Gekisou combo factors, the skills' execute and finish frames. The page's deck model is the plain score-up skill: effect 2000, 5 s, the whole deck, no condition. A deck scores",
+        "title": "Score model",
+        "body": [
+          "Rankings and charts use the selected scenario’s theoretical best baseline: with Gekisou on, Just inside Just missions and Perfect elsewhere, all ranges at rank 1 by default; Free Live disables Gekisou and uses Perfect throughout. The baseline has a full combo, life above zero and no card Gekisou skills. The single-play calculator runs your per-note judgements, skill order and seed again; section 6 explains its inputs. ournotes-deck live::full processes the whole live frame by frame, with 40 ms score frames. The statistics use ordinary effect 2000: 5 seconds, all members, no condition. A deck scores"
         ],
-        math: [
+        "math": [
           "S = P · ( base + Σ_k x_{π(k)} · w_k )",
-          "base = score / P₀,   w_k = (score with a factor-1 skill at position k − score) / P₀,   P₀ = 300000",
-        ],
-        after: [
-          "score is the model's no-skill score (in Gekisou Live with the range rank bonuses), w_k the score a factor-1 plain skill (value 10000, +100 %) on the member at position k adds over the whole live; both per point of the measurement power P₀. "
-            + "The value becomes a factor with a floor (⌊value/10000 × 10⁵⌋/10⁵) and every note score is floored, so the formula holds up to the floors: for every seed deck plays a random deck of real skill values at another power (1000003) through the whole live, and a chart whose deviation exceeds the bound fails. All 340 current charts pass. "
-            + "This check only shows that the formula agrees with the simulation, not that the simulation agrees with the game.",
-          "The page's decks have plain skills only, no member Gekisou skills and no snap Gekisou support skills, and every score figure is without them; section 7 has how they work.",
-          "Every song has three Gekisou missions (combo, luck or Just, set per song and shared by every difficulty), one for each of the chart's three fevers in order. Just judgements are only on inside Just mission ranges, so the songs without a Just mission (41 of 85: 21 all combo, 20 all luck) have no Just all live; "
-            + "27 songs have three Just missions, and 17 have one each of combo, luck and Just.",
-          "By this model Gekisou weighs a lot: against Gekisou off, an Expert chart's no-skill score is 1.6–4.7 times higher (median 2.4). Most of it is the range rank bonus (MasterLiveGekisouRankingScoreBonus): every completed range adds a percentage of its own score, looked up by rank, rank 1 by default; "
-            + "that is 250 % on the songs whose three missions are the same (68 of 85) and 370 % on those whose three missions all differ (17), and in multiplayer even rank 5 gets 100 %. At rank 1 it makes 36–69 % (median 53 %) of an Expert chart's base. "
-            + "Next come the Just judgements inside Just mission ranges (230 %, against 100 % for a Perfect): charts with long ranges and many Just notes gain the most, and the 4.7 times chart has three Just ranges of about 52 s in all with 233 Just notes; the Gekisou combo factor of combo mission ranges matters little without Gekisou skills (about 1 %). "
-            + "A skill inside a Gekisou range raises the rank bonus too, so the positions inside ranges weigh much more.",
-          "Luck mission ranges draw their lottery and luck rushes from the live's random seed. Charts with a luck range (148 of 340) come with the first 8 published seeds; the page takes the mean over the seeds and shows the seeds' base range in the details (1.3 % apart at the median, 4.2 % at most). "
-            + "The game's seed law is unknown, so the seed mean need not equal the game's own expectation.",
-        ],
+          "base = score / P₀,   w_k = (score with a factor-1 skill at position k − score) / P₀,   P₀ = 300000"
+        ],
+        "after": [
+          "score is the model's no-skill score (in Gekisou Live with the range rank bonuses), w_k the score a factor-1 plain skill (value 10000, +100 %) on the member at position k adds over the whole live; both per point of the measurement power P₀. The value becomes a factor with a floor (⌊value/10000 × 10⁵⌋/10⁵) and every note score is floored, so the formula holds up to the floors: for every seed deck plays a random deck of real skill values at another power (1000003) through the whole live, and a chart whose deviation exceeds the bound fails. All 340 current charts pass. This check only shows that the formula agrees with the simulation, not that the simulation agrees with the game.",
+          "Every song has three Gekisou missions (combo, luck or Just, set per song and shared by every difficulty), one for each of the chart's three fevers in order. Just judgements are only on inside Just mission ranges, so the songs without a Just mission (41 of 85: 21 all combo, 20 all luck) have no Just all live; 27 songs have three Just missions, and 17 have one each of combo, luck and Just.",
+          "By this model Gekisou weighs a lot: against Gekisou off, an Expert chart's no-skill score is 1.6–4.7 times higher (median 2.4). Most of it is the range rank bonus (MasterLiveGekisouRankingScoreBonus): every completed range adds a percentage of its own score, looked up by rank, rank 1 by default; that is 250 % on the songs whose three missions are the same (68 of 85) and 370 % on those whose three missions all differ (17), and in multiplayer even rank 5 gets 100 %. At rank 1 it makes 36–69 % (median 53 %) of an Expert chart's base. Next come the Just judgements inside Just mission ranges (230 %, against 100 % for a Perfect): charts with long ranges and many Just notes gain the most, and the 4.7 times chart has three Just ranges of about 52 s in all with 233 Just notes; the Gekisou combo factor of combo mission ranges matters little without Gekisou skills (about 1 %). A skill inside a Gekisou range raises the rank bonus too, so the positions inside ranges weigh much more.",
+          "Luck mission ranges draw their lottery and luck rushes from the live's random seed. Charts with a luck range (148 of 340) come with the first 8 published seeds; the page takes the mean over the seeds and shows the seeds' base range in the details (1.3 % apart at the median, 4.2 % at most). The game's seed law is unknown, so the seed mean need not equal the game's own expectation."
+        ]
       },
       {
-        title: "Play scenarios and ranks",
-        body: [
-          "In Gekisou Live every Gekisou range ranks the players of the room by that range's mission measure (combo, luck points or Just count), equal values sharing a rank; a completed range adds a percentage of its own score as the rank bonus (MasterLiveGekisouRankingScoreBonus, looked up by mission mode and rank, smaller for lower ranks). "
-            + "The page takes a rank 1–5 for each of the three ranges, rank 1 everywhere by default, the best case. The ranks are not simulated again but follow from the rank-1 simulation linearly:",
+        "title": "Play scenarios and ranks",
+        "body": [
+          "Each Gekisou range awards a percentage of its score using the mission pattern and placement derived from combo, luck points or Just count. Rankings and aptitude let you select rank 1–5 for each range, rank 1 by default. These fixed-rank references use the original Solo range scoring method; the statistical adjustment is:",
+          "A single-play JSON can specify fixed Solo ranks and let the complete engine settle them. External ranking instead supplies the confirmation frame, range, group rank and bonus percentage, using client frame snapshots. These are different inputs. The page does not simulate opponents, network delays or server decisions."
         ],
-        math: [
+        "math": [
           "base_r = ( score − Σ_i B_i + Σ_i trunc( RS_i · p_i(r_i) / 100 ) ) / P₀",
-          "w_r[k] = w[k] + Σ_i ( p_i(r_i) − p_i(1) ) / 100 · u_i[k]",
-        ],
-        after: [
-          "RS_i is range i's score, p_i(r) range i's bonus percent at rank r, B_i = trunc(RS_i · p_i(1) / 100) the rank-1 bonus (every range of every seed of the current data meets this), and u_i[k] the score the skill at position k adds to range i, per P₀. "
-            + "Why: by the decompiled code the bonus is added once at the range's end and leaves the score factors of the notes after it alone, and the rank reaches one skill condition only (7012), which no skill of the current master data uses. So by this model a rank changes the bonus term only; w_r is off by the skill floors, less than 3/P₀. deck also runs whole lives at random ranks against these formulas, and the current data stays within the error bound. "
-            + "By this model the no-skill score at rank 1 in all three ranges is 1.25–1.65 times that at rank 5 (340 charts, median 1.46).",
-          "The Free Live figures come from a separate whole-live simulation with Gekisou off, not from Gekisou Live minus the bonuses: without Gekisou there are no Just judgements, Gekisou combo factor or luck rushes either. Without Gekisou there is no luck lottery, and the page's skill has no probability condition, so every chart has one seed; "
-            + "charts with more than 3 fevers, unplayable in Gekisou Live, are computed as usual in Free Live.",
-          "By the decompiled code, Gekisou Live reports two scores: one with every Gekisou effect (Just, luck, the Gekisou combo, the rank bonuses and the cards' Gekisou skills), which the page's Gekisou Live figures stand for (with a deck without Gekisou skills); the other without any Gekisou effect (no Gekisou skills either), kept as the song's best score, by this model about the Free Live score. The chart details show both. "
-            + "How the server uses the two (for event points, say) is not in the client code.",
+          "w_r[k] = w[k] + Σ_i ( p_i(r_i) − p_i(1) ) / 100 · u_i[k]"
         ],
+        "after": [
+          "RS_i is range i's score, p_i(r) range i's bonus percent at rank r, B_i = trunc(RS_i · p_i(1) / 100) the rank-1 bonus (every range of every seed of the current data meets this), and u_i[k] the score the skill at position k adds to range i, per P₀. Why: by the decompiled code the bonus is added once at the range's end and leaves the score factors of the notes after it alone, and the rank reaches one skill condition only (7012), which no skill of the current master data uses. So by this model a rank changes the bonus term only; w_r is off by the skill floors, less than 3/P₀. deck also runs whole lives at random ranks against these formulas, and the current data stays within the error bound. By this model the no-skill score at rank 1 in all three ranges is 1.25–1.65 times that at rank 5 (340 charts, median 1.46).",
+          "The Free Live figures come from a separate whole-live simulation with Gekisou off, not from Gekisou Live minus the bonuses: without Gekisou there are no Just judgements, Gekisou combo factor or luck rushes either. Without Gekisou there is no luck lottery, and the page's skill has no probability condition, so every chart has one seed; charts with more than 3 fevers, unplayable in Gekisou Live, are computed as usual in Free Live.",
+          "By the decompiled code, Gekisou Live reports two scores: one with every Gekisou effect (Just, luck, the Gekisou combo, the rank bonuses and the Gekisou skills), which the page's Gekisou Live figures stand for (without the Gekisou skills for now, section 7); the other without any Gekisou effect (Gekisou skills included), kept as the song's best score, by this model about the Free Live score. The chart details show both. How the server uses the two (for event points, say) is not in the client code."
+        ]
       },
       {
-        title: "The skill order is random",
-        body: [
-          "From the decompiled code: at the start of every live the client builds MemberDataContainer; the skill order is set to 0…n−1 and Fisher–Yates shuffled with the MemberShuffle random stream, seeded from the client clock (a solo retry keeps the seed, and the order). "
-            + "Skill event e fires the member at position e of the shuffled order, and the snap skill lists follow the same order. So the page takes π as uniform over the 5! = 120 orders; the deck's slot order is not a choice.",
+        "title": "The skill order is random",
+        "body": [
+          "From the decompiled code: at the start of every live the client builds MemberDataContainer; the skill order is set to 0…n−1 and Fisher–Yates shuffled with the MemberShuffle random stream, seeded from the client clock (a solo retry keeps the seed, and the order). Skill event e fires the member at position e of the shuffled order, and the snap skill lists follow the same order. So the page takes π as uniform over the 5! = 120 orders; the deck's slot order is not a choice."
         ],
-        math: [
+        "math": [
           "E[S] / P = base + x̄ · W,   x̄ = (1/n) Σ_i x_i,   W = Σ_k W_k",
-          "Var[S / P] = (1/(n−1)) · Σ_i (x_i − x̄)² · Σ_k (W_k − W̄)²",
+          "Var[S / P] = (1/(n−1)) · Σ_i (x_i − x̄)² · Σ_k (W_k − W̄)²"
         ],
-        after: [
+        "after": [
           "First: the expectation depends on the mean skill value only, not on how the values are spread over members or who stands where. The strongest skill on the heaviest position is the best of the 120 orders, an upper bound, not the expectation.",
-          "Second: the spread is the product of the skills' spread and the position weights' spread; five equal skills score the same every live. By this model, with skills [140, 100, 60, 30, 0] % over every Expert chart, the best and the worst order differ by 15.4 % at the median and 29.2 % at most, and the best order is 7.6 % (median) above the expectation; the Gekisou ranges pull the position weights apart, so the order matters far more than without Gekisou. "
-            + "The page shows the expectation, the range over the 120 orders and P10.",
-        ],
+          "Second: the spread is the product of the skills' spread and the position weights' spread; five equal skills score the same every live. By this model, with skills [140, 100, 60, 30, 0] % over every Expert chart, the best and the worst order differ by 15.4 % at the median and 29.2 % at most, and the best order is 7.6 % (median) above the expectation; the Gekisou ranges pull the position weights apart, so the order matters far more than without Gekisou. The page shows the expectation, the range over the 120 orders and P10.",
+          "A single play does not average the 120 orders. Its JSON specifies performers, skillOrder and seed. Chart skill events map to that order; member attributes and paired supports remain with their performer record. The same data and inputs replay the same play."
+        ]
       },
       {
-        title: "Efficiency and dominance",
-        body: ["A play takes T = L + c: L is the BGM length (the ACB cue length, audio not decoded) or the chart length (last note + 1 s, the music length of the score code), c the time outside the song. "
-          + "When a live hands over to the results on a device is not measured yet, so both L are offered and every result holds for each."],
-        math: [
-          "efficiency = E[S] / (P · T) = (base + x̄ W) / (L + c)",
-          "a ≻ b  ⇔  ∀ x̄ ∈ [0, x_max], ∀ c ≥ 0:  S_a(x̄)/(L_a + c) ≥ S_b(x̄)/(L_b + c), strictly somewhere",
+        "title": "Efficiency and dominance",
+        "body": [
+          "A play takes T = L + c: L is the BGM length (the ACB cue length, audio not decoded) or the chart length (last note + 1 s, the music length of the score code), c the time outside the song. When a live hands over to the results on a device is not measured yet, so both L are offered and every result holds for each."
         ],
-        after: [
-          "For a fixed x̄ the difference times (L_a + c)(L_b + c) is linear in c, and for a fixed c it is linear in x̄, so four corners decide: S_a ≥ S_b and S_a/L_a ≥ S_b/L_b at x̄ = 0 and at x̄ = x_max. "
-            + "x_max = 150 %, the largest single skill value in the master data (MasterLiveSkillEffect, level 5). Without a bound, some Easy charts stay on the frontier only for skill values above 500 %, which do not exist.",
-          "Within this model the frontier (the charts nothing beats) does not depend on x̄ and c: for any of them the best chart is on it; a ranking for given parameters is one ordering of it. "
-            + "Another play scenario, rank or Just rate changes every chart's figures, and the frontier may change with them; the Great share is one factor for every chart and leaves it alone. On the current data, Gekisou Live at rank 1, the frontier holds 2 of the 340 charts for either L.",
-          "The comparison assumes the deck has the same power on both songs. Card song-type (musicType) and tag bonuses make P depend on the song; then compare P_a S_a with P_b S_b.",
+        "math": [
+          "efficiency = E[S] / (P · T) = (base + x̄ W) / (L + c)",
+          "a ≻ b  ⇔  ∀ x̄ ∈ [0, x_max], ∀ c ≥ 0:  S_a(x̄)/(L_a + c) ≥ S_b(x̄)/(L_b + c), strictly somewhere"
         ],
+        "after": [
+          "For a fixed x̄ the difference times (L_a + c)(L_b + c) is linear in c, and for a fixed c it is linear in x̄, so four corners decide: S_a ≥ S_b and S_a/L_a ≥ S_b/L_b at x̄ = 0 and at x̄ = x_max. x_max = 150 %, the largest single skill value in the master data (MasterLiveSkillEffect, level 5). Without a bound, some Easy charts stay on the frontier only for skill values above 500 %, which do not exist.",
+          "This frontier result applies to one theoretical-best statistical baseline. A different scenario or fixed rank needs a new comparison. Arbitrary mixed judgements, breaks and skill combinations cannot share one accuracy multiplier.",
+          "The comparison assumes the deck has the same power on both songs. Card song-type (musicType) and tag bonuses make P depend on the song; then compare P_a S_a with P_b S_b."
+        ]
       },
       {
-        title: "Score ranks and events",
-        body: [
-          "Rank thresholds are per song: MasterLiveMusic._liveScoreRankGroup selects rows of MasterLiveScoreRank, shared by every difficulty; the rank is the highest threshold the score reaches. "
-            + "Free Live uses the solo threshold R (_requiredScore). Gekisou Live has thresholds of its own, R_battle (_battleLiveRequiredScore), and rates the sum of every player's score in the room against trunc(√(5/n) · R_battle · n) for n connected players, E counting as D. "
-            + "In Gekisou Live the page takes a room of n players (5 by default, 1–5) who all score the same as you, so you need about √(5/n) · R_battle; teammates scoring above or below you lower or raise what you actually need.",
-          "In the decompiled code event points are computed as below; v comes from the (event, rank) table, the bonus from the deck, and the rate is 5k for k boosts spent, 1 for none:",
+        "title": "Score ranks and events",
+        "body": [
+          "Rank thresholds are per song: MasterLiveMusic._liveScoreRankGroup selects rows of MasterLiveScoreRank, shared by every difficulty; the rank is the highest threshold the score reaches. Free Live uses the solo threshold R (_requiredScore). Gekisou Live has thresholds of its own, R_battle (_battleLiveRequiredScore), and rates the sum of every player's score in the room against trunc(√(5/n) · R_battle · n) for n connected players, E counting as D. In Gekisou Live the page takes a room of n players (5 by default, 1–5) who all score the same as you, so you need about √(5/n) · R_battle; teammates scoring above or below you lower or raise what you actually need.",
+          "In the decompiled code event points are computed as below; v comes from the (event, rank) table, the bonus from the deck, and the rate is 5k for k boosts spent, 1 for none:"
         ],
-        math: [
+        "math": [
           "points = trunc( (10000 + bonus) · rate · v(event, rank) / 10000 )",
           "by time:  max_s  Σ_r v(r) · Pr_s(rank = r) / (L_s + c)",
-          "a ≻_event b  ⇔  L_a ≤ L_b  and  ∀ r, ∀ x̄ ∈ [0, x_max]:  S_a(x̄)/R_a(r) ≥ S_b(x̄)/R_b(r)",
+          "a ≻_event b  ⇔  L_a ≤ L_b  and  ∀ r, ∀ x̄ ∈ [0, x_max]:  S_a(x̄)/R_a(r) ≥ S_b(x̄)/R_b(r)"
         ],
-        after: [
-          "The song enters the points only through the rank, so the points a boost buys do not depend on the song; songs differ only in their rank chances and their length. "
-            + "Event dominance needs no point table, only v non-decreasing in the rank: when it holds, any deck needs no more power on a than on b for any rank, and a is no longer.",
+        "after": [
+          "The song enters the points only through the rank, so the points a boost buys do not depend on the song; songs differ only in their rank chances and their length. Event dominance needs no point table, only v non-decreasing in the rank: when it holds, any deck needs no more power on a than on b for any rank, and a is no longer.",
           "The table can be recovered without the master data: bonus and rate of a live are known, so v = points × 10000 / ((10000 + bonus) × rate) with a truncation error below 1/rate; one result per rank determines v.",
-          "The chance is the share of the 120 skill orders with P · S_π ≥ R (S with the accuracy approximation of section 6); the power needed uses the expectation, its range the best and the worst order. "
-            + "By this model, with every skill at 140 %, in Gekisou Live at rank 1 in a room of 5, SS on Expert needs 0.27 to 2.05 million power, a factor 7.5. A least-squares fit through the origin of the SS thresholds against this model's score capacity leaves a median relative residual of about 32 %: the thresholds do not seem to be set by capacity, so event choices are best computed song by song rather than read straight off the efficiency ranking. "
-            + "For 20 of the 85 songs SS is easier on Hard than on Expert.",
-        ],
+          "The chance is the share of the 120 skill orders with P · S_π ≥ R (S from the selected theoretical-best baseline); the power needed uses the expectation, its range the best and the worst order. By this model, with every skill at 140 %, in Gekisou Live at rank 1 in a room of 5, SS on Expert needs 0.27 to 2.05 million power, a factor 7.5. A least-squares fit through the origin of the SS thresholds against this model's score capacity leaves a median relative residual of about 32 %: the thresholds do not seem to be set by capacity, so event choices are best computed song by song rather than read straight off the efficiency ranking. For 20 of the 85 songs SS is easier on Hard than on Expert."
+        ]
       },
       {
-        title: "Judgements and accuracy",
-        body: ["Judgement factors: Perfect 100 %, Great 80 %, Good 50 %, Bad and Miss 0 and a combo break; Just 230 %, only possible inside the Just mission ranges of Gekisou Live. The page's two accuracy sliders are both approximations, and neither has combo breaks:"],
-        math: [
-          "g(q) = 1 − 0.2 q",
-          "X(j) = X_P + j · (X_J − X_P),   X ∈ { the whole-live score without rank bonuses N,  the range scores RS_i }",
-          "S ≈ g(q) · [ N(j) + Σ_i trunc( RS_i(j) · p_i(r_i) / 100 ) ]",
-          "w_k ≈ g(q) · [ w_r[k] + Σ_i ( ρ_i − 1 ) · ( 1 + p_i(r_i) / 100 ) · u_i[k] ],   ρ_i = RS_i(j) / RS_i",
-        ],
-        after: [
-          "The Great share q applies to every note: with Perfects and Greats only (no break) and a Great chance q that does not depend on the note, plain notes and rank bonuses scale by g(q), and the page applies that factor to every score figure (efficiency, the power needed, the chance and the details). "
-            + "Notes inside Just ranges do not quite: a Great there falls from 230 % to 80 %, far more than 20 %, so the factor is optimistic on charts with much Just range.",
-          "The Just rate j applies to the Just mission ranges of Gekisou Live only: deck runs the live once more with Perfects instead of Justs in those ranges and no skills (X_P), the page interpolates linearly by j between it and the all-Just run (X_J), recomputes the rank bonuses on the interpolated range scores (the floor formula of section 2) and applies g(q). "
-            + "The skill position weights are scaled by the same ratio ρ_i inside every range, again an approximation. At j = 100 % and q = 0 the figures are those of sections 1 and 2; Free Live has no Just, only the Great share.",
-          "Breaks do not meet the condition: the combo and Gekisou combo factors depend on the running combo and a break fails a combo mission range, so a break costs differently at different notes (the deck statistics do not export a chart's break-cost distribution yet). "
-            + "Judgement conversion (12006 turns Greats into Perfects, 13005 into Justs) lowers q; recovery and guard skills change the score only once life reaches zero (every note × 0.3 after that).",
-        ],
+        "title": "Judgements and one-play calculation",
+        "body": [
+          "Judgement factors are Perfect 100%, Great 80%, Good 50%, Bad and Miss 0%; Bad and Miss break combo. Just is 230%, normally enabled by the client inside Just missions, and conversion skills may change the result. The same grade proportions on different notes can produce different scores.",
+          "Ranking accuracy sliders are estimates: Great scales the overall score and Just interpolates between two baselines. They do not model combo breaks or all judgement-conversion and cumulative effects. The detail’s one-live calculator simulates explicit per-note results in Rust; equal accuracy percentages at different notes can produce different scores."
+        ],
+        "math": [
+          "Perfect 100% · Great 80% · Good 50% · Bad / Miss 0% · Just 230%"
+        ],
+        "after": [
+          "The chart’s single-play calculator defaults to no skills and Perfect on judged notes, retaining Pass on unscored nodes. Edit individual judgements, or export the template JSON and import it after setting ordinary, support and Gekisou skills, order, seed, ranks or frame times. Unknown notes, duplicate or missing results and invalid clocks fail; missing notes are not silently turned into Miss.",
+          "Browser WASM calls the same Rust engine as the data tools. It processes conversion, combo, life, skills and Gekisou settlement frame by frame. Audio length and score-table length are separate inputs. The default clock is 60 Hz; 30/120 Hz are also supported, and the clock can affect activation and settlement. Results include same-frame score and settled calculator score, life, current combo, maximum sampled frame combo, converted judgement counts and range mission measures.",
+          "This is the result for the declared judgement stream. It does not derive judgements from touch actions or guarantee the same results as physical play on a device. Window effects require original result metadata; unsupported inputs or effects fail. Rankings and aptitude retain their theoretical-best baseline, without Great/Just share scaling or endpoint interpolation replacing that play."
+        ]
       },
       {
-        title: "Gekisou skills",
-        body: [
-          "Member cards carry a Gekisou skill and the snap paired with them a Gekisou support skill. By the decompiled code they exist only with Gekisou on and add to the score with Gekisou (battleLiveScore) only, never to the score without it (soloScore), and Free Live has none. "
-            + "Skills are gated by their Gekisou mission (combo, luck, Just or all) and fire only in applicable ranges, whatever the performance position and the shuffle; a support skill may carry a band condition (condition 5000) on the member it is paired with. "
-            + "ournotes-deck's whole-live simulation can take Gekisou skills, and computes their effects (the Gekisou combo boost, the luck gauge and luck points, Just count boosts, the support skills' score ups and others) frame by frame.",
-          "The rankings and scenario scores still have no Gekisou skills. The aptitude table separately shows the score and range-measure gains of one Gekisou or support skill, not a recommended formation. Member skills use their highest level; support skills use their snap’s highest-rank level. Equal scoring-effect parameters form one shape whose skill names are listed together. A member skill is equipped on one performer, leaving the others empty. A support skill uses a synthetic empty Gekisou-skill host (negative id, no effect rows, the same mission), never a real card. Band conditions have matched and unmatched variants, using the target band or band 0.",
-        ],
-        math: [
-          "Δ(x) = P · ( Δscore / P₀ + x̄ · Σ_k Δw_k )",
-          "Δscore(r) = Δtail + Σ_i ΔrangeScore_i · (1 + p_i(r_i)/100)",
-          "Δw_k(r) = Δw_k + Σ_i (p_i(r_i) − p_i(1))/100 · ΔrangeWeights_k,i",
-        ],
-        after: [
-          "Exact and approximate. With Gekisou skills taken and the formulas of sections 1, 2 and 6 applied: at rank 1, all Just and no Great the score is the whole-live simulation's, and the plain skills' part keeps the linear formula of section 1, the same approximation as without Gekisou skills. "
-            + "The ranks keep the linear formula of section 2: by the decompiled code the rank bonus is a fixed amount added at the range's end that changes no score factor, so aptitude gains at other ranks follow from the tail plus range gains times rank factors, with about ±1 point per range from the two floors. Without range cross weights, cross terms remain at rank 1 and are labelled accordingly. "
-            + "A Just rate below 100 % keeps the interpolation of section 6, an approximation with Gekisou skills: Just conversion (13005), the per-Just support score up (2001) and cumulative Just (13002) are not linear in the Just count. The Great share keeps 1 − 0.2 q, an approximation too.",
-          "Skills that do nothing in the theoretical best play. The combo guard (12004) and Great to Perfect (12006) act only on Greats or Misses: 0 in the theoretical best play, and the Great share approximation leaves them out; with every note hit at its exact time, the wider Just window (4004) does nothing either. "
-            + "Some Gekisou skills raise a rank measure only and add no score (Just count boost 13000, cumulative Just 13002, luck points 11002): the page does not model opponents and takes the ranks you pick, so they leave the page's scores alone; in a real room they may win you a better rank. "
-            + "The aptitude verification records report whole-live confirmation of these zero-effect types on all charts. This is still an internal model check, not proof of agreement with the native game.",
-          "Seeds. Four seeds first test determinism; identical gains in every field are reported with one seed and zero SE. Otherwise batches of 32, 64, 128, 256, 512 and 1024 stop when score-gain SE is within the larger of 1% of the absolute mean gain or 0.1% of the baseline mean on the same seeds. A flag warns when the cap still misses the target. Cross terms use at most the first 64 seeds. Shapes can use different counts. Seed means are not the game’s expectation; its seed distribution is unknown. ± denotes SE on raw statistics only; combined values have no SE because covariances are unavailable. Deltas compare the same seeds and play; unit ordinary skills at each position measure cross terms, checked with random ranks and a random ordinary-skill deck. Below full Just with nonzero ordinary skills, missing Perfect cross weights prevent a complete aptitude gain. "
-            + "The performance positions are shuffled every live, but the Gekisou skills do not depend on the position; the shuffle changes only the order of the chance draws within a seed, not the expectation.",
-          "Gains cannot be added. Combo boosts saturate, so adding single-skill gains can overestimate a combination. Rush support and luck-gauge skills (11001, 11003, 11005) reinforce each other; judgement conversion by 13005 may also change other skills’ triggers and gains. Raising the Just counter with 13000/13002 does not by itself establish an effect on support triggered by Just judgements. One set of whole-live runs found no such interaction, but this does not establish independence for every combination. Single-skill aptitude cannot predict a multi-skill formation; the two band variants cannot be added either.",
-          "State of the checks. This layer has been audited item by item against the decompiled code and agrees with the rewrite; the whole-live comparison with the game's native code is in progress, and until it is done the figures of this layer are still being checked. The conclusions “by this model” rest on that too.",
-        ],
+        "title": "Gekisou skills",
+        "body": [
+          "What is modelled. Member cards carry Gekisou skills, and the support cards paired with them Gekisou support skills. By the decompiled code they are only set up with Gekisou on and only add to the score with Gekisou (battleLiveScore), never to the one without (soloScore), and Free Live has none of them. Every skill belongs to one Gekisou mission (combo, luck or Just) and only triggers in the ranges of that mission, independent of the performance position and the shuffle; a support skill can carry a band condition (condition 5000) on whether its paired member is in a given band. By type the effects are the Gekisou combo bonus, the luck gauge multiplier, luck points, a full gauge, the Just count bonus and cumulative Just, a score up during luck rushes, points per 10 combo or per Just, and combo protection, Great to Perfect, conversion to Just, a looser Just judgement and a few more; ournotes-deck computes them frame by frame in the whole-live simulation.",
+          "Ranks and judgements. Fixed-rank statistical references use the range bonus formula in section 2; a single play runs its declared judgement stream. Conversion, per-Just scoring and cumulative Just can change later state, so an average accuracy multiplier does not calculate these effects.",
+          "A theoretical-best baseline cannot show every skill’s benefit. Protection and conversion need the relevant breaks or grades, and wider windows need original result metadata. A skill that raises mission measures may improve a real placement, but a fixed-rank reference does not change its placement automatically. Single-play JSON can check a concrete input.",
+          "Seeds. Luck ranges draw from the live's random seed, and so do the luck Gekisou skills' effects, so with Gekisou skills the luck ranges may spread wider between seeds. The page takes the mean over the seeds given, which is not the game's own expectation; the game's seed law is unknown. The performance positions are shuffled every live, but Gekisou skills do not depend on the position; the shuffle only reorders a seed's probability draws and leaves the expectation alone.",
+          "Native coverage is now documented by case in the validation table. Ordinary-skill and no-card-Gekisou update chains have frame comparisons; this does not certify every card Gekisou skill or every combination. Unchecked effects and conditions remain unchecked.",
+          "Aptitude measures one skill at a time. Member Gekisou skills use their highest level, support skills their highest limit-break level. Equal scoring parameters share a shape; band conditions have matched and unmatched variants. One performer carries a member skill alone; a support skill uses a synthetic empty Gekisou skill of its mission, not a real card. Missing data is pending, not zero. The ranking and chart baseline still carries no Gekisou skills.",
+          "Aptitude subtracts complete runs with and without one skill on the same seed. The theoretical-best rank-1 value uses the mean score increment. Ordinary skill and rank adjustments use exported weights and range increments, as references limited by rounding and linear assumptions. A concrete mix of skills and judgements uses the complete engine in section 6.",
+          "Gains of several skills cannot be added: the Gekisou combo factor saturates, rush supports interact with luck-gauge skills, and judgement conversion can change other effects; single-skill increments do not reconstruct a whole formation. Aptitude is a single-skill response, not a formation result. Chart factors give judged notes, Just notes, notes that can only be Perfect in Just ranges, tail notes from End to Complete, starting combo and no-skill lotteries to help explain differences.",
+          "Each [mean, standard error] uses sample standard deviation divided by the square root of the seed count; SE is not model error. Random dependencies are checked before the four-seed probe, and four equal results alone do not prove determinism. Random variants double from 32 seeds up to a guard of 65536. Both theoretical-best and all-Perfect score increments must meet the larger of 1% of the absolute increment and 0.1% of the same-seed no-skill baseline. Meeting the baseline target need not mean 1% relative precision. A formal artifact requires both endpoints to pass; failure to converge within the guard rejects generation. Cross terms use at most the first 64 seeds; covariance is unavailable, so errors cannot be combined as independent.",
+          "All-Perfect ordinary-skill cross weights are unavailable. Statistical adjustments without corresponding weights remain limited-precision references; arbitrary judgements and multiple skills use single-play calculation, rather than combined endpoint increments."
+        ],
+        "defs": [
+          [
+            "Probability activation (condition 4011)",
+            "The model compares a float32 draw from the skill random stream with the activation threshold. In the current master, condition 4011 is used by luck Gekisou member skill 11003 and support skill 11005. Two native whole-live checks with real cards and supports passed, covering activation, rejection and a successful 5% branch; see the table below. The full model calculates one live for a given seed; seed means and standard errors describe aptitude. Ordinary skill inputs are unconditional score up: p × value cannot substitute for probability effects."
+          ]
+        ]
       },
       {
-        title: "Mechanisms not modelled yet",
-        defs: [
-          ["Other skill types", "music-data.json's deck.kinds lists every score-up kind of the master data whose score is linear in the factor (effects 2000, 2002, 2004, 2005, told apart by duration, targets and conditions), with each chart's position weights per kind; "
-            + "the page uses the plain score-up kind only. Judgement score up (2004, target judgements 41/46) and conditional 2000s (condition groups 14, 15) weigh differently and need a deck's own kinds summed; cumulative score up (2001, 2003) and judgement conversion are not linear and need the simulation itself, and so do Gekisou skills and Gekisou support skills (section 7)."],
-          ["Gekisou Live opponents", "The ranks depend on the other players' mission measures in every range. The page does not model opponents and lets you pick the ranks instead (rank 1 is the best case); which kind of rank the bonus table takes on equal values is not fully checked, and picking the ranks directly does not depend on it. Whether the server fills a room of fewer than 5 is not in the client code. The game has no co-op mode."],
-          ["Snap skills (plain support skills)", "Shuffled with their member; mostly conditional (the member's band, life, judgement counts), so deck-specific and left out here. A score up whose condition holds all live multiplies base by (1 + y). A snap's Gekisou support skill is another matter, see section 7."],
-          ["Probability skills (condition 4011)", "With an activation chance p independent of the rest, the expected contribution is that of the value p · x, which can be entered as the skill value; the spread is larger than shown."],
-          ["Real play time", "When the results start and how long loading takes depend on the device and the network; the overhead c stands for them, and dominance holds for every c ≥ 0."],
-          ["Scope of the checks", "The figures on this page do not come from running the game's code: ournotes-deck is our simulation, rewritten after the decompiled code, and it computes every chart's whole live. "
-            + "The game's own functions check the rewrite piece by piece: the client's relevant functions (scoring, skill execute and finish, the Gekisou combo and others) run alone in an ARM64 emulator and are compared case by case with the rewrite; the parts checked so far show no difference. "
-            + "A native whole-live run now covers chart 10000201 at power 300000, without skills and with Gekisou off: the note IDs, times and frames of 364 Perfects match the theoretical input, and the final score 1063422 matches deck. This checks only one chart’s input and final score. Per-frame scores, skills and Gekisou remain unchecked; the environment still substitutes for Unity and external dependencies. This does not establish full equivalence with the game. Unchecked parts may be wrong, and comparisons against real device results are still pending. "
-            + "The Gekisou skill layer (section 7) has been audited item by item against the decompiled code and agrees with the rewrite; the whole-live comparison with the native code is in progress, and until it is done the layer is still being checked. "
-            + "Judgement window skills (4000–4003, 13001) are not in the whole-live simulation yet, and a few Gekisou conditions only have synthetic tests; the page uses the plain score-up skill only and is affected by neither, the Gekisou skills may use those conditions, and that is part of the check still under way. A game update or hotfix patch may also change these rules."],
-        ],
+        "title": "Scope of the statistics",
+        "defs": [
+          [
+            "Other skill types",
+            "The statistics’ deck.kinds lists score effects linear in their factor (2000, 2002, 2004, 2005); the page’s skill sliders use ordinary score up. Cumulative scoring, conversion, support and Gekisou combinations need a complete simulation. Single-play JSON accepts supported skill IDs, levels and member attributes; unknown IDs or unsupported effects fail."
+          ],
+          [
+            "Gekisou Live opponents",
+            "The page does not predict other players’ range measures. Statistics select fixed placements; single-play external ranking requires explicit confirmations. Fixed-rank results do not determine online tie order, disconnects, room filling or server settlement."
+          ],
+          [
+            "Snap skills",
+            "Statistics omit specific Snap condition combinations. A single play can supply paired supports and member attributes; the complete engine processes life, grade counts, band and other conditions frame by frame."
+          ],
+          [
+            "Real play time",
+            "When the results start and how long loading takes depend on the device and the network; the overhead c stands for them, and dominance holds for every c ≥ 0."
+          ]
+        ]
       },
       {
-        title: "Chart facts",
-        defs: [
-          ["Level", "The display level (_musicScoreDisplayLevel, with decimals); the score uses the whole level (_musicScoreLevel)."],
-          ["Notes", "Judged notes, the combo of a full combo; hidden notes, guide ends and unjudged slide ticks are left out. By NoteOperateType: tap {1, 101}, flick {40, 41, 42, 102}, slide {20, 21, 22}, trace {60–63, 104, 105}, combo tick {120}."],
-          ["Main BPM, density", "The main BPM holds longest from the first to the last judged note; density = judged notes ÷ that span in seconds."],
-          ["Base, W, skip", "Base and W as in sections 1 and 3: in Gekisou Live base includes the range rank bonuses of the ranks chosen, in Free Live it has none; both scale with the accuracy. Skip: score per point of power of a skipped live (every note Great, combo 0, no skills), independent of the length, and the same in every scenario on this page."],
-          ["Where other sources disagree", "The figures come from our reading of the decompiled code, with no official data to check them against, and may be wrong; where other sites, tools or real plays disagree, trust them first. "
-            + "Different conventions (how the length is taken, the play scenario and ranks, the accuracy, the deck, Gekisou skills or none) also make differences; set the page's parameters to theirs before comparing."],
-        ],
+        "title": "Chart facts",
+        "defs": [
+          [
+            "Level",
+            "The display level (_musicScoreDisplayLevel, with decimals); the score uses the whole level (_musicScoreLevel)."
+          ],
+          [
+            "Notes",
+            "Judged notes, the combo of a full combo; hidden notes, guide ends and unjudged slide ticks are left out. By NoteOperateType: tap {1, 101}, flick {40, 41, 42, 102}, slide {20, 21, 22}, trace {60–63, 104, 105}, combo tick {120}."
+          ],
+          [
+            "Main BPM, density",
+            "The main BPM holds longest from the first to the last judged note; density = judged notes ÷ that span in seconds."
+          ],
+          [
+            "Base, W, skip",
+            "Base and W are defined in sections 1 and 3 for the selected theoretical-best baseline: Gekisou includes fixed-rank range bonuses, Free Live does not. Skip is score per point of power for a skipped live (all Great, combo 0, no skills), independent of duration and unchanged by the page’s scenario."
+          ]
+        ]
       },
+      {
+        "title": "Checks against native code",
+        "body": [],
+        "table": {
+          "headers": [
+            "Case / input",
+            "What was checked",
+            "Result",
+            "What remains unchecked"
+          ],
+          "rows": [
+            [
+              "10000201; power 300000; no skills; Gekisou off",
+              "5500 frames, 13 fields, 71500 comparisons; 364 judgement events",
+              "0 differences; six float32 factor states match by bits",
+              "Fresh, no rewind; simulator max combo is not protected live max combo"
+            ],
+            [
+              "Five ordinary skill-1 members; Perfect and mixed P/Great/Good/Bad/Miss",
+              "5500 frames per case; 253000 core comparisons per case; native SkillExecutor trigger/pool/phases and applier dispatch",
+              "0 differences; float32 max ULP 0",
+              "One unconditional 2000 skill family; elapsed mirror excluded; not a complete game lifecycle"
+            ],
+            [
+              "Real skills 1/4/6/7/5; high/medium/low accuracy × 30/60/120 fps",
+              "Nine cases: 57750 frames; 35 effect-pool instances; 18826500 core comparisons; chart events and converted judgements in order",
+              "0 differences; float32 max ULP 0",
+              "Selected target and life-condition effects; not all skills or input windows"
+            ],
+            [
+              "Nonzero per-note timing offsets",
+              "Native actual P274 / Great58 / Good32; 5500 frames; 1793000 core comparisons",
+              "0 differences; float32 max ULP 0",
+              "Native auto-input window classification; Rust still consumes native judgements, not independent touch replay"
+            ],
+            [
+              "Life condition boundary 700→600",
+              "5500 frames; 45 effect-pool instances; 2288000 core comparisons",
+              "0 differences; float32 max ULP 0",
+              "The high-life effect is selected at 700 and continues at 600; the active effect does not switch to the low-life branch"
+            ],
+            [
+              "Real skills 3/5/1/2/7 at level 5",
+              "5500 frames; 1545500 core comparisons, including actual float32 skill factors",
+              "0 differences; compared float32 max ULP 0",
+              "This skill combination only; value 13000 converts to 1.29999…, not a hand-entered 1.3"
+            ],
+            [
+              "Real card Gekisou and support skills; eight high/medium/low accuracy and 30/60/120 fps cases",
+              "48750 frames, 35777250 checks: pools, converted results, combo protection, cumulative Just, luck gauge and rush",
+              "Zero differences in declared fields; exact float32 bits",
+              "Specified configurations; member-power effects and complete failure/result transitions need separate checks"
+            ],
+            [
+              "Dynamic Just windows through the published model’s public API",
+              "1600-frame native capture; 9 window types, 39 units; 388800 window and 62400 core checks",
+              "451200 checks, zero differences; enable state and window widths match",
+              "Window states and widths, scoring, life and current combo; consumes classified judgements"
+            ],
+            [
+              "Probability 4011; real member card 43 / support 66; high life and life 600 + 4 Miss",
+              "Two cases: 15000 frames, 10680000 core checks; 72 random-value, threshold and boolean checks",
+              "Zero differences; final scores 2835163 / 2760861",
+              "Seed 14 was selected to cover 5% success; fixed-input checks do not measure the probability distribution"
+            ],
+            [
+              "Solo Gekisou combo / Just / luck; no card skills",
+              "10000103 / 10000201 / 10000303; 19000 frames; 646000 integer comparisons",
+              "0 differences in the listed score channels, life, combo, random count and range states",
+              "Some range counters and float32 fields remain unpaired; frame score observation is separate from score()"
+            ],
+            [
+              "Offline multiplayer combo / Just / luck; actual mixed judgements and life zero",
+              "19000 frames; 646000 core comparisons; 76000 ranking-derived comparisons listed separately",
+              "0 differences; 431 native random draws in the luck case",
+              "No card skills, independent touch windows, full failure transition or server rewards; ranking-derived fields are not production observers"
+            ],
+            [
+              "Native multiplayer ranking",
+              "572 invocation cases, including ties, secondary measures, missing inputs and error boundaries",
+              "15259 exact comparisons, 0 differences",
+              "A subsystem test, not 572 lives; within-tie raw member order is outside the Rust API contract"
+            ],
+            [
+              "Challenge: None / FullCombo / AllPerfect assists; actual mixed grades",
+              "Three cases, 5858 frames and 1382503 core checks; native Enter/Update/Exit",
+              "Declared fields match; native Bad/Good retry branches also observed",
+              "Retry decisions are native-side observations; zero-latency animation substitutes, no full result screen/server check"
+            ],
+            [
+              "Mission / SoloGekisou; mixed grades, combo breaks and zero life",
+              "5502 frames, 1469049 core checks; 22008 derived ranking checks listed separately",
+              "Zero differences; final score 439015; frame display and calculator scores checked separately",
+              "No full result screen/server check; derived ranks are not independent production observers"
+            ],
+            [
+              "Free / Solo Gekisou / challenge / mission / battle / arena / tutorial",
+              "Seven native setup entries and chart/bootstrap branches executed",
+              "Entry evidence only; full mode coverage pending",
+              "Entering a mode is not a whole-live verdict; actual event/arena master and server lifecycle remain separate"
+            ]
+          ],
+          "caption": "Client 1.0.1-25 · Checked 2026-09-30"
+        },
+        "after": [
+          "All declared integers match and float32 bits are identical. The model passes 272 regression tests; per-note Rust and WASM results also match across all 340 charts."
+        ]
+      }
     ],
-  },
+    "reminder": {
+      "title": "When other results disagree",
+      "text": "For comparisons, align version, chart, scenario, power, judgement stream, skills, order, seed and frame clock. Include the request JSON and result when reporting a difference. Statistical sampling error, limited-precision references and native check coverage are explained above.",
+      "priority": "When you find a disagreement with other sources, the other sources are correct."
+    },
+    "contentsLabel": "Contents",
+    "methodsLabel": "Method and remaining gaps",
+    "method": {
+      "title": "Sources and verification",
+      "text": "Charts and master data come from game resources extracted by nnnotes; ournotes-deck’s Rust model calculates the figures. We run the game client’s libil2cpp binary directly in the offline ARM64 emulator Unicorn. With the chart, skills, seed and clock fixed, we compare scoring, life, combo, skills and ranking against Rust frame by frame. Files, audio, display and Unity JSON object assembly use substitutes; scoring still executes native instructions. The table’s checked integers and float32 bits match exactly, showing that the model reproduces client calculations under these conditions. Real devices and server results are outside this comparison."
+    }
+  }
 };
diff --git a/tests/unit/replay-preset.test.mjs b/tests/unit/replay-preset.test.mjs
new file mode 100644
index 0000000..358c356
--- /dev/null
+++ b/tests/unit/replay-preset.test.mjs
@@ -0,0 +1,222 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { applyAccuracyPreset, applySegmentPreset, parseJustJudgementTypes } from "../../examples/songs/replay-preset.js";
+
+function fixture() {
+  const notes = Array.from({ length: 8 }, (_, i) => ({ noteId: 20 - i, noteMs: i * 10,
+    judgementType: i === 2 ? 2 : 1, defaultJudgement: 5 }));
+  notes.push({ noteId: 99, noteMs: 20, judgementType: 1, defaultJudgement: 7 });
+  const description = { notes, fevers: [[10, 50]], missions: [3] };
+  const request = { format: "ournotes.replay/1", mode: { kind: "soloGekisou" }, seed: 4,
+    frames: Array.from({ length: 8 }, (_, i) => ({ timeMs: i * 10, deltaSeconds: .01, judgements: [
+      { noteId: notes[i].noteId, judgement: 5, judgementTimeMs: i * 10, rawResult: null },
+      ...(i === 2 ? [{ noteId: 99, judgement: 7, judgementTimeMs: 20 }] : []),
+    ] })) };
+  return { request, description };
+}
+const grades = request => request.frames.flatMap(frame => frame.judgements.map(j => j.judgement));
+const segment = (changes = {}) => ({ startMs: null, endMs: null, great: 0, good: 0, bad: 0, miss: 0, just: 0, ...changes });
+
+test("segment endpoints are half-open chart times and later overlapping segments win", () => {
+  const { request, description } = fixture();
+  request.mode = { kind: "normal" };
+  for (const frame of request.frames) frame.timeMs += 1000;
+  const counts = applySegmentPreset(request, description, [1], [segment({ miss: 1 }),
+    segment({ startMs: 10, endMs: 30, great: 1 }), segment({ startMs: 20, endMs: 40, good: 1 }),
+    segment({ startMs: 30, endMs: 40, bad: 1 })], 0);
+  assert.deepEqual(grades(request), [1, 4, 3, 7, 2, 1, 1, 1, 1]);
+  assert.deepEqual(counts, { great: 1, good: 1, bad: 1, miss: 5, just: 0, perfect: 0, total: 8 });
+});
+
+test("segment probabilities 0 and 100 cover every grade and eligible Just only", () => {
+  for (const [name, grade] of [["great", 4], ["good", 3], ["bad", 2], ["miss", 1]]) {
+    const { request, description } = fixture();
+    const counts = applySegmentPreset(request, description, [1], [segment({ [name]: 1, just: 1 })], 0xffffffff);
+    assert.equal(counts[name], 8);
+    assert.equal(counts.just, 0);
+    assert.deepEqual(grades(request).filter(g => g !== 7), Array(8).fill(grade));
+  }
+  const { request, description } = fixture();
+  assert.deepEqual(applySegmentPreset(request, description, [1], [segment({ just: 1 })], 0),
+    { great: 0, good: 0, bad: 0, miss: 0, just: 3, perfect: 5, total: 8 });
+  request.mode = { kind: "normal" };
+  assert.equal(applySegmentPreset(request, description, [1], [segment({ just: 1 })], 0).perfect, 8);
+});
+
+test("LCG32 plan seeds reproduce inputs independently of the game seed and preserve the stream", () => {
+  const { request, description } = fixture();
+  const original = structuredClone(request), copy = structuredClone(request), other = structuredClone(request);
+  const rules = [segment({ great: .25, good: .25, bad: .25, miss: .25 })];
+  const counts = applySegmentPreset(request, description, [1], rules, 123);
+  assert.deepEqual(applySegmentPreset(copy, description, [1], rules, 123), counts);
+  assert.deepEqual(copy, request);
+  applySegmentPreset(other, description, [1], rules, 124);
+  assert.notDeepEqual(grades(other), grades(request));
+  assert.equal(request.seed, original.seed);
+  for (let f = 0; f < request.frames.length; f++) {
+    const current = request.frames[f], before = original.frames[f];
+    assert.deepEqual({ ...current, judgements: before.judgements }, before);
+    current.judgements.forEach((j, k) => {
+      assert.deepEqual({ ...j, judgement: before.judgements[k].judgement }, before.judgements[k]);
+      if (before.judgements[k].judgement === 7) assert.deepEqual(j, before.judgements[k]);
+    });
+  }
+});
+
+test("segment raw imports, invalid fractions/ranges/IDs and invalid seeds reject before any input write", () => {
+  for (const variant of ["raw", "runtime", "probability", "default", "range", "id", "negativeSeed", "largeSeed", "fractionSeed"]) {
+    const { request, description } = fixture();
+    let rules = [segment()], seed = 0;
+    if (variant === "raw") request.frames.at(-1).judgements[0].rawResult = {};
+    if (variant === "runtime") request.rawRuntime = {};
+    if (variant === "probability") rules = [segment({ great: .6, miss: .5 })];
+    if (variant === "default") rules = [segment({ startMs: 0 })];
+    if (variant === "range") rules.push(segment({ startMs: 20, endMs: 20 }));
+    if (variant === "id") request.frames.at(-1).judgements[0].noteId = -1;
+    if (variant === "negativeSeed") seed = -1;
+    if (variant === "largeSeed") seed = 0x100000000;
+    if (variant === "fractionSeed") seed = 1.5;
+    const before = structuredClone(request);
+    assert.throws(() => applySegmentPreset(request, description, [1], rules, seed));
+    assert.deepEqual(request, before);
+  }
+});
+
+test("Just types follow actual columns, deduplicate and accept parsed or JSON data", () => {
+  const data = { format: "nnnotes.deck-data/1", master: { MasterLiveJudgementTiming: {
+    columns: ["_afterMs", "_noteSimulateJudgement", "_noteJudgementType"], rows: [[20, 6, 1], [30, 5, 2], [5, 6, 1], [9, 6, 3]],
+  } } };
+  assert.deepEqual(parseJustJudgementTypes(data), [1, 3]);
+  assert.deepEqual(parseJustJudgementTypes(JSON.stringify(data)), [1, 3]);
+  assert.throws(() => parseJustJudgementTypes({ ...data, format: "other" }));
+  assert.throws(() => parseJustJudgementTypes({ format: data.format, master: {} }));
+});
+
+test("0 and 100 percent have exact counts; Normal never presets Just", () => {
+  const { request, description } = fixture();
+  assert.deepEqual(applyAccuracyPreset(request, description, [1], 0, 0),
+    { great: 0, just: 0, perfect: 8, total: 8, justEligible: 3 });
+  assert.deepEqual(applyAccuracyPreset(request, description, [1], 0, 1),
+    { great: 0, just: 3, perfect: 5, total: 8, justEligible: 3 });
+  assert.deepEqual(grades(request), [5, 6, 5, 7, 6, 6, 5, 5, 5]);
+  assert.deepEqual(applyAccuracyPreset(request, description, [1], 1, 1),
+    { great: 8, just: 0, perfect: 0, total: 8, justEligible: 0 });
+  request.mode = { kind: "normal" };
+  assert.deepEqual(applyAccuracyPreset(request, description, [1], 0, 1),
+    { great: 0, just: 0, perfect: 8, total: 8, justEligible: 0 });
+});
+
+test("Great is uniformly counted first, then Just on remaining eligible inputs", () => {
+  const { request, description } = fixture();
+  const counts = applyAccuracyPreset(request, description, new Set([1]), .25, .5);
+  assert.deepEqual(counts, { great: 2, just: 1, perfect: 5, total: 8, justEligible: 2 });
+  assert.deepEqual(grades(request), [5, 5, 5, 7, 4, 6, 5, 5, 4]);
+  const copied = structuredClone(request);
+  assert.deepEqual(applyAccuracyPreset(copied, description, [1], .25, .5), counts);
+  assert.deepEqual(copied, request);
+});
+
+test("the activation frame is eligible even for equal fever start/end, and late frames stop it", () => {
+  const { request, description } = fixture();
+  description.fevers = [[15, 15]];
+  const counts = applyAccuracyPreset(request, description, [1, 2], 0, 1);
+  assert.equal(counts.just, 1);
+  assert.deepEqual(grades(request), [5, 5, 6, 7, 5, 5, 5, 5, 5]);
+  description.missions = [1];
+  assert.equal(applyAccuracyPreset(request, description, [1, 2], 0, 1).just, 0);
+});
+
+test("a sparse clock can activate multiple ranges in one frame, each stopping on its next frame", () => {
+  // FeverUpdater and JustRule advance each range independently, not one global range per frame.
+  const description = { notes: [1, 2, 3].map(noteId => ({ noteId, judgementType: 1, defaultJudgement: 5 })),
+    fevers: [[10, 20], [40, 60]], missions: [3, 3] };
+  const request = { format: "ournotes.replay/1", mode: { kind: "soloGekisou" }, frames: [
+    { timeMs: 0, judgements: [] },
+    { timeMs: 100, judgements: [{ noteId: 1, judgement: 5 }, { noteId: 2, judgement: 5 }] },
+    { timeMs: 200, judgements: [{ noteId: 3, judgement: 5 }] },
+  ] };
+  assert.deepEqual(applyAccuracyPreset(request, description, [1], 0, 1),
+    { great: 0, just: 2, perfect: 1, total: 3, justEligible: 2 });
+  assert.deepEqual(grades(request), [6, 6, 5]);
+});
+
+test("frame times, result order, Pass, seed and other request fields are preserved", () => {
+  const { request, description } = fixture();
+  const original = structuredClone(request);
+  const frames = request.frames, judgements = frames.map(frame => frame.judgements);
+  applyAccuracyPreset(request, description, [1], .5, 1);
+  assert.equal(request.frames, frames);
+  for (let f = 0; f < frames.length; f++) {
+    assert.equal(frames[f].judgements, judgements[f]);
+    for (let j = 0; j < judgements[f].length; j++) {
+      const current = judgements[f][j], before = original.frames[f].judgements[j];
+      assert.deepEqual({ ...current, judgement: before.judgement }, before);
+      if (before.judgement === 7) assert.deepEqual(current, before);
+    }
+    assert.deepEqual({ ...frames[f], judgements: original.frames[f].judgements }, original.frames[f]);
+  }
+  assert.equal(request.seed, original.seed);
+});
+
+test("raw imports and invalid plans fail atomically, including a raw result late in the stream", () => {
+  for (const variant of ["rawResult", "rawRuntime", "unknown", "fraction"]) {
+    const { request, description } = fixture();
+    if (variant === "rawResult") request.frames.at(-1).judgements[0].rawResult = { origin: 5, diffMs: 0 };
+    if (variant === "rawRuntime") request.rawRuntime = {};
+    if (variant === "unknown") request.frames.at(-1).judgements[0].noteId = -1;
+    const before = structuredClone(request);
+    assert.throws(() => applyAccuracyPreset(request, description, [1], variant === "fraction" ? NaN : 1, 1));
+    assert.deepEqual(request, before);
+  }
+});
+
+test("empty and unscored-only inputs do not divide by zero", () => {
+  const request = { format: "ournotes.replay/1", mode: { kind: "normal" }, frames: [] };
+  assert.deepEqual(applyAccuracyPreset(request, { notes: [] }, [], 1, 1),
+    { great: 0, just: 0, perfect: 0, total: 0, justEligible: 0 });
+});
+
+const runtimeData = process.env.OURNOTES_REPLAY_DATA;
+const runtimeEngine = process.env.OURNOTES_REPLAY_ENGINE;
+test("a real Rust WASM template and description accept the explicit preset plan", { skip: !runtimeData || !runtimeEngine }, async () => {
+  const dataJSON = await fs.readFile(runtimeData, "utf8");
+  const data = JSON.parse(dataJSON);
+  const types = parseJustJudgementTypes(data);
+  assert.ok(types.length > 0);
+  const { default: init, ReplaySession } = await import(pathToFileURL(path.join(runtimeEngine, "ournotes_replay.js")));
+  await init({ module_or_path: await fs.readFile(path.join(runtimeEngine, "ournotes_replay_bg.wasm")) });
+  const session = new ReplaySession(dataJSON);
+  try {
+    let description;
+    for (const chart of data.charts) {
+      const candidate = JSON.parse(session.describeChart(chart.scoreId));
+      if (candidate.fevers.some((_, i) => candidate.missions[i] === 3)) { description = candidate; break; }
+    }
+    assert.ok(description, "fixture needs a real Just mission");
+    const request = JSON.parse(session.template(description.scoreId, 300000, 60));
+    request.mode = { kind: "soloGekisou" };
+    const counts = applyAccuracyPreset(request, description, types, .3, .6);
+    assert.ok(counts.justEligible > 0 && counts.just > 0);
+    assert.equal(counts.great, Math.round(counts.total * .3));
+    assert.equal(counts.just, Math.round(counts.justEligible * .6));
+    const result = JSON.parse(session.run(JSON.stringify(request)));
+    assert.equal(result.complete, true);
+    assert.deepEqual([result.judgements.great, result.judgements.just, result.judgements.perfect],
+      [counts.great, counts.just, counts.perfect]);
+    const segmentRequest = JSON.parse(session.template(description.scoreId, 300000, 60));
+    segmentRequest.mode = { kind: "soloGekisou" };
+    const start = description.fevers.find((_, i) => description.missions[i] === 3)[0];
+    const segmentCounts = applySegmentPreset(segmentRequest, description, types,
+      [segment({ great: .1, good: .05, bad: .05, miss: .05, just: 1 }),
+        segment({ startMs: 0, endMs: start, great: 1 })], 42);
+    assert.ok(segmentCounts.just > 0 && segmentCounts.great > 0 && segmentCounts.miss > 0);
+    const segmentResult = JSON.parse(session.run(JSON.stringify(segmentRequest)));
+    assert.equal(segmentResult.complete, true);
+    for (const key of ["great", "good", "bad", "miss", "just", "perfect"]) {
+      assert.equal(segmentResult.judgements[key], segmentCounts[key]);
+    }
+  } finally { session.free(); }
+});
diff --git a/tests/unit/songs-page.test.mjs b/tests/unit/songs-page.test.mjs
index 91922a4..db7781b 100644
--- a/tests/unit/songs-page.test.mjs
+++ b/tests/unit/songs-page.test.mjs
@@ -579,20 +579,28 @@ test("master skill factor uses float32 before truncation, unlike user percentage
   assert.equal(meanSkill([130 / 100], 1), 1.3); // UI percent conversion must not use masterSkillFactor
 });
 
-test("Beta notice explains testing, sampling error and unfinished native checks in both languages", () => {
+test("Beta notice identifies the model and native checks", () => {
   assert.equal(UI.zh.beta, "Beta");
   assert.equal(UI.en.beta, "Beta");
-  for (const term of ["测试中", "数值可能调整", "采样误差", "原生整局核对尚未完成"]) assert.ok(UI.zh.betaNote.includes(term));
-  for (const term of ["In testing", "figures may change", "sampling error", "native game", "not yet complete"]) assert.ok(UI.en.betaNote.includes(term));
+  for (const term of ["Rust", "ARM64"]) assert.ok(UI.zh.betaNote.includes(term));
+  for (const term of ["Rust", "ARM64"]) assert.ok(UI.en.betaNote.includes(term));
   for (const locale of [UI.zh, UI.en]) assert.ok(!/https?:|反馈|feedback/i.test(locale.betaNote));
 });
 
-test("native evidence is limited to one chart input and final score, not full equivalence", () => {
-  const zh = GUIDE.zh.sections.find(s => s.title === "尚未纳入的机制").defs.find(([key]) => key === "核对范围")[1];
-  const en = GUIDE.en.sections.find(s => s.title === "Mechanisms not modelled yet").defs.find(([key]) => key === "Scope of the checks")[1];
-  for (const text of [zh, en]) for (const value of ["10000201", "300000", "364", "1063422", "Unity"]) assert.ok(text.includes(value));
-  assert.ok(zh.includes("逐帧分数、技能与激走尚未完成核对"));
-  assert.ok(en.includes("Per-frame scores, skills and Gekisou remain unchecked"));
+test("native evidence table is aligned across languages and states its coverage boundaries", () => {
+  const zh = GUIDE.zh.method.text;
+  const en = GUIDE.en.method.text;
+  assert.ok(zh.includes("不包含真实设备或服务器结算"));
+  assert.ok(en.includes("Real devices and server results are outside"));
+  const tables = [GUIDE.zh, GUIDE.en].map(g => g.sections.find(s => s.table).table);
+  assert.equal(tables[0].headers.length, 4);
+  assert.equal(tables[0].rows.length, tables[1].rows.length);
+  for (const table of tables) for (const row of table.rows) {
+    assert.equal(row.length, table.headers.length);
+    assert.ok(row.every(cell => typeof cell === "string" && cell.length));
+  }
+  // Counts and identifiers are shared between translations; no translation can silently enlarge the evidence.
+  assert.deepEqual(tables[0].rows.map(r => r.slice(0, 2).join(" ").match(/\d+/g)), tables[1].rows.map(r => r.slice(0, 2).join(" ").match(/\d+/g)));
   assert.ok(!zh.includes("整局从没有用游戏代码跑过"));
   assert.ok(!en.includes("no whole live has been run"));
 });
diff --git a/tests/unit/songs-pareto.test.mjs b/tests/unit/songs-pareto.test.mjs
new file mode 100644
index 0000000..570727c
--- /dev/null
+++ b/tests/unit/songs-pareto.test.mjs
@@ -0,0 +1,22 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { axisGoal, paretoPoints } from "../../examples/songs/pareto.js";
+
+test("score figures maximize reward and duration minimizes cost on either axis", () => {
+  for (const axis of ["base", "skip", "rate", "perMinute"]) assert.equal(axisGoal(axis), "max");
+  assert.equal(axisGoal("bgmMs"), "min");
+});
+
+test("lower cost and higher reward retain trade-offs, reject dominated candidates", () => {
+  assert.deepEqual(paretoPoints([[1, 5], [2, 8], [3, 7], [2, 6], [4, 9]]), [[1, 5], [2, 8], [4, 9]]);
+});
+test("all four objective directions distinguish their optimal corners", () => {
+  const points = [[1, 1], [1, 3], [3, 1], [3, 3], [2, 2]];
+  for (const x of ["min", "max"]) for (const y of ["min", "max"]) {
+    assert.deepEqual(paretoPoints(points, x, y), [[x === "min" ? 1 : 3, y === "min" ? 1 : 3]]);
+  }
+});
+test("equal-coordinate candidates survive together; missing values are excluded", () => {
+  assert.deepEqual(paretoPoints([[1, 5, "a"], [1, 5, "b"], [NaN, 9], [1, Infinity], [2, 4]]), [[1, 5, "a"], [1, 5, "b"]]);
+  assert.deepEqual(paretoPoints([]), []);
+});