diff --git a/bun.lock b/bun.lock
index cd5a7613..1407e75a 100644
--- a/bun.lock
+++ b/bun.lock
@@ -22,6 +22,9 @@
       },
     },
   },
+  "patchedDependencies": {
+    "ournotes-player@0.1.5": "patches/ournotes-player@0.1.5.patch",
+  },
   "packages": {
     "@astrojs/check": ["@astrojs/check@0.9.10", "https://registry.npmmirror.com/@astrojs/check/-/check-0.9.10.tgz", { "dependencies": { "@astrojs/language-server": "^2.16.7", "chokidar": "^4.0.3", "kleur": "^4.1.5", "yargs": "^18.0.0" }, "peerDependencies": { "typescript": "^5.0.0 || ^6.0.0" }, "bin": { "astro-check": "./bin/astro-check.js" } }, "sha512-zgx/UQMozdjOa3bOxjgeCFdtpE3c9rRX6xHwa+2QXvy8z8Akifu2AtubHyv/zzC2znO8dl8fFWL4K+Ba9kS8HQ=="],
 
diff --git a/docs/snap-ranking-browser-proof.json b/docs/snap-ranking-browser-proof.json
new file mode 100644
index 00000000..98d63526
--- /dev/null
+++ b/docs/snap-ranking-browser-proof.json
@@ -0,0 +1,55 @@
+{
+  "observedAt": "2026-10-01",
+  "scope": "CNB Chromium, existing Rust WASM and a SHA-bound saved TW snapshot; not latest JP runtime certification",
+  "source": {
+    "region": "tw",
+    "masterVersion": "0b21c9f4a3911370d5f981fb894c7544",
+    "modelCommit": "dbd9cf01a4854808dceb6aedcd4041af372faeee",
+    "fixtureManifestSha256": "27cc19ec2cc30594984e1db02f717221d8977e7b40ec5a505b8695ed8e2b388d",
+    "deckDataSha256": "589e5631cc4595bb4da12bc15841b6c87cedc8662cfb48342c1d6a0f703ef8a4",
+    "labelsSha256": "a27d19c14b286f1263c2aef5f369b23cae799c9e4f600ee0a60512bbf4257984"
+  },
+  "ui": {
+    "defaultSlots": 5,
+    "defaultSelected": 0,
+    "defaultReplayRequests": 0,
+    "profile": { "memberSkillPercent": [100,100,100,100,100], "power": 300000, "greatFraction": 0.4, "justFraction": 1, "mode": "fixedSoloGekisou", "ranks": [1,1,1], "seed": 1, "fps": 60, "skillOrder": [0,1,2,3,4] },
+    "skill": { "kind": "support", "skillId": 31, "level": 1 },
+    "oneSlot": { "memberIds": [1,null,null,null,null], "gekisouLevels": [null,null,null,null,null], "chartsCompleted": 85, "youth": { "score":4459467,"delta":5124 }, "ave": { "score":2850116,"delta":1320 } },
+    "fiveSlots": { "memberIds": [1,2,3,4,5], "gekisouLevels": [null,null,null,null,null], "chartsCompleted": 85, "youth": { "score":4469543,"delta":15200 }, "ave": { "score":2866889,"delta":18093 } },
+    "urlReloadSameResult": true,
+    "needsContextCanReopenPicker": true,
+    "detail": { "sameMeasuredPoint":true,"easySiblingCalculates":true,"linearWeights":false,"thresholdColumns":2,"thresholdMode":"raw-solo" },
+    "resetSelected": 0,
+    "resetRemovesSelectionQuery": true,
+    "mobileViewport": [390,844],
+    "mobileDocumentOverflow": false,
+    "pageErrors": []
+  },
+  "devIntegration": {
+    "baseCommit": "9be87d787d9a8219e67b4c12f90948b11c702acc",
+    "environment": "Windows headed Codex browser, Astro development server",
+    "sameSourceAndUiProfile": true,
+    "tests": 187,
+    "assertions": 679,
+    "typescriptVersion": "5.9.3",
+    "selectedSlots": 5,
+    "coverButtons": 0,
+    "chartsCompleted": 85,
+    "youthScore": 4469543,
+    "aveScore": 2866889,
+    "detailThresholdColumns": 2,
+    "detailLegacyWeights": 0,
+    "detailIndependentEditor": 0,
+    "easySibling": { "scoreId": 10002100, "score": 3391762, "baselineScore": 3355940, "delta": 35822 }
+  },
+  "productionWorker": {
+    "build": "Vite production ES-module Worker",
+    "profileDifferenceFromUi": { "seed":0,"pairedGekisouLevels":[1,1,1,1,1] },
+    "matchesIndependentSameInputWasmProbe": true,
+    "rows": [
+      { "scoreId":10002103,"score":4469543,"baselineScore":4454343,"delta":15200,"convertedJudgements":15 },
+      { "scoreId":10002603,"score":2900352,"baselineScore":2882211,"delta":18141,"convertedJudgements":15 }
+    ]
+  }
+}
diff --git a/docs/snap-ranking.md b/docs/snap-ranking.md
new file mode 100644
index 00000000..015ad182
--- /dev/null
+++ b/docs/snap-ranking.md
@@ -0,0 +1,33 @@
+# Optional Snap skills in chart rankings
+
+The ranking page accepts five optional, physically paired Snap skill slots. All five default to None. Clearing the profile restores the existing ranking and requires no WASM download. A selection records its ordinary/Gekisou kind, actual skill ID and level, rather than assuming a card's maximum growth.
+
+The picker reuses `Modal`, `FilterButton`, `SupportCardArtwork` and `MemberCardArtwork`. Names, descriptions and IDs are searchable with NFKC normalization and AND tokens; source card names, characters and bands are included. Levels stay explicit. Skills that require a paired member expose its reference card and Gekisou level. A missing condition returns `needs-context`, with no guessed score.
+
+## Calculation and architecture
+
+The source client transports files. `snap-bridge` verifies replay manifest/resource SHA-256, sizes, region, master version and model commit before calling the existing Rust WASM `ReplaySession`. `snap-catalogue`, `snap-query`, `snap-profile` and source view models handle input and display identities. The Worker owns sessions, bounded point-result caching, job revisions and cancellation. React renders controls and measured results. There is no JavaScript scoring formula or WebGPU path.
+
+Selected skills use a declared standard profile: five ordinary 5-second score-up skills at the percentages already entered, chosen measurement power, Great/Just input preset, seed 1, 60 fps, physical skill order 1–5, and Free Live or solo Gekisou with three fixed ranks. Reference members provide real attributes for conditions; their growth power and original live skill are not substituted for this standard profile. This is a reproducible measurement, not a random-order expectation, player's owned deck, or multiplayer simulation.
+
+Each chart is replayed both with the selections and with all five Snap slots removed, retaining the other inputs. Rank rows show simulated score, signed difference and score per minute. Pending or invalid rows remain empty. The chart detail reuses the same point; switching difficulty adds its chart to the replay job. It shows raw solo thresholds and chart event markers, without guessing Snap duration changes or deriving required power, success probability or dominance from legacy linear weights. Those objectives need the separate search in [the model/search design](deck-integration.md). The legacy range metrics, Gekisou aptitude and independent replay editor use other profiles and are hidden while Snap is active.
+
+Changing a profile or source immediately hides previous results. Worker revisions reject late jobs; it yields after each paired chart result and disposes sessions on cancellation. Cache keys include the complete source identity, profile and chart ID, with a 1,500-point LRU limit. Changes to displayed duration or overhead reuse scores and only reorder the table.
+
+## Source updates
+
+`nnnotes` [#7](https://github.com/StarMoe-org/nnnotes/pull/7) adds region-separated source refresh, consumer identity and raw score-rank validation. [#8](https://github.com/StarMoe-org/nnnotes/pull/8) exports a SHA-bound `nnnotes.replay-labels/1` sidecar at `replay.snapLabels`, containing the same snapshot's skill descriptions and card artwork metadata. Payload resources precede their manifest during publishing.
+
+The UI never borrows the site's merged build-time master tables. Without the optional label sidecar it uses names from the same music-data catalogue, omits unexpanded descriptions and artwork with unknown asset IDs, and keeps ID search available. Card artwork uses the verified music snapshot's server scope. `MasterSkillTarget` names resolve through their actual character/band predicates; condition targets are separate from effect targets.
+
+Judged-input replays cannot reproduce raw touch timing effects. Those choices are visible and disabled with an explanation. This feature's current source/model snapshot is not certification of the latest JP 1.0.4 runtime or online IFix rules. The native whole-live and search gates remain separate prerequisites for formal deck recommendation.
+
+## Verification
+
+Pure tests cover default None, URL restoration, slot pairing, search/filter/level behavior, source mismatch, unresolved descriptions, source/profile changes, stale Worker responses, cancellation, bounded cache and the unchanged legacy ranking. The browser check runs on CNB with the actual shipped WASM and SHA-bound same-snapshot fixtures, not mock scores. Full source resources stay outside Git. Five core locales, architecture, routes, UI text and search/SEO checks are required.
+
+[Browser proof](snap-ranking-browser-proof.json) records 85-chart real UI runs, five slots, URL restoration, mobile overflow, and the production-built Worker matching two independently captured same-input WASM cases. The proof distinguishes the UI seed/member Gekisou settings from those two reference cases. It does not claim native-game certification from a WASM-to-WASM comparison.
+
+The `ournotes-player@0.1.5` Bun patch exposes the original player input-plan helper without changing its algorithm. Its source is the player file at commit `0e2c2352b01fa0fad26cd8365d09be00737d63eb`; the package release otherwise omits that example directory and export. Use Bun 1.4.2 to reproduce the patched installation and tests.
+
+The feature and data-update PRs integrate into `dev`. Production data publishing and native whole-live certification remain separate steps.
diff --git a/package.json b/package.json
index ffd08aaa..6a367d92 100644
--- a/package.json
+++ b/package.json
@@ -37,5 +37,8 @@
     "@types/react": "^19.2.7",
     "@types/react-dom": "^19.2.3",
     "typescript": "^5.9.3"
+  },
+  "patchedDependencies": {
+    "ournotes-player@0.1.5": "patches/ournotes-player@0.1.5.patch"
   }
 }
diff --git a/patches/ournotes-player@0.1.5.patch b/patches/ournotes-player@0.1.5.patch
new file mode 100644
index 00000000..4dc4e4ba
--- /dev/null
+++ b/patches/ournotes-player@0.1.5.patch
@@ -0,0 +1,199 @@
+diff --git a/node_modules/ournotes-player/examples/songs/replay-preset.js b/examples/songs/replay-preset.js
+new file mode 100644
+index 0000000000000000000000000000000000000000..d4b99b0d30086c432219398cecbb56a0dd278b8f
+--- /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/package.json b/package.json
+index d7061ce0d1d2dfafaa54c5984e9ba85b22eefdb2..e302f9fd76b7f5f2af49f3f884d43e333c04234c 100644
+--- a/package.json
++++ b/package.json
+@@ -53,7 +53,11 @@
+     },
+     "./dist/*": "./dist/*",
+     "./schema/*": "./schema/*",
+-    "./package.json": "./package.json"
++    "./package.json": "./package.json",
++    "./replay/preset": {
++      "types": "./types/replay-preset.d.ts",
++      "default": "./examples/songs/replay-preset.js"
++    }
+   },
+   "sideEffects": [
+     "./src/element.js",
+@@ -81,7 +85,8 @@
+     "examples/story/",
+     "examples/story-list/",
+     "LICENSE",
+-    "LICENSE-EXCEPTION"
++    "LICENSE-EXCEPTION",
++    "examples/songs/replay-preset.js"
+   ],
+   "engines": {
+     "node": ">=20"
+diff --git a/node_modules/ournotes-player/types/replay-preset.d.ts b/types/replay-preset.d.ts
+new file mode 100644
+index 0000000000000000000000000000000000000000..2f695a7005384d3f116cea115b73c2a936a8ddcb
+--- /dev/null
++++ b/types/replay-preset.d.ts
+@@ -0,0 +1,9 @@
++/** Declared input plans; the Rust replay retains conversion, state updates and scoring. */
++export function parseJustJudgementTypes(deckData: string | Record<string, unknown>): number[];
++export function applyAccuracyPreset(
++  request: Record<string, unknown>,
++  description: Record<string, unknown>,
++  justTypes: readonly number[] | Set<number>,
++  greatFraction: number,
++  justFraction: number,
++): Record<string, unknown>;
diff --git a/src/components/chart-data/ChartDataTool.tsx b/src/components/chart-data/ChartDataTool.tsx
index a6546e08..e1e7a7fa 100644
--- a/src/components/chart-data/ChartDataTool.tsx
+++ b/src/components/chart-data/ChartDataTool.tsx
@@ -1,5 +1,6 @@
 import { memo, useCallback, useEffect, useMemo, useState } from "react";
 import type { AppLocale } from "@/config/locales";
+import { assetConfig } from "@/config/assets";
 import { t } from "@/i18n";
 import type { ChartDataGuide } from "@/i18n/guides/chart-data";
 import { localizePath } from "@/i18n/routing";
@@ -12,6 +13,8 @@ import { parseChartDataQuery, playScenario, serializeChartDataQuery, VIEWS, type
 import { scenarioSupport } from "@/lib/chart-data/scenario";
 import { localizeDataText } from "@/lib/chart-data/text";
 import type { MusicData } from "@/lib/chart-data/types";
+import { chartSnapProfile, snapDisplayedMeasurement } from "@/lib/chart-data/snap-profile";
+import { emptySnapRanking, isCurrentSnapCatalogue, type SnapRankingCatalogue, type SnapRankingSource, type SnapRankingState } from "@/lib/chart-data/snap-client";
 import { getChartPreviewHref } from "@/lib/music/chart-preview";
 import { getMusicJacketUrl } from "@/lib/music/data";
 import { isMusicDifficulty } from "@/lib/music/difficulty";
@@ -20,6 +23,8 @@ import ChartDetail from "./ChartDetail";
 import ChartsView from "./ChartsView";
 import GuideView from "./GuideView";
 import RankView from "./RankView";
+import SnapRankingController from "./SnapRankingController";
+import SnapRankingPanel from "./SnapRankingPanel";
 import { Icon, diffShort, type ChartDataContext } from "./shared";
 
 interface Props {
@@ -44,6 +49,11 @@ export default function ChartDataTool({ locale, guide }: Props) {
   const [view, setView] = useState<View>("rank");
   const [restored, setRestored] = useState(false);
   const [state, setState] = useState<ChartDataState | null>(null);
+  const [snapRequested, setSnapRequested] = useState(false);
+  const [snapCatalogue, setSnapCatalogue] = useState<SnapRankingCatalogue | null>(null);
+  const [snapCatalogueError, setSnapCatalogueError] = useState(false);
+  const [snapAttempt, setSnapAttempt] = useState(0);
+  const [snapMeasurement, setSnapMeasurement] = useState<SnapRankingState>(emptySnapRanking);
 
   useEffect(() => {
     const v = new URLSearchParams(window.location.search).get("v");
@@ -61,6 +71,8 @@ export default function ChartDataTool({ locale, guide }: Props) {
   }, [attempt]);
 
   const data = load.status === "ready" ? load.data : null;
+  const currentSnapCatalogue = useMemo(() => isCurrentSnapCatalogue(snapCatalogue, data) ? snapCatalogue : null, [snapCatalogue, data]);
+  useEffect(() => { setSnapCatalogue(null); setSnapCatalogueError(false); }, [data]);
   const support = useMemo(() => scenarioSupport(data), [data]);
   const hasStats = support.battle || support.free;
   const queryContext = useMemo<QueryContext>(() => ({ hasStats, support }), [hasStats, support]);
@@ -102,6 +114,18 @@ export default function ChartDataTool({ locale, guide }: Props) {
   const mode = state?.mode, ranks = state?.ranks, great = state?.great, just = state?.just;
   const scenario = useMemo(() => (mode && ranks && great !== undefined && just !== undefined ? playScenario({ mode, ranks, great, just }) : null), [mode, ranks, great, just]);
   const rows = useMemo(() => (data && scenario ? chartRows(data, scenario) : []), [data, scenario]);
+  const snapActive = current?.snapSkills.some(Boolean) ?? false;
+  const snapEvaluation = useMemo(() => current ? chartSnapProfile(current, currentSnapCatalogue?.data) : null, [current, currentSnapCatalogue]);
+  const snapSource = useMemo<SnapRankingSource | null>(() => {
+    const region = data?.provenance?.region, masterVersion = data?.provenance?.master?.version, modelCommit = data?.provenance?.deck?.commit;
+    return data?.replay && region && masterVersion && modelCommit && (snapRequested || snapActive)
+      ? { site: assetConfig.musicDataSite, reference: data.replay, expected: { region, masterVersion, modelCommit } } : null;
+  }, [data, snapRequested, snapActive]);
+  const snapScoreIds = useMemo(() => {
+    const ids = view === "rank" ? rows.filter((r) => current?.diffs.includes(r.difficulty as typeof DIFFICULTIES[number]) && (!current.band || r.bandIds.map(String).includes(current.band))).map((r) => r.scoreId) : [];
+    if (current?.chart && rows.some((row) => row.scoreId === current.chart) && !ids.includes(current.chart)) ids.push(current.chart);
+    return ids;
+  }, [rows, current?.diffs, current?.band, current?.chart, view]);
   const ctx = useMemo<ChartDataContext | null>(() => {
     if (!data || !current) return null;
     const bands = new Map((data.bands ?? []).map((b) => [String(b.id), b]));
@@ -133,8 +157,9 @@ export default function ChartDataTool({ locale, guide }: Props) {
         : { rate: null, perMinute: null }),
       openChart: (scoreId) => update({ chart: scoreId }),
       pool: rows.filter((r) => current.diffs.includes(r.difficulty as typeof DIFFICULTIES[number]) && (!current.band || r.bandIds.map(String).includes(current.band))),
+      snap: snapEvaluation ? { active: snapActive, profile: snapEvaluation.profile, measurement: snapDisplayedMeasurement(snapEvaluation, snapSource, snapMeasurement), source: snapSource } : undefined,
     };
-  }, [data, current, rows, locale, tr, hasStats, support, update]);
+  }, [data, current, rows, locale, tr, hasStats, support, update, snapEvaluation, snapActive, snapMeasurement, snapSource]);
 
   const detail = ctx && current?.chart ? ctx.byScore.get(current.chart) ?? null : null;
 
@@ -162,12 +187,20 @@ export default function ChartDataTool({ locale, guide }: Props) {
                 <small>{load.message}</small>
                 <button type="button" className="mn-cd-ghost" onClick={() => setAttempt((n) => n + 1)}>{tr("retry")}</button>
               </div>
-            ) : ctx && view === "rank" ? <BackgroundRankView ctx={ctx} /> : ctx ? <BackgroundChartsView ctx={ctx} /> : null}
+            ) : ctx && view === "rank" ? <>
+              <SnapRankingPanel ctx={ctx} catalogue={currentSnapCatalogue} measurement={snapMeasurement}
+                loading={!!snapSource && !currentSnapCatalogue} invalidMembers={snapEvaluation?.invalidMembers ?? []}
+                available={!!data?.replay} catalogueError={snapCatalogueError} onOpen={() => { setSnapRequested(true); if (snapCatalogueError) { setSnapCatalogueError(false); setSnapAttempt((value) => value + 1); } }} />
+              <BackgroundRankView ctx={ctx} />
+            </> : ctx ? <BackgroundChartsView ctx={ctx} /> : null}
           </main>
         </>
       )}
 
       {data ? <Footer locale={locale} data={data} /> : null}
+      {snapEvaluation ? <SnapRankingController key={snapAttempt} source={snapSource} profile={snapEvaluation.profile} scoreIds={snapScoreIds}
+        enabled={snapActive && snapScoreIds.length > 0 && !!currentSnapCatalogue && snapEvaluation.invalidMembers.length === 0} locale={locale}
+        onState={setSnapMeasurement} onCatalogue={setSnapCatalogue} onCatalogueError={() => setSnapCatalogueError(true)} /> : null}
 
       {ctx ? (
         <Modal
@@ -228,14 +261,15 @@ function Footer({ locale, data }: { locale: AppLocale; data: MusicData }) {
   const c = p.client ?? {};
   const d = p.deck ?? null;
   const development = p.developmentSample;
-  // the data is the same on every server as far as we know; the region and versions it was taken from go in the hint
+  // Region snapshots can differ in score ranks and skills; always name the actual data source.
   const client = c.versionName ? `${c.versionName}${c.versionCode ? ` (${c.versionCode})` : ""}` : "?";
   const master = m.version ?? "?";
+  const region = p.region && ["tw", "jp", "en", "kr"].includes(p.region) ? t(locale, `gameServer.names.${p.region}`) : p.region ?? "?";
   const tr = (key: string, values?: Record<string, string | number>) => t(locale, `chartData.${key}`, values);
   return (
     <footer className="mn-cd-foot">
       <span>
-        <span title={tr("sourceHint", { region: p.region ?? "?", master, client })}>{tr("source", { version: /^[0-9a-f]{32}$/i.test(master) ? master.slice(0, 8) : master })}</span>
+        <span title={tr("sourceHint", { region: p.region ?? "?", master, client })}>{tr("source", { region, version: /^[0-9a-f]{32}$/i.test(master) ? master.slice(0, 8) : master })}</span>
         {d?.source && d.commit ? (
           <>
             {` · ${tr("deckModel")} `}
diff --git a/src/components/chart-data/ChartDetail.tsx b/src/components/chart-data/ChartDetail.tsx
index 574b6c8d..68c81a66 100644
--- a/src/components/chart-data/ChartDetail.tsx
+++ b/src/components/chart-data/ChartDetail.tsx
@@ -5,6 +5,7 @@ import { SCORE_RANKS, chartFigures, formatLength, modelPower, orderRates, plainK
 import { FREE } from "@/lib/chart-data/scenario";
 import AptitudeDetail from "./AptitudeDetail";
 import ReplayDetail from "./ReplayDetail";
+import { currentSnapRanking } from "@/lib/chart-data/snap-client";
 import { MISSIONS, ScenarioPanel } from "./SettingsPanel";
 import { Heading, Icon, Jacket, fmt, fmtInt, diffShort, SongLink, type ChartDataContext } from "./shared";
 
@@ -55,8 +56,8 @@ function Timeline({ ctx, row }: { ctx: ChartDataContext; row: ChartRow }) {
         );
       })}
       {(c.skillEventsMs ?? []).map((ms, i) => {
-        const wEnd = Math.min(ms + 5000, row.chartMs || ms + 5000);
-        const w = eventW(i);
+        const wEnd = ctx.snap?.active ? ms : Math.min(ms + 5000, row.chartMs || ms + 5000);
+        const w = ctx.snap?.active ? null : eventW(i);
         const op = w !== null && maxW ? 0.35 + (0.65 * w) / maxW : 0.8;
         return (
           <g key={`s${i}`}>
@@ -200,9 +201,13 @@ function RanksTable({ ctx, row }: { ctx: ChartDataContext; row: Figured }) {
 export default function ChartDetail({ ctx, row }: { ctx: ChartDataContext; row: ChartRow }) {
   const { tr, state } = ctx;
   const siblings = ctx.rows.filter((x) => x.musicId === row.musicId);
-  const e = ctx.eff(row);
   const c = row.chart;
-  const figured = row.weights ? (row as Figured) : null;
+  const snap = ctx.snap?.active ? ctx.snap : null;
+  const e = snap ? { rate: null, perMinute: null } : ctx.eff(row);
+  const measured = snap ? currentSnapRanking(snap.profile, snap.source, snap.measurement)?.rows.get(row.scoreId) : null;
+  const duration = ctx.lengthOf(row);
+  const measuredPerMinute = measured && duration !== null && duration + state.overhead * 1000 > 0 ? measured.score * 60000 / (duration + state.overhead * 1000) : null;
+  const figured = !snap && row.weights ? (row as Figured) : null;
   const orders = figured ? orderRates(figured, ctx.skills) : null;
   const battle = state.mode === "battle";
   // Free Live's score per power at the Great share chosen (the one Gekisou Live keeps as the song's best score)
@@ -245,10 +250,16 @@ export default function ChartDetail({ ctx, row }: { ctx: ChartDataContext; row:
         {ctx.hasStats ? (
           <>
             <Heading level={3} title={tr("detail.score")} />
-            <ScenarioPanel ctx={ctx} rooms missions={row.song.gekisouMissions ?? null} />
+            <ScenarioPanel ctx={ctx} rooms={!snap} missions={row.song.gekisouMissions ?? null} />
           </>
         ) : null}
         <div className="mn-cd-tiles">
+          {snap ? <>
+            <Tile label={tr("snap.score")} value={fmtInt(measured?.score)} sub={tr("snap.measurementHint")} />
+            <Tile label={tr("snap.baseline")} value={fmtInt(measured?.baselineScore)} />
+            <Tile label={tr("snap.delta")} value={measured ? `${measured.delta > 0 ? "+" : ""}${fmtInt(measured.delta)}` : "–"} />
+            <Tile label={tr("snap.perMinute")} value={fmt(measuredPerMinute, 3)} />
+          </> : null}
           {figured && orders ? (
             <Tile
               label={tr("col.rate")}
@@ -273,11 +284,12 @@ export default function ChartDetail({ ctx, row }: { ctx: ChartDataContext; row:
           {battle && row.unplayable ? (
             <Tile label={tr("detail.unplayable")} value="–" sub={`${tr("detail.unplayableHint")}${ctx.support.free ? tr("detail.unplayableFree") : ""}`} />
           ) : null}
-          {!figured && !(battle && row.unplayable) && row.stats ? <Tile label={tr("detail.noFigures")} value="–" sub={tr("scenario.pending")} /> : null}
+          {!snap && !figured && !(battle && row.unplayable) && row.stats ? <Tile label={tr("detail.noFigures")} value="–" sub={tr("scenario.pending")} /> : null}
         </div>
-        {battle ? <Measures ctx={ctx} row={row} /> : null}
+        {battle && !snap ? <Measures ctx={ctx} row={row} /> : null}
         <Heading level={3} title={tr("detail.timeline")} />
         <div className="mn-cd-tl-scroll"><Timeline ctx={ctx} row={row} /></div>
+        {snap ? <p className="mn-cd-hint">{tr("snap.timelineHint")}</p> : null}
         <div className="mn-cd-grid2">
           <section><Heading level={3} title={tr("detail.composition")} /><Composition ctx={ctx} row={row} /></section>
           {figured ? (
@@ -288,16 +300,21 @@ export default function ChartDetail({ ctx, row }: { ctx: ChartDataContext; row:
             </section>
           ) : null}
         </div>
-        {figured && row.scoreRanks.length ? (
+        {(figured || snap) && row.scoreRanks.length ? (
           <section>
             <Heading level={3} title={tr("detail.ranks")} />
-            <RanksTable ctx={ctx} row={figured} />
-            <p className="mn-cd-hint">{roomSize(state) ? tr("detail.ranksHintRoom", { n: state.room }) : tr("detail.ranksHint")}</p>
+            {snap ? <div className="mn-cd-table-scroll"><table className="mn-cd-ranks">
+              <thead><tr><th>{tr("detail.rank")}</th><th>{tr("detail.required")}</th></tr></thead>
+              <tbody>{SCORE_RANKS.filter((rank) => rankThreshold(row, rank, 0) !== null).reverse().map((rank) => <tr key={rank}>
+                <td><span className={`mn-cd-rk rk-${rank}`}>{rank}</span></td><td className="num">{fmtInt(rankThreshold(row, rank, 0))}</td>
+              </tr>)}</tbody>
+            </table></div> : figured ? <RanksTable ctx={ctx} row={figured} /> : null}
+            <p className="mn-cd-hint">{snap ? tr("snap.eventMeasurementHint") : roomSize(state) ? tr("detail.ranksHintRoom", { n: state.room }) : tr("detail.ranksHint")}</p>
           </section>
         ) : null}
         <p className="mn-cd-ids">{`${tr("detail.musicId")} ${row.musicId} · ${tr("detail.scoreId")} ${row.scoreId} · ${tr("detail.musicType")} ${row.song.musicType ?? "–"}`}</p>
-        <ReplayDetail ctx={ctx} row={row} />
-        <AptitudeDetail ctx={ctx} row={row} />
+        {!snap ? <ReplayDetail ctx={ctx} row={row} /> : null}
+        {!snap ? <AptitudeDetail ctx={ctx} row={row} /> : null}
       </div>
     </div>
   );
diff --git a/src/components/chart-data/RankView.tsx b/src/components/chart-data/RankView.tsx
index 72e560d3..c0002743 100644
--- a/src/components/chart-data/RankView.tsx
+++ b/src/components/chart-data/RankView.tsx
@@ -2,11 +2,12 @@ import { useMemo, useState, type ReactNode } from "react";
 import { matches, sortBy, type ChartRow } from "@/lib/chart-data/catalog";
 import { EFF_RANKS, RANKS, SPEEDS, roomSize, type RankBy } from "@/lib/chart-data/query";
 import { X_MAX, eventDominance, formatLength, lengthMs, orderRates, rank, rankThreshold, reachChance, requiredPower } from "@/lib/chart-data/ranking";
+import { snapProfileKey, snapSourceKey } from "@/lib/chart-data/snap-client";
 import SettingsPanel, { ScenarioPanel } from "./SettingsPanel";
 import { Icon, LevelBadge, Seg, SongCell, fmt, fmtInt, type ChartDataContext } from "./shared";
 
 type Col = "rank" | "song" | "level" | "time" | "bpm" | "notes" | "density" | "rate" | "perMinute" | "relative" | "dom"
-  | "need" | "chance" | "perHour" | "goal" | "skip";
+  | "need" | "chance" | "perHour" | "goal" | "skip" | "score" | "delta";
 
 interface Listed extends ChartRow {
   rate?: number;
@@ -17,6 +18,18 @@ interface Listed extends ChartRow {
   goal?: number | null;
   dominatedBy?: number[];
   frontier?: boolean;
+  score?: number | null;
+  baselineScore?: number | null;
+  delta?: number | null;
+}
+
+const snapActive = (ctx: ChartDataContext) => !!ctx.snap?.active && (ctx.state.rankBy === "efficiency" || ctx.state.rankBy === "event");
+function currentMeasurement(ctx: ChartDataContext) {
+  const snap = ctx.snap;
+  if (!snap?.source || snap.measurement.profileKey !== snapProfileKey(snap.profile)
+    || snap.measurement.sourceKey !== snapSourceKey(snap.source)) return null;
+  if (snap.measurement.source && snap.measurement.source.manifestSha256 !== snap.source.reference.sha256) return null;
+  return snap.measurement;
 }
 
 /** The ranking of the pool by the chosen measure, as ournotes-player's chart data page ranks it. */
@@ -27,7 +40,19 @@ function useRanking(ctx: ChartDataContext) {
     let hi: Col | "" = "";
     let unsorted: Listed[] | null = null;                                    // the list the dominance indexes refer to
     const cols: Col[] = ["rank", "song", "level", "time", "bpm", "notes", "density"];
-    if (state.rankBy === "efficiency") {
+    if (snapActive(ctx)) {
+      const measured = currentMeasurement(ctx);
+      list = pool.map((row) => {
+        const result = measured?.rows.get(row.scoreId);
+        const duration = ctx.lengthOf(row);
+        const time = duration === null ? null : duration + state.overhead * 1000;
+        return { ...row, score: result?.score ?? null, baselineScore: result?.baselineScore ?? null, delta: result?.delta ?? null,
+          perMinute: result && time !== null && time > 0 ? result.score * 60000 / time : null };
+      });
+      list = sortBy(list, (row) => row.perMinute);
+      cols.push("score", "delta", "perMinute", ...(state.rankBy === "efficiency" ? ["relative" as const] : []));
+      hi = "perMinute";
+    } else if (state.rankBy === "efficiency") {
       unsorted = list.filter((r) => r.weights);
       list = rank(unsorted as Array<ChartRow & { base: number; weights: number[] }>, { skills, source: state.len, overheadMs: state.overhead * 1000 });
       cols.push("rate", "perMinute", "relative", "dom");
@@ -76,12 +101,15 @@ function useRanking(ctx: ChartDataContext) {
 
 export default function RankView({ ctx }: { ctx: ChartDataContext }) {
   const { tr, state, update, hasStats } = ctx;
-  const tabs = RANKS.filter((k) => hasStats || !EFF_RANKS.has(k)).map((k) => ({ value: k, label: tr(`rankBy.${k}`) }));
+  const active = snapActive(ctx);
+  const measurement = active ? currentMeasurement(ctx) : null;
+  const tabs = RANKS.filter((k) => hasStats || (!!ctx.snap?.active && (k === "efficiency" || k === "event")) || !EFF_RANKS.has(k)).map((k) => ({ value: k, label: tr(`rankBy.${k}`) }));
   return (
     <>
       <div className="mn-cd-rank-head">
         <Seg<RankBy> variant="tabs" label={tr("views.rank")} value={state.rankBy} onPick={(rankBy) => update({ rankBy })} options={tabs} />
       </div>
+      {active ? <p className="mn-cd-hint">{tr(state.rankBy === "event" ? "snap.eventMeasurementHint" : "snap.measurementHint")}</p> : null}
         {state.rankBy === "speed" ? (
           <div className="mn-cd-hint">
           <Seg label={tr("rankBy.speed")} value={state.speedBy} onPick={(speedBy) => update({ speedBy })} options={SPEEDS.map((k) => ({ value: k, label: tr(`speedBy.${k}`) }))} />
@@ -89,11 +117,20 @@ export default function RankView({ ctx }: { ctx: ChartDataContext }) {
         ) : null}
       {state.rankBy === "efficiency" || state.rankBy === "event" ? (
         <>
-          <ScenarioPanel ctx={ctx} rooms={state.rankBy === "event"} />
-          <SettingsPanel ctx={ctx} event={state.rankBy === "event"} frontier />
+          <ScenarioPanel ctx={ctx} rooms={state.rankBy === "event" && !active} />
+          <SettingsPanel ctx={ctx} event={state.rankBy === "event" && !active} frontier={!active} />
         </>
       ) : null}
-      {!hasStats ? <p className="mn-cd-hint warn">{tr("noStats")}</p> : null}
+      {!hasStats && !active ? <p className="mn-cd-hint warn">{tr("noStats")}</p> : null}
+      {active ? (
+        <p className={`mn-cd-snap-state${measurement?.error ? " warn" : ""}`} role={measurement?.error ? "alert" : "status"}>
+          {measurement?.status === "complete" ? tr("snap.ready", { n: measurement.done })
+            : measurement?.status === "needs-context" ? tr("snap.needsContext")
+            : measurement?.status === "unsupported" ? tr("snap.unsupportedScenario")
+            : measurement?.status === "error" ? tr("snap.calculationError")
+            : tr("snap.calculating", { done: measurement?.done ?? 0, total: measurement?.total ?? ctx.pool.length })}
+        </p>
+      ) : null}
       <RankTable ctx={ctx} />
     </>
   );
@@ -110,7 +147,9 @@ function RankTable({ ctx }: { ctx: ChartDataContext }) {
     <span className="mn-cd-bar" style={{ ["--w" as string]: `${barMax && typeof v === "number" ? Math.max(0, Math.min(100, (100 * v) / barMax)) : 0}%` }}>{text}</span>
   );
   const clear = () => ctx.update({ band: "", search: "", frontier: false, diffs: ["easy", "normal", "hard", "expert"] });
-  const head = (k: Col) => (k === "bpm" && state.rankBy === "speed" && state.speedBy === "bpmMax" ? tr("speedBy.bpmMax") : tr(`col.${k}`));
+  const head = (k: Col) => k === "score" || k === "delta" ? tr(`snap.${k}`)
+    : k === "perMinute" && snapActive(ctx) ? tr("snap.perMinute")
+    : k === "bpm" && state.rankBy === "speed" && state.speedBy === "bpmMax" ? tr("speedBy.bpmMax") : tr(`col.${k}`);
   const names = (r: Listed) => (r.dominatedBy ?? []).map((j) => unsorted?.[j]).filter((x): x is Listed => !!x)
     .map((x) => `${ctx.title(x)} ${tr(`difficulties.${x.difficulty}`)}`).join(tr("listSeparator"));
 
@@ -126,6 +165,8 @@ function RankTable({ ctx }: { ctx: ChartDataContext }) {
         return hi === "bpm" ? bar(main, text) : text;
       }
       case "notes": return hi === "notes" ? bar(r.notes, fmtInt(r.notes)) : fmtInt(r.notes);
+      case "score": return <span title={typeof r.baselineScore === "number" ? `${tr("snap.baseline")}: ${fmtInt(r.baselineScore)}` : undefined}>{fmtInt(r.score)}</span>;
+      case "delta": return typeof r.delta === "number" ? <span title={`${tr("snap.baseline")}: ${fmtInt(r.baselineScore)}`}>{r.delta > 0 ? "+" : ""}{fmtInt(r.delta)}</span> : "–";
       case "density": return hi === "density" ? bar(r.density, fmt(r.density)) : fmt(r.density);
       case "rate": {
         if (!r.weights) return fmt(r.rate, 3);
@@ -145,7 +186,7 @@ function RankTable({ ctx }: { ctx: ChartDataContext }) {
       case "skip": return bar(r.skip, fmt(r.skip, 3));
     }
   };
-  const tdClass = (k: Col) => ["num", "level", "time", "bpm", "notes", "density", "rate", "need", "chance", "perHour", "goal", "perMinute", "relative", "skip"].includes(k)
+  const tdClass = (k: Col) => ["num", "level", "time", "bpm", "notes", "density", "rate", "need", "chance", "perHour", "goal", "perMinute", "relative", "skip", "score", "delta"].includes(k)
     ? `num${k === "relative" ? " dim" : ""}` : k === "song" ? "song-td" : k === "rank" ? "rank" : "";
 
   return (
@@ -165,6 +206,7 @@ function RankTable({ ctx }: { ctx: ChartDataContext }) {
                 {list.map((r, i) => (
                   <tr
                     key={r.scoreId}
+                    data-score-id={r.scoreId}
                     className={r.frontier && unsorted ? "on-front" : undefined}
                     tabIndex={0}
                     onClick={() => ctx.openChart(r.scoreId)}
diff --git a/src/components/chart-data/SettingsPanel.tsx b/src/components/chart-data/SettingsPanel.tsx
index b4525f88..79a930f5 100644
--- a/src/components/chart-data/SettingsPanel.tsx
+++ b/src/components/chart-data/SettingsPanel.tsx
@@ -73,10 +73,11 @@ export function ScenarioPanel({ ctx, rooms = false, missions = null }: { ctx: Ch
           value={state.mode}
           onPick={(mode) => update({ mode })}
           options={[
-            { value: "battle", label: tr("scenario.battle") },
+            { value: "battle", label: tr(ctx.snap?.active ? "snap.fixedGekisou" : "scenario.battle") },
             { value: "free", label: support.free ? tr("scenario.free") : `${tr("scenario.free")} · ${tr("scenario.pending")}`, disabled: !support.free },
           ]}
         />
+        {battle && ctx.snap?.active ? <small className="mn-cd-note">{tr("snap.fixedGekisouHint")}</small> : null}
       </div>
       {battle ? (
         <div className="mn-cd-field">
diff --git a/src/components/chart-data/SnapPairedMemberControls.tsx b/src/components/chart-data/SnapPairedMemberControls.tsx
new file mode 100644
index 00000000..348e2b52
--- /dev/null
+++ b/src/components/chart-data/SnapPairedMemberControls.tsx
@@ -0,0 +1,33 @@
+import { t } from "@/i18n";
+import type { AppLocale } from "@/config/locales";
+import MemberCardArtwork from "@/components/shared/MemberCardArtwork";
+import type { CardViewModel } from "@/lib/cards/data";
+import type { SnapMemberSelection } from "@/lib/chart-data/snap-query";
+
+export interface SnapReferenceMember { id: number; name: string; vm?: CardViewModel; gkLevels: number[] }
+
+/** Explicit reference predicates for the paired slot, without assuming the player's ownership or growth. */
+export default function SnapPairedMemberControls({ locale, members, value, onChange }: {
+  locale: AppLocale;
+  members: readonly SnapReferenceMember[];
+  value: SnapMemberSelection | null;
+  onChange: (member: SnapMemberSelection | null) => void;
+}) {
+  const tr = (key: string, values?: Record<string, string | number>) => t(locale, `chartData.snap.${key}`, values);
+  const member = members.find((entry) => entry.id === value?.memberId);
+  const vm = member?.vm;
+  return <div className="mn-cd-snap-paired">
+    {vm ? <MemberCardArtwork key={`${vm.id}:${vm.assetId}`} assetId={vm.assetId} characterId={vm.characterId} rarity={vm.rarity} cardType={vm.cardType}
+      alt="" attributeLabel={t(locale, `cards.attributes.${vm.cardType}`)} fallbackLabel={member!.name} className="mn-cd-snap-member-art" /> : null}
+    <label><span>{tr("pairedMember")}</span><select value={value?.memberId ?? ""} onChange={(event) => onChange(event.target.value ? { memberId: Number(event.target.value), gekisouLevel: null } : null)}>
+      <option value="">{tr("chooseMember")}</option>
+      {value && !member ? <option value={value.memberId}>{tr("unavailable")}</option> : null}
+      {members.map((entry) => <option key={entry.id} value={entry.id}>{entry.name || String(entry.id)}</option>)}
+    </select></label>
+    {member ? <label><span>{tr("gkLevel")}</span><select value={value?.gekisouLevel ?? ""}
+      onChange={(event) => onChange({ memberId: member.id, gekisouLevel: event.target.value ? Number(event.target.value) : null })}>
+      <option value="">{tr("noGkSkill")}</option>
+      {member.gkLevels.map((level) => <option key={level} value={level}>{tr("level", { n: level })}</option>)}
+    </select></label> : null}
+  </div>;
+}
diff --git a/src/components/chart-data/SnapRankingController.tsx b/src/components/chart-data/SnapRankingController.tsx
new file mode 100644
index 00000000..c1dcdd65
--- /dev/null
+++ b/src/components/chart-data/SnapRankingController.tsx
@@ -0,0 +1,51 @@
+import { useEffect, useRef } from "react";
+import type { AppLocale } from "@/config/locales";
+import { emptySnapRanking, SnapRankingClient, snapProfileKey, snapSourceKey, type SnapRankingCatalogue, type SnapRankingSource, type SnapRankingState } from "@/lib/chart-data/snap-client";
+import type { SnapEvaluationProfile } from "@/lib/chart-data/snap-types";
+
+export interface SnapRankingControllerProps {
+  source: SnapRankingSource | null;
+  profile: SnapEvaluationProfile;
+  scoreIds: readonly number[];
+  enabled: boolean;
+  locale: AppLocale;
+  onState: (state: SnapRankingState) => void;
+  onCatalogue: (catalogue: SnapRankingCatalogue) => void;
+  onCatalogueError?: (error: { code: string; message: string }) => void;
+}
+
+/** The catalogue can load on picker-open while all five slots remain None. */
+export default function SnapRankingController(props: SnapRankingControllerProps) {
+  const callbacks = useRef(props);
+  callbacks.current = props;
+  const client = useRef<SnapRankingClient | null>(null);
+  const sourceKey = props.source ? snapSourceKey(props.source) : "";
+  const profileKey = snapProfileKey(props.profile);
+  const chartKey = JSON.stringify([...new Set(props.scoreIds)].sort((a, b) => a - b));
+  const active = props.enabled && props.profile.selections.some(Boolean);
+
+  useEffect(() => {
+    if (!props.source) {
+      callbacks.current.onState(emptySnapRanking());
+      return;
+    }
+    const instance = new SnapRankingClient((state) => callbacks.current.onState(state),
+      (catalogue) => callbacks.current.onCatalogue(catalogue), undefined,
+      (error) => callbacks.current.onCatalogueError?.(error));
+    client.current = instance;
+    return () => { instance.dispose(); if (client.current === instance) client.current = null; };
+  }, [sourceKey]);
+
+  useEffect(() => {
+    if (props.source) client.current?.loadCatalogue(props.source, props.locale);
+  }, [sourceKey, props.locale]);
+
+  useEffect(() => {
+    const instance = client.current;
+    if (!instance) return;
+    if (active && props.source) instance.measure(props.source, props.profile, JSON.parse(chartKey) as number[]);
+    else instance.reset();
+    return () => instance.cancel();
+  }, [sourceKey, profileKey, chartKey, active]);
+  return null;
+}
diff --git a/src/components/chart-data/SnapRankingPanel.tsx b/src/components/chart-data/SnapRankingPanel.tsx
new file mode 100644
index 00000000..31710cc5
--- /dev/null
+++ b/src/components/chart-data/SnapRankingPanel.tsx
@@ -0,0 +1,54 @@
+import { useMemo } from "react";
+import { isGameServer, PRIMARY_SERVER } from "@/config/servers";
+import { ContentServerProvider } from "@/lib/servers/use-content-server";
+import { snapProfileKey, snapSourceKey, type SnapRankingCatalogue, type SnapRankingState } from "@/lib/chart-data/snap-client";
+import { buildSnapSourceCards, labelSnapRankingCatalogue } from "@/lib/chart-data/snap-source-vms";
+import { replaceSnapSlot } from "@/lib/chart-data/snap-query";
+import SnapSkillPicker from "./SnapSkillPicker";
+import SnapPairedMemberControls from "./SnapPairedMemberControls";
+import type { ChartDataContext } from "./shared";
+
+export default function SnapRankingPanel({ ctx, catalogue, measurement, loading, invalidMembers, available, catalogueError, onOpen }: {
+  ctx: ChartDataContext;
+  catalogue: SnapRankingCatalogue | null;
+  measurement: SnapRankingState;
+  loading: boolean;
+  invalidMembers: readonly number[];
+  available: boolean;
+  catalogueError: boolean;
+  onOpen: () => void;
+}) {
+  const { locale, tr, state, update } = ctx;
+  const region = ctx.data.provenance?.region;
+  const server = isGameServer(region) ? region : PRIMARY_SERVER;
+  const cards = useMemo(() => catalogue ? buildSnapSourceCards(catalogue.data, ctx.data, catalogue.labelSource, locale) : null, [catalogue, ctx.data, locale]);
+  const choices = useMemo(() => catalogue ? labelSnapRankingCatalogue(catalogue.choices, catalogue.data, ctx.data, catalogue.labelSource, locale) : [], [catalogue, ctx.data, locale]);
+  const active = state.snapSkills.some(Boolean);
+  const memberContextVisible = state.snapSkills.some((selection) => selection && choices.some((choice) => choice.kind === selection.kind
+    && choice.skillId === selection.skillId && choice.level === selection.level && choice.requirements.includes("paired-member")));
+  const current = ctx.snap?.source && snapProfileKey(ctx.snap.profile) === measurement.profileKey && snapSourceKey(ctx.snap.source) === measurement.sourceKey;
+  const catalogueStatus = !available ? "loadUnavailable" : catalogueError ? "calculationError" : null;
+  const status = invalidMembers.length ? "invalidMember" : catalogueStatus ?? (current && measurement.status === "error" ? "calculationError"
+    : current && measurement.status === "needs-context" ? "needsContext" : current && measurement.status === "unsupported" ? "unsupportedScenario" : null);
+  return <ContentServerProvider server={server} servers={[server]}><div className="mn-cd-snap-area">
+    <SnapSkillPicker locale={locale} choices={choices} selections={state.snapSkills} cards={cards?.snaps}
+      loading={loading && !catalogueStatus} error={catalogueStatus ? tr(`snap.${catalogueStatus}`) : null} onOpen={onOpen}
+      onSelect={(slot, selection) => update({ snapSkills: replaceSnapSlot(state.snapSkills, slot, selection) })}
+      onReset={() => update({ snapSkills: [null, null, null, null, null], snapMembers: [null, null, null, null, null], snapPower: 300000 })}
+      renderContext={(slot, choice) => memberContextVisible || choice?.kind === "gekisou-support" || state.snapMembers[slot]
+        ? <SnapPairedMemberControls locale={locale} members={cards?.members ?? []} value={state.snapMembers[slot] ?? null}
+          onChange={(member) => update({ snapMembers: replaceSnapSlot(state.snapMembers, slot, member) })} /> : null} />
+    {catalogue && !catalogue.labelSource ? <p className="mn-cd-note">{tr("snap.snapshotFallback")}</p> : null}
+    {active ? <div className="mn-cd-snap-measure mn-cd-panel">
+      <label className="mn-cd-field"><span>{tr("snap.measurementPower")}</span><input type="number" className="mn-cd-num power" inputMode="numeric"
+        min={1} max={20000000} step={1000} value={state.snapPower} onChange={(event) => update({ snapPower: Math.min(20000000, Math.max(1, Math.round(Number(event.target.value) || 1))) })} /></label>
+      <div><strong>{tr("snap.fixedConditions")}</strong><p>{tr(state.mode === "free" ? "scenario.free" : "snap.fixedGekisou")} {state.mode === "battle" ? `· ${state.ranks.join(" / ")}` : ""}</p>
+        <p>{tr("snap.fixedPlan", { great: state.great, just: state.mode === "free" ? 0 : state.just })}</p><small>{tr("snap.profileHint")}</small></div>
+      <p className="mn-cd-snap-progress" role="status" aria-live="polite">
+        {status ? tr(`snap.${status}`) : current && measurement.status === "complete" ? tr("snap.ready", { n: measurement.rows.size })
+          : tr("snap.calculating", { done: current ? measurement.done : 0, total: current ? measurement.total : ctx.pool.length })}
+      </p>
+      {current && measurement.total > 0 && measurement.status === "running" ? <progress value={measurement.done} max={measurement.total} aria-label={tr("snap.calculating", { done: measurement.done, total: measurement.total })} /> : null}
+    </div> : null}
+  </div></ContentServerProvider>;
+}
diff --git a/src/components/chart-data/SnapSkillPicker.tsx b/src/components/chart-data/SnapSkillPicker.tsx
new file mode 100644
index 00000000..1751fe7d
--- /dev/null
+++ b/src/components/chart-data/SnapSkillPicker.tsx
@@ -0,0 +1,128 @@
+import { useMemo, useState, type ReactNode } from "react";
+import type { AppLocale } from "@/config/locales";
+import { t } from "@/i18n";
+import Modal from "@/components/shared/Modal";
+import FilterButton from "@/components/shared/FilterButton";
+import SupportCardArtwork from "@/components/support-cards/SupportCardArtwork";
+import type { SupportCardViewModel } from "@/lib/support-cards/data";
+import { groupSnapSkills, searchSnapSkills } from "@/lib/chart-data/snap-search";
+import { snapChoiceKey } from "@/lib/chart-data/snap-catalogue";
+import type { FiveSlots, SnapSkillChoice, SnapSkillKind, SnapSkillSelection } from "@/lib/chart-data/snap-types";
+import { Icon } from "./shared";
+
+interface Props {
+  locale: AppLocale;
+  choices: readonly SnapSkillChoice[];
+  selections: FiveSlots<SnapSkillSelection | null>;
+  cards?: ReadonlyMap<number, SupportCardViewModel> | undefined;
+  loading?: boolean;
+  error?: string | null;
+  onOpen?: () => void;
+  onSelect: (slot: number, selection: SnapSkillSelection | null) => void;
+  onReset: () => void;
+  renderContext?: (slot: number, choice: SnapSkillChoice | undefined) => ReactNode;
+}
+
+/** Five paired effect slots. Artwork, filters and accessible dialog come from the site's component library. */
+export default function SnapSkillPicker({ locale, choices, selections, cards, loading = false, error, onOpen, onSelect, onReset, renderContext }: Props) {
+  const tr = (key: string, values?: Record<string, string | number>) => t(locale, `chartData.snap.${key}`, values);
+  const [slot, setSlot] = useState<number | null>(null);
+  const [query, setQuery] = useState("");
+  const [kind, setKind] = useState<SnapSkillKind | "all">("all");
+  const [availableOnly, setAvailableOnly] = useState(false);
+  const [limit, setLimit] = useState(24);
+  const byKey = useMemo(() => new Map(choices.map((choice) => [choice.key, choice])), [choices]);
+  const groups = useMemo(() => groupSnapSkills(searchSnapSkills(choices, query, kind, availableOnly)), [choices, query, kind, availableOnly]);
+  const active = selections.filter(Boolean).length;
+  const title = (choice: SnapSkillChoice) => choice.name || tr("unnamed", { id: choice.skillId });
+  const selectedChoice = (selection: SnapSkillSelection | null) => selection ? byKey.get(snapChoiceKey(selection.kind, selection.skillId, selection.level)) : undefined;
+  const open = (index: number) => { setSlot(index); setQuery(""); setLimit(24); onOpen?.(); };
+  const pick = (choice: SnapSkillChoice | null) => {
+    if (slot === null) return;
+    onSelect(slot, choice ? { kind: choice.kind, skillId: choice.skillId, level: choice.level } : null);
+    setSlot(null);
+  };
+  const art = (choice: SnapSkillChoice, className: string) => {
+    const card = choice.cardIds.map((id) => cards?.get(id)).find(Boolean);
+    return card ? <SupportCardArtwork key={`${card.id}:${card.assetId}`} assetId={card.assetId} characterIds={card.characterIds} rarity={card.rarity}
+      cardType={card.cardType} alt="" attributeLabel={t(locale, `cards.attributes.${card.cardType}`)} fallbackLabel={card.name} className={className} />
+      : <span className={`mn-cd-snap-symbol ${className}`} aria-hidden="true"><Icon name="star" /></span>;
+  };
+
+  return (
+    <section className="mn-cd-snap mn-cd-glass" aria-label={tr("title")}>
+      <div className="mn-cd-snap-heading">
+        <div><h3><Icon name="star" />{tr("title")}<span className="mn-cd-snap-optional">{tr("optional")}</span></h3><p>{tr("intro")}</p></div>
+        <button type="button" className="mn-cd-ghost" disabled={!active} onClick={onReset}>{tr("reset")}</button>
+      </div>
+      <div className="mn-cd-snap-slots">
+        {selections.map((selection, index) => {
+          const choice = selectedChoice(selection);
+          const context = renderContext?.(index, choice);
+          return (
+            <div key={index} data-snap-slot={index} className={`mn-cd-snap-slot${selection ? " selected" : ""}`}>
+              <button type="button" className="mn-cd-snap-slot-button" aria-haspopup="dialog" aria-expanded={slot === index}
+                aria-label={tr("chooseSlot", { n: index + 1 })} onClick={() => open(index)}>
+                <span className="mn-cd-snap-slot-no">{tr("slot", { n: index + 1 })}</span>
+                {choice ? art(choice, "mn-cd-snap-slot-art") : <span className="mn-cd-snap-plus" aria-hidden="true">+</span>}
+                <span className="mn-cd-snap-slot-name">{choice ? title(choice) : selection ? tr("unavailable") : tr("none")}</span>
+                <span className="mn-cd-snap-slot-meta">{choice ? `${tr(`kind.${choice.kind}`)} · ${tr("level", { n: choice.level })}` : tr("choose")}</span>
+              </button>
+              {context ? <div className="mn-cd-snap-context">{context}</div> : null}
+              {selection ? <button type="button" className="mn-cd-snap-remove" aria-label={tr("removeSlot", { n: index + 1 })} onClick={() => onSelect(index, null)}>×</button> : null}
+            </div>
+          );
+        })}
+      </div>
+      <p className="mn-cd-snap-footnote">{active ? tr("selected", { n: active }) : tr("defaultNone")}</p>
+      <Modal isOpen={slot !== null} onClose={() => setSlot(null)} title={tr("dialog", { n: (slot ?? 0) + 1 })} closeLabel={tr("close")} size="xl">
+        <div className="mn-cd-snap-picker">
+          <label className="mn-cd-snap-search"><Icon name="search" /><input type="search" value={query} placeholder={tr("searchPlaceholder")}
+            aria-label={tr("search")} onChange={(event) => { setQuery(event.target.value); setLimit(24); }} /></label>
+          <div className="mn-cd-snap-filter-row">
+            {(["all", "support", "gekisou-support"] as const).map((value) => <FilterButton key={value} active={kind === value}
+              onClick={() => { setKind(value); setLimit(24); }}>{tr(value === "all" ? "allKinds" : `kind.${value}`)}</FilterButton>)}
+            <label className="mn-cd-snap-available"><input type="checkbox" checked={availableOnly} onChange={(event) => { setAvailableOnly(event.target.checked); setLimit(24); }} />{tr("availableOnly")}</label>
+          </div>
+          <button type="button" className="mn-cd-snap-none" onClick={() => pick(null)}><span aria-hidden="true">–</span><strong>{tr("none")}</strong><span>{tr("noneHint")}</span></button>
+          {loading ? <p className="mn-cd-snap-state" role="status">{tr("loading")}</p> : error ? <p className="mn-cd-snap-state" role="alert">{error}</p> : (
+            <>
+              <p className="mn-cd-snap-results" role="status">{tr("results", { n: groups.length })}</p>
+              <div className="mn-cd-snap-options">
+                {groups.slice(0, limit).map((levels) => {
+                  const current = slot === null ? null : selections[slot];
+                  const choice = current && current.kind === levels[0]!.kind && current.skillId === levels[0]!.skillId
+                    ? levels.find((entry) => entry.level === current.level) ?? levels.at(-1)! : levels.at(-1)!;
+                  return <SkillOption key={`${choice.kind}:${choice.skillId}`} choice={choice} levels={levels} title={title(choice)}
+                    art={art(choice, "mn-cd-snap-option-art")} selected={current?.kind === choice.kind && current.skillId === choice.skillId}
+                    tr={tr} onPick={pick} />;
+                })}
+              </div>
+              {!groups.length ? <p className="mn-cd-snap-state">{tr("empty")}</p> : groups.length > limit
+                ? <button type="button" className="mn-cd-ghost mn-cd-snap-more" onClick={() => setLimit((value) => value + 24)}>{tr("showMore")}</button> : null}
+            </>
+          )}
+        </div>
+      </Modal>
+    </section>
+  );
+}
+
+function SkillOption({ choice: initial, levels, title, art, selected, tr, onPick }: {
+  choice: SnapSkillChoice; levels: SnapSkillChoice[]; title: string; art: ReactNode; selected: boolean;
+  tr: (key: string, values?: Record<string, string | number>) => string; onPick: (choice: SnapSkillChoice) => void;
+}) {
+  const [level, setLevel] = useState(initial.level);
+  const choice = levels.find((entry) => entry.level === level) ?? initial;
+  return (
+    <article data-skill-kind={choice.kind} data-skill-id={choice.skillId} className={`mn-cd-snap-option${selected ? " selected" : ""}`}>
+      <div className="mn-cd-snap-option-top">{art}<div><span className="mn-cd-snap-kind">{tr(`kind.${choice.kind}`)}</span><h4>{title}</h4>
+        <span className="mn-cd-snap-id">{tr("skillId", { id: choice.skillId })}</span></div></div>
+      {choice.description ? <p className="mn-cd-snap-description">{choice.description}</p> : null}
+      {choice.requirements.length ? <p className="mn-cd-snap-requirements">{choice.requirements.map((requirement) => tr(`requirements.${requirement}`)).join(" · ")}</p> : null}
+      <div className="mn-cd-snap-option-actions"><label><span>{tr("levelLabel")}</span><select value={choice.level} onChange={(event) => setLevel(Number(event.target.value))}>
+        {levels.map((entry) => <option key={entry.level} value={entry.level}>{tr("level", { n: entry.level })}</option>)}</select></label>
+        <button type="button" className="mn-cd-ghost" disabled={choice.status === "unsupported"} onClick={() => onPick(choice)}>{tr(choice.status === "unsupported" ? "unsupported" : "select")}</button></div>
+    </article>
+  );
+}
diff --git a/src/components/chart-data/shared.tsx b/src/components/chart-data/shared.tsx
index 09c877db..0706bdb3 100644
--- a/src/components/chart-data/shared.tsx
+++ b/src/components/chart-data/shared.tsx
@@ -4,6 +4,8 @@ import type { ChartRow } from "@/lib/chart-data/catalog";
 import type { ChartDataState } from "@/lib/chart-data/query";
 import type { ScenarioSupport } from "@/lib/chart-data/scenario";
 import type { DataBand, MusicData } from "@/lib/chart-data/types";
+import type { SnapRankingSource, SnapRankingState } from "@/lib/chart-data/snap-client";
+import type { SnapEvaluationProfile } from "@/lib/chart-data/snap-types";
 import { DIFFICULTY_SHORT_LABELS, isMusicDifficulty } from "@/lib/music/difficulty";
 
 /** Everything the views share: the data, the choices and the text helpers. */
@@ -34,6 +36,7 @@ export interface ChartDataContext {
   openChart: (scoreId: number) => void;
   /** The rows the band and difficulty filters leave. */
   pool: ChartRow[];
+  snap?: { active: boolean; profile: SnapEvaluationProfile; measurement: SnapRankingState; source: SnapRankingSource | null } | undefined;
 }
 
 export const fmt = (v: number | null | undefined, d = 2) => (v === null || v === undefined || !Number.isFinite(v) ? "–" : v.toFixed(d));
diff --git a/src/i18n/messages/en-US.ts b/src/i18n/messages/en-US.ts
index 9e7967ca..dabc0859 100644
--- a/src/i18n/messages/en-US.ts
+++ b/src/i18n/messages/en-US.ts
@@ -1036,6 +1036,77 @@ export const enUS = {
     developmentData: "Local development data",
     uncommittedModel: "Uncommitted model changes",
     betaHint: "Rust model calculations; see the guide for native ARM64 checks and per-note replay.",
+    snap: {
+      "timelineHint": "The timeline shows source chart skill events, excluding Snap duration changes and additional effects.",
+      "fixedGekisou": "Solo Gekisou · fixed ranks",
+      "fixedGekisouHint": "Each song is replayed with the three declared ranks and the same team and input conditions.",
+      "perMinute": "Simulated score / minute",
+      "eventMeasurementHint": "Snap profiles compare simulated scores at the same power. Event power requirements and reach probabilities need a separate search.",
+      "noMeasurement": "No measurement",
+      "cancel": "Cancel",
+      "fixedPlan": "Fixed skill order 1 → 2 → 3 → 4 → 5; Great {great}%, Just {just}%.",
+      "snapshotFallback": "Some skill descriptions are unavailable in this data version. Card names and IDs remain searchable.",
+      "invalidMember": "A paired member or level is unavailable in this snapshot. Choose it again.",
+      "loadUnavailable": "This data version has no verified replay resources.",
+      "title": "Snap skills",
+      "optional": "Optional",
+      "intro": "Choose up to five paired skills to compare songs under the same profile.",
+      "reset": "Clear all",
+      "slot": "Slot {n}",
+      "chooseSlot": "Choose the Snap skill for slot {n}",
+      "removeSlot": "Remove the Snap skill from slot {n}",
+      "none": "None",
+      "choose": "Choose a skill",
+      "unavailable": "Skill unavailable in this snapshot",
+      "unnamed": "Snap skill #{id}",
+      "level": "Lv. {n}",
+      "levelLabel": "Skill level",
+      "defaultNone": "No Snap skills by default. The existing ranking stays unchanged.",
+      "selected": "{n} of 5 slots selected. Paired conditions are included in the measurement.",
+      "dialog": "Snap skill · slot {n}",
+      "close": "Close",
+      "search": "Search Snap skills",
+      "searchPlaceholder": "Name, effect, character, band or ID…",
+      "allKinds": "All skills",
+      "availableOnly": "Hide unsupported effects",
+      "noneHint": "Apply no Snap skill in this slot.",
+      "loading": "Loading the skill catalogue…",
+      "results": "{n} skills",
+      "empty": "No matching skills. Try another name or remove a filter.",
+      "showMore": "Show more",
+      "skillId": "Skill #{id}",
+      "unsupported": "Not supported",
+      "select": "Select",
+      "kind": {
+        "support": "Live Snap skill",
+        "gekisou-support": "Gekisou Snap skill"
+      },
+      "requirements": {
+        "paired-member": "Choose a paired member",
+        "gekisou-mode": "Gekisou Live only",
+        "paired-gekisou-skill": "Requires a paired Gekisou skill",
+        "raw-timing": "Requires raw timing input",
+        "missing-dependency": "Source dependencies unavailable"
+      },
+      "pairedMember": "Paired reference member",
+      "chooseMember": "Choose a member",
+      "gkLevel": "Member Gekisou level",
+      "noGkSkill": "No Gekisou skill",
+      "profile": "Standard skill profile",
+      "profileHint": "Reference members define skill conditions; unassigned slots have no member attributes. Scores use the declared measurement power.",
+      "measurementPower": "Measurement power",
+      "calculating": "Recalculating {done}/{total} charts…",
+      "ready": "Recalculated {n} charts",
+      "needsContext": "Complete the paired member settings to calculate this profile.",
+      "calculationError": "This profile could not be calculated.",
+      "unsupportedScenario": "This skill is unavailable for the selected play scenario.",
+      "measurementHint": "Theoretical play in the declared seed and skill order. Each song uses the same conditions.",
+      "score": "Simulated score",
+      "delta": "Snap difference",
+      "baseline": "Without Snap skills",
+      "fixedConditions": "Measurement conditions",
+      "retry": "Retry"
+    },
     views: { rank: "Rankings", charts: "Charts", guide: "Guide" },
     lead: {
       rank: "Efficiency, event ranks, speed, level and length of {songs} songs and {charts} charts. Score figures follow the play scenario chosen: by default Gekisou Live at rank 1 in all three ranges (the best case), or Free Live without Gekisou; see the guide. Open any row for the chart's details; credits, audio and chart previews are on each song's page.",
@@ -1215,7 +1286,7 @@ export const enUS = {
       "factorsHint": "Range notes lie after Start through the End score frame; the tail lies after End through Complete and is outside the range score. Some judgement types in Just ranges have no Just row and can only be Perfect. Lotteries are baseline seed means ± standard errors."
     },
     kinds: { tap: "Tap", flick: "Flick", slide: "Slide", trace: "Trace", combo: "Combo tick" },
-    source: "Data: Global / Japan · version {version}",
+    source: "Data: {region} · version {version}",
     sourceHint: "extracted from region {region} · master {master} · client {client}",
     deckModel: "score model",
     caveat: "Figures sourced from the decompiled game client: we aim for accuracy but cannot guarantee it; where other sources disagree, trust them",
diff --git a/src/i18n/messages/ja-JP.ts b/src/i18n/messages/ja-JP.ts
index 18f58120..e84e680e 100644
--- a/src/i18n/messages/ja-JP.ts
+++ b/src/i18n/messages/ja-JP.ts
@@ -1067,6 +1067,77 @@ export const jaJP = {
     developmentData: "ローカル開発データ",
     uncommittedModel: "未コミットのモデル変更",
     betaHint: "Rustモデルで計算。ARM64ネイティブ照合とノーツ別1ライブ計算は説明へ。",
+    snap: {
+      "timelineHint": "タイムラインは譜面の元のスキルイベントを表示します。Snap の時間延長や追加効果は含みません。",
+      "fixedGekisou": "ソロ撃奏 · 順位固定",
+      "fixedGekisouHint": "各曲を指定した3区間の順位と同じチーム・入力条件でリプレイします。",
+      "perMinute": "シミュレーションスコア / 分",
+      "eventMeasurementHint": "Snap 設定は同じ総合力でシミュレーションスコアを比較します。イベント目標に必要な総合力と達成確率は別途探索が必要です。",
+      "noMeasurement": "測定結果なし",
+      "cancel": "キャンセル",
+      "fixedPlan": "スキル順序固定 1 → 2 → 3 → 4 → 5；Great {great}%、Just {just}%。",
+      "snapshotFallback": "このデータ版では一部のスキル説明がありません。カード名と ID で検索できます。",
+      "invalidMember": "ペアのメンバーまたはレベルがこのデータ版にありません。選び直してください。",
+      "loadUnavailable": "このデータ版には検証可能なリプレイリソースがありません。",
+      "title": "スナップスキル",
+      "optional": "任意",
+      "intro": "5つの枠でスキルを選び、同じ条件で楽曲を比較します。",
+      "reset": "すべて解除",
+      "slot": "枠 {n}",
+      "chooseSlot": "枠 {n} のスナップスキルを選択",
+      "removeSlot": "枠 {n} のスナップスキルを解除",
+      "none": "なし",
+      "choose": "スキルを選択",
+      "unavailable": "このデータにないスキル",
+      "unnamed": "スナップスキル #{id}",
+      "level": "Lv. {n}",
+      "levelLabel": "スキルレベル",
+      "defaultNone": "初期設定はスナップスキルなし。従来のランキングを表示します。",
+      "selected": "{n}/5 枠を選択。測定時にペア条件を確認します。",
+      "dialog": "スナップスキル · 枠 {n}",
+      "close": "閉じる",
+      "search": "スナップスキルを検索",
+      "searchPlaceholder": "スキル名、効果、キャラクター、バンド、ID…",
+      "allKinds": "すべて",
+      "availableOnly": "未対応の効果を非表示",
+      "noneHint": "この枠にはスナップスキルを適用しません。",
+      "loading": "スキル一覧を読み込み中…",
+      "results": "{n} 件のスキル",
+      "empty": "該当するスキルがありません。検索語や条件を変更してください。",
+      "showMore": "もっと表示",
+      "skillId": "スキル #{id}",
+      "unsupported": "未対応",
+      "select": "選択",
+      "kind": {
+        "support": "ライブスナップスキル",
+        "gekisou-support": "撃奏スナップスキル"
+      },
+      "requirements": {
+        "paired-member": "ペアメンバーを選択",
+        "gekisou-mode": "撃奏ライブのみ",
+        "paired-gekisou-skill": "ペアの撃奏スキルが必要",
+        "raw-timing": "入力タイミングが必要",
+        "missing-dependency": "必要な元データが不足"
+      },
+      "pairedMember": "ペアの参照メンバー",
+      "chooseMember": "メンバーを選択",
+      "gkLevel": "メンバーの撃奏スキルレベル",
+      "noGkSkill": "撃奏スキルなし",
+      "profile": "標準スキル構成",
+      "profileHint": "参照メンバーでスキル条件を判定します。未選択スロットにメンバー属性はありません。指定した測定総合力で得点を計算します。",
+      "measurementPower": "測定総合力",
+      "calculating": "{done}/{total} 譜面を再計算中…",
+      "ready": "{n} 譜面を再計算しました",
+      "needsContext": "ペアメンバーを設定すると計算できます。",
+      "calculationError": "このスキル構成は計算できませんでした。",
+      "unsupportedScenario": "選択したライブ条件ではこのスキルを使用できません。",
+      "measurementHint": "指定のシードとスキル順序での理論プレイ。すべての楽曲に同じ条件を適用します。",
+      "score": "シミュレーションスコア",
+      "delta": "スナップによる差",
+      "baseline": "スナップスキルなし",
+      "fixedConditions": "測定条件",
+      "retry": "再試行"
+    },
     views: { rank: "ランキング", charts: "グラフ", guide: "解説" },
     lead: {
       rank: "{songs} 曲・{charts} 譜面の効率、イベントランク、速さ、レベル、長さ。スコア数値は選んだプレイ想定に従います。初期設定は 3 区間すべて 1 位の撃奏ライブ（最良のケース）で、撃奏なしのフリーライブにも切り替えられます。詳しくは解説をご覧ください。行を開くと譜面の詳細を表示します。作詞・作曲などのクレジット、音源、譜面プレビューは各楽曲ページにあります。",
@@ -1246,7 +1317,7 @@ export const jaJP = {
       "factorsHint": "区間のノーツは Start 後から End のスコアフレームまで、末尾は End 後から Complete までで区間スコアには入りません。Just 区間にも Just 行のない判定種類があり、Perfect にしかなりません。抽選回数は基準シードの平均 ± 標準誤差です。"
     },
     kinds: { tap: "タップ", flick: "フリック", slide: "スライド", trace: "トレース", combo: "コンボ判定点" },
-    source: "データ：グローバル版 / 日本版 · バージョン {version}",
+    source: "データ：{region} · バージョン {version}",
     sourceHint: "{region} リージョンから抽出 · master {master} · クライアント {client}",
     deckModel: "スコアモデル",
     caveat: "数値はゲームクライアントの逆コンパイルに基づいています。正しさを目指していますが、保証はできません。ほかの資料と食い違う場合は、そちらを信頼してください",
diff --git a/src/i18n/messages/ko-KR.ts b/src/i18n/messages/ko-KR.ts
index a11c1042..f4e63cf7 100644
--- a/src/i18n/messages/ko-KR.ts
+++ b/src/i18n/messages/ko-KR.ts
@@ -1036,6 +1036,77 @@ export const koKR = {
     developmentData: "로컬 개발 데이터",
     uncommittedModel: "커밋되지 않은 모델 변경",
     betaHint: "Rust 모델로 계산합니다. ARM64 네이티브 비교와 노트별 한 판 계산은 설명에서 확인할 수 있습니다.",
+    snap: {
+      "timelineHint": "타임라인은 원본 채보의 스킬 이벤트를 보여 줍니다. Snap 지속 시간 변경과 추가 효과는 포함하지 않습니다.",
+      "fixedGekisou": "솔로 격주 · 순위 고정",
+      "fixedGekisouHint": "각 곡을 지정한 세 구간 순위와 같은 팀 및 입력 조건으로 리플레이합니다.",
+      "perMinute": "시뮬레이션 점수 / 분",
+      "eventMeasurementHint": "Snap 설정은 같은 종합력의 시뮬레이션 점수를 비교합니다. 이벤트 목표에 필요한 종합력과 달성 확률은 별도 탐색이 필요합니다.",
+      "noMeasurement": "측정 결과 없음",
+      "cancel": "취소",
+      "fixedPlan": "스킬 순서 고정 1 → 2 → 3 → 4 → 5; Great {great}%, Just {just}%.",
+      "snapshotFallback": "이 데이터 버전에는 일부 스킬 설명이 없습니다. 카드 이름과 ID로 검색할 수 있습니다.",
+      "invalidMember": "짝 멤버 또는 레벨이 이 데이터 버전에 없습니다. 다시 선택하세요.",
+      "loadUnavailable": "이 데이터 버전에는 검증 가능한 리플레이 리소스가 없습니다.",
+      "title": "스냅 스킬",
+      "optional": "선택 사항",
+      "intro": "다섯 슬롯의 스킬을 선택하여 같은 조건에서 곡을 비교합니다.",
+      "reset": "모두 해제",
+      "slot": "슬롯 {n}",
+      "chooseSlot": "슬롯 {n}의 스냅 스킬 선택",
+      "removeSlot": "슬롯 {n}의 스냅 스킬 해제",
+      "none": "없음",
+      "choose": "스킬 선택",
+      "unavailable": "이 데이터에 없는 스킬",
+      "unnamed": "스냅 스킬 #{id}",
+      "level": "Lv. {n}",
+      "levelLabel": "스킬 레벨",
+      "defaultNone": "기본값은 스냅 스킬 없음이며 기존 순위를 유지합니다.",
+      "selected": "{n}/5 슬롯 선택. 계산 시 페어 조건을 확인합니다.",
+      "dialog": "스냅 스킬 · 슬롯 {n}",
+      "close": "닫기",
+      "search": "스냅 스킬 검색",
+      "searchPlaceholder": "스킬명, 효과, 캐릭터, 밴드 또는 ID…",
+      "allKinds": "모든 스킬",
+      "availableOnly": "미지원 효과 숨기기",
+      "noneHint": "이 슬롯에는 스냅 스킬을 적용하지 않습니다.",
+      "loading": "스킬 목록 불러오는 중…",
+      "results": "스킬 {n}개",
+      "empty": "일치하는 스킬이 없습니다. 검색어나 필터를 바꿔 보세요.",
+      "showMore": "더 보기",
+      "skillId": "스킬 #{id}",
+      "unsupported": "미지원",
+      "select": "선택",
+      "kind": {
+        "support": "라이브 스냅 스킬",
+        "gekisou-support": "격주 스냅 스킬"
+      },
+      "requirements": {
+        "paired-member": "페어 멤버 선택 필요",
+        "gekisou-mode": "격주 라이브 전용",
+        "paired-gekisou-skill": "페어 격주 스킬 필요",
+        "raw-timing": "원시 입력 타이밍 필요",
+        "missing-dependency": "필수 원본 데이터 부족"
+      },
+      "pairedMember": "페어 참조 멤버",
+      "chooseMember": "멤버 선택",
+      "gkLevel": "멤버 격주 스킬 레벨",
+      "noGkSkill": "격주 스킬 없음",
+      "profile": "표준 스킬 구성",
+      "profileHint": "참조 멤버로 스킬 조건을 판정합니다. 미선택 슬롯에는 멤버 속성이 없습니다. 지정한 측정 종합력으로 점수를 계산합니다.",
+      "measurementPower": "측정 종합력",
+      "calculating": "{done}/{total}개 채보 다시 계산 중…",
+      "ready": "채보 {n}개 계산 완료",
+      "needsContext": "페어 멤버 설정을 완료하면 계산할 수 있습니다.",
+      "calculationError": "이 스킬 구성을 계산하지 못했습니다.",
+      "unsupportedScenario": "선택한 라이브 조건에서는 이 스킬을 사용할 수 없습니다.",
+      "measurementHint": "지정한 시드와 스킬 순서의 이론 플레이이며 모든 곡에 같은 조건을 적용합니다.",
+      "score": "시뮬레이션 점수",
+      "delta": "스냅 점수 차이",
+      "baseline": "스냅 스킬 없음",
+      "fixedConditions": "측정 조건",
+      "retry": "재시도"
+    },
     views: { rank: "랭킹", charts: "그래프", guide: "설명" },
     lead: {
       rank: "{songs}곡, 채보 {charts}개의 효율, 이벤트 랭크, 속도, 레벨, 길이입니다. 스코어 수치는 선택한 플레이 시나리오를 따릅니다. 기본값은 세 구간 모두 1위인 격주 라이브(최선의 경우)이며, 격주가 없는 프리 라이브로 바꿀 수도 있습니다. 자세한 내용은 설명을 참고하세요. 행을 누르면 채보 상세를 볼 수 있고, 작사·작곡, 음원, 채보 미리보기는 각 곡 페이지에 있습니다.",
@@ -1215,7 +1286,7 @@ export const koKR = {
       "factorsHint": "구간 노트는 Start 이후 End 스코어 프레임까지, 꼬리는 End 이후 Complete까지로 구간 점수에서 제외됩니다. Just 구간에도 Just 행이 없는 판정 종류는 Perfect만 됩니다. 추첨 횟수는 기준 시드 평균 ± 표준오차입니다."
     },
     kinds: { tap: "탭", flick: "플릭", slide: "슬라이드", trace: "트레이스", combo: "콤보 틱" },
-    source: "데이터: 글로벌 / 일본 서버 · 버전 {version}",
+    source: "데이터: {region} · 버전 {version}",
     sourceHint: "{region} 서버에서 추출 · master {master} · 클라이언트 {client}",
     deckModel: "스코어 모델",
     caveat: "수치는 게임 클라이언트의 디컴파일에 근거합니다. 올바르도록 노력하지만 보장할 수는 없으며, 다른 자료와 다를 때는 그쪽을 믿어 주세요",
diff --git a/src/i18n/messages/zh-CN.ts b/src/i18n/messages/zh-CN.ts
index 3247d285..e7a22960 100644
--- a/src/i18n/messages/zh-CN.ts
+++ b/src/i18n/messages/zh-CN.ts
@@ -1073,6 +1073,77 @@ export const zhCN = {
     developmentData: "本地开发数据",
     uncommittedModel: "模型含未提交修改",
     betaHint: "Rust 模型计算；ARM64 原生核对与逐音符单局计算见说明。",
+    snap: {
+      "timelineHint": "时间轴显示谱面原始技能事件，不含留影的技能延长或追加效果。",
+      "fixedGekisou": "单人击奏 · 固定名次",
+      "fixedGekisouHint": "每首歌按选定的三段名次重放，使用相同队伍和输入条件。",
+      "perMinute": "模拟分数 / 分钟",
+      "eventMeasurementHint": "Snap 配置按相同综合力比较模拟分数。活动达标所需综合力与概率需要另行搜索计算。",
+      "noMeasurement": "暂无测量结果",
+      "cancel": "取消",
+      "fixedPlan": "固定技能顺序 1 → 2 → 3 → 4 → 5；Great {great}%，Just {just}%。",
+      "snapshotFallback": "此数据版本缺少部分技能说明，仍可按卡片名称和 ID 检索。",
+      "invalidMember": "配对成员或等级不属于此数据版本，请重新选择。",
+      "loadUnavailable": "此数据版本尚无可验证的重放资源。",
+      "title": "留影技能",
+      "optional": "可选",
+      "intro": "为五个槽位选择技能，在相同条件下比较歌曲。",
+      "reset": "全部清空",
+      "slot": "槽位 {n}",
+      "chooseSlot": "选择第 {n} 槽留影技能",
+      "removeSlot": "移除第 {n} 槽留影技能",
+      "none": "无",
+      "choose": "选择技能",
+      "unavailable": "此快照中无此技能",
+      "unnamed": "留影技能 #{id}",
+      "level": "Lv. {n}",
+      "levelLabel": "技能等级",
+      "defaultNone": "默认不计入留影技能，保持原有排行。",
+      "selected": "已选择 {n}/5 个槽位，测量时会核对配对条件。",
+      "dialog": "选择留影技能 · 第 {n} 槽",
+      "close": "关闭",
+      "search": "检索留影技能",
+      "searchPlaceholder": "技能名、效果、角色、乐队或 ID…",
+      "allKinds": "全部技能",
+      "availableOnly": "隐藏暂不支持的效果",
+      "noneHint": "此槽位不应用留影技能。",
+      "loading": "正在加载技能目录…",
+      "results": "找到 {n} 个技能",
+      "empty": "没有匹配的技能，试试其他关键词或减少筛选。",
+      "showMore": "显示更多",
+      "skillId": "技能 #{id}",
+      "unsupported": "暂不支持",
+      "select": "选择",
+      "kind": {
+        "support": "演出留影技能",
+        "gekisou-support": "击奏留影技能"
+      },
+      "requirements": {
+        "paired-member": "需选择配对成员",
+        "gekisou-mode": "仅适用于击奏演出",
+        "paired-gekisou-skill": "需配对成员的击奏技能",
+        "raw-timing": "需原始触控时序",
+        "missing-dependency": "源数据依赖不完整"
+      },
+      "pairedMember": "配对参考成员",
+      "chooseMember": "选择成员",
+      "gkLevel": "成员击奏技能等级",
+      "noGkSkill": "不使用击奏技能",
+      "profile": "标准技能组合",
+      "profileHint": "参考成员用于判定技能条件，未选成员的槽位无成员属性。分数使用所声明的测量综合力。",
+      "measurementPower": "测量综合力",
+      "calculating": "正在重算 {done}/{total} 张谱面…",
+      "ready": "已重算 {n} 张谱面",
+      "needsContext": "补齐配对成员设置后即可计算此组合。",
+      "calculationError": "此技能组合暂时无法计算。",
+      "unsupportedScenario": "此技能不适用于所选演出场景。",
+      "measurementHint": "按声明的种子与技能顺序进行理论演出，各首歌曲使用相同条件。",
+      "score": "模拟分数",
+      "delta": "留影带来的差值",
+      "baseline": "不使用留影技能",
+      "fixedConditions": "测量条件",
+      "retry": "重试"
+    },
     views: { rank: "排行", charts: "图表", guide: "说明" },
     lead: {
       rank: "{songs} 首歌、{charts} 张谱面的效率、活动评级、速度、等级与时长。得分数值按所选游玩场景计算：默认撃奏ライブ、三个区间都是第 1 名（最佳情况），也可切到不开激走的自由 Live，见说明。点任意一行看谱面详情；作词作曲、音频和谱面预览见各歌曲页。",
@@ -1252,7 +1323,7 @@ export const zhCN = {
       "factorsHint": "区间音符在 Start 后至 End 得分帧内；尾部在 End 后至 Complete，不计入区间分。Just 区间内部分判定类型没有 Just 行，只能是 Perfect。抽签次数为基线种子均值 ± 标准误。"
     },
     kinds: { tap: "点击", flick: "划键", slide: "长条", trace: "追踪", combo: "连击节点" },
-    source: "数据：国际服 / 日服 · 版本 {version}",
+    source: "数据：{region} · 版本 {version}",
     sourceHint: "提取自 {region} 区服 · master {master} · 客户端 {client}",
     deckModel: "得分模型",
     caveat: "数值以游戏反编译为来源，尽量准确但不保证正确；与其它资料有出入时请以它们为准",
diff --git a/src/i18n/messages/zh-TW.ts b/src/i18n/messages/zh-TW.ts
index 3ae413f3..140cb327 100644
--- a/src/i18n/messages/zh-TW.ts
+++ b/src/i18n/messages/zh-TW.ts
@@ -1073,6 +1073,77 @@ export const zhTW = {
     developmentData: "本地開發資料",
     uncommittedModel: "模型含未提交修改",
     betaHint: "Rust 模型計算；ARM64 原生核對及逐音符單局計算見說明。",
+    snap: {
+      "timelineHint": "時間軸顯示譜面原始技能事件，不含留影的技能延長或追加效果。",
+      "fixedGekisou": "單人擊奏 · 固定名次",
+      "fixedGekisouHint": "每首歌按選定的三段名次重放，使用相同隊伍和輸入條件。",
+      "perMinute": "模擬分數 / 分鐘",
+      "eventMeasurementHint": "Snap 配置按相同綜合力比較模擬分數。活動達標所需綜合力與機率需要另行搜尋計算。",
+      "noMeasurement": "暫無測量結果",
+      "cancel": "取消",
+      "fixedPlan": "固定技能順序 1 → 2 → 3 → 4 → 5；Great {great}%，Just {just}%。",
+      "snapshotFallback": "此資料版本缺少部分技能說明，仍可按卡片名稱和 ID 檢索。",
+      "invalidMember": "配對成員或等級不屬於此資料版本，請重新選擇。",
+      "loadUnavailable": "此資料版本尚無可驗證的重放資源。",
+      "title": "留影技能",
+      "optional": "可選",
+      "intro": "為五個槽位選擇技能，在相同條件下比較歌曲。",
+      "reset": "全部清空",
+      "slot": "槽位 {n}",
+      "chooseSlot": "選擇第 {n} 槽留影技能",
+      "removeSlot": "移除第 {n} 槽留影技能",
+      "none": "無",
+      "choose": "選擇技能",
+      "unavailable": "此快照中無此技能",
+      "unnamed": "留影技能 #{id}",
+      "level": "Lv. {n}",
+      "levelLabel": "技能等級",
+      "defaultNone": "預設不計入留影技能，保留原有排行。",
+      "selected": "已選擇 {n}/5 個槽位，測量時會核對配對條件。",
+      "dialog": "選擇留影技能 · 第 {n} 槽",
+      "close": "關閉",
+      "search": "檢索留影技能",
+      "searchPlaceholder": "技能名、效果、角色、樂團或 ID…",
+      "allKinds": "全部技能",
+      "availableOnly": "隱藏暫不支援的效果",
+      "noneHint": "此槽位不套用留影技能。",
+      "loading": "正在載入技能目錄…",
+      "results": "找到 {n} 個技能",
+      "empty": "沒有符合的技能，試試其他關鍵字或減少篩選。",
+      "showMore": "顯示更多",
+      "skillId": "技能 #{id}",
+      "unsupported": "暫不支援",
+      "select": "選擇",
+      "kind": {
+        "support": "演出留影技能",
+        "gekisou-support": "擊奏留影技能"
+      },
+      "requirements": {
+        "paired-member": "需選擇配對成員",
+        "gekisou-mode": "僅適用於擊奏演出",
+        "paired-gekisou-skill": "需配對成員的擊奏技能",
+        "raw-timing": "需原始觸控時序",
+        "missing-dependency": "來源資料依賴不完整"
+      },
+      "pairedMember": "配對參考成員",
+      "chooseMember": "選擇成員",
+      "gkLevel": "成員擊奏技能等級",
+      "noGkSkill": "不使用擊奏技能",
+      "profile": "標準技能組合",
+      "profileHint": "參考成員用於判定技能條件，未選成員的槽位無成員屬性。分數使用所聲明的測量綜合力。",
+      "measurementPower": "測量綜合力",
+      "calculating": "正在重算 {done}/{total} 張譜面…",
+      "ready": "已重算 {n} 張譜面",
+      "needsContext": "補齊配對成員設定後即可計算此組合。",
+      "calculationError": "此技能組合暫時無法計算。",
+      "unsupportedScenario": "此技能不適用於所選演出場景。",
+      "measurementHint": "按聲明的種子與技能順序進行理論演出，各首歌曲使用相同條件。",
+      "score": "模擬分數",
+      "delta": "留影帶來的差值",
+      "baseline": "不使用留影技能",
+      "fixedConditions": "測量條件",
+      "retry": "重試"
+    },
     views: { rank: "排行", charts: "圖表", guide: "說明" },
     lead: {
       rank: "{songs} 首歌、{charts} 張譜面的效率、活動評級、速度、等級與時長。得分數值按所選遊玩場景計算：預設為撃奏ライブ、三個區間都是第 1 名（最佳情況），也可切換到不開激走的自由 Live，見說明。點選任一列查看譜面詳情；作詞作曲、音訊和譜面預覽見各歌曲頁面。",
@@ -1252,7 +1323,7 @@ export const zhTW = {
       "factorsHint": "區間音符在 Start 後至 End 得分影格內；尾部在 End 後至 Complete，不計入區間分。Just 區間內部分判定類型沒有 Just 列，只能是 Perfect。抽籤次數為基線種子平均 ± 標準誤。"
     },
     kinds: { tap: "點擊", flick: "劃鍵", slide: "長條", trace: "追蹤", combo: "連擊節點" },
-    source: "資料：國際服 / 日服 · 版本 {version}",
+    source: "資料：{region} · 版本 {version}",
     sourceHint: "擷取自 {region} 伺服器 · master {master} · 用戶端 {client}",
     deckModel: "得分模型",
     caveat: "數值以遊戲反編譯為來源，盡量準確但不保證正確；與其他資料有出入時請以它們為準",
diff --git a/src/lib/cards/skills.ts b/src/lib/cards/skills.ts
index 4a56f23e..f4672087 100644
--- a/src/lib/cards/skills.ts
+++ b/src/lib/cards/skills.ts
@@ -41,6 +41,7 @@ export interface RawSkillConditionSet {
 export interface RawSkillCondition {
   id: number;
   conditionValues: number[];
+  conditionTargetIDs?: number[];
 }
 
 export interface RawSkillCumulativeCondition {
diff --git a/src/lib/chart-data/client.ts b/src/lib/chart-data/client.ts
index 97b4beee..5da4416d 100644
--- a/src/lib/chart-data/client.ts
+++ b/src/lib/chart-data/client.ts
@@ -20,3 +20,10 @@ export async function fetchMusicData(signal?: AbortSignal): Promise<MusicData> {
   if (typeof data.format === "string" && data.format !== MUSIC_DATA_FORMAT) throw new MusicDataError(`music-data.json: format ${data.format}`);
   return data;
 }
+
+/** Transport only. The replay bridge verifies the exact manifest SHA, size and snapshot identity. */
+export async function fetchMusicReplayResource(url: string, signal?: AbortSignal): Promise<ArrayBuffer> {
+  const response = await fetch(url, { credentials: "omit", signal: signal ?? null });
+  if (!response.ok) throw new MusicDataError(`Replay resource: HTTP ${response.status}`);
+  return response.arrayBuffer();
+}
diff --git a/src/lib/chart-data/query.ts b/src/lib/chart-data/query.ts
index f7a04331..9eee3297 100644
--- a/src/lib/chart-data/query.ts
+++ b/src/lib/chart-data/query.ts
@@ -1,6 +1,7 @@
 import { DIFFICULTIES, SCORE_RANKS, type Difficulty, type LengthSource, type ScoreRank } from "./ranking";
 import { BEST_RANKS, RANK_MAX, formatRanks, parseRanks, type Scenario, type ScenarioId, type ScenarioSupport } from "./scenario";
 import { axisGoal } from "./pareto";
+import { parseSnapQuery, writeSnapQuery, type SnapQueryState } from "./snap-query";
 
 /**
  * The chart data tool's choices live in the query, as on ournotes-player's chart data page (the page's language is
@@ -30,7 +31,7 @@ export const EFF_AXES: ReadonlySet<Axis> = new Set(["perMinute", "rate", "base",
 export const SKILL_SLOTS = 5;
 const DEFAULT_SKILLS = "100,100,100,100,100";
 
-export interface ChartDataState {
+export interface ChartDataState extends SnapQueryState {
   view: View;
   band: string;
   diffs: Difficulty[];
@@ -94,6 +95,7 @@ export function parseChartDataQuery(search: string, ctx: QueryContext): ChartDat
   const parsedAx = oneOf(AXES, ax) ? ax : "displayLevel";
   const parsedAy = oneOf(AXES, ay) ? ay : defaultY(ctx);
   return {
+    ...parseSnapQuery(q),
     view: oneOf(VIEWS, view) ? view : "rank",
     band: q.get("band") || "",
     diffs: (q.get("d") || "expert").split(",").filter((d): d is Difficulty => oneOf(DIFFICULTIES, d)),
@@ -146,6 +148,7 @@ export function serializeChartDataQuery(state: ChartDataState, ctx: QueryContext
   put("xg", state.xGoal, axisGoal(state.ax));
   put("yg", state.yGoal, axisGoal(state.ay));
   put("c", state.chart, null);
+  writeSnapQuery(p, state);
   let text = p.toString();
   if (state.frontier) text += `${text ? "&" : ""}frontier`;
   return text;
diff --git a/src/lib/chart-data/snap-bridge.ts b/src/lib/chart-data/snap-bridge.ts
new file mode 100644
index 00000000..7b09e923
--- /dev/null
+++ b/src/lib/chart-data/snap-bridge.ts
@@ -0,0 +1,140 @@
+import { buildSnapSkillCatalogue, snapChoiceKey, snapRows } from "./snap-catalogue";
+import type { SnapDeckData, SnapEvaluationProfile, SnapReplayEngine, SnapReplayManifest, SnapReplayReference, SnapReplayResource, SnapReplayResult } from "./snap-types";
+import type { SnapLabelSource } from "./snap-labels";
+import { fetchMusicReplayResource } from "./client";
+
+/** The original player's input-plan helper is injected; this bridge never recreates its algorithm. */
+export type SnapInputPlanPreparer = (request: Record<string, unknown>, description: Record<string, unknown>, data: SnapDeckData, profile: SnapEvaluationProfile) => void;
+export type SnapEngineFactory = (dataJson: string) => SnapReplayEngine;
+export interface LoadedSnapReplay {
+  data: SnapDeckData;
+  manifestSha256: string;
+  dataSha256: string;
+  modelCommit: string;
+  factory: SnapEngineFactory;
+  labelSource?: SnapLabelSource;
+}
+export class SnapReplayError extends Error {
+  constructor(public readonly code: "invalid-profile" | "unsupported" | "needs-context" | "identity" | "accuracy-plan", message: string) { super(message); this.name = "SnapReplayError"; }
+}
+const invalid = (message: string): never => { throw new SnapReplayError("invalid-profile", message); };
+function immutable<T>(value: T): T {
+  if (value && typeof value === "object" && !Object.isFrozen(value)) {
+    for (const child of Object.values(value)) immutable(child);
+    Object.freeze(value);
+  }
+  return value;
+}
+
+/** Validate every selection before allocating an engine or producing any scores. */
+export function validateSnapProfile(data: SnapDeckData, profile: SnapEvaluationProfile): void {
+  if ([profile.selections, profile.pairedMembers, profile.memberSkillPercent, profile.skillOrder].some((slots) => slots.length !== 5)) invalid("Exactly five physical slots are required");
+  if (profile.memberSkillPercent.some((value) => !Number.isFinite(value) || value < 0 || value * 100 > 2147483647 || Math.abs(value * 100 - Math.round(value * 100)) > 1e-7)) invalid("Skill percent needs a non-negative native factor at 0.01 percent precision");
+  if (new Set(profile.skillOrder).size !== 5 || profile.skillOrder.some((i) => !Number.isInteger(i) || i < 0 || i > 4)) invalid("Skill order must preserve all five performer indexes");
+  if (!Number.isInteger(profile.power) || profile.power <= 0 || profile.power > 2147483647 || !Number.isInteger(profile.seed) || profile.seed < -2147483648 || profile.seed > 2147483647) invalid("Measurement power and signed native seed are required");
+  if (![30, 60, 120].includes(profile.fps) || [profile.greatFraction, profile.justFraction].some((n) => !Number.isFinite(n) || n < 0 || n > 1)) invalid("Invalid declared play plan");
+  if (profile.mode.kind !== "normal" && (profile.mode.kind !== "fixedSoloGekisou" || profile.mode.ranks.length !== 3 || profile.mode.ranks.some((r) => !Number.isInteger(r) || r < 1 || r > 5))) invalid("Invalid fixed rank scenario");
+  profile.pairedMembers.forEach((member, i) => {
+    if (!member) return;
+    if (![member.bandId, member.characterId, member.cardType, member.gekisouMissionType].every(Number.isSafeInteger)
+      || member.bandId <= 0 || member.characterId <= 0 || member.cardType < 1 || member.cardType > 5
+      || [member.tagIds, member.liveSkillCategories, member.gekisouSkillCategories].some((values) => !Array.isArray(values) || values.some((v) => !Number.isSafeInteger(v)))) invalid(`Slot ${i}: member predicates are incomplete`);
+    if (!snapRows(data, "MasterCharacter").some((row) => row._id === member.characterId && row._bandID === member.bandId)) invalid(`Slot ${i}: character and band differ from source`);
+    if (member.gekisouSkill) {
+      const [id, level] = member.gekisouSkill;
+      const row = snapRows(data, "MasterGekisouSkill").find((skill) => skill._id === id);
+      if (!row || row._gekisouMissionType !== member.gekisouMissionType || JSON.stringify(row._skillCategories) !== JSON.stringify(member.gekisouSkillCategories)
+        || !snapRows(data, "MasterGekisouSkillEffect").some((effect) => effect._gekisouSkillID === id && effect._level === level)) invalid(`Slot ${i}: Gekisou predicates differ from its declared skill`);
+    }
+  });
+  const choices = new Map(buildSnapSkillCatalogue(data).map((choice) => [choice.key, choice]));
+  profile.selections.forEach((selection, i) => {
+    if (!selection) return;
+    const choice = choices.get(snapChoiceKey(selection.kind, selection.skillId, selection.level));
+    if (!choice || choice.status === "unsupported") throw new SnapReplayError("unsupported", `Slot ${i}: skill is not available for this judged-stream snapshot`);
+    const member = profile.pairedMembers[i];
+    if (choice.requirements.includes("paired-member") && !member) throw new SnapReplayError("needs-context", `Slot ${i}: paired member predicates are required`);
+    if (selection.kind === "gekisou-support" && (profile.mode.kind === "normal" || !member?.gekisouSkill)) throw new SnapReplayError("needs-context", `Slot ${i}: Gekisou mode and paired member Gekisou skill are required`);
+  });
+}
+
+/** Add declared plain 5s skills to an in-memory copy, retaining all native Snap rules unchanged. */
+export function snapProfileData(data: SnapDeckData, profile: SnapEvaluationProfile): SnapDeckData {
+  validateSnapProfile(data, profile);
+  const plain = snapRows(data, "MasterLiveSkillEffect").find((r) => r._skillEffectType === 2000 && r._activationTimeSecond === 5 && r._skillConditionGroup === 0 && r._skillReleaseConditionGroup === 0 && Array.isArray(r._skillTargetIDs) && r._skillTargetIDs.length === 0 && r._skillCumulativeConditionID === 0);
+  if (!plain) throw new SnapReplayError("unsupported", "The source has no plain 5s native skill shape");
+  const standardCategories = snapRows(data, "MasterLiveSkill").find((r) => r._id === plain._liveSkillID)?._skillCategories;
+  if (!Array.isArray(standardCategories)) throw new SnapReplayError("identity", "The plain skill prototype has no category identity");
+  const master = { ...data.master };
+  for (const tableName of ["MasterLiveSkill", "MasterLiveSkillEffect"]) {
+    const table = data.master[tableName];
+    if (!table) throw new SnapReplayError("identity", "Missing live skill table");
+    const additions = profile.memberSkillPercent.map((percent, i) => {
+      const id = -1000001 - i;
+      if (snapRows(data, tableName).some((r) => r._id === id)) throw new SnapReplayError("identity", "Synthetic profile ID collides with source");
+      const row = tableName === "MasterLiveSkill" ? { _id: id, _skillCategories: standardCategories }
+        : { ...plain, _id: id, _liveSkillID: id, _level: 1, _effectValue: Math.round(percent * 100), _maxEffectValue: 0, _effectLimitCount: 0, _effectExecuteLimitCount: 0, _effectExecuteLimitResetConditionGroup: 0 };
+      return table.columns.map((column) => row[column as keyof typeof row]);
+    });
+    master[tableName] = { columns: table.columns, rows: [...table.rows, ...additions] };
+  }
+  return { ...data, master };
+}
+
+/** Reuse one parsed Rust session for every chart of one declared evaluation context. */
+export function createSnapEvaluator(loaded: LoadedSnapReplay, profile: SnapEvaluationProfile, prepareInputPlan?: SnapInputPlanPreparer) {
+  // Later UI edits cannot relabel a parsed native session with another profile.
+  profile = immutable(structuredClone(profile));
+  const derived = snapProfileData(loaded.data, profile);
+  if (!prepareInputPlan && (profile.greatFraction !== 0 || profile.justFraction !== 0)) throw new SnapReplayError("accuracy-plan", "The shared input-plan helper is required for Great/Just presets");
+  const session = loaded.factory(JSON.stringify(derived));
+  return {
+    scope: "standard-skill-profile" as const,
+    source: { manifestSha256: loaded.manifestSha256, dataSha256: loaded.dataSha256, modelCommit: loaded.modelCommit },
+    profile,
+    evaluate(scoreId: number): SnapReplayResult {
+      const request = JSON.parse(session.template(scoreId, profile.power, profile.fps)) as Record<string, unknown>;
+      request.seed = profile.seed;
+      request.mode = profile.mode;
+      request.skillOrder = [...profile.skillOrder];
+      request.performers = profile.pairedMembers.map((member, i) => {
+        const selection = profile.selections[i];
+        const { memberId: _memberId, ...predicates } = member ?? { bandId: 0, characterId: 0, cardType: 0, tagIds: [], liveSkillCategories: [], gekisouSkillCategories: [], gekisouMissionType: 0, gekisouSkill: null };
+        const liveSkillCategories = snapRows(derived, "MasterLiveSkill").find((r) => r._id === -1000001 - i)?._skillCategories;
+        return { ...predicates, liveSkillCategories, liveSkill: [-1000001 - i, 1], supportSkills: selection?.kind === "support" ? [[selection.skillId, selection.level]] : [], gekisouSupportSkills: selection?.kind === "gekisou-support" ? [[selection.skillId, selection.level]] : [] };
+      });
+      if (prepareInputPlan) prepareInputPlan(request, JSON.parse(session.describeChart(scoreId)) as Record<string, unknown>, derived, profile);
+      const result = JSON.parse(session.run(JSON.stringify(request))) as SnapReplayResult;
+      if (result.format !== "ournotes.replay-result/1" || !result.complete || result.scoreId !== scoreId || !Number.isSafeInteger(result.score) || result.score < 0) throw new SnapReplayError("identity", "Replay did not return a complete matching result");
+      return result;
+    },
+    dispose: () => session.free?.(),
+  };
+}
+
+async function verified(url: string, identity: Pick<SnapReplayResource, "sha256" | "bytes">, signal?: AbortSignal): Promise<ArrayBuffer> {
+  const bytes = await fetchMusicReplayResource(url, signal);
+  const digest = [...new Uint8Array(await crypto.subtle.digest("SHA-256", bytes))].map((x) => x.toString(16).padStart(2, "0")).join("");
+  if (!/^[0-9a-f]{64}$/.test(identity.sha256) || digest !== identity.sha256 || (identity.bytes !== undefined && bytes.byteLength !== identity.bytes)) throw new SnapReplayError("identity", "Replay resource identity differs from its manifest");
+  return bytes;
+}
+
+/** Worker-compatible loader; JS only verifies bytes and transports JSON to the shared Rust engine. */
+export async function loadSnapReplayRuntime(site: string, reference: SnapReplayReference, expected: { region: string; masterVersion: string; modelCommit: string }, signal?: AbortSignal): Promise<LoadedSnapReplay> {
+  if (reference.format !== "nnnotes.replay-manifest/1") throw new SnapReplayError("identity", "Unsupported replay manifest");
+  const manifestUrl = new URL(reference.manifestUrl, `${site.replace(/\/+$/, "")}/`).href;
+  const manifest = JSON.parse(new TextDecoder().decode(await verified(manifestUrl, reference, signal))) as SnapReplayManifest;
+  if (manifest.format !== reference.format || manifest.engine?.requestFormat !== "ournotes.replay/1" || manifest.engine.model.commit !== expected.modelCommit) throw new SnapReplayError("identity", "Replay engine does not match the music data model");
+  const resource = (item: SnapReplayResource) => verified(new URL(item.url, manifestUrl).href, item, signal);
+  const [input, js, wasm] = await Promise.all([resource(manifest.deckData), resource(manifest.engine.js), resource(manifest.engine.wasm)]);
+  const data = JSON.parse(new TextDecoder().decode(input)) as SnapDeckData;
+  const master = data.provenance.master as { version?: string } | undefined, model = data.provenance.deck as { commit?: string } | undefined;
+  if (data.format !== "nnnotes.deck-data/1" || data.provenance.region !== expected.region || master?.version !== expected.masterVersion || model?.commit !== expected.modelCommit) throw new SnapReplayError("identity", "Replay inputs do not match the selected music-data snapshot");
+  const labelSource = manifest.snapLabels ? JSON.parse(new TextDecoder().decode(await resource(manifest.snapLabels))) as SnapLabelSource : undefined;
+  const moduleUrl = URL.createObjectURL(new Blob([js], { type: "text/javascript" }));
+  try {
+    const engine = await import(/* @vite-ignore */ moduleUrl) as { default(options: { module_or_path: ArrayBuffer }): Promise<void>; ReplaySession: new (input: string) => SnapReplayEngine };
+    await engine.default({ module_or_path: wasm });
+    return { data: immutable(data), manifestSha256: reference.sha256, dataSha256: manifest.deckData.sha256, modelCommit: expected.modelCommit, factory: (json) => new engine.ReplaySession(json), ...(labelSource ? { labelSource: immutable(labelSource) } : {}) };
+  } finally { URL.revokeObjectURL(moduleUrl); }
+}
diff --git a/src/lib/chart-data/snap-catalogue.ts b/src/lib/chart-data/snap-catalogue.ts
new file mode 100644
index 00000000..39b6d2ee
--- /dev/null
+++ b/src/lib/chart-data/snap-catalogue.ts
@@ -0,0 +1,87 @@
+import type { SnapDeckData, SnapMemberContext, SnapRequirement, SnapSkillChoice, SnapSkillKind } from "./snap-types";
+
+type Row = Record<string, unknown>;
+export function snapRows(data: SnapDeckData, name: string): Row[] {
+  const table = data.master[name];
+  if (!table || !Array.isArray(table.columns) || !Array.isArray(table.rows)) throw new Error(`Missing replay table: ${name}`);
+  return table.rows.map((row) => Object.fromEntries(table.columns.map((key, i) => [key, row[i]])));
+}
+const number = (value: unknown): number => { if (!Number.isSafeInteger(value)) throw new Error("Invalid replay integer"); return value as number; };
+const numbers = (value: unknown): number[] => { if (!Array.isArray(value)) throw new Error("Invalid replay integer array"); return value.map(number); };
+export const snapChoiceKey = (kind: SnapSkillKind, skillId: number, level: number) => `${kind}:${skillId}:${level}`;
+export type SnapLabeler = (kind: SnapSkillKind, skillId: number, level: number) => { name: string; description: string; iconUrl?: string } | undefined;
+
+/** Only skills actually bound to cards/ranks in this verified replay snapshot are choices. */
+export function buildSnapSkillCatalogue(data: SnapDeckData, label?: SnapLabeler): SnapSkillChoice[] {
+  const ranks = snapRows(data, "MasterSupportCardRank");
+  const conditions = new Map(snapRows(data, "MasterSkillCondition").map((r) => [number(r._id), r]));
+  const sets = snapRows(data, "MasterSkillConditionSet");
+  const targets = new Map(snapRows(data, "MasterSkillTarget").map((r) => [number(r._id), r]));
+  const cumulative = new Map(snapRows(data, "MasterSkillCumulativeCondition").map((r) => [number(r._id), r]));
+  const ordinary = snapRows(data, "MasterSupportSkillEffect"), gekisou = snapRows(data, "MasterGekisouSupportSkillEffect");
+  const choices = new Map<string, SnapSkillChoice>();
+  for (const card of snapRows(data, "MasterSupportCard")) for (const rank of ranks.filter((r) => r._group === card._supportCardRankGroup)) {
+    for (const kind of ["support", "gekisou-support"] as const) for (const binding of [1, 2] as const) {
+      const suffix = `0${binding}`;
+      const skillId = number(card[`_${kind === "support" ? "supportSkillId" : "gekisouSupportSkillId"}${suffix}`]);
+      if (!skillId) continue;
+      const level = number(rank[`_${kind === "support" ? "supportSkill" : "gekisouSupportSkill"}${suffix}Level`]);
+      const key = snapChoiceKey(kind, skillId, level);
+      let choice = choices.get(key);
+      if (!choice) {
+        const effects = (kind === "support" ? ordinary : gekisou).filter((r) => r[kind === "support" ? "_supportSkillID" : "_gekisouSupportSkillID"] === skillId && r._level === level);
+        const required = new Set<SnapRequirement>();
+        if (!effects.length) required.add("missing-dependency");
+        if (kind === "gekisou-support") { required.add("gekisou-mode"); required.add("paired-gekisou-skill"); }
+        for (const effect of effects) {
+          // Timing-window effects need actual raw timing input; a completed judgement plan cannot measure them.
+          if ([4000, 4001, 4002, 4003, 4004, 13001].includes(number(effect._skillEffectType))) required.add("raw-timing");
+          const targetIds = numbers(effect._skillTargetIDs);
+          const cumulativeId = number(effect._skillCumulativeConditionID);
+          if (cumulativeId && !cumulative.has(cumulativeId)) required.add("missing-dependency");
+          for (const field of ["_skillTriggerConditionGroup", "_skillConditionGroup", "_skillReleaseConditionGroup", "_effectExecuteLimitResetConditionGroup"]) {
+            const group = number(effect[field]);
+            if (!group) continue;
+            const groupSets = sets.filter((s) => s._group === group);
+            if (!groupSets.length) required.add("missing-dependency");
+            for (const set of groupSets) for (const id of numbers(set._conditionIds)) {
+              const condition = conditions.get(id);
+              if (!condition) { required.add("missing-dependency"); continue; }
+              if (condition._conditionType === 5000) required.add("paired-member");
+              targetIds.push(...numbers(condition._conditionTargetIDs));
+            }
+          }
+          for (const id of targetIds) {
+            const target = targets.get(id);
+            if (!target) { required.add("missing-dependency"); continue; }
+            if (["_characterID", "_bandID", "_cardType", "_tagID", "_gekisouMissionType"].some((f) => number(target[f]) !== 0)
+              || numbers(target._liveSkillCategories).length || numbers(target._gekisouSkillCategories).length) required.add("paired-member");
+          }
+        }
+        const text = label?.(kind, skillId, level);
+        choice = { key, kind, skillId, level, name: text?.name ?? "", description: text?.description ?? "", ...(text?.iconUrl ? { iconUrl: text.iconUrl } : {}), searchTerms: [String(skillId), text?.name ?? "", text?.description ?? ""], cardIds: [], rankBindings: [],
+          effectTypes: [...new Set(effects.map((r) => number(r._skillEffectType)))], requirements: [...required],
+          status: required.has("missing-dependency") || required.has("raw-timing") ? "unsupported" : required.size ? "needs-context" : "supported" };
+        choices.set(key, choice);
+      }
+      const cardId = number(card._id);
+      if (!choice.cardIds.includes(cardId)) choice.cardIds.push(cardId);
+      choice.rankBindings.push({ cardId, rank: number(rank._rank), binding });
+    }
+  }
+  return [...choices.values()];
+}
+
+/** Native predicate context from this same snapshot. Growth level is caller supplied. */
+export function snapMemberContext(data: SnapDeckData, memberId: number, gekisouLevel: number | null): SnapMemberContext {
+  const card = snapRows(data, "MasterMemberCard").find((r) => r._id === memberId);
+  if (!card) throw new Error("Member is absent from this replay snapshot");
+  const character = snapRows(data, "MasterCharacter").find((r) => r._id === card._characterID);
+  const live = snapRows(data, "MasterLiveSkill").find((r) => r._id === card._liveSkillID);
+  const gekisou = snapRows(data, "MasterGekisouSkill").find((r) => r._id === card._gekisouSkillID);
+  if (!character || !live || !gekisou) throw new Error("Member predicates have missing source dependencies");
+  if (gekisouLevel !== null && !snapRows(data, "MasterGekisouSkillEffect").some((r) => r._gekisouSkillID === card._gekisouSkillID && r._level === gekisouLevel)) throw new Error("Unknown paired member Gekisou level");
+  return { memberId, bandId: number(character._bandID), characterId: number(card._characterID), cardType: number(card._cardType), tagIds: numbers(card._bestMusicTagIDs),
+    liveSkillCategories: numbers(live._skillCategories), gekisouSkillCategories: numbers(gekisou._skillCategories), gekisouMissionType: number(gekisou._gekisouMissionType),
+    gekisouSkill: gekisouLevel === null ? null : [number(card._gekisouSkillID), gekisouLevel] };
+}
diff --git a/src/lib/chart-data/snap-client.ts b/src/lib/chart-data/snap-client.ts
new file mode 100644
index 00000000..e0b75315
--- /dev/null
+++ b/src/lib/chart-data/snap-client.ts
@@ -0,0 +1,163 @@
+import type { AppLocale } from "@/config/locales";
+import type { SnapLabelSource } from "./snap-labels";
+import type { SnapDeckData, SnapEvaluationProfile, SnapReplayReference, SnapSkillChoice } from "./snap-types";
+import type { MusicData } from "./types";
+
+export interface SnapRankingSource {
+  site: string;
+  reference: SnapReplayReference;
+  expected: { region: string; masterVersion: string; modelCommit: string };
+}
+export interface SnapMeasurementSource { manifestSha256: string; dataSha256: string; modelCommit: string }
+export interface SnapRankingCatalogue {
+  choices: SnapSkillChoice[];
+  /** A same-source metadata projection. Chart inputs stay in the Worker. */
+  data: SnapDeckData;
+  labelSource?: SnapLabelSource;
+  source: SnapMeasurementSource;
+}
+
+/** Reject late catalogue projections before invoking source-bound view model builders. */
+export function isCurrentSnapCatalogue(catalogue: SnapRankingCatalogue | null, music: MusicData | null): catalogue is SnapRankingCatalogue {
+  const master = catalogue?.data.provenance.master as { version?: string } | undefined;
+  const model = catalogue?.data.provenance.deck as { commit?: string } | undefined;
+  return !!catalogue && !!music?.replay && catalogue.source.manifestSha256 === music.replay.sha256
+    && catalogue.data.provenance.region === music.provenance?.region
+    && master?.version === music.provenance?.master?.version && model?.commit === music.provenance?.deck?.commit;
+}
+export interface SnapMeasuredRow {
+  scoreId: number;
+  score: number;
+  baselineScore: number;
+  delta: number;
+  life: number;
+  combo: number;
+  randomDraws: number;
+  convertedJudgements: number;
+}
+export type SnapRankingStatus = "idle" | "loading" | "running" | "complete" | "needs-context" | "unsupported" | "error";
+export interface SnapRankingState {
+  status: SnapRankingStatus;
+  revision: number;
+  profileKey: string;
+  sourceKey: string;
+  done: number;
+  total: number;
+  rows: ReadonlyMap<number, SnapMeasuredRow>;
+  source?: SnapMeasurementSource;
+  error?: { code: string; message: string };
+}
+export type SnapWorkerRequest =
+  | { kind: "catalogue"; revision: number; source: SnapRankingSource; locale: AppLocale }
+  | { kind: "measure"; revision: number; source: SnapRankingSource; profile: SnapEvaluationProfile; scoreIds: readonly number[] }
+  | { kind: "cancel"; revision: number };
+export type SnapWorkerResponse =
+  | { kind: "catalogue"; revision: number; catalogue: SnapRankingCatalogue }
+  | { kind: "progress"; revision: number; profileKey: string; done: number; total: number; rows: SnapMeasuredRow[]; source: SnapMeasurementSource }
+  | { kind: "complete"; revision: number; profileKey: string; done: number; total: number; source: SnapMeasurementSource; cacheHits: number }
+  | { kind: "cancelled"; revision: number }
+  | { kind: "error"; revision: number; phase: "catalogue" | "measure"; code: string; message: string };
+
+/** Conservative identity: changes in any declared input invalidate displayed rows. */
+export const snapProfileKey = (profile: SnapEvaluationProfile): string => JSON.stringify(profile);
+export const snapSourceKey = (source: SnapRankingSource): string => JSON.stringify(source);
+export function currentSnapRanking(profile: SnapEvaluationProfile, source: SnapRankingSource | null, measurement: SnapRankingState): SnapRankingState | null {
+  if (!source || measurement.profileKey !== snapProfileKey(profile) || measurement.sourceKey !== snapSourceKey(source)
+    || (measurement.source && measurement.source.manifestSha256 !== source.reference.sha256)) return null;
+  return measurement;
+}
+export const emptySnapRanking = (profileKey = "", revision = 0): SnapRankingState => ({ status: "idle", revision, profileKey, sourceKey: "", done: 0, total: 0, rows: new Map() });
+
+export interface SnapWorkerPort {
+  postMessage(message: SnapWorkerRequest): void;
+  addEventListener(type: "message", listener: (event: MessageEvent<SnapWorkerResponse>) => void): void;
+  addEventListener(type: "error", listener: (event: ErrorEvent) => void): void;
+  removeEventListener(type: "message", listener: (event: MessageEvent<SnapWorkerResponse>) => void): void;
+  removeEventListener(type: "error", listener: (event: ErrorEvent) => void): void;
+  terminate(): void;
+}
+
+/** Revisions protect both catalogue loads and chart jobs from late Worker messages. */
+export class SnapRankingClient {
+  private revision = 0;
+  private catalogueRevision = 0;
+  private jobRevision = 0;
+  private state = emptySnapRanking();
+  private disposed = false;
+  constructor(
+    private readonly onState: (state: SnapRankingState) => void,
+    private readonly onCatalogue: (catalogue: SnapRankingCatalogue) => void,
+    private readonly worker: SnapWorkerPort = new Worker(new URL("./snap-worker.ts", import.meta.url), { type: "module" }),
+    private readonly onCatalogueError?: (error: { code: string; message: string }) => void,
+  ) {
+    worker.addEventListener("message", this.message);
+    worker.addEventListener("error", this.workerError);
+  }
+  loadCatalogue(source: SnapRankingSource, locale: AppLocale): void {
+    if (this.disposed) return;
+    this.catalogueRevision = ++this.revision;
+    this.worker.postMessage({ kind: "catalogue", revision: this.catalogueRevision, source, locale });
+  }
+  measure(source: SnapRankingSource, profile: SnapEvaluationProfile, scoreIds: readonly number[]): void {
+    if (this.disposed) return;
+    this.cancel();
+    this.jobRevision = ++this.revision;
+    this.state = { status: "loading", revision: this.jobRevision, profileKey: snapProfileKey(profile), sourceKey: snapSourceKey(source), done: 0,
+      total: new Set(scoreIds).size, rows: new Map() };
+    this.onState(this.state);
+    this.worker.postMessage({ kind: "measure", revision: this.jobRevision, source, profile, scoreIds });
+  }
+  cancel(): void {
+    if (!this.jobRevision || this.disposed) return;
+    this.worker.postMessage({ kind: "cancel", revision: this.jobRevision });
+    this.jobRevision = 0;
+  }
+  reset(): void {
+    this.cancel();
+    this.state = emptySnapRanking("", ++this.revision);
+    if (!this.disposed) this.onState(this.state);
+  }
+  dispose(): void {
+    if (this.disposed) return;
+    this.cancel();
+    this.disposed = true;
+    this.worker.removeEventListener("message", this.message);
+    this.worker.removeEventListener("error", this.workerError);
+    this.worker.terminate();
+  }
+  private message = (event: MessageEvent<SnapWorkerResponse>): void => {
+    if (this.disposed) return;
+    const value = event.data;
+    if (value.kind === "catalogue") {
+      if (value.revision === this.catalogueRevision) this.onCatalogue(value.catalogue);
+      return;
+    }
+    if (value.kind === "error" && value.phase === "catalogue") {
+      if (value.revision === this.catalogueRevision) this.onCatalogueError?.(value);
+      return;
+    }
+    if (!this.jobRevision || value.revision !== this.jobRevision) return;
+    if (value.kind === "error") {
+      const status = value.code === "needs-context" ? "needs-context" : value.code === "unsupported" ? "unsupported" : "error";
+      this.state = { ...this.state, status, error: { code: value.code, message: value.message }, rows: new Map() };
+    } else if (value.kind === "cancelled") {
+      this.state = emptySnapRanking(this.state.profileKey, value.revision);
+    } else {
+      if (value.profileKey !== this.state.profileKey) return;
+      const rows = new Map(this.state.rows);
+      if (value.kind === "progress") for (const row of value.rows) rows.set(row.scoreId, row);
+      this.state = { ...this.state, status: value.kind === "complete" ? "complete" : "running", done: value.done,
+        total: value.total, rows, source: value.source };
+    }
+    this.onState(this.state);
+  };
+  private workerError = (event: ErrorEvent): void => {
+    if (this.disposed) return;
+    const error = { code: "worker", message: event.message };
+    this.onCatalogueError?.(error);
+    if (this.jobRevision) {
+      this.state = { ...this.state, status: "error", error, rows: new Map() };
+      this.onState(this.state);
+    }
+  };
+}
diff --git a/src/lib/chart-data/snap-labels.ts b/src/lib/chart-data/snap-labels.ts
new file mode 100644
index 00000000..a1ff200e
--- /dev/null
+++ b/src/lib/chart-data/snap-labels.ts
@@ -0,0 +1,62 @@
+import type { AppLocale } from "@/config/locales";
+import { normalizeCards, validateMasterTable, type RawBand, type RawCharacter, type RawMemberCard, type RawText } from "@/lib/cards/data";
+import type { RawSkillCondition, RawSkillConditionSet, RawSkillCumulativeCondition, RawSkillDefinition, RawSkillIcon } from "@/lib/cards/skills";
+import { normalizeSupportSkill, supportSkillTargetNames, type RawSupportSkillEffect, type RawSupportSkillTarget } from "@/lib/support-cards/skills";
+import { normalizeSupportCards, type RawSupportCard } from "@/lib/support-cards/data";
+import type { SnapLabeler } from "./snap-catalogue";
+import type { SnapDeckData } from "./snap-types";
+
+/** A caller-verified label sidecar from the same master, never the current build's unbound tables. */
+export interface SnapLabelSource {
+  format: "nnnotes.replay-labels/1";
+  region: string;
+  masterVersion: string;
+  tables: Record<string, { sha256: string; rows: Record<string, unknown>[] }>;
+}
+const TABLES = ["MasterSupportSkill", "MasterSupportSkillEffect", "MasterGekisouSupportSkill", "MasterGekisouSupportSkillEffect", "MasterText", "MasterSkillConditionSet", "MasterSkillCondition", "MasterSkillCumulativeCondition", "MasterSkillTarget", "MasterCharacter", "MasterBand"] as const;
+
+function checkSource(data: SnapDeckData, source: SnapLabelSource, tables: readonly string[]) {
+  const provenance = data.provenance.master as { version?: string; tables?: Record<string, { sha256?: string }> } | undefined;
+  if (source.format !== "nnnotes.replay-labels/1" || source.region !== data.provenance.region || source.masterVersion !== provenance?.version) throw new Error("Snap labels belong to another replay snapshot");
+  for (const name of tables) {
+    if (!source.tables[name] || !/^[0-9a-f]{64}$/.test(source.tables[name]!.sha256) || source.tables[name]!.sha256 !== provenance?.tables?.[name]?.sha256) throw new Error(`Snap label table identity differs: ${name}`);
+  }
+}
+function sourceRows<T>(source: SnapLabelSource, name: string): T[] { return validateMasterTable<T>(source.tables[name]!.rows)._allData; }
+
+/** Existing formatting/localization at the selected level; no skill description formula is duplicated here. */
+export function buildSnapLabeler(data: SnapDeckData, source: SnapLabelSource, locale: AppLocale): SnapLabeler {
+  checkSource(data, source, TABLES);
+  const parsed = new Map(TABLES.map((name) => [name, sourceRows(source, name)]));
+  const rows = <T>(name: string): T[] => parsed.get(name as typeof TABLES[number]) as T[];
+  // Existing exports do not bind MasterSkillIcon. Omit its icon rather than silently borrowing another snapshot.
+  const icons: RawSkillIcon[] = [];
+  if (source.tables.MasterSkillIcon && (data.provenance.master as { tables?: Record<string, { sha256?: string }> }).tables?.MasterSkillIcon) {
+    checkSource(data, source, ["MasterSkillIcon"]);
+    icons.push(...sourceRows<RawSkillIcon>(source, "MasterSkillIcon"));
+  }
+  const characterMap = new Map(rows<RawCharacter>("MasterCharacter").map((row) => [row.id, row]));
+  const targetNames = supportSkillTargetNames(rows<RawSupportSkillTarget>("MasterSkillTarget"), rows<RawCharacter>("MasterCharacter"), rows<RawBand>("MasterBand"), rows<RawText>("MasterText"), locale);
+  const cache = new Map<string, ReturnType<typeof normalizeSupportSkill>>();
+  return (kind, skillId, level) => {
+    const key = `${kind}:${skillId}`;
+    if (!cache.has(key)) cache.set(key, normalizeSupportSkill(kind, skillId,
+      rows<RawSkillDefinition>(kind === "support" ? "MasterSupportSkill" : "MasterGekisouSupportSkill"),
+      rows<RawSupportSkillEffect>(kind === "support" ? "MasterSupportSkillEffect" : "MasterGekisouSupportSkillEffect"),
+      icons, rows<RawText>("MasterText"), locale,
+      rows<RawSkillConditionSet>("MasterSkillConditionSet"), rows<RawSkillCondition>("MasterSkillCondition"),
+      rows<RawSkillCumulativeCondition>("MasterSkillCumulativeCondition"), characterMap, targetNames));
+    const skill = cache.get(key), effectLevel = skill?.levels.find((row) => row.level === level);
+    return skill && effectLevel ? { name: skill.name, description: effectLevel.description, iconUrl: skill.iconUrl } : undefined;
+  };
+}
+
+/** Actual existing card VMs/artwork IDs, localized from the same verified source. Max-power fields are display only. */
+export function buildSnapReferenceCards(data: SnapDeckData, source: SnapLabelSource, locale: AppLocale) {
+  checkSource(data, source, ["MasterMemberCard", "MasterSupportCard", "MasterCharacter", "MasterBand", "MasterText"]);
+  const characters = sourceRows<RawCharacter>(source, "MasterCharacter"), bands = sourceRows<RawBand>(source, "MasterBand"), texts = sourceRows<RawText>(source, "MasterText");
+  return {
+    members: normalizeCards(sourceRows<RawMemberCard>(source, "MasterMemberCard"), characters, bands, texts, locale),
+    snaps: normalizeSupportCards(sourceRows<RawSupportCard>(source, "MasterSupportCard"), characters, bands, texts, locale),
+  };
+}
diff --git a/src/lib/chart-data/snap-profile.ts b/src/lib/chart-data/snap-profile.ts
new file mode 100644
index 00000000..7518b0eb
--- /dev/null
+++ b/src/lib/chart-data/snap-profile.ts
@@ -0,0 +1,35 @@
+import type { ChartDataState } from "./query";
+import { snapMemberContext } from "./snap-catalogue";
+import type { FiveSlots, SnapDeckData, SnapEvaluationProfile, SnapMemberContext } from "./snap-types";
+import { emptySnapRanking, snapProfileKey, snapSourceKey, type SnapRankingSource, type SnapRankingState } from "./snap-client";
+
+/** A reproducible standard profile. This is a measurement, not an ownership or shuffle model. */
+export function chartSnapProfile(state: ChartDataState, data?: SnapDeckData): { profile: SnapEvaluationProfile; invalidMembers: number[] } {
+  const invalidMembers: number[] = [];
+  const pairedMembers = state.snapMembers.map((selection, slot) => {
+    if (!selection || !data) return null;
+    try { return snapMemberContext(data, selection.memberId, selection.gekisouLevel); }
+    catch { invalidMembers.push(slot); return null; }
+  }) as unknown as FiveSlots<SnapMemberContext | null>;
+  return {
+    invalidMembers,
+    profile: {
+      memberSkillPercent: state.skills.slice(0, 5) as unknown as FiveSlots<number>,
+      selections: state.snapSkills,
+      pairedMembers,
+      power: state.snapPower,
+      mode: state.mode === "free" ? { kind: "normal" } : { kind: "fixedSoloGekisou", ranks: [state.ranks[0] ?? 1, state.ranks[1] ?? 1, state.ranks[2] ?? 1] },
+      seed: 1,
+      fps: 60,
+      greatFraction: state.great / 100,
+      justFraction: state.mode === "free" ? 0 : state.just / 100,
+      skillOrder: [0, 1, 2, 3, 4],
+    },
+  };
+}
+
+/** Invalid URL member IDs must clear displayed rows before the Controller's next effect runs. */
+export function snapDisplayedMeasurement(evaluation: ReturnType<typeof chartSnapProfile>, source: SnapRankingSource | null, measurement: SnapRankingState): SnapRankingState {
+  return evaluation.invalidMembers.length ? { ...emptySnapRanking(snapProfileKey(evaluation.profile)),
+    sourceKey: source ? snapSourceKey(source) : "", status: "needs-context" } : measurement;
+}
diff --git a/src/lib/chart-data/snap-query.ts b/src/lib/chart-data/snap-query.ts
new file mode 100644
index 00000000..5974745b
--- /dev/null
+++ b/src/lib/chart-data/snap-query.ts
@@ -0,0 +1,37 @@
+import type { FiveSlots, SnapSkillSelection } from "./snap-types";
+
+export interface SnapMemberSelection { memberId: number; gekisouLevel: number | null }
+export interface SnapQueryState {
+  snapSkills: FiveSlots<SnapSkillSelection | null>;
+  snapMembers: FiveSlots<SnapMemberSelection | null>;
+  snapPower: number;
+}
+const integer = (value: string | undefined): number | null => value && /^\d+$/.test(value) && Number.isSafeInteger(Number(value)) && Number(value) > 0 && Number(value) <= 2147483647 ? Number(value) : null;
+
+/** IDs are revalidated against the loaded snapshot; the URL stores choices, not evaluation results. */
+export function parseSnapQuery(query: URLSearchParams): SnapQueryState {
+  const skills = (query.get("ss") ?? "").split(","), members = (query.get("sm") ?? "").split(",");
+  const snapSkills = [0, 1, 2, 3, 4].map((i) => {
+    const [kind, id, level, extra] = (skills[i] ?? "").split(":");
+    const skillId = integer(id), skillLevel = integer(level);
+    return (kind === "support" || kind === "gekisou-support") && skillId && skillLevel && extra === undefined ? { kind, skillId, level: skillLevel } : null;
+  }) as unknown as FiveSlots<SnapSkillSelection | null>;
+  const snapMembers = [0, 1, 2, 3, 4].map((i) => {
+    const [id, level, extra] = (members[i] ?? "").split(":");
+    const memberId = integer(id), gekisouLevel = level === "0" ? null : integer(level);
+    return memberId && extra === undefined && (level === "0" || gekisouLevel !== null) ? { memberId, gekisouLevel } : null;
+  }) as unknown as FiveSlots<SnapMemberSelection | null>;
+  const power = integer(query.get("mp") ?? undefined);
+  return { snapSkills, snapMembers, snapPower: power && power <= 20000000 ? power : 300000 };
+}
+
+export function writeSnapQuery(query: URLSearchParams, state: SnapQueryState): void {
+  if (state.snapSkills.some(Boolean)) query.set("ss", state.snapSkills.map((skill) => skill ? `${skill.kind}:${skill.skillId}:${skill.level}` : "0").join(","));
+  if (state.snapMembers.some(Boolean)) query.set("sm", state.snapMembers.map((member) => member ? `${member.memberId}:${member.gekisouLevel ?? 0}` : "0").join(","));
+  if (state.snapPower !== 300000) query.set("mp", String(state.snapPower));
+}
+
+export function replaceSnapSlot<T>(slots: FiveSlots<T>, slot: number, value: T): FiveSlots<T> {
+  if (!Number.isInteger(slot) || slot < 0 || slot >= 5) throw new Error("Invalid Snap slot");
+  return slots.map((entry, i) => i === slot ? value : entry) as unknown as FiveSlots<T>;
+}
diff --git a/src/lib/chart-data/snap-search.ts b/src/lib/chart-data/snap-search.ts
new file mode 100644
index 00000000..f8a3b755
--- /dev/null
+++ b/src/lib/chart-data/snap-search.ts
@@ -0,0 +1,33 @@
+import type { SnapSkillChoice, SnapSkillKind } from "./snap-types";
+
+const normalized = (text: string) => text.normalize("NFKC").toLocaleLowerCase().replace(/\s+/g, " ").trim();
+
+/** Search names, source Snap names, descriptions and IDs; every token must match. */
+export function searchSnapSkills(
+  choices: readonly SnapSkillChoice[],
+  query: string,
+  kind: SnapSkillKind | "all" = "all",
+  availableOnly = false,
+): SnapSkillChoice[] {
+  const terms = normalized(query).split(" ").filter(Boolean);
+  return choices.filter((choice) => {
+    if (kind !== "all" && choice.kind !== kind) return false;
+    if (availableOnly && choice.status === "unsupported") return false;
+    const text = normalized([choice.name, choice.description, ...choice.searchTerms, String(choice.skillId),
+      ...choice.cardIds.map(String), ...choice.effectTypes.map(String)].join(" "));
+    return terms.every((term) => text.includes(term));
+  });
+}
+
+/** One visible tile per skill; levels remain explicit in the picker rather than repeating identical tiles. */
+export function groupSnapSkills(choices: readonly SnapSkillChoice[]): SnapSkillChoice[][] {
+  const groups = new Map<string, SnapSkillChoice[]>();
+  for (const choice of choices) {
+    const key = `${choice.kind}:${choice.skillId}`;
+    const group = groups.get(key) ?? [];
+    if (!group.some((entry) => entry.level === choice.level)) group.push(choice);
+    groups.set(key, group);
+  }
+  return [...groups.values()].map((group) => group.sort((a, b) => a.level - b.level))
+    .sort((a, b) => Number(a[0]!.kind === "gekisou-support") - Number(b[0]!.kind === "gekisou-support") || a[0]!.skillId - b[0]!.skillId);
+}
diff --git a/src/lib/chart-data/snap-source-vms.ts b/src/lib/chart-data/snap-source-vms.ts
new file mode 100644
index 00000000..f2811165
--- /dev/null
+++ b/src/lib/chart-data/snap-source-vms.ts
@@ -0,0 +1,91 @@
+import type { AppLocale } from "@/config/locales";
+import type { CardViewModel } from "@/lib/cards/data";
+import type { SupportCardViewModel } from "@/lib/support-cards/data";
+import { buildSnapSkillCatalogue, snapChoiceKey, snapMemberContext, snapRows } from "./snap-catalogue";
+import { buildSnapLabeler, buildSnapReferenceCards, type SnapLabelSource } from "./snap-labels";
+import { localizeDataText } from "./text";
+import type { DataText, MusicData } from "./types";
+import type { SnapDeckData, SnapSkillChoice } from "./snap-types";
+
+interface SourceCharacter { id: number; name?: DataText | null; bandId?: number; mainColor?: string }
+interface SourceMeta extends MusicData { characters?: readonly SourceCharacter[] }
+export interface SnapSourceMember { id: number; name: string; vm?: CardViewModel; gkLevels: number[] }
+
+function assertSourceMusic(data: SnapDeckData, music: MusicData) {
+  const master = data.provenance.master as { version?: string } | undefined, model = data.provenance.deck as { commit?: string } | undefined;
+  if (music.format !== "nnnotes.music-data/1" || music.provenance?.region !== data.provenance.region || music.provenance?.master?.version !== master?.version || music.provenance?.deck?.commit !== model?.commit) throw new Error("Display catalog belongs to another replay snapshot");
+}
+const number = (value: unknown, fallback = 0): number => typeof value === "number" && Number.isFinite(value) ? value : fallback;
+const text = (value: unknown): string => typeof value === "string" ? value : "";
+
+/** Same-source reference labels only. Missing artwork IDs stay missing; never infer them from card IDs. */
+export function buildSnapSourceCards(data: SnapDeckData, sourceMusicData: MusicData, labelSource: SnapLabelSource | undefined, locale: AppLocale) {
+  assertSourceMusic(data, sourceMusicData);
+  const source = sourceMusicData as SourceMeta;
+  const full = labelSource ? buildSnapReferenceCards(data, labelSource, locale) : undefined;
+  const fullMembers = new Map(full?.members.map((card) => [card.id, card]) ?? []);
+  const snaps = new Map<number, SupportCardViewModel>(full?.snaps.map((card) => [card.id, card]) ?? []);
+  const sourceMembers = new Map(source.gekisouCatalog?.members?.map((m) => [m.id, m]) ?? []);
+  const sourceSnaps = new Map(source.gekisouCatalog?.snaps?.map((s) => [s.id, s]) ?? []);
+  const characters = new Map(source.characters?.map((c) => [c.id, c]) ?? []);
+  const bands = new Map(source.bands?.map((b) => [b.id, b]) ?? []);
+  const nativeCharacters = new Map(snapRows(data, "MasterCharacter").map((c) => [number(c._id), c]));
+  const gkEffects = snapRows(data, "MasterGekisouSkillEffect");
+  const members: SnapSourceMember[] = snapRows(data, "MasterMemberCard").map((row) => {
+    const id = number(row._id), named = sourceMembers.get(id), existing = fullMembers.get(id);
+    const name = (existing ? [existing.characterName, existing.title].filter(Boolean).join(" ") : "") || localizeDataText(named?.name, locale) || String(id);
+    const gkLevels = [...new Set(gkEffects.filter((e) => e._gekisouSkillID === row._gekisouSkillID).map((e) => number(e._level)))].filter((n) => n > 0).sort((a, b) => a - b);
+    let vm = existing;
+    // Current normalized exports omit _assetID. Future additive columns can supply it without a global lookup.
+    if (!vm && Number.isSafeInteger(row._assetID) && number(row._assetID) > 0 && [2, 3, 4].includes(number(row._rarity)) && [1, 2, 3, 4, 5].includes(number(row._cardType))) {
+      const characterId = number(row._characterID), character = characters.get(characterId), bandId = number(nativeCharacters.get(characterId)?._bandID), band = bands.get(bandId);
+      vm = { id, assetId: number(row._assetID), characterId, bandId, rarity: number(row._rarity) as 2 | 3 | 4, cardType: number(row._cardType) as 1 | 2 | 3 | 4 | 5, title: localizeDataText(named?.subtitle, locale) || name,
+        characterName: localizeDataText(character?.name, locale), bandName: localizeDataText(band?.name, locale), characterColor: character?.mainColor ?? "",
+        performancePower: number(row._performancePowerMax), technicPower: number(row._technicPowerMax), visualPower: number(row._visualPowerMax), totalPower: number(row._performancePowerMax) + number(row._technicPowerMax) + number(row._visualPowerMax),
+        startAt: text(row._startAt), gachaVoice: "", liveSkillId: number(row._liveSkillID), leaderSkillId: number(row._leaderSkillID), gekisouSkillId: number(row._gekisouSkillID), searchText: `${id} ${name}`.toLowerCase() };
+    }
+    return { id, name, gkLevels, ...(vm ? { vm } : {}) };
+  });
+  if (!full) for (const row of snapRows(data, "MasterSupportCard")) {
+    const id = number(row._id);
+    if (!Number.isSafeInteger(row._assetID) || number(row._assetID) <= 0 || ![2, 3, 4, 10].includes(number(row._rarity)) || ![1, 2, 3, 4, 5].includes(number(row._cardType))) continue;
+    const named = sourceSnaps.get(id), characterIds = Array.isArray(row._characterIDs) ? row._characterIDs.map((x) => number(x)) : [];
+    const bandId = number(nativeCharacters.get(characterIds[0] ?? 0)?._bandID);
+    const name = localizeDataText(named?.name, locale) || String(id), title = localizeDataText(named?.subtitle, locale);
+    snaps.set(id, { id, assetId: number(row._assetID), rarity: number(row._rarity) as 2 | 3 | 4 | 10, cardType: number(row._cardType) as 1 | 2 | 3 | 4 | 5, title, name, diaryText: "", characterIds,
+      characters: characterIds.map((charId) => ({ id: charId, name: localizeDataText(characters.get(charId)?.name, locale), color: characters.get(charId)?.mainColor ?? "" })), bandId, bandName: localizeDataText(bands.get(bandId)?.name, locale),
+      performancePower: number(row._performancePowerMax), technicPower: number(row._technicPowerMax), visualPower: number(row._visualPowerMax), totalPower: number(row._performancePowerMax) + number(row._technicPowerMax) + number(row._visualPowerMax), startAt: text(row._startAt),
+      supportSkillId01: number(row._supportSkillId01), supportSkillId02: number(row._supportSkillId02), gekisouSupportSkillId01: number(row._gekisouSupportSkillId01), gekisouSupportSkillId02: number(row._gekisouSupportSkillId02), searchText: `${id} ${name} ${title}`.toLowerCase() });
+  }
+  return { members, snaps, memberContext: (id: number, level: number | null) => snapMemberContext(data, id, level) };
+}
+
+/** Without label resources use only names from this music-data snapshot, never an unexpanded template. */
+export function labelSnapRankingCatalogue(choices: SnapSkillChoice[], data: SnapDeckData, sourceMusicData: MusicData, labelSource: SnapLabelSource | undefined, locale: AppLocale): SnapSkillChoice[] {
+  assertSourceMusic(data, sourceMusicData);
+  if (labelSource) {
+    const cards = new Map(buildSnapReferenceCards(data, labelSource, locale).snaps.map((card) => [card.id, card]));
+    const localized = new Map(buildSnapSkillCatalogue(data, buildSnapLabeler(data, labelSource, locale)).map((choice) => [choice.key, choice]));
+    return choices.map((choice) => {
+      const resolved = { ...choice, ...localized.get(snapChoiceKey(choice.kind, choice.skillId, choice.level)) };
+      const cardTerms = choice.cardIds.flatMap((id) => { const card = cards.get(id); return card ? [String(id), card.searchText, card.name, card.title, card.bandName, ...card.characters.map((character) => character.name)] : [String(id)]; });
+      return { ...resolved, searchTerms: [...resolved.searchTerms, ...cardTerms].filter(Boolean) };
+    });
+  }
+  const names = new Map(sourceMusicData.gekisouCatalog?.snaps?.map((card) => [card.id, localizeDataText(card.name, locale)]) ?? []);
+  const titles = new Map(sourceMusicData.gekisouCatalog?.snaps?.map((card) => [card.id, localizeDataText(card.subtitle, locale)]) ?? []);
+  const gkNames = new Map(sourceMusicData.gekisouCatalog?.supportSkills?.map((skill) => [skill.id, localizeDataText(skill.name, locale)]) ?? []);
+  const characters = new Map((sourceMusicData as SourceMeta).characters?.map((character) => [character.id, character]) ?? []);
+  const nativeCharacters = new Map(snapRows(data, "MasterCharacter").map((character) => [number(character._id), character]));
+  const sourceCards = new Map(snapRows(data, "MasterSupportCard").map((card) => [number(card._id), card]));
+  const bands = new Map(sourceMusicData.bands?.map((band) => [band.id, band]) ?? []);
+  return choices.map((choice) => {
+    const cards = choice.cardIds.map((id) => names.get(id)).filter((name): name is string => Boolean(name));
+    const name = (choice.kind === "gekisou-support" ? gkNames.get(choice.skillId) : cards[0]) || String(choice.skillId);
+    const identityTerms = choice.cardIds.flatMap((id) => {
+      const ids = sourceCards.get(id)?._characterIDs;
+      return [titles.get(id) ?? "", ...(Array.isArray(ids) ? ids.flatMap((characterId) => { const character = characters.get(number(characterId)), band = bands.get(number(nativeCharacters.get(number(characterId))?._bandID)); return [localizeDataText(character?.name, locale), localizeDataText(band?.name, locale)]; }) : [])];
+    });
+    return { ...choice, name, description: "", searchTerms: [name, ...cards, ...identityTerms, String(choice.skillId), ...choice.cardIds.map(String)].filter(Boolean) };
+  });
+}
diff --git a/src/lib/chart-data/snap-types.ts b/src/lib/chart-data/snap-types.ts
new file mode 100644
index 00000000..fc501463
--- /dev/null
+++ b/src/lib/chart-data/snap-types.ts
@@ -0,0 +1,75 @@
+/** Inputs to the shared Rust replay. These types contain no scoring rules. */
+export type SnapSkillKind = "support" | "gekisou-support";
+export interface SnapSkillSelection { kind: SnapSkillKind; skillId: number; level: number }
+export type FiveSlots<T> = readonly [T, T, T, T, T];
+export type SnapRequirement = "paired-member" | "gekisou-mode" | "paired-gekisou-skill" | "raw-timing" | "missing-dependency";
+export interface SnapSkillChoice extends SnapSkillSelection {
+  key: string;
+  name: string;
+  description: string;
+  iconUrl?: string;
+  searchTerms: string[];
+  cardIds: number[];
+  rankBindings: Array<{ cardId: number; rank: number; binding: 1 | 2 }>;
+  effectTypes: number[];
+  requirements: SnapRequirement[];
+  status: "supported" | "needs-context" | "unsupported";
+}
+export interface SnapTable { columns: string[]; rows: unknown[][] }
+export interface SnapDeckData {
+  format: string;
+  provenance: Record<string, unknown>;
+  master: Record<string, SnapTable>;
+  charts: unknown[];
+}
+export interface SnapMemberContext {
+  memberId?: number;
+  bandId: number;
+  characterId: number;
+  cardType: number;
+  tagIds: number[];
+  liveSkillCategories: number[];
+  gekisouSkillCategories: number[];
+  gekisouMissionType: number;
+  gekisouSkill: readonly [number, number] | null;
+}
+export interface SnapReplayResource { url: string; sha256: string; bytes?: number }
+export interface SnapReplayReference { format: string; manifestUrl: string; sha256: string }
+export interface SnapReplayManifest {
+  format: string;
+  deckData: SnapReplayResource;
+  /** Optional same-snapshot full labels/card artwork metadata, SHA-bound by this manifest. */
+  snapLabels?: SnapReplayResource;
+  engine: { model: { commit: string }; requestFormat: string; js: SnapReplayResource; wasm: SnapReplayResource };
+}
+export interface SnapReplayEngine {
+  template(scoreId: number, power: number, fps: number): string;
+  describeChart(scoreId: number): string;
+  run(request: string): string;
+  free?(): void;
+}
+export interface SnapReplayResult {
+  format: string;
+  scoreId: number;
+  complete: boolean;
+  score: number;
+  life: number;
+  combo: number;
+  randomDraws: number;
+  convertedJudgements: number;
+}
+export interface SnapEvaluationProfile {
+  /** Declared synthetic plain score-up skills, duration exactly 5s. */
+  memberSkillPercent: FiveSlots<number>;
+  selections: FiveSlots<SnapSkillSelection | null>;
+  /** Explicit member predicates for conditional Snap skills, never inferred from power. */
+  pairedMembers: FiveSlots<SnapMemberContext | null>;
+  power: number;
+  mode: { kind: "normal" } | { kind: "fixedSoloGekisou"; ranks: readonly [number, number, number] };
+  seed: number;
+  fps: 30 | 60 | 120;
+  greatFraction: number;
+  justFraction: number;
+  /** Physical slots stay fixed; this permutation changes only skill execution order. */
+  skillOrder: FiveSlots<number>;
+}
diff --git a/src/lib/chart-data/snap-worker.ts b/src/lib/chart-data/snap-worker.ts
new file mode 100644
index 00000000..e4b61831
--- /dev/null
+++ b/src/lib/chart-data/snap-worker.ts
@@ -0,0 +1,147 @@
+import { applyAccuracyPreset, parseJustJudgementTypes } from "ournotes-player/replay/preset";
+import type { AppLocale } from "@/config/locales";
+import { createSnapEvaluator, loadSnapReplayRuntime, SnapReplayError, validateSnapProfile, type LoadedSnapReplay } from "./snap-bridge";
+import { buildSnapSkillCatalogue } from "./snap-catalogue";
+import { buildSnapLabeler } from "./snap-labels";
+import type { SnapMeasuredRow, SnapRankingCatalogue, SnapRankingSource, SnapWorkerRequest, SnapWorkerResponse } from "./snap-client";
+import type { SnapEvaluationProfile, SnapReplayResult } from "./snap-types";
+
+type Evaluator = { evaluate(scoreId: number): SnapReplayResult; dispose(): void };
+interface WorkerDependencies {
+  load(source: SnapRankingSource): Promise<LoadedSnapReplay>;
+  evaluator(loaded: LoadedSnapReplay, profile: SnapEvaluationProfile): Evaluator;
+  catalogue(loaded: LoadedSnapReplay, locale: AppLocale): SnapRankingCatalogue;
+  validate(loaded: LoadedSnapReplay, profile: SnapEvaluationProfile): void;
+  yieldControl(): Promise<void>;
+}
+const inputPlan: Parameters<typeof createSnapEvaluator>[2] = (request, description, data, profile) => {
+  applyAccuracyPreset(request, description, parseJustJudgementTypes(data as unknown as Record<string, unknown>), profile.greatFraction, profile.justFraction);
+};
+const defaults: WorkerDependencies = {
+  load: (source) => loadSnapReplayRuntime(source.site, source.reference, source.expected),
+  evaluator: (loaded, profile) => createSnapEvaluator(loaded, profile, inputPlan),
+  catalogue: (loaded, locale) => ({
+    choices: buildSnapSkillCatalogue(loaded.data, loaded.labelSource ? buildSnapLabeler(loaded.data, loaded.labelSource, locale) : undefined),
+    data: { ...loaded.data, charts: [] },
+    ...(loaded.labelSource ? { labelSource: loaded.labelSource } : {}),
+    source: { manifestSha256: loaded.manifestSha256, dataSha256: loaded.dataSha256, modelCommit: loaded.modelCommit },
+  }),
+  validate: (loaded, profile) => validateSnapProfile(loaded.data, profile),
+  yieldControl: () => new Promise((resolve) => setTimeout(resolve, 0)),
+};
+
+/** Transport, bounded memoization and cancellation only. Every score comes from Rust. */
+export function createSnapWorkerHandler(post: (value: SnapWorkerResponse) => void, overrides: Partial<WorkerDependencies> = {}, cacheLimit = 1500) {
+  if (!Number.isInteger(cacheLimit) || cacheLimit < 0) throw new Error("Invalid replay cache limit");
+  const dependencies = { ...defaults, ...overrides };
+  let loadedKey = "";
+  let loadedPromise: Promise<LoadedSnapReplay> | null = null;
+  let activeJob = 0;
+  const cancelled = new Set<number>();
+  const cache = new Map<string, SnapReplayResult>();
+  const cacheGet = (key: string) => {
+    const value = cache.get(key);
+    if (value) { cache.delete(key); cache.set(key, value); }
+    return value;
+  };
+  const cacheSet = (key: string, value: SnapReplayResult) => {
+    cache.set(key, value);
+    while (cache.size > cacheLimit) cache.delete(cache.keys().next().value!);
+  };
+  const load = (source: SnapRankingSource) => {
+    const key = JSON.stringify(source);
+    if (key !== loadedKey || !loadedPromise) {
+      loadedKey = key;
+      cache.clear();
+      loadedPromise = dependencies.load(source).catch((error: unknown) => {
+        if (loadedKey === key) loadedPromise = null;
+        throw error;
+      });
+    }
+    return loadedPromise;
+  };
+  const isCurrent = (revision: number) => activeJob === revision && !cancelled.has(revision);
+
+  async function handle(value: SnapWorkerRequest): Promise<void> {
+    if (value.kind === "cancel") {
+      if (activeJob === value.revision) cancelled.add(value.revision);
+      return;
+    }
+    if (value.kind === "measure") activeJob = value.revision;
+    try {
+      const loaded = await load(value.source);
+      if (value.kind === "catalogue") {
+        post({ kind: "catalogue", revision: value.revision, catalogue: dependencies.catalogue(loaded, value.locale) });
+        return;
+      }
+      const { revision, profile } = value;
+      if (!isCurrent(revision)) { cancelled.delete(revision); post({ kind: "cancelled", revision }); return; }
+      const scoreIds = [...new Set(value.scoreIds)];
+      if (scoreIds.some((id) => !Number.isSafeInteger(id) || id <= 0)) throw new SnapReplayError("invalid-profile", "Invalid chart IDs");
+      dependencies.validate(loaded, profile);
+      const profileKey = JSON.stringify(profile);
+      const baselineProfile: SnapEvaluationProfile = { ...profile, selections: [null, null, null, null, null] };
+      const baselineKey = JSON.stringify(baselineProfile);
+      const source = { manifestSha256: loaded.manifestSha256, dataSha256: loaded.dataSha256, modelCommit: loaded.modelCommit };
+      const sourceKey = JSON.stringify(source);
+      let selected: Evaluator | null = null;
+      let baseline: Evaluator | null = null;
+      let cacheHits = 0;
+      let done = 0;
+      try {
+        post({ kind: "progress", revision, profileKey, done, total: scoreIds.length, rows: [], source });
+        for (const scoreId of scoreIds) {
+          if (!isCurrent(revision)) { post({ kind: "cancelled", revision }); return; }
+          const key = `${sourceKey}/${profileKey}/${scoreId}`;
+          const noSnapKey = `${sourceKey}/${baselineKey}/${scoreId}`;
+          let result = cacheGet(key), withoutSnap = cacheGet(noSnapKey);
+          if (result) cacheHits++;
+          if (withoutSnap) cacheHits++;
+          if (!result) {
+            selected ??= dependencies.evaluator(loaded, profile);
+            result = selected.evaluate(scoreId);
+            cacheSet(key, result);
+          }
+          if (!withoutSnap) {
+            baseline ??= dependencies.evaluator(loaded, baselineProfile);
+            withoutSnap = baseline.evaluate(scoreId);
+            cacheSet(noSnapKey, withoutSnap);
+          }
+          if (!Number.isSafeInteger(result.score) || !Number.isSafeInteger(withoutSnap.score) || !Number.isSafeInteger(result.score - withoutSnap.score)) {
+            throw new SnapReplayError("identity", "Replay score exceeds exact browser integer range");
+          }
+          const row: SnapMeasuredRow = { scoreId, score: result.score, baselineScore: withoutSnap.score,
+            delta: result.score - withoutSnap.score, life: result.life, combo: result.combo,
+            randomDraws: result.randomDraws, convertedJudgements: result.convertedJudgements };
+          done++;
+          post({ kind: "progress", revision, profileKey, done, total: scoreIds.length, rows: [row], source });
+          // Each paired result is atomic. Yield between charts so new profiles/cancel
+          // messages can stop further work instead of queueing behind a whole pool.
+          await dependencies.yieldControl();
+        }
+        if (isCurrent(revision)) {
+          post({ kind: "complete", revision, profileKey, done, total: scoreIds.length, source, cacheHits });
+          activeJob = 0;
+        } else post({ kind: "cancelled", revision });
+      } finally {
+        selected?.dispose();
+        baseline?.dispose();
+        if (cancelled.has(revision) && activeJob === revision) activeJob = 0;
+        cancelled.delete(revision);
+      }
+    } catch (error: unknown) {
+      const code = error instanceof SnapReplayError ? error.code : "runtime";
+      if (value.kind === "catalogue" || isCurrent(value.revision)) post({ kind: "error", phase: value.kind === "catalogue" ? "catalogue" : "measure",
+        revision: value.revision, code, message: error instanceof Error ? error.message : String(error) });
+      cancelled.delete(value.revision);
+      if (value.kind === "measure" && activeJob === value.revision) activeJob = 0;
+    }
+  }
+  return { handle, cacheSize: () => cache.size };
+}
+
+// Importable for protocol tests, with no browser-main-thread handlers or scores.
+if (typeof document === "undefined" && typeof self !== "undefined" && typeof self.postMessage === "function") {
+  const transport = createSnapWorkerHandler((message) => self.postMessage(message));
+  self.onmessage = (event: MessageEvent<SnapWorkerRequest>) => { void transport.handle(event.data); };
+}
diff --git a/src/lib/chart-data/types.ts b/src/lib/chart-data/types.ts
index 53efcbef..13e1a5f0 100644
--- a/src/lib/chart-data/types.ts
+++ b/src/lib/chart-data/types.ts
@@ -210,10 +210,19 @@ export interface CatalogSkill {
   description?: DataText | null;
 }
 
-/** The Gekisou skill names (top-level `gekisouCatalog`). */
+/** Same-snapshot member and Snap card labels used when the full replay label sidecar is absent. */
+export interface CatalogCard {
+  id: number;
+  name?: DataText | null;
+  subtitle?: DataText | null;
+}
+
+/** The Gekisou skill names and optional source card labels (top-level `gekisouCatalog`). */
 export interface GekisouCatalog {
   skills?: readonly CatalogSkill[];
   supportSkills?: readonly CatalogSkill[];
+  members?: readonly CatalogCard[];
+  snaps?: readonly CatalogCard[];
 }
 
 export interface DataChart {
@@ -275,6 +284,7 @@ export interface DataProvenance {
 
 export interface MusicData {
   format?: string;
+  /** Resources belong to this music-data snapshot and are SHA-verified before replay. */
   replay?: ReplayReference;
   provenance?: DataProvenance;
   languages?: readonly string[];
diff --git a/src/lib/masterdata/build-data.ts b/src/lib/masterdata/build-data.ts
index 84f7f90d..777081fd 100644
--- a/src/lib/masterdata/build-data.ts
+++ b/src/lib/masterdata/build-data.ts
@@ -37,7 +37,7 @@ import type { DeckCardLookup } from "@/lib/game-api/music-ranking";
 import { buildSupportCardGrowth, type RawSupportCardRank, type SupportCardGrowth } from "@/lib/support-cards/growth";
 import { normalizeCharacters, type CharacterViewModel, type RawCharacter as RawCharacterDetail } from "@/lib/characters/data";
 import { normalizeSupportCards, type RawSupportCard, type SupportCardViewModel } from "@/lib/support-cards/data";
-import { normalizeSupportSkill, type RawSupportSkillEffect } from "@/lib/support-cards/skills";
+import { normalizeSupportSkill, supportSkillTargetNames, type RawSupportSkillEffect, type RawSupportSkillTarget } from "@/lib/support-cards/skills";
 import {
   normalizeMusic,
   type MusicViewModel,
@@ -705,7 +705,7 @@ const EMPTY_SUPPORT_CARD_DETAIL: SupportCardDetailData = { card: null, skills: [
 
 function supportCardDetailOn(server: GameServer, locale: AppLocale, cardId: number): Promise<SupportCardDetailData | null> {
   return memo(`support-card-detail:${server}:${locale}:${cardId}`, async () => {
-    const [cards, rawCards, levels, ranks, supportSkills, supportEffects, gekisouSkills, gekisouEffects, icons, conditionSets, conditions, cumulativeConditions, textTable, characters] = await Promise.all([
+    const [cards, rawCards, levels, ranks, supportSkills, supportEffects, gekisouSkills, gekisouEffects, icons, conditionSets, conditions, cumulativeConditions, textTable, characters, bands, targets] = await Promise.all([
       supportCardsOn(server, locale),
       table<RawSupportCard>("MasterSupportCard.json", server),
       table<RawCardLevel>("MasterSupportCardLevel.json", server),
@@ -720,15 +720,18 @@ function supportCardDetailOn(server: GameServer, locale: AppLocale, cardId: numb
       table<RawSkillCumulativeCondition>("MasterSkillCumulativeCondition.json", server),
       texts(server),
       table<RawCharacter>("MasterCharacter.json", server),
+      table<RawBand>("MasterBand.json", server),
+      table<RawSupportSkillTarget>("MasterSkillTarget.json", server),
     ]);
     const card = cards.find((entry) => entry.id === cardId) ?? null;
     const rawCard = rawCards._allData.find((entry) => entry.id === cardId);
     if (!card || !rawCard) return null;
     const growth = buildSupportCardGrowth(rawCard, levels._allData, ranks._allData);
     const characterMap = new Map(characters._allData.map((entry) => [entry.id, entry]));
+    const targetNames = supportSkillTargetNames(targets._allData, characters._allData, bands._allData, textTable._allData, locale);
     const skills = [
-      normalizeSupportSkill("support", card.supportSkillId01, supportSkills._allData, supportEffects._allData, icons._allData, textTable._allData, locale, conditionSets._allData, conditions._allData, cumulativeConditions._allData, characterMap),
-      normalizeSupportSkill("gekisou-support", card.gekisouSupportSkillId01, gekisouSkills._allData, gekisouEffects._allData, icons._allData, textTable._allData, locale, conditionSets._allData, conditions._allData, cumulativeConditions._allData, characterMap),
+      normalizeSupportSkill("support", card.supportSkillId01, supportSkills._allData, supportEffects._allData, icons._allData, textTable._allData, locale, conditionSets._allData, conditions._allData, cumulativeConditions._allData, characterMap, targetNames),
+      normalizeSupportSkill("gekisou-support", card.gekisouSupportSkillId01, gekisouSkills._allData, gekisouEffects._allData, icons._allData, textTable._allData, locale, conditionSets._allData, conditions._allData, cumulativeConditions._allData, characterMap, targetNames),
     ].filter((entry): entry is SkillViewModel => entry !== null);
     return { card, skills, growth };
   });
diff --git a/src/lib/support-cards/skills.ts b/src/lib/support-cards/skills.ts
index e7e895a7..f09dbf68 100644
--- a/src/lib/support-cards/skills.ts
+++ b/src/lib/support-cards/skills.ts
@@ -1,6 +1,6 @@
 import type { AppLocale } from "@/config/locales";
 import { getSkillIconUrl } from "@/lib/cards/assets";
-import type { RawText, RawCharacter } from "@/lib/cards/data";
+import type { RawText, RawCharacter, RawBand } from "@/lib/cards/data";
 import { localizeMasterText } from "@/lib/masterdata/localize-text";
 import {
   groupEffectsByLevel,
@@ -24,6 +24,22 @@ export interface RawSupportSkillEffect extends RawSkillEffect {
 
 export type SupportSkillKind = "support" | "gekisou-support";
 
+export interface RawSupportSkillTarget { id: number; characterID?: number; bandID?: number }
+
+/** MasterSkillTarget IDs are not character IDs. Resolve the actual named predicates for descriptions. */
+export function supportSkillTargetNames(targets: RawSupportSkillTarget[], characters: RawCharacter[], bands: RawBand[], texts: RawText[], locale: AppLocale): ReadonlyMap<number, string> {
+  const charactersById = new Map(characters.map((row) => [row.id, row]));
+  const bandsById = new Map(bands.map((row) => [row.id, row]));
+  const textById = new Map(texts.map((row) => [row.id, row]));
+  const result = new Map<number, string>();
+  for (const target of targets) {
+    const character = charactersById.get(target.characterID ?? 0), band = bandsById.get(target.bandID ?? 0);
+    const names = [character ? localizeText(textById.get(character.nameTextID), locale) : "", band ? localizeText(textById.get(band.nameTextID), locale) : ""].filter(Boolean);
+    if (names.length) result.set(target.id, names.join(" / "));
+  }
+  return result;
+}
+
 export function normalizeSupportSkill(
   kind: SupportSkillKind,
   skillId: number,
@@ -36,6 +52,7 @@ export function normalizeSupportSkill(
   conditions: RawSkillCondition[],
   cumulativeConditions: RawSkillCumulativeCondition[],
   characterMap: Map<number, RawCharacter>,
+  targetNames?: ReadonlyMap<number, string>,
 ): SkillViewModel | null {
   const definition = definitions.find((entry) => entry.id === skillId);
   if (!definition) return null;
@@ -63,6 +80,7 @@ export function normalizeSupportSkill(
         cumulativeConditions,
         characterMap,
         resolveText,
+        targetNames,
       ),
       effects: levelEffects.map(toSkillEffectViewModel),
     })),
@@ -82,12 +100,14 @@ function formatDescription(
   cumulativeConditions: RawSkillCumulativeCondition[],
   characterMap: Map<number, RawCharacter>,
   resolveText: (id: string) => string,
+  targetNames?: ReadonlyMap<number, string>,
 ): string {
   if (!template) return "";
   const conditionMap = new Map(conditions.map((entry) => [entry.id, entry]));
   const setsByGroup = new Map<number, RawSkillConditionSet[]>();
   conditionSets.forEach((entry) => setsByGroup.set(entry.group, [...(setsByGroup.get(entry.group) ?? []), entry]));
   const cumulativeMap = new Map(cumulativeConditions.map((entry) => [entry.id, entry]));
+  let unresolvedTarget = false;
 
   let ternaryParsed = template;
   const ternaryRegex = /\{([^{}]+?)\?([^{}]+?):([^{}]+?)\}/g;
@@ -137,12 +157,16 @@ function formatDescription(
     })
     // 4. Targets name resolution:
     // e.g. {effects[1].con[0][0].targets[0].name} or {effects[1].targets[0].name}
-    .replace(/\{effects\[(\d+)\]\.(?:con\[\d+\](?:\[\d+\])?\.)?targets\[(\d+)\]\.name\}/g, (_, effectIndex, targetIndex) => {
+    .replace(/\{effects\[(\d+)\]\.(?:(con|tCon)\[(\d+)\](?:\[(\d+)\])?\.)?targets\[(\d+)\]\.name\}/g, (_, effectIndex, conditionKind, setIndex, conditionIndex, targetIndex) => {
       const effect = Math.max(0, Number(effectIndex)) < effects.length ? effects[Number(effectIndex)] : undefined;
-      const targetId = effect?.skillTargetIDs?.[Number(targetIndex)];
-      if (targetId === undefined) return "";
-      const char = characterMap.get(targetId);
-      return char ? resolveText(char.nameTextID) : "";
+      const group = conditionKind === "tCon" ? effect?.skillTriggerConditionGroup : effect?.skillConditionGroup;
+      const conditionId = conditionKind ? setsByGroup.get(group ?? 0)?.[Number(setIndex)]?.conditionIds[Number(conditionIndex ?? 0)] : undefined;
+      const targetId = (conditionKind ? conditionMap.get(conditionId ?? -1)?.conditionTargetIDs : effect?.skillTargetIDs)?.[Number(targetIndex)];
+      // A condition's targets and an effect's targets are separate MasterSkillTarget references.
+      const name = targetId === undefined ? undefined : targetNames?.get(targetId);
+      if (name) return name;
+      unresolvedTarget = true;
+      return "";
     })
     // 5. Cumulative max count:
     // e.g. {effects[0].cCon.maxCount}
@@ -177,7 +201,7 @@ function formatDescription(
     .replace(/\\n/g, "\n")
     .trim();
 
-  return formatted.includes("{effects[") ? "" : formatted;
+  return unresolvedTarget || formatted.includes("{effects[") ? "" : formatted;
 }
 
 function formatNumber(value: number | undefined, digits?: string): string {
diff --git a/src/styles/chart-data.css b/src/styles/chart-data.css
index 07bb3fcb..d35016cb 100644
--- a/src/styles/chart-data.css
+++ b/src/styles/chart-data.css
@@ -494,3 +494,67 @@ html[data-theme="dark"] .mn-cd {
   .mn-cd-defs dt { border-top: 1px solid var(--mn-glass-border); }
   .mn-cd-defs dd { border-top: 0; }
 }
+/* Optional Snap profile: the card artwork, modal and filter buttons keep the site's shared appearance. */
+.mn-cd-snap{margin:1rem 0;padding:1rem;border:1.5px solid var(--mn-border);border-radius:1.25rem}
+.mn-cd-snap-heading{display:flex;align-items:flex-start;justify-content:space-between;gap:1rem;margin-bottom:.9rem}
+.mn-cd-snap-heading h3{display:flex;align-items:center;gap:.5rem;margin:0;font-size:1rem;font-weight:850;color:var(--mn-text)}
+.mn-cd-snap-heading p{margin:.35rem 0 0;font-size:.75rem;line-height:1.7;color:var(--mn-text-muted)}
+.mn-cd-snap-optional{border:1px solid var(--mn-border);border-radius:999px;padding:.1rem .45rem;font-size:.6rem;font-weight:700;color:var(--mn-text-muted)}
+.mn-cd-snap-slots{display:grid;grid-template-columns:repeat(5,minmax(120px,1fr));gap:.65rem;overflow-x:auto;padding:.15rem .1rem .65rem;scroll-snap-type:x proximity}
+.mn-cd-snap-slot{position:relative;min-width:0;scroll-snap-align:start;border:1px dashed color-mix(in oklab,var(--mn-border) 78%,transparent);border-radius:1rem;background:color-mix(in oklab,var(--mn-paper) 76%,transparent);transition:border-color .15s,background .15s}
+.mn-cd-snap-slot.selected{border-style:solid;border-color:var(--mn-accent);background:color-mix(in oklab,var(--mn-accent) 5%,var(--mn-paper))}
+.mn-cd-snap-slot-button{display:flex;flex-direction:column;align-items:center;width:100%;min-height:148px;padding:.65rem .5rem;gap:.4rem;border:0;border-radius:1rem;background:transparent;text-align:center;cursor:pointer;color:var(--mn-text)}
+.mn-cd-snap-slot-button:hover{background:color-mix(in oklab,var(--mn-accent) 7%,transparent)}
+.mn-cd-snap-slot-button:focus-visible,.mn-cd-snap-remove:focus-visible,.mn-cd-snap-picker input:focus-visible,.mn-cd-snap-picker select:focus-visible,.mn-cd-snap-context select:focus-visible{outline:2px solid var(--mn-accent);outline-offset:3px}
+.mn-cd-snap-slot-no{align-self:flex-start;border-radius:999px;padding:.12rem .4rem;background:var(--mn-cream-deep);font-size:.6rem;font-weight:800;color:var(--mn-text-muted)}
+.mn-cd-snap-slot-art{width:58px;flex-shrink:0;border-radius:.5rem;overflow:hidden}
+.mn-cd-snap-symbol{display:grid;place-items:center;aspect-ratio:1;background:var(--mn-cream-deep);color:var(--mn-accent-deep)}
+.mn-cd-snap-symbol svg{width:25px;height:25px}
+.mn-cd-snap-plus{display:grid;place-items:center;width:52px;height:52px;border-radius:50%;border:1px dashed var(--mn-border);font-size:1.65rem;font-weight:400;color:var(--mn-accent-deep);background:color-mix(in oklab,var(--mn-accent) 5%,transparent)}
+.mn-cd-snap-slot-name{display:-webkit-box;-webkit-line-clamp:2;-webkit-box-orient:vertical;overflow:hidden;font-size:.75rem;line-height:1.5;font-weight:800}
+.mn-cd-snap-slot-meta{font-size:.6rem;color:var(--mn-text-muted)}
+.mn-cd-snap-remove{position:absolute;right:.35rem;top:.35rem;display:grid;place-items:center;width:23px;height:23px;border-radius:50%;border:1px solid var(--mn-border);background:var(--mn-paper);font-size:1rem;cursor:pointer;color:var(--mn-text-muted)}
+.mn-cd-snap-footnote{margin:.45rem 0 0;font-size:.7rem;line-height:1.7;color:var(--mn-text-muted)}
+.mn-cd-snap-context{display:grid;gap:.4rem;padding:0 .55rem .65rem;font-size:.65rem;color:var(--mn-text-muted)}
+.mn-cd-snap-context label{display:grid;gap:.25rem}
+.mn-cd-snap-context select{width:100%;min-width:0;padding:.3rem;border:1px solid var(--mn-border);border-radius:.45rem;color:var(--mn-text);background:var(--mn-paper);font-size:.65rem}
+.mn-cd-snap-search{display:flex;align-items:center;gap:.55rem;padding:.65rem .85rem;border:1.5px solid var(--mn-border);border-radius:.85rem;background:var(--mn-cream-deep);color:var(--mn-text-muted)}
+.mn-cd-snap-search input{width:100%;min-width:0;border:0;background:transparent;color:var(--mn-text);font-size:.875rem;outline-offset:5px}
+.mn-cd-snap-filter-row{display:flex;align-items:center;flex-wrap:wrap;gap:.5rem;margin:.8rem 0}
+.mn-cd-snap-available{display:flex;align-items:center;gap:.4rem;margin-left:auto;font-size:.7rem;color:var(--mn-text-muted)}
+.mn-cd-snap-none{display:flex;align-items:center;gap:.7rem;width:100%;padding:.8rem;border:1px dashed var(--mn-border);border-radius:.8rem;background:var(--mn-paper);text-align:left;color:var(--mn-text);cursor:pointer}
+.mn-cd-snap-none>span:first-child{display:grid;place-items:center;width:30px;height:30px;border-radius:50%;background:var(--mn-cream-deep);font-size:1.3rem}
+.mn-cd-snap-none strong{font-size:.8rem}
+.mn-cd-snap-none>span:last-child{font-size:.7rem;color:var(--mn-text-muted)}
+.mn-cd-snap-results{font-size:.7rem;color:var(--mn-text-muted)}
+.mn-cd-snap-options{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:.75rem}
+.mn-cd-snap-option{display:flex;flex-direction:column;gap:.65rem;padding:.8rem;border:1px solid var(--mn-border);border-radius:.9rem;background:var(--mn-paper)}
+.mn-cd-snap-option.selected{border-color:var(--mn-accent);box-shadow:0 0 0 1px var(--mn-accent)}
+.mn-cd-snap-option-top{display:flex;align-items:center;gap:.75rem;min-width:0}
+.mn-cd-snap-option-top>div:last-child{min-width:0}
+.mn-cd-snap-option-art{width:62px;flex-shrink:0;border-radius:.6rem;overflow:hidden}
+.mn-cd-snap-kind{font-size:.6rem;font-weight:800;letter-spacing:.04em;color:var(--mn-accent-deep)}
+.mn-cd-snap-option h4{margin:.15rem 0;font-size:.85rem;line-height:1.5;font-weight:850;color:var(--mn-text)}
+.mn-cd-snap-id{font-size:.6rem;color:var(--mn-text-muted)}
+.mn-cd-snap-description{margin:0;white-space:pre-line;font-size:.75rem;line-height:1.75;color:var(--mn-text)}
+.mn-cd-snap-requirements{margin:0;padding:.35rem .5rem;border-radius:.4rem;background:var(--mn-cream-deep);font-size:.65rem;line-height:1.6;color:var(--mn-text-muted)}
+.mn-cd-snap-option-actions{display:flex;align-items:center;justify-content:space-between;gap:.5rem;margin-top:auto}
+.mn-cd-snap-option-actions label{display:flex;align-items:center;gap:.4rem;font-size:.7rem;color:var(--mn-text-muted)}
+.mn-cd-snap-option-actions select{padding:.25rem .35rem;border:1px solid var(--mn-border);border-radius:.4rem;background:var(--mn-paper);color:var(--mn-text);font-size:.75rem}
+.mn-cd-snap-state{padding:1.8rem .5rem;text-align:center;font-size:.8rem;color:var(--mn-text-muted)}
+.mn-cd-snap-more{display:block;margin:1rem auto .25rem}
+@media(max-width:600px){.mn-cd-snap{padding:.8rem}.mn-cd-snap-options{grid-template-columns:1fr}.mn-cd-snap-none>span:last-child{display:none}.mn-cd-snap-available{margin-left:0;width:100%}}
+.mn-cd-snap-area { margin-bottom: 1.25rem; }
+.mn-cd-snap-measure { display: flex; flex-wrap: wrap; align-items: center; gap: .75rem 1.5rem; margin-top: .7rem; }
+.mn-cd-snap-measure p { margin: .3rem 0; }
+.mn-cd-snap-measure small { color: var(--mn-text-muted); }
+.mn-cd-snap-progress { width: 100%; color: var(--mn-text-muted); }
+.mn-cd-snap-measure progress { width: 100%; accent-color: var(--mn-accent); height: .35rem; }
+.mn-cd-snap-paired { display: grid; gap: .4rem; }
+.mn-cd-snap-paired label { display: grid; gap: .2rem; font-size: .72rem; }
+.mn-cd-snap-paired select { width: 100%; min-width: 0; padding: .35rem; border-radius: .45rem; background: var(--mn-surface); color: var(--mn-text); border: 1px solid var(--mn-border); }
+.mn-cd-snap-member-art { width: 2.5rem; justify-self: center; }
+.mn-cd-snap-heading > .mn-cd-ghost { flex: none; white-space: nowrap; }
+.mn-cd-snap-slot-art > img:last-child,
+.mn-cd-snap-option-art > img:last-child,
+.mn-cd-snap-member-art > img:last-child { width: .75rem; height: .75rem; left: .15rem; top: .15rem; }
diff --git a/tests/snap-description.test.ts b/tests/snap-description.test.ts
new file mode 100644
index 00000000..fb6ac6eb
--- /dev/null
+++ b/tests/snap-description.test.ts
@@ -0,0 +1,24 @@
+import { expect, test } from "bun:test";
+import { normalizeSupportSkill, supportSkillTargetNames, type RawSupportSkillEffect } from "../src/lib/support-cards/skills";
+import type { RawBand, RawCharacter, RawText } from "../src/lib/cards/data";
+
+const texts = [
+  { id: "name", english: "Conditional support" },
+  { id: "desc", english: "If {effects[0].con[0][0].targets[0].name}, give {effects[0].value/100:F0}% to {effects[0].targets[0].name}" },
+  { id: "character", english: "Mutsumi" }, { id: "band", english: "Ave Mujica" },
+] as RawText[];
+const definitions = [{ id: 31, nameTextID: "name", descriptionTextFormatID: "desc", skillIconID: 0 }];
+const effects: RawSupportSkillEffect[] = [1, 2].map((level) => ({ id: level, supportSkillID: 31, level, effectValue: level * 1000, skillEffectType: 2000, skillConditionGroup: 5, skillTargetIDs: [14] }));
+const conditions = [{ id: 3, conditionValues: [], conditionTargetIDs: [11] }];
+const sets = [{ id: 8, group: 5, conditionIds: [3] }];
+
+test("support descriptions resolve separate condition and effect targets at the selected level", () => {
+  const names = supportSkillTargetNames([{ id: 11, bandID: 7 }, { id: 14, characterID: 3 }], [{ id: 3, nameTextID: "character" }] as RawCharacter[], [{ id: 7, nameTextID: "band" }] as RawBand[], texts, "en-US");
+  const skill = normalizeSupportSkill("support", 31, definitions, effects, [], texts, "en-US", sets, conditions, [], new Map(), names)!;
+  expect(skill.levels.map((level) => level.description)).toEqual(["If Ave Mujica, give 10% to Mutsumi", "If Ave Mujica, give 20% to Mutsumi"]);
+});
+
+test("an unresolved predicate omits the description instead of inventing an unconditional effect", () => {
+  const skill = normalizeSupportSkill("support", 31, definitions, effects, [], texts, "en-US", sets, conditions, [], new Map(), new Map([[14, "Mutsumi"]]))!;
+  expect(skill.levels.every((level) => level.description === "")).toBe(true);
+});
diff --git a/tests/snap-loader.test.ts b/tests/snap-loader.test.ts
new file mode 100644
index 00000000..2d7e1a4d
--- /dev/null
+++ b/tests/snap-loader.test.ts
@@ -0,0 +1,11 @@
+import { expect, spyOn, test } from "bun:test";
+import { loadSnapReplayRuntime } from "../src/lib/chart-data/snap-bridge";
+
+test("relative replay manifests stay under the music-data site directory", async () => {
+  const urls: string[] = [];
+  const fetch = spyOn(globalThis, "fetch").mockImplementation(async (url) => { urls.push(String(url)); return new Response("unavailable", { status: 503 }); });
+  try {
+    await expect(loadSnapReplayRuntime("https://example.invalid/music-data", { format: "nnnotes.replay-manifest/1", manifestUrl: "replay/source/manifest.json", sha256: "a".repeat(64) }, { region: "tw", masterVersion: "source", modelCommit: "engine" })).rejects.toThrow("HTTP 503");
+    expect(urls).toEqual(["https://example.invalid/music-data/replay/source/manifest.json"]);
+  } finally { fetch.mockRestore(); }
+});
diff --git a/tests/snap-ranking.test.tsx b/tests/snap-ranking.test.tsx
new file mode 100644
index 00000000..ff433d1a
--- /dev/null
+++ b/tests/snap-ranking.test.tsx
@@ -0,0 +1,86 @@
+import { expect, test } from "bun:test";
+import { renderToStaticMarkup } from "react-dom/server";
+import RankView from "../src/components/chart-data/RankView";
+import ChartDetail from "../src/components/chart-data/ChartDetail";
+import type { ChartDataContext } from "../src/components/chart-data/shared";
+import { chartRows } from "../src/lib/chart-data/catalog";
+import { parseChartDataQuery } from "../src/lib/chart-data/query";
+import { emptySnapRanking, snapProfileKey, snapSourceKey, type SnapRankingSource } from "../src/lib/chart-data/snap-client";
+import type { SnapEvaluationProfile } from "../src/lib/chart-data/snap-types";
+import type { MusicData } from "../src/lib/chart-data/types";
+
+const profile: SnapEvaluationProfile = { memberSkillPercent: [100, 100, 100, 100, 100], selections: [{ kind: "support", skillId: 1, level: 1 }, null, null, null, null],
+  pairedMembers: [null, null, null, null, null], power: 300000, mode: { kind: "fixedSoloGekisou", ranks: [1, 1, 1] }, seed: 1,
+  fps: 60, greatFraction: 0, justFraction: 1, skillOrder: [0, 1, 2, 3, 4] };
+const source: SnapRankingSource = { site: "https://example.invalid/", reference: { format: "nnnotes.replay-manifest/1", manifestUrl: "replay.json", sha256: "a".repeat(64) }, expected: { region: "tw", masterVersion: "saved", modelCommit: "frozen" } };
+const measured = 1234567;
+function context(): ChartDataContext {
+  const data: MusicData = { songs: [{ id: 1, title: { en: "First" }, charts: [{ scoreId: 10, difficulty: "expert", level: 25, musicLengthMs: 60000 }] },
+    { id: 2, title: { en: "Second" }, charts: [{ scoreId: 11, difficulty: "expert", level: 25, musicLengthMs: 120000 }] }] };
+  const rows = chartRows(data).map((row) => ({ ...row, base: 1, weights: [1, 1, 1, 1, 1] }));
+  const support = { battle: true, free: true, ranks: true, just: true };
+  const state = parseChartDataQuery("?oh=0", { hasStats: true, support });
+  return { locale: "en-US", tr: (key) => key, data, rows, pool: rows, byScore: new Map(rows.map((row) => [row.scoreId, row])), bands: new Map(),
+    hasStats: true, support, state, update: () => {}, skills: [1, 1, 1, 1, 1], title: (row) => String(row.musicId), bandName: () => "", bandColor: () => "", jacketUrl: () => null,
+    songHref: () => "#", previewHref: () => "#", lengthOf: (row) => row.chartMs, eff: () => ({ rate: null, perMinute: null }), openChart: () => {},
+    snap: { active: true, profile, source, measurement: { ...emptySnapRanking(snapProfileKey(profile), 1), sourceKey: snapSourceKey(source), status: "complete", done: 1, total: 2,
+      source: { manifestSha256: source.reference.sha256, dataSha256: "b".repeat(64), modelCommit: "frozen" },
+      rows: new Map([[10, { scoreId: 10, score: measured, baselineScore: 1000000, delta: 234567, life: 1000, combo: 200, randomDraws: 4, convertedJudgements: 0 }]]) } } };
+}
+
+test("Snap event view shows fixed measurements without linear need, chance, frontier or room controls", () => {
+  const ctx = context();
+  ctx.state.rankBy = "event";
+  ctx.state.frontier = true;
+  const html = renderToStaticMarkup(<RankView ctx={ctx} />);
+  expect(html).toContain(measured.toLocaleString());
+  expect(html).toContain("snap.eventMeasurementHint");
+  expect(html).toContain("snap.delta");
+  expect(html).toContain("snap.perMinute");
+  expect(html).not.toContain('class="c-need');
+  expect(html).not.toContain('class="c-chance');
+  expect(html).not.toContain('class="c-dom');
+  expect(html).not.toContain("scenario.roomHint");
+  expect(html).not.toContain('aria-label="target"');
+  expect(html).toContain("chartsCount");
+  // The missing second result remains missing; synthetic linear weights do not fill it.
+  expect((html.match(/c-score/g) ?? []).length).toBe(3);
+});
+test("profile or source change hides old values before the next effect/Worker response", () => {
+  const ctx = context();
+  ctx.snap!.profile = { ...profile, seed: 7 };
+  expect(renderToStaticMarkup(<RankView ctx={ctx} />)).not.toContain(measured.toLocaleString());
+  ctx.snap!.profile = profile;
+  ctx.snap!.source = { ...source, reference: { ...source.reference, sha256: "c".repeat(64) } };
+  expect(renderToStaticMarkup(<RankView ctx={ctx} />)).not.toContain(measured.toLocaleString());
+});
+test("all None preserves the exact existing RankView markup", () => {
+  const ctx = context();
+  ctx.snap!.active = false;
+  ctx.snap!.profile = { ...profile, selections: [null, null, null, null, null] };
+  const withNone = renderToStaticMarkup(<RankView ctx={ctx} />);
+  const { snap: _, ...plain } = ctx;
+  expect(withNone).toBe(renderToStaticMarkup(<RankView ctx={plain} />));
+  expect(withNone).toContain('class="c-rate');
+  expect(withNone).toContain('class="c-dom');
+  expect(withNone).not.toContain("snap.measurementHint");
+  expect(withNone).not.toContain(measured.toLocaleString());
+});
+
+test("Snap detail reuses the same point and raw solo thresholds without linear power or chance", () => {
+  const ctx = context(), row = ctx.rows[0]!;
+  row.scoreRanks = [{ rank: "SS", requiredScore: 7777777, battleRequiredScore: 9999999 }];
+  ctx.data.replay = source.reference;
+  ctx.eff = () => { throw new Error("Legacy linear scoring must not run for an active Snap detail"); };
+  const html = renderToStaticMarkup(<ChartDetail ctx={ctx} row={row} />);
+  expect(html).toContain(measured.toLocaleString());
+  expect(html).toContain("snap.baseline");
+  expect(html).toContain((7777777).toLocaleString());
+  expect(html).not.toContain((9999999).toLocaleString());
+  expect(html).not.toContain("detail.needPower");
+  expect(html).not.toContain("scenario.roomHint");
+  expect(html).not.toContain("col.rate");
+  expect(html).toContain("snap.timelineHint");
+  expect(html).not.toContain('class="mn-cd-replay"');
+  expect(html).not.toContain("detail.measures");
+});
diff --git a/tests/snap-replay.test.ts b/tests/snap-replay.test.ts
new file mode 100644
index 00000000..5a736d1e
--- /dev/null
+++ b/tests/snap-replay.test.ts
@@ -0,0 +1,142 @@
+import { describe, expect, test } from "bun:test";
+import { buildSnapSkillCatalogue, snapMemberContext } from "../src/lib/chart-data/snap-catalogue";
+import { createSnapEvaluator, snapProfileData, validateSnapProfile } from "../src/lib/chart-data/snap-bridge";
+import type { SnapDeckData, SnapEvaluationProfile, SnapTable } from "../src/lib/chart-data/snap-types";
+import { buildSnapLabeler, type SnapLabelSource } from "../src/lib/chart-data/snap-labels";
+import { buildSnapSourceCards, labelSnapRankingCatalogue } from "../src/lib/chart-data/snap-source-vms";
+
+function table(rows: Record<string, unknown>[]): SnapTable {
+  const columns = [...new Set(rows.flatMap((r) => Object.keys(r)))];
+  return { columns, rows: rows.map((r) => columns.map((k) => r[k])) };
+}
+function fixture(): SnapDeckData {
+  const effect = { _id: 1, _supportSkillID: 1, _level: 1, _skillEffectType: 15000, _activationTimeSecond: 0, _effectValue: 250,
+    _skillTriggerConditionGroup: 0, _skillConditionGroup: 1, _skillReleaseConditionGroup: 0, _skillTargetIDs: [], _maxEffectValue: 0,
+    _effectLimitCount: 0, _skillCumulativeConditionID: 0, _effectExecuteLimitCount: 0, _effectExecuteLimitResetConditionGroup: 0 };
+  return { format: "nnnotes.deck-data/1", provenance: {}, charts: [], master: {
+    MasterSupportCard: table([{ _id: 7, _characterIDs: [10], _rarity: 2, _cardType: 1, _supportCardRankGroup: 1, _supportSkillId01: 1, _supportSkillId02: 0, _gekisouSupportSkillId01: 2, _gekisouSupportSkillId02: 0 }]),
+    MasterSupportCardRank: table([{ _id: 1, _group: 1, _rank: 1, _supportSkill01Level: 1, _supportSkill02Level: 1, _gekisouSupportSkill01Level: 1, _gekisouSupportSkill02Level: 1 }]),
+    MasterSupportSkillEffect: table([effect, { ...effect, _id: 99, _supportSkillID: 99 }]),
+    MasterGekisouSupportSkillEffect: table([{ ...effect, _gekisouSupportSkillID: 2, _skillEffectType: 2000 }]),
+    MasterSkillCondition: table([{ _id: 1, _conditionType: 5000, _conditionTargetIDs: [1] }]),
+    MasterSkillConditionSet: table([{ _id: 1, _group: 1, _conditionIds: [1] }]),
+    MasterSkillTarget: table([{ _id: 1, _characterID: 0, _bandID: 3, _cardType: 0, _tagID: 0, _gekisouMissionType: 0, _liveSkillCategories: [], _gekisouSkillCategories: [] }]),
+    MasterSkillCumulativeCondition: table([]),
+    MasterMemberCard: table([{ _id: 5, _characterID: 10, _cardType: 2, _bestMusicTagIDs: [8], _liveSkillID: 4, _gekisouSkillID: 3 }]),
+    MasterCharacter: table([{ _id: 10, _bandID: 3 }]),
+    MasterLiveSkill: table([{ _id: 1, _skillCategories: [7] }, { _id: 4, _skillCategories: [99] }]),
+    MasterLiveSkillEffect: table([{ ...effect, _liveSkillID: 1, _skillEffectType: 2000, _activationTimeSecond: 5, _skillConditionGroup: 0 }]),
+    MasterGekisouSkill: table([{ _id: 3, _skillCategories: [6], _gekisouMissionType: 2 }]),
+    MasterGekisouSkillEffect: table([{ _gekisouSkillID: 3, _level: 1 }]),
+  } };
+}
+function profile(data = fixture()): SnapEvaluationProfile {
+  const member = snapMemberContext(data, 5, 1);
+  return { memberSkillPercent: [100, 90, 80, 70, 60], selections: [null, null, null, null, null], pairedMembers: [member, member, member, member, member],
+    power: 300000, mode: { kind: "normal" }, seed: 0, fps: 60, greatFraction: 0, justFraction: 0, skillOrder: [0, 1, 2, 3, 4] };
+}
+
+describe("same-snapshot Snap inputs", () => {
+  test("catalogue excludes unbound future skills and gives the actual level to labels", () => {
+    const calls: number[] = [];
+    const choices = buildSnapSkillCatalogue(fixture(), (_kind, _id, level) => { calls.push(level); return { name: String(level), description: String(level) }; });
+    expect(choices.map((c) => c.key)).toEqual(["support:1:1", "gekisou-support:2:1"]);
+    expect(calls).toEqual([1, 1]);
+    expect(choices[0]?.requirements).toContain("paired-member");
+    expect(choices[0]?.rankBindings).toEqual([{ cardId: 7, rank: 1, binding: 1 }]);
+  });
+  test("missing predicates and paired Gekisou skill refuse computation", () => {
+    const data = fixture(), p = profile(data);
+    p.selections = [{ kind: "support", skillId: 1, level: 1 }, null, null, null, null];
+    p.pairedMembers = [null, null, null, null, null];
+    expect(() => validateSnapProfile(data, p)).toThrow("paired member");
+    p.selections = [{ kind: "gekisou-support", skillId: 2, level: 1 }, null, null, null, null];
+    p.pairedMembers = [snapMemberContext(data, 5, null), null, null, null, null];
+    p.mode = { kind: "fixedSoloGekisou", ranks: [1, 1, 1] };
+    expect(() => validateSnapProfile(data, p)).toThrow("paired member Gekisou skill");
+  });
+  test("a raw-window skill cannot pretend to work on completed judgement inputs", () => {
+    const data = fixture();
+    const t = data.master.MasterSupportSkillEffect!;
+    t.rows[0]![t.columns.indexOf("_skillEffectType")] = 4004;
+    expect(buildSnapSkillCatalogue(data)[0]?.status).toBe("unsupported");
+  });
+  test("a supplied object with unknown predicates is not a confirmed member context", () => {
+    const data = fixture(), p = profile(data);
+    p.pairedMembers = [{ ...p.pairedMembers[0]!, bandId: 0 }, null, null, null, null];
+    expect(() => validateSnapProfile(data, p)).toThrow("incomplete");
+    p.pairedMembers = [{ ...snapMemberContext(data, 5, 1), gekisouMissionType: 3 }, null, null, null, null];
+    expect(() => validateSnapProfile(data, p)).toThrow("Gekisou predicates");
+  });
+  test("synthetic profile categories describe the injected plain skill, not the reference card skill", () => {
+    const data = fixture(), original = JSON.stringify(data), p = profile(data), derived = snapProfileData(data, p);
+    expect(JSON.stringify(data)).toBe(original);
+    const table = derived.master.MasterLiveSkill!;
+    expect(table.rows.slice(-5).map((r) => r[table.columns.indexOf("_skillCategories")])).toEqual([[7], [7], [7], [7], [7]]);
+    expect(p.pairedMembers[0]?.liveSkillCategories).toEqual([99]);
+  });
+  test("bridge preserves physical pairing while skill order changes; Rust alone returns the score", () => {
+    const data = fixture(), p = profile(data);
+    p.selections = [null, null, { kind: "support", skillId: 1, level: 1 }, null, null];
+    p.skillOrder = [4, 3, 2, 1, 0];
+    let input: Record<string, unknown> = {};
+    const runtime = createSnapEvaluator({ data, manifestSha256: "a", dataSha256: "b", modelCommit: "c", factory: () => ({
+      template: () => JSON.stringify({ format: "ournotes.replay/1", frames: [], scoreId: 10 }), describeChart: () => "{}",
+      run: (raw) => { input = JSON.parse(raw); return JSON.stringify({ format: "ournotes.replay-result/1", scoreId: 10, complete: true, score: 123 }); },
+    }) }, p);
+    expect(runtime.evaluate(10).score).toBe(123);
+    expect(input.skillOrder).toEqual([4, 3, 2, 1, 0]);
+    const performers = input.performers as Array<Record<string, unknown>>;
+    expect(performers[2]?.supportSkills).toEqual([[1, 1]]);
+    expect(performers[0]?.supportSkills).toEqual([]);
+    expect(performers[2]?.liveSkillCategories).toEqual([7]);
+  });
+  test("non-default accuracy needs the shared input-plan helper", () => {
+    const data = fixture(), p = profile(data); p.justFraction = 1;
+    expect(() => createSnapEvaluator({ data, manifestSha256: "a", dataSha256: "b", modelCommit: "c", factory: () => { throw Error("must not allocate"); } }, p)).toThrow("input-plan helper");
+  });
+  test("same-version labels still require exact table hashes and actual-level descriptions", () => {
+    const data = fixture();
+    const names = ["MasterSupportSkill", "MasterSupportSkillEffect", "MasterGekisouSupportSkill", "MasterGekisouSupportSkillEffect", "MasterText", "MasterSkillConditionSet", "MasterSkillCondition", "MasterSkillCumulativeCondition", "MasterSkillTarget", "MasterCharacter", "MasterBand"];
+    data.provenance = { region: "tw", master: { version: "v", tables: Object.fromEntries(names.map((n) => [n, { sha256: "a".repeat(64) }])) } };
+    const source: SnapLabelSource = { format: "nnnotes.replay-labels/1", region: "tw", masterVersion: "v", tables: Object.fromEntries(names.map((n) => [n, { sha256: "a".repeat(64), rows: [] }])) };
+    source.tables.MasterSupportSkill!.rows = [{ _id: 1, _nameTextID: "name", _descriptionTextFormatID: "desc", _skillIconID: 1 }];
+    source.tables.MasterSupportSkillEffect!.rows = [{ _id: 1, _supportSkillID: 1, _level: 1, _skillEffectType: 15000, _effectValue: 250 }, { _id: 2, _supportSkillID: 1, _level: 2, _skillEffectType: 15000, _effectValue: 500 }];
+    source.tables.MasterText!.rows = [{ _id: "name", _english: "Extension" }, { _id: "desc", _english: "{effects[0].value/100:F2}" }];
+    const label = buildSnapLabeler(data, source, "en-US");
+    expect(label("support", 1, 1)?.description).toBe("2.50");
+    expect(label("support", 1, 2)?.description).toBe("5.00");
+    source.tables.MasterText!.sha256 = "b".repeat(64);
+    expect(() => buildSnapLabeler(data, source, "en-US")).toThrow("table identity");
+  });
+  test("later caller edits cannot change the evaluated profile or its reported identity", () => {
+    const data = fixture(), p = profile(data); let power = 0;
+    const runtime = createSnapEvaluator({ data, manifestSha256: "a", dataSha256: "b", modelCommit: "c", factory: () => ({
+      template: (_id, measurementPower) => { power = measurementPower; return JSON.stringify({ format: "ournotes.replay/1", frames: [] }); }, describeChart: () => "{}",
+      run: () => JSON.stringify({ format: "ournotes.replay-result/1", scoreId: 10, complete: true, score: 123 }),
+    }) }, p);
+    p.power = 900000;
+    runtime.evaluate(10);
+    expect(power).toBe(300000);
+    expect(runtime.profile.power).toBe(300000);
+    expect(Object.isFrozen(runtime.profile.pairedMembers)).toBe(true);
+  });
+  test("same-source fallback searches card/character/band names but suppresses raw templates", () => {
+    const data = fixture(); data.provenance = { region: "tw", master: { version: "v" }, deck: { commit: "c" } };
+    const music = { format: "nnnotes.music-data/1", provenance: { region: "tw", master: { version: "v" }, deck: { commit: "c" } },
+      bands: [{ id: 3, name: { en: "Source band" } }], characters: [{ id: 10, name: { en: "Source character" } }],
+      gekisouCatalog: { snaps: [{ id: 7, name: { en: "Source Snap" }, subtitle: { en: "Source subtitle" } }], members: [{ id: 5, name: { en: "Source member" } }], supportSkills: [{ id: 2, name: { en: "Source skill" }, description: { en: "{effects[0].value}" } }] } };
+    const choices = labelSnapRankingCatalogue(buildSnapSkillCatalogue(data), data, music, undefined, "en-US");
+    expect(choices[0]?.name).toBe("Source Snap");
+    expect(choices[0]?.searchTerms).toContain("Source character");
+    expect(choices[0]?.searchTerms).toContain("Source band");
+    expect(choices[0]?.searchTerms).toContain("Source subtitle");
+    expect(choices[1]?.description).toBe("");
+    const cards = buildSnapSourceCards(data, music, undefined, "en-US");
+    expect(cards.members[0]?.name).toBe("Source member");
+    expect(cards.members[0]?.gkLevels).toEqual([1]);
+    expect(cards.members[0]?.vm).toBeUndefined();
+    expect(cards.snaps.size).toBe(0); // _assetID is not in this source; card ID is not a substitute.
+    expect(() => buildSnapSourceCards(data, { ...music, provenance: { ...music.provenance, master: { version: "different" } } }, undefined, "en-US")).toThrow("another replay snapshot");
+  });
+});
diff --git a/tests/snap-selection.test.ts b/tests/snap-selection.test.ts
new file mode 100644
index 00000000..3d840e1c
--- /dev/null
+++ b/tests/snap-selection.test.ts
@@ -0,0 +1,66 @@
+import { describe, expect, test } from "bun:test";
+import { parseSnapQuery, replaceSnapSlot, writeSnapQuery } from "../src/lib/chart-data/snap-query";
+import { groupSnapSkills, searchSnapSkills } from "../src/lib/chart-data/snap-search";
+import type { SnapSkillChoice } from "../src/lib/chart-data/snap-types";
+import { parseChartDataQuery, serializeChartDataQuery } from "../src/lib/chart-data/query";
+import { scenarioSupport } from "../src/lib/chart-data/scenario";
+import { chartSnapProfile, snapDisplayedMeasurement } from "../src/lib/chart-data/snap-profile";
+import { emptySnapRanking, snapProfileKey } from "../src/lib/chart-data/snap-client";
+
+const choice = (id: number, level: number, extras: Partial<SnapSkillChoice> = {}): SnapSkillChoice => ({
+  kind: "support", skillId: id, level, key: `support:${id}:${level}`, name: "技能 ABC", description: "Great 转换",
+  searchTerms: ["睦 Ave Mujica"], cardIds: [17], rankBindings: [], effectTypes: [2000], requirements: [], status: "supported", ...extras,
+});
+
+describe("five optional Snap selections", () => {
+  test("empty URL stays empty and all five slots default to none", () => {
+    const state = parseSnapQuery(new URLSearchParams());
+    expect(state.snapSkills).toEqual([null, null, null, null, null]);
+    expect(state.snapMembers).toEqual([null, null, null, null, null]);
+    const query = new URLSearchParams(); writeSnapQuery(query, state);
+    expect(query.toString()).toBe("");
+  });
+  test("levels, member context and physical slots round-trip through the chart URL", () => {
+    const ctx = { hasStats: false, support: scenarioSupport(null) };
+    const state = parseChartDataQuery("ss=0,support:31:2,0,gekisou-support:19:3,0&sm=0,7:0,0,4:2,0&mp=321000", ctx);
+    expect(state.snapSkills[1]).toEqual({ kind: "support", skillId: 31, level: 2 });
+    expect(state.snapMembers[3]).toEqual({ memberId: 4, gekisouLevel: 2 });
+    expect(parseChartDataQuery(serializeChartDataQuery(state, ctx), ctx)).toEqual(state);
+  });
+  test("untrusted URL cannot inject malformed IDs, levels or out-of-range power", () => {
+    const state = parseSnapQuery(new URLSearchParams("ss=support:1:2:3,unknown:1:2,support:-1:2,support:1:NaN,support:9007199254740993:1&sm=2:0:9,1:4,0:1&mp=20000001"));
+    expect(state.snapSkills).toEqual([null, null, null, null, null]);
+    expect(state.snapMembers[0]).toBeNull();
+    expect(state.snapMembers[1]).toEqual({ memberId: 1, gekisouLevel: 4 });
+    expect(state.snapPower).toBe(300000);
+    expect(() => replaceSnapSlot(state.snapSkills, 5, null)).toThrow();
+  });
+  test("an invalid member URL hides same-null-profile results synchronously", () => {
+    const ctx = { hasStats: false, support: scenarioSupport(null) };
+    const state = parseChartDataQuery("ss=support:31:1&sm=999:0", ctx);
+    const evaluation = chartSnapProfile(state, { format: "nnnotes.deck-data/1", provenance: {}, master: { MasterMemberCard: { columns: ["_id"], rows: [] } }, charts: [] });
+    const previous = { ...emptySnapRanking(snapProfileKey(evaluation.profile)), status: "complete" as const,
+      rows: new Map([[1, { scoreId: 1, score: 100, baselineScore: 99, delta: 1, life: 1000, combo: 1, randomDraws: 0, convertedJudgements: 0 }]]) };
+    const shown = snapDisplayedMeasurement(evaluation, null, previous);
+    expect(evaluation.invalidMembers).toEqual([0]);
+    expect(shown.status).toBe("needs-context");
+    expect(shown.rows.size).toBe(0);
+    expect(previous.rows.size).toBe(1);
+  });
+});
+
+describe("Snap catalogue search", () => {
+  test("NFKC token search includes source card names, effects and IDs", () => {
+    const list = [choice(31, 1), choice(8, 1, { searchTerms: [], cardIds: [99] })];
+    expect(searchSnapSkills(list, "ＡＢＣ 睦 17").map((c) => c.skillId)).toEqual([31]);
+    expect(searchSnapSkills(list, "31 Great").map((c) => c.skillId)).toEqual([31]);
+    expect(searchSnapSkills(list, "睦 99")).toEqual([]);
+  });
+  test("kind and unsupported filters apply independently; levels stay explicit", () => {
+    const list = [choice(31, 2), choice(31, 1), choice(31, 1), choice(4, 1, { status: "unsupported" }), choice(2, 1, { kind: "gekisou-support" })];
+    expect(searchSnapSkills(list, "", "support", true)).toHaveLength(3);
+    expect(groupSnapSkills(list).map((group) => [group[0]!.kind, group[0]!.skillId, group.map((entry) => entry.level)])).toEqual([
+      ["support", 4, [1]], ["support", 31, [1, 2]], ["gekisou-support", 2, [1]],
+    ]);
+  });
+});
diff --git a/tests/snap-worker.test.ts b/tests/snap-worker.test.ts
new file mode 100644
index 00000000..c1c761d1
--- /dev/null
+++ b/tests/snap-worker.test.ts
@@ -0,0 +1,127 @@
+import { describe, expect, test } from "bun:test";
+import { SnapRankingClient, isCurrentSnapCatalogue, snapProfileKey, snapSourceKey, type SnapRankingCatalogue, type SnapRankingSource, type SnapRankingState, type SnapWorkerPort, type SnapWorkerRequest, type SnapWorkerResponse } from "../src/lib/chart-data/snap-client";
+import { createSnapWorkerHandler } from "../src/lib/chart-data/snap-worker";
+import { SnapReplayError, type LoadedSnapReplay } from "../src/lib/chart-data/snap-bridge";
+import type { SnapEvaluationProfile } from "../src/lib/chart-data/snap-types";
+
+const source: SnapRankingSource = { site: "https://example.invalid/", reference: { format: "nnnotes.replay-manifest/1", manifestUrl: "replay.json", sha256: "a".repeat(64) }, expected: { region: "tw", masterVersion: "saved", modelCommit: "frozen" } };
+const identity = { manifestSha256: "a".repeat(64), dataSha256: "b".repeat(64), modelCommit: "frozen" };
+const profile = (): SnapEvaluationProfile => ({ memberSkillPercent: [100, 120, 140, 160, 180], selections: [{ kind: "support", skillId: 1, level: 1 }, null, null, null, null],
+  pairedMembers: [null, null, null, null, null], power: 300000, mode: { kind: "normal" }, seed: -1, fps: 60,
+  greatFraction: 0.1, justFraction: 0.5, skillOrder: [4, 3, 2, 1, 0] });
+const loaded: LoadedSnapReplay = { ...identity, data: { format: "nnnotes.deck-data/1", provenance: {}, master: {}, charts: [] }, factory: () => { throw Error("No scoring in transport tests"); } };
+const catalogue: SnapRankingCatalogue = { choices: [], data: loaded.data, source: identity };
+
+test("catalogue admission checks content identity even when source version strings are unchanged", () => {
+  const current: SnapRankingCatalogue = { ...catalogue, data: { ...catalogue.data, provenance: { region: "tw", master: { version: "saved" }, deck: { commit: "frozen" } } } };
+  const music = { replay: source.reference, provenance: { region: "tw", master: { version: "saved" }, deck: { commit: "frozen" } } };
+  expect(isCurrentSnapCatalogue(current, music)).toBe(true);
+  expect(isCurrentSnapCatalogue(current, { ...music, replay: { ...music.replay, sha256: "c".repeat(64) } })).toBe(false);
+  expect(isCurrentSnapCatalogue(current, { ...music, provenance: { ...music.provenance, region: "jp" } })).toBe(false);
+  expect(isCurrentSnapCatalogue(current, null)).toBe(false);
+});
+
+describe("Snap Worker transport and paired replay", () => {
+  test("same seed/order/accuracy/context paired replay, then version/profile/chart cache", async () => {
+    const messages: SnapWorkerResponse[] = [], used: SnapEvaluationProfile[] = [];
+    let calls = 0, frees = 0;
+    const handler = createSnapWorkerHandler((value) => messages.push(value), { load: async () => loaded, validate: () => {}, catalogue: () => catalogue,
+      evaluator: (_, p) => { used.push(p); return { evaluate: (scoreId) => { calls++; return { format: "ournotes.replay-result/1", scoreId, complete: true,
+        score: p.selections.some(Boolean) ? 250 : 100, life: 1000, combo: 20, randomDraws: 2, convertedJudgements: 0 }; }, dispose: () => { frees++; } }; },
+      yieldControl: async () => {} });
+    const request: SnapWorkerRequest = { kind: "measure", revision: 1, source, profile: profile(), scoreIds: [10, 11, 10] };
+    await handler.handle(request);
+    expect(calls).toBe(4);
+    expect(frees).toBe(2);
+    expect(used).toHaveLength(2);
+    expect({ ...used[1]!, selections: used[0]!.selections }).toEqual(used[0]);
+    expect(used[1]!.selections).toEqual([null, null, null, null, null]);
+    const rows = messages.flatMap((value) => value.kind === "progress" ? value.rows : []);
+    expect(rows.map((row) => [row.scoreId, row.score, row.baselineScore, row.delta])).toEqual([[10, 250, 100, 150], [11, 250, 100, 150]]);
+    await handler.handle({ ...request, revision: 2 });
+    expect(calls).toBe(4);
+    expect(messages.at(-1)).toMatchObject({ kind: "complete", revision: 2, cacheHits: 4, done: 2, total: 2 });
+    await handler.handle({ ...request, revision: 3, profile: { ...profile(), seed: 7 } });
+    expect(calls).toBe(8);
+    await handler.handle({ ...request, revision: 4, source: { ...source, reference: { ...source.reference, sha256: "c".repeat(64) } } });
+    expect(calls).toBe(12);
+  });
+  test("cancel between charts releases both sessions and never declares completion", async () => {
+    const messages: SnapWorkerResponse[] = [];
+    let calls = 0, freed = 0;
+    const handler = createSnapWorkerHandler((value) => messages.push(value), { load: async () => loaded, validate: () => {}, catalogue: () => catalogue,
+      evaluator: () => ({ evaluate: (scoreId) => { calls++; return { format: "ournotes.replay-result/1", scoreId, complete: true, score: 100, life: 1, combo: 1, randomDraws: 0, convertedJudgements: 0 }; }, dispose: () => { freed++; } }),
+      yieldControl: async () => { await handler.handle({ kind: "cancel", revision: 8 }); } });
+    await handler.handle({ kind: "measure", revision: 8, source, profile: profile(), scoreIds: [10, 11, 12] });
+    expect(calls).toBe(2);
+    expect(freed).toBe(2);
+    expect(messages.some((value) => value.kind === "complete")).toBe(false);
+    expect(messages.at(-1)).toEqual({ kind: "cancelled", revision: 8 });
+  });
+  test("a missing paired context fails before allocation and cached-score lookup", async () => {
+    const messages: SnapWorkerResponse[] = [];
+    let allocations = 0;
+    const handler = createSnapWorkerHandler((value) => messages.push(value), { load: async () => loaded, catalogue: () => catalogue,
+      validate: () => { throw new SnapReplayError("needs-context", "Missing source-bound member"); },
+      evaluator: () => { allocations++; throw Error("Must not run"); } });
+    await handler.handle({ kind: "measure", revision: 2, source, profile: profile(), scoreIds: [10] });
+    expect(allocations).toBe(0);
+    expect(messages.at(-1)).toMatchObject({ kind: "error", phase: "measure", code: "needs-context", revision: 2 });
+  });
+  test("native replay errors still reach the client after session cleanup", async () => {
+    const messages: SnapWorkerResponse[] = [];
+    let freed = 0;
+    const handler = createSnapWorkerHandler((value) => messages.push(value), { load: async () => loaded, catalogue: () => catalogue, validate: () => {},
+      evaluator: () => ({ evaluate: () => { throw new SnapReplayError("unsupported", "Unsupported chart"); }, dispose: () => { freed++; } }) });
+    await handler.handle({ kind: "measure", revision: 9, source, profile: profile(), scoreIds: [10] });
+    expect(freed).toBe(1);
+    expect(messages.at(-1)).toMatchObject({ kind: "error", code: "unsupported", phase: "measure", revision: 9 });
+  });
+  test("bounded cache does not grow with profiles", async () => {
+    const handler = createSnapWorkerHandler(() => {}, { load: async () => loaded, catalogue: () => catalogue, validate: () => {}, yieldControl: async () => {},
+      evaluator: () => ({ evaluate: (scoreId) => ({ format: "ournotes.replay-result/1", scoreId, complete: true, score: 1, life: 1, combo: 1, randomDraws: 0, convertedJudgements: 0 }), dispose: () => {} }) }, 2);
+    await handler.handle({ kind: "measure", revision: 1, source, profile: profile(), scoreIds: [10, 11, 12] });
+    expect(handler.cacheSize()).toBe(2);
+  });
+});
+
+class FakeWorker implements SnapWorkerPort {
+  requests: SnapWorkerRequest[] = [];
+  stopped = false;
+  message?: (event: MessageEvent<SnapWorkerResponse>) => void;
+  error?: (event: ErrorEvent) => void;
+  postMessage(value: SnapWorkerRequest) { this.requests.push(value); }
+  addEventListener(type: "message", listener: (event: MessageEvent<SnapWorkerResponse>) => void): void;
+  addEventListener(type: "error", listener: (event: ErrorEvent) => void): void;
+  addEventListener(type: "message" | "error", listener: ((event: MessageEvent<SnapWorkerResponse>) => void) | ((event: ErrorEvent) => void)) {
+    if (type === "message") this.message = listener as (event: MessageEvent<SnapWorkerResponse>) => void;
+    else this.error = listener as (event: ErrorEvent) => void;
+  }
+  removeEventListener(type: "message", listener: (event: MessageEvent<SnapWorkerResponse>) => void): void;
+  removeEventListener(type: "error", listener: (event: ErrorEvent) => void): void;
+  removeEventListener(type: "message" | "error") { if (type === "message") delete this.message; else delete this.error; }
+  terminate() { this.stopped = true; }
+  emit(value: SnapWorkerResponse) { this.message?.({ data: value } as MessageEvent<SnapWorkerResponse>); }
+}
+test("client discards stale job/profile messages, independently accepts latest catalogue, and terminates", () => {
+  const worker = new FakeWorker(), states: SnapRankingState[] = [], catalogues: SnapRankingCatalogue[] = [];
+  const client = new SnapRankingClient((state) => states.push(state), (value) => catalogues.push(value), worker);
+  client.loadCatalogue(source, "en-US");
+  const catalogueRevision = worker.requests.at(-1)!.revision;
+  client.measure(source, profile(), [10]);
+  const oldRevision = worker.requests.at(-1)!.revision;
+  const next = { ...profile(), seed: 7 };
+  client.measure(source, next, [11]);
+  const nextRevision = worker.requests.at(-1)!.revision;
+  worker.emit({ kind: "complete", revision: oldRevision, profileKey: snapProfileKey(profile()), done: 1, total: 1, source: identity, cacheHits: 0 });
+  expect(states.at(-1)?.status).toBe("loading");
+  expect(states.at(-1)?.sourceKey).toBe(snapSourceKey(source));
+  worker.emit({ kind: "catalogue", revision: catalogueRevision, catalogue });
+  expect(catalogues).toEqual([catalogue]);
+  worker.emit({ kind: "progress", revision: nextRevision, profileKey: snapProfileKey(profile()), done: 1, total: 1, rows: [], source: identity });
+  expect(states.at(-1)?.done).toBe(0);
+  worker.emit({ kind: "complete", revision: nextRevision, profileKey: snapProfileKey(next), done: 0, total: 0, source: identity, cacheHits: 0 });
+  expect(states.at(-1)?.status).toBe("complete");
+  client.dispose();
+  expect(worker.stopped).toBe(true);
+});