diff --git a/.env.example b/.env.example
index 1ae987ffc..f40055661 100644
--- a/.env.example
+++ b/.env.example
@@ -48,6 +48,9 @@ SQL_LOG=none
 
 VITE_SHOW_LUTI_NAV_ITEM=false
 
+// If false the scanner page and its ingest endpoint are admin only
+VITE_SCANNER_ENABLED=false
+
 // Push notification. Generate values here https://vapidkeys.com/
 VITE_VAPID_PUBLIC_KEY=
 VAPID_PRIVATE_KEY=
diff --git a/.gitignore b/.gitignore
index 844ddee71..473235b62 100644
--- a/.gitignore
+++ b/.gitignore
@@ -34,3 +34,6 @@ dump
 .e2e-build-marker
 
 notepad.txt
+
+# proprietary game fonts for the scanner glyph-atlas builders (scripts/scanner)
+/assets/fonts/
diff --git a/AGENTS.md b/AGENTS.md
index 7a515827c..bf000a8a0 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -98,3 +98,11 @@
 
 - use the template `/github/pull_request_template.md`
 - do not mention claude or claude code in the description
+
+## Scanner feature (app/features/scanner)
+
+- computer-vision match-event detection; full docs in `app/features/scanner/README.md` — read it before touching detector/recognition code
+- OpenCV ROI-view gotcha: `.data`/`.clone()` are broken on ROI views — always `view.copyTo(freshMat)` before pixel access
+- fixture workflow: every live misread becomes a fixture under `app/features/scanner/tests/fixtures/`; ground-truth labels are hand-corrected by the maintainer and definitive over any matcher output
+- test with `pnpm test:scanner`; accuracy report with `pnpm scanner:report`; atlas regen commands and the assets-repo/CDN flow are in the README
+- events, snap tables, and fixtures speak sendou ids (`ModeShort`/`StageId`/weapon ids/`Ability`) — never reintroduce English game-name literals outside the generated localized snap tables
diff --git a/app/components/FormWithConfirm.tsx b/app/components/FormWithConfirm.tsx
index 8661e677c..bc06fa3bb 100644
--- a/app/components/FormWithConfirm.tsx
+++ b/app/components/FormWithConfirm.tsx
@@ -2,7 +2,10 @@ import * as React from "react";
 import { createPortal } from "react-dom";
 import { useTranslation } from "react-i18next";
 import { type FetcherWithComponents, useFetcher } from "react-router";
-import type { SendouButtonProps } from "~/components/elements/Button";
+import {
+	SendouButton,
+	type SendouButtonProps,
+} from "~/components/elements/Button";
 import { SendouDialog } from "~/components/elements/Dialog";
 import { useHydrated } from "~/hooks/useHydrated";
 import invariant from "~/utils/invariant";
@@ -26,6 +29,7 @@ export function FormWithConfirm({
 	fetcher: _fetcher,
 	isOpen,
 	onOpenChange,
+	onConfirm,
 }: {
 	fields?: (
 		| [name: string, value: string | number]
@@ -43,6 +47,8 @@ export function FormWithConfirm({
 	/** Controls the dialog open state. When provided, no child trigger is needed. */
 	isOpen?: boolean;
 	onOpenChange?: (isOpen: boolean) => void;
+	/** Confirming runs this callback instead of submitting a form (client only action) */
+	onConfirm?: () => void;
 }) {
 	const componentsFetcher = useFetcher();
 	const fetcher = _fetcher ?? componentsFetcher;
@@ -69,7 +75,7 @@ export function FormWithConfirm({
 
 	return (
 		<>
-			{isHydrated
+			{isHydrated && !onConfirm
 				? // using portal here makes nesting this component in another form work
 					createPortal(
 						<fetcher.Form
@@ -99,13 +105,26 @@ export function FormWithConfirm({
 						<FormMessage type="info">{description}</FormMessage>
 					) : null}
 					<div className="stack horizontal md justify-center mt-2">
-						<SubmitButton
-							form={id}
-							variant={submitButtonVariant}
-							testId={dialogOpen ? "confirm-button" : submitButtonTestId}
-						>
-							{submitButtonText ?? t("common:actions.delete")}
-						</SubmitButton>
+						{onConfirm ? (
+							<SendouButton
+								variant={submitButtonVariant}
+								testId={dialogOpen ? "confirm-button" : submitButtonTestId}
+								onPress={() => {
+									closeDialog();
+									onConfirm();
+								}}
+							>
+								{submitButtonText ?? t("common:actions.delete")}
+							</SendouButton>
+						) : (
+							<SubmitButton
+								form={id}
+								variant={submitButtonVariant}
+								testId={dialogOpen ? "confirm-button" : submitButtonTestId}
+							>
+								{submitButtonText ?? t("common:actions.delete")}
+							</SubmitButton>
+						)}
 					</div>
 				</div>
 			</SendouDialog>
diff --git a/app/components/ObjectiveTimeline.module.css b/app/components/ObjectiveTimeline.module.css
new file mode 100644
index 000000000..3a3e04d56
--- /dev/null
+++ b/app/components/ObjectiveTimeline.module.css
@@ -0,0 +1,6 @@
+.container {
+	height: 300px;
+	background-color: var(--color-bg-high);
+	border-radius: var(--radius-box);
+	padding: var(--s-2-5) var(--s-3);
+}
diff --git a/app/components/ObjectiveTimeline.tsx b/app/components/ObjectiveTimeline.tsx
new file mode 100644
index 000000000..42584e904
--- /dev/null
+++ b/app/components/ObjectiveTimeline.tsx
@@ -0,0 +1,284 @@
+/**
+ * Line chart of a game's objective-counter reads: one line per team
+ * (remaining count over match time, so lines fall toward 0). Control is a
+ * state rather than a count, so it gets its own lane in a gutter below the
+ * zero gridline instead of sharing the count axis — a strip in the
+ * controlling team's color, absent while neither team controls. The
+ * zero gridline is drawn in the stronger border color to read as the
+ * divider between the counts above and the lane below. Penalty is a
+ * translucent band filled between score and score + penalty — its thickness
+ * is the extra count the team must burn through before its score moves
+ * again, so it grows when a penalty lands and shrinks as it counts down.
+ * Control state and exact values stay in the shared hover tooltip.
+ *
+ * Series colors are the chart tokens from vars.css — the theme's text-tier
+ * colors are too pastel to tell apart as marks; these are the same two hues
+ * re-stepped per theme and validated for CVD separation and surface
+ * contrast.
+ */
+
+import {
+	Chart as ChartJS,
+	Filler,
+	Legend,
+	LinearScale,
+	LineElement,
+	PointElement,
+	Tooltip,
+} from "chart.js";
+import { Line } from "react-chartjs-2";
+import { useTranslation } from "react-i18next";
+import { useThemeColors } from "~/hooks/useThemeColors";
+import styles from "./ObjectiveTimeline.module.css";
+import { smoothPenalties } from "./objective-timeline-utils";
+
+ChartJS.register(
+	LinearScale,
+	PointElement,
+	LineElement,
+	Filler,
+	Tooltip,
+	Legend,
+);
+
+/** count-axis units of gutter kept below zero for the control lane */
+const CONTROL_LANE_DEPTH = 13;
+const CONTROL_LANE_Y = -6;
+const CONTROL_LANE_WIDTH = 6;
+const COUNT_TICK_STEP = 25;
+
+/** One objective-counter read, values in `[alpha, bravo]` order. */
+export interface ObjectiveTimelineSample {
+	/** seconds shown on the match timer at the read ("3:35" = 215); null = unreadable */
+	time: number | null;
+	/** displayed count per team; null = unreadable */
+	score: [number | null, number | null];
+	/** penalty pill value per team; null = no pill (or unreadable) */
+	penalty: [number | null, number | null];
+	/** which team held the objective at the read */
+	control: [boolean, boolean];
+}
+
+export interface ObjectiveTimelineEvent {
+	/** whole seconds into the source (video, stream or game) the read was made at */
+	t: number;
+	data: ObjectiveTimelineSample;
+}
+
+export function ObjectiveTimeline({
+	events,
+	teamLabels,
+}: {
+	events: readonly ObjectiveTimelineEvent[];
+	teamLabels: readonly [string, string];
+}) {
+	const { t } = useTranslation(["common"]);
+	const colors = useThemeColors({
+		alpha: "--color-chart-alpha",
+		bravo: "--color-chart-bravo",
+		border: "--color-border",
+		borderHigh: "--color-border-high",
+		text: "--color-text-high",
+	});
+	const sorted = events.toSorted((a, b) => a.t - b.t);
+	if (sorted.length === 0) return null;
+
+	const teamColors = [colors.alpha, colors.bravo];
+	const scoreDatasets = ([0, 1] as const).map((side) => ({
+		label: teamLabels[side],
+		data: sorted.map((event) => ({
+			x: event.t,
+			y: event.data.score[side],
+		})),
+		borderColor: teamColors[side],
+		backgroundColor: teamColors[side],
+		pointBackgroundColor: teamColors[side],
+		pointBorderColor: teamColors[side],
+		borderWidth: 2,
+		pointRadius: 0,
+		pointHoverRadius: 4,
+		hitRadius: 20,
+		spanGaps: true,
+		cubicInterpolationMode: "monotone" as const,
+	}));
+	// strip along the lane while the team is in control; the losing edge is
+	// kept in the lane too so the strip extends exactly to where control ended
+	const controlDatasets = ([0, 1] as const).map((side) => ({
+		label: `${teamLabels[side]} control`,
+		data: sorted.map((event, i) => ({
+			x: event.t,
+			y:
+				event.data.control[side] || sorted[i - 1]?.data.control[side]
+					? CONTROL_LANE_Y
+					: null,
+		})),
+		borderColor: teamColors[side],
+		borderWidth: CONTROL_LANE_WIDTH,
+		borderCapStyle: "round" as const,
+		pointRadius: 0,
+		pointHoverRadius: 0,
+		hitRadius: 0,
+		spanGaps: false,
+		stepped: "after" as const,
+	}));
+	// band between score and score + penalty; its thickness is the penalty
+	const penaltyDatasets = ([0, 1] as const).map((side) => {
+		const penalties = smoothPenalties(
+			sorted.map((event) => ({
+				t: event.t,
+				penalty: event.data.penalty[side],
+			})),
+		);
+		let lastScore: number | null = null;
+		return {
+			label: `${teamLabels[side]} penalty`,
+			data: sorted.map((event, i) => {
+				lastScore = event.data.score[side] ?? lastScore;
+				return {
+					x: event.t,
+					y: lastScore === null ? null : lastScore + (penalties[i] ?? 0),
+				};
+			}),
+			borderColor: `${teamColors[side]}8c`,
+			backgroundColor: `${teamColors[side]}38`,
+			borderWidth: 1,
+			pointRadius: 0,
+			pointHoverRadius: 0,
+			cubicInterpolationMode: "monotone" as const,
+			fill: { target: side },
+			// edge only where a penalty exists so zero-height bands stay invisible
+			segment: {
+				borderColor: (ctx: { p0DataIndex: number; p1DataIndex: number }) =>
+					(penalties[ctx.p0DataIndex] ?? 0) > 0 ||
+					(penalties[ctx.p1DataIndex] ?? 0) > 0
+						? undefined
+						: "transparent",
+			},
+		};
+	});
+	const datasets = [...scoreDatasets, ...penaltyDatasets, ...controlDatasets];
+
+	return (
+		<div className={styles.container}>
+			<Line
+				data={{ datasets }}
+				options={{
+					animation: false,
+					maintainAspectRatio: false,
+					interaction: { mode: "index", intersect: false },
+					scales: {
+						x: {
+							type: "linear",
+							min: sorted[0]!.t,
+							max: sorted[sorted.length - 1]!.t,
+							grid: { color: colors.border },
+							border: { color: colors.borderHigh },
+							ticks: {
+								color: colors.text,
+								maxRotation: 0,
+								maxTicksLimit: 8,
+								callback: (value) => formatElapsed(Number(value)),
+							},
+						},
+						y: {
+							min: -CONTROL_LANE_DEPTH,
+							suggestedMax: 100,
+							bounds: "data",
+							grid: {
+								color: (ctx) => gridColor(ctx.tick?.value ?? 0, colors),
+								tickColor: (ctx) => gridColor(ctx.tick?.value ?? 0, colors),
+							},
+							border: { color: colors.borderHigh },
+							afterBuildTicks: (axis) => {
+								axis.ticks = countAxisTicks(axis.max);
+							},
+							ticks: { color: colors.text, autoSkip: false },
+						},
+					},
+					plugins: {
+						legend: {
+							labels: {
+								color: colors.text,
+								boxWidth: 10,
+								boxHeight: 10,
+								filter: (item) => (item.datasetIndex ?? 0) < 2,
+							},
+						},
+						tooltip: {
+							filter: (item) => item.datasetIndex < 2,
+							callbacks: {
+								title: (items) => {
+									if (!items[0]) return "";
+									const clock = sorted[items[0].dataIndex]?.data.time;
+									const elapsed = formatElapsed(items[0].parsed.x ?? 0);
+									return clock != null
+										? `${elapsed} · ${t("common:objectiveTimeline.timeLeft", {
+												time: formatClock(clock),
+											})}`
+										: elapsed;
+								},
+								label: (item) => {
+									const event = sorted[item.dataIndex];
+									if (!event) return "";
+									const side = item.datasetIndex as 0 | 1;
+									const { score, penalty, control } = event.data;
+									return [
+										`${teamLabels[side]}: ${score[side] ?? "?"}`,
+										penalty[side] !== null
+											? t("common:objectiveTimeline.penalty", {
+													value: penalty[side],
+												})
+											: null,
+										control[side]
+											? t("common:objectiveTimeline.inControl")
+											: null,
+									]
+										.filter(Boolean)
+										.join(" · ");
+								},
+							},
+						},
+					},
+				}}
+			/>
+		</div>
+	);
+}
+
+/**
+ * One tick every 25 up to the top of the data and none below zero, so the
+ * control gutter stays free of axis furniture.
+ */
+function countAxisTicks(max: number) {
+	const ticks = [];
+	for (let value = 0; value <= max; value += COUNT_TICK_STEP) {
+		ticks.push({ value });
+	}
+	return ticks;
+}
+
+/** zero divides counts from the lane, so it is drawn stronger; the gutter has no grid */
+function gridColor(
+	value: number,
+	colors: { border: string; borderHigh: string },
+) {
+	if (value < 0) return "transparent";
+	return value === 0 ? colors.borderHigh : colors.border;
+}
+
+/** Position on the x-axis: m:ss, growing an hours part only when needed. */
+function formatElapsed(seconds: number): string {
+	const hours = Math.floor(seconds / 3600);
+	const minutes = Math.floor((seconds % 3600) / 60);
+	const rest = String(Math.floor(seconds % 60)).padStart(2, "0");
+	return hours > 0
+		? `${hours}:${String(minutes).padStart(2, "0")}:${rest}`
+		: `${minutes}:${rest}`;
+}
+
+/** the match timer's M:SS (215 → "3:35") */
+function formatClock(seconds: number): string {
+	const minutes = Math.floor(seconds / 60);
+	const rest = String(Math.floor(seconds % 60)).padStart(2, "0");
+	return `${minutes}:${rest}`;
+}
diff --git a/app/components/StageBannerBox.module.css b/app/components/StageBannerBox.module.css
new file mode 100644
index 000000000..065799eb2
--- /dev/null
+++ b/app/components/StageBannerBox.module.css
@@ -0,0 +1,17 @@
+.banner {
+	background-image:
+		linear-gradient(
+			to right,
+			var(--stage-banner-fade, var(--color-bg-high)) 35%,
+			transparent 80%
+		),
+		var(--stage-banner);
+	background-origin: border-box;
+	background-position: right center;
+	/* fade layer is grown a pixel past the box so subpixel box sizes can't
+	   leave a sliver of the banner showing at the edges */
+	background-size:
+		calc(100% + 2px) calc(100% + 2px),
+		cover;
+	background-repeat: no-repeat;
+}
diff --git a/app/components/StageBannerBox.tsx b/app/components/StageBannerBox.tsx
new file mode 100644
index 000000000..8c5e33aeb
--- /dev/null
+++ b/app/components/StageBannerBox.tsx
@@ -0,0 +1,33 @@
+import clsx from "clsx";
+import type * as React from "react";
+import type { StageId } from "~/modules/in-game-lists/types";
+import { stageBannerImageUrl } from "~/utils/urls";
+import styles from "./StageBannerBox.module.css";
+
+/**
+ * Box with a stage banner image fading in from the right. The fade color
+ * defaults to `--color-bg-high`; override per use with the
+ * `--stage-banner-fade` CSS variable.
+ */
+export function StageBannerBox({
+	stageId,
+	className,
+	children,
+}: {
+	stageId: StageId;
+	className?: string;
+	children: React.ReactNode;
+}) {
+	return (
+		<div
+			className={clsx(styles.banner, className)}
+			style={
+				{
+					"--stage-banner": `url(${stageBannerImageUrl(stageId)})`,
+				} as React.CSSProperties
+			}
+		>
+			{children}
+		</div>
+	);
+}
diff --git a/app/components/WeaponSelect.tsx b/app/components/WeaponSelect.tsx
index 2921084e5..db9d6c276 100644
--- a/app/components/WeaponSelect.tsx
+++ b/app/components/WeaponSelect.tsx
@@ -1,3 +1,4 @@
+import type { TFunction } from "i18next";
 import * as React from "react";
 import type { Key } from "react-aria-components";
 import { useTranslation } from "react-i18next";
@@ -74,23 +75,25 @@ export function WeaponSelect<
 			: value && typeof value === "object" && value.type === "MAIN"
 				? (value.id as MainWeaponId)
 				: null;
+	const isControlled = value !== undefined;
+	const [isOpen, setIsOpen] = React.useState(false);
+	const [lastUncontrolledKey, setLastUncontrolledKey] = React.useState<
+		string | null
+	>(() => keyify(initialValue) ?? null);
+	const selectedKey = isControlled ? keyify(value) : lastUncontrolledKey;
 	const { items, filterValue, setFilterValue } = useWeaponItems({
 		includeSubSpecial,
 		quickSelectWeaponsIds,
 		selectedWeaponId,
+		isOpen,
+		selectedKey,
 	});
 	const filter = useWeaponFilter();
 
-	const isControlled = value !== undefined;
-
-	const keyify = (value?: MainWeaponId | AnyWeapon | null) => {
-		if (typeof value === "number") return `MAIN_${value}`;
-		if (!value) return value;
-
-		return `${value.type}_${value.id}`;
-	};
-
 	const handleOnChange = (key: Key | null) => {
+		if (!isControlled) {
+			setLastUncontrolledKey(key === null ? null : String(key));
+		}
 		if (key === null) return onChange?.(null as any);
 		const [type, id] = (key as string).split("_");
 		const weapon = {
@@ -117,6 +120,7 @@ export function WeaponSelect<
 			}}
 			searchInputValue={filterValue}
 			onSearchInputChange={setFilterValue}
+			onOpenChange={setIsOpen}
 			selectedKey={isControlled ? keyify(value) : undefined}
 			defaultSelectedKey={
 				isControlled ? undefined : (keyify(initialValue) as Key)
@@ -191,26 +195,16 @@ export function WeaponSelect<
 	);
 }
 
+const weaponNameToWeaponMapCache = new Map<string, Map<string, AnyWeapon>>();
+
 function useWeaponFilter() {
-	const { t } = useTranslation(["weapons"]);
+	const { t, i18n } = useTranslation(["weapons"]);
 
-	const weaponNameToWeaponMap = (() => {
-		const map = new Map<string, AnyWeapon>();
-
-		for (const id of mainWeaponIds) {
-			map.set(t(`weapons:MAIN_${id}`), { id, type: "MAIN" });
-		}
-
-		for (const id of subWeaponIds) {
-			map.set(t(`weapons:SUB_${id}`), { id, type: "SUB" });
-		}
-
-		for (const id of specialWeaponIds) {
-			map.set(t(`weapons:SPECIAL_${id}`), { id, type: "SPECIAL" });
-		}
-
-		return map;
-	})();
+	const cached = weaponNameToWeaponMapCache.get(i18n.language);
+	const weaponNameToWeaponMap = cached ?? buildWeaponNameToWeaponMap(t);
+	if (!cached && i18n.hasLoadedNamespace("weapons")) {
+		weaponNameToWeaponMapCache.set(i18n.language, weaponNameToWeaponMap);
+	}
 
 	return (value: string, searchValue: string) => {
 		const weapon = weaponNameToWeaponMap.get(value);
@@ -224,19 +218,52 @@ function useWeaponFilter() {
 	};
 }
 
+function buildWeaponNameToWeaponMap(t: TFunction<["weapons"]>) {
+	const map = new Map<string, AnyWeapon>();
+
+	for (const id of mainWeaponIds) {
+		map.set(t(`weapons:MAIN_${id}`), { id, type: "MAIN" });
+	}
+
+	for (const id of subWeaponIds) {
+		map.set(t(`weapons:SUB_${id}`), { id, type: "SUB" });
+	}
+
+	for (const id of specialWeaponIds) {
+		map.set(t(`weapons:SPECIAL_${id}`), { id, type: "SPECIAL" });
+	}
+
+	return map;
+}
+
 function useWeaponItems({
 	includeSubSpecial,
 	quickSelectWeaponsIds,
 	selectedWeaponId,
+	isOpen,
+	selectedKey,
 }: {
 	includeSubSpecial: boolean | undefined;
 	quickSelectWeaponsIds?: Array<MainWeaponId>;
 	selectedWeaponId?: MainWeaponId | null;
+	isOpen: boolean;
+	selectedKey: string | null | undefined;
 }) {
 	const items = useAllWeaponCategories(includeSubSpecial);
 	const [filterValue, setFilterValue] = React.useState("");
 	const { t } = useTranslation(["common"]);
 
+	// While closed only the selected item is needed (the trigger's value
+	// display); react-aria renders every item passed to it into a hidden
+	// collection even when the popover is closed.
+	if (!isOpen) {
+		return {
+			items: collapseToSelectedItem(items, selectedKey),
+			filterValue,
+			setFilterValue,
+		};
+	}
+
 	const showQuickSelectWeapons =
 		filterValue === "" && quickSelectWeaponsIds?.length;
 
@@ -285,9 +312,29 @@ function useWeaponItems({
 	};
 }
 
-function useAllWeaponCategories(withSubSpecial = false) {
-	const { t } = useTranslation(["weapons"]);
+const allWeaponCategoriesCache = new Map<
+	string,
+	ReturnType<typeof buildAllWeaponCategories>
+>();
 
+function useAllWeaponCategories(withSubSpecial = false) {
+	const { t, i18n } = useTranslation(["weapons"]);
+
+	const cacheKey = `${i18n.language}-${withSubSpecial}`;
+	const cached = allWeaponCategoriesCache.get(cacheKey);
+	if (cached) return cached;
+
+	const categories = buildAllWeaponCategories(t, withSubSpecial);
+	if (i18n.hasLoadedNamespace("weapons")) {
+		allWeaponCategoriesCache.set(cacheKey, categories);
+	}
+	return categories;
+}
+
+function buildAllWeaponCategories(
+	t: TFunction<["weapons"]>,
+	withSubSpecial: boolean,
+) {
 	const mainWeaponCategories = weaponCategories.map((category, idx) => ({
 		name: category.name,
 		key: category.name,
@@ -343,3 +390,37 @@ function useAllWeaponCategories(withSubSpecial = false) {
 		...mainWeaponCategories.map((c) => ({ ...c, idx: c.idx + 2 })),
 	];
 }
+
+function keyify(value?: MainWeaponId | AnyWeapon | null) {
+	if (typeof value === "number") return `MAIN_${value}`;
+	if (!value) return value;
+
+	return `${value.type}_${value.id}`;
+}
+
+function collapseToSelectedItem<
+	Category extends { items: Array<{ weapon: { anyWeaponId: string } }> },
+>(categories: Category[], selectedKey: string | null | undefined): Category[] {
+	// react-stately refuses to open a select whose collection is empty, so even
+	// with nothing selected the closed collection keeps one item around.
+	const fallbackItems = () => {
+		const firstCategory = categories[0];
+		if (!firstCategory) return [];
+		return [
+			{ ...firstCategory, items: firstCategory.items.slice(0, 1) } as Category,
+		];
+	};
+
+	if (!selectedKey) return fallbackItems();
+
+	for (const category of categories) {
+		const selectedItem = category.items.find(
+			(item) => item.weapon.anyWeaponId === selectedKey,
+		);
+		if (selectedItem) {
+			return [{ ...category, items: [selectedItem] } as Category];
+		}
+	}
+
+	return fallbackItems();
+}
diff --git a/app/components/elements/Select.tsx b/app/components/elements/Select.tsx
index 04de433d7..76812b05f 100644
--- a/app/components/elements/Select.tsx
+++ b/app/components/elements/Select.tsx
@@ -78,6 +78,7 @@ export function SendouSelect<T extends object>({
 	clearable = false,
 	className,
 	filter,
+	onOpenChange,
 	...props
 }: SendouSelectProps<T>) {
 	const { t } = useTranslation(["common"]);
@@ -86,6 +87,8 @@ export function SendouSelect<T extends object>({
 	const isControlled = !!onSearchInputChange;
 
 	const handleOpenChange = (isOpen: boolean) => {
+		onOpenChange?.(isOpen);
+
 		if (!isControlled) return;
 
 		if (!isOpen) {
diff --git a/app/components/match-page/MatchTimeline.module.css b/app/components/match-page/MatchTimeline.module.css
index 358f25839..1970f427b 100644
--- a/app/components/match-page/MatchTimeline.module.css
+++ b/app/components/match-page/MatchTimeline.module.css
@@ -67,14 +67,7 @@
 	display: grid;
 	grid-template-rows: auto 1fr auto;
 	align-self: stretch;
-
-	&:first-child {
-		justify-self: end;
-	}
-
-	&:last-child {
-		justify-self: start;
-	}
+	container: weapon-pool / inline-size;
 }
 
 .mapCenter {
@@ -110,6 +103,21 @@
 	align-items: center;
 	justify-content: center;
 	gap: var(--s-2-5);
+
+	.mapSideBravo & {
+		justify-self: start;
+	}
+
+	.mapSide:not(.mapSideBravo) & {
+		justify-self: end;
+	}
+}
+
+.resultHeaderGroup {
+	display: flex;
+	flex-direction: column;
+	align-items: center;
+	gap: var(--s-0-5);
 }
 
 .resultHeader {
@@ -119,14 +127,168 @@
 }
 
 .resultLabel {
-	font-size: var(--font-xs);
+	font-size: var(--font-sm);
 	font-weight: var(--weight-extra);
 	text-transform: uppercase;
 }
 
 .resultPoints {
+	font-size: var(--font-xs);
+	font-weight: var(--weight-semi);
+	color: var(--color-text);
+}
+
+.scoreboard {
+	grid-column: 1 / -1;
+	display: flex;
+	flex-direction: column;
+	gap: var(--s-2);
+	margin-top: calc(-1 * var(--s-4));
+}
+
+.scoreboardToggle {
+	display: flex;
+	align-items: center;
+	gap: var(--s-2);
+	width: 100%;
+	padding: 0;
+	border: none;
+	background: transparent;
+	cursor: pointer;
+	font-size: var(--font-2xs);
+	font-weight: var(--weight-semi);
+	text-transform: uppercase;
+	letter-spacing: 0.05em;
+
+	&::before,
+	&::after {
+		content: "";
+		height: 1px;
+		flex: 1;
+		background-color: var(--color-border);
+	}
+}
+
+.scoreboardChevron {
+	transition: transform 0.15s ease;
+}
+
+.scoreboardChevronOpen {
+	transform: rotate(180deg);
+}
+
+.scoreboardPanel {
+	display: flex;
+	flex-direction: column;
+	gap: var(--s-3);
+	background-color: var(--color-bg);
+	border: var(--border-style);
+	border-radius: var(--radius-box);
+	padding: var(--s-3);
+	font-size: var(--font-xs);
+}
+
+.scoreboardTables {
+	display: flex;
+	flex-direction: column;
+	gap: var(--s-4);
+	overflow-x: auto;
+	overscroll-behavior-x: contain;
+}
+
+.scoreboardTable {
+	width: 100%;
+	min-width: 24rem;
+	table-layout: fixed;
+	border-collapse: collapse;
+}
+
+.scoreboardWeaponColumn,
+.scoreboardBuildColumn,
+.scoreboardStatHeader,
+.scoreboardTeamName,
+.scoreboardWeaponCell,
+.scoreboardPlayerName,
+.scoreboardStat,
+.scoreboardBuildCell {
+	padding: var(--s-1) var(--s-2);
+	vertical-align: middle;
+}
+
+.scoreboardHeaderRow {
+	border-bottom: var(--border-style);
+}
+
+.scoreboardPlayerRow:nth-child(even) {
+	background-color: var(--color-bg-high);
+}
+
+.scoreboardWeaponColumn {
+	width: 3rem;
+}
+
+.scoreboardBuildColumn {
+	width: 2.5rem;
+}
+
+.scoreboardStatHeader {
+	width: 3.5rem;
+	text-align: center;
 	font-size: var(--font-3xs);
 	font-weight: var(--weight-semi);
+	color: var(--color-text-high);
+}
+
+.scoreboardTeamName {
+	text-align: start;
+	font-size: var(--font-3xs);
+	font-weight: var(--weight-semi);
+	color: var(--color-text-high);
+	overflow: hidden;
+	white-space: nowrap;
+	text-overflow: ellipsis;
+}
+
+.scoreboardWeaponCell {
+	line-height: 0;
+}
+
+.scoreboardPlayerName {
+	text-align: start;
+	font-weight: var(--weight-semi);
+	overflow: hidden;
+	white-space: nowrap;
+	text-overflow: ellipsis;
+}
+
+.scoreboardStat {
+	text-align: center;
+	font-variant-numeric: tabular-nums;
+}
+
+.scoreboardBuildCell {
+	text-align: center;
+	line-height: 0;
+}
+
+.scoreboardAbilities {
+	display: flex;
+	flex-direction: column;
+	gap: var(--s-1);
+}
+
+.scoreboardAbilityRow {
+	display: flex;
+	align-items: center;
+	gap: var(--s-1);
+}
+
+.scoreboardUnknownWeapon {
+	opacity: 0.6;
+}
+
+:global(html.light) .scoreboardUnknownWeapon {
+	filter: drop-shadow(0 0 1px var(--color-text));
 }
 
 .eventRow {
diff --git a/app/components/match-page/MatchTimeline.tsx b/app/components/match-page/MatchTimeline.tsx
index bfb78c12c..41c3d82c2 100644
--- a/app/components/match-page/MatchTimeline.tsx
+++ b/app/components/match-page/MatchTimeline.tsx
@@ -1,36 +1,55 @@
 import clsx from "clsx";
 import {
 	ArrowRight,
+	ChevronDown,
 	MousePointerClick,
 	RefreshCcw,
 	TrendingUp,
 	Users,
 	X,
 } from "lucide-react";
+import { useState } from "react";
 import { useTranslation } from "react-i18next";
 import { LocaleTime } from "~/components/LocaleTime";
 import type {
 	GroupSkillDifference,
 	UserSkillDifference,
 } from "~/db/tables-json";
+import { abilities } from "~/modules/in-game-lists/abilities";
 import { shortStageName } from "~/modules/in-game-lists/stage-ids";
 import type {
+	AbilityWithUnknown,
 	MainWeaponId,
 	ModeShort,
 	StageId,
 } from "~/modules/in-game-lists/types";
 import type { CommonUser } from "~/utils/kysely.server";
 import { roundToNDecimalPlaces } from "~/utils/number";
+import { abilityImageUrl, navIconUrl } from "~/utils/urls";
+import { Ability } from "../Ability";
 import { Avatar } from "../Avatar";
 import { SendouButton } from "../elements/Button";
 import { SendouPopover } from "../elements/Popover";
-import { ModeImage, StageImage } from "../Image";
+import { Image, ModeImage, StageImage, WeaponImage } from "../Image";
+import {
+	ObjectiveTimeline,
+	type ObjectiveTimelineEvent,
+} from "../ObjectiveTimeline";
+import { matchScoresFromObjective } from "../objective-timeline-utils";
 import styles from "./MatchTimeline.module.css";
 import { type InferredSubstitution, inferSubstitutions } from "./utils";
+import type { WeaponPoolWeapon } from "./WeaponPool";
 import { WeaponPool } from "./WeaponPool";
 
 const LONG_TEAM_NAME_THRESHOLD = 16;
 
+/** Ingested team scores run 0-100; a knockout shows as 100 for the winner. */
+const SCOREBOARD_KO_SCORE = 100;
+
+const ABILITY_NAMES: ReadonlySet<string> = new Set(
+	abilities.map((ability) => ability.name),
+);
+
 type MatchSide = "ALPHA" | "BRAVO";
 
 export interface TimelineTeam {
@@ -38,6 +57,17 @@ export interface TimelineTeam {
 	avatar?: string;
 }
 
+export interface TimelineScoreboardPlayer {
+	name: string;
+	weaponSplId: MainWeaponId | null;
+	ka: number | null;
+	d: number | null;
+	s: number | null;
+	paint: number | null;
+	/** [head, clothes, shoes] ability rows (main + subs) as ability codes */
+	abilities?: string[][];
+}
+
 export interface TimelineMap {
 	stageId: StageId;
 	mode: ModeShort;
@@ -48,13 +78,22 @@ export interface TimelineMap {
 		bravo: CommonUser[];
 	};
 	weapons?: {
-		alpha: Array<MainWeaponId | null>;
-		bravo: Array<MainWeaponId | null>;
+		alpha: WeaponPoolWeapon[];
+		bravo: WeaponPoolWeapon[];
 	};
 	/** Whether the game ended in a knockout. Undefined if not collected. */
 	ko?: boolean;
 	/** Side that picked this map (counterpick / postGame map PICK). Renders a click indicator next to that side's WIN/LOSS label. */
 	pickedBy?: MatchSide;
+	/** Ingested end-of-game scoreboard rendered as an expandable stats section below the map row. */
+	scoreboard?: {
+		/** [alpha, bravo] on the ingested 0-100 scale (100 = knockout) */
+		scores: [number | null, number | null];
+		alpha: TimelineScoreboardPlayer[];
+		bravo: TimelineScoreboardPlayer[];
+		/** Objective-counter reads ([alpha, bravo] values) charted above the stats tables. */
+		objective?: ObjectiveTimelineEvent[];
+	};
 }
 
 interface TimelineSpMember {
@@ -133,7 +172,7 @@ export function MatchTimeline({
 								{substitutions.map((sub, j) => (
 									<TimelineSubstitutionRow key={j} substitution={sub} />
 								))}
-								<TimelineMapRow map={map} />
+								<TimelineMapRow map={map} teams={teams} />
 							</div>
 						);
 					})}
@@ -210,8 +249,20 @@ function TimelineHeader({
 	);
 }
 
-function TimelineMapRow({ map }: { map: TimelineMap }) {
+function TimelineMapRow({
+	map,
+	teams,
+}: {
+	map: TimelineMap;
+	teams: MatchTimelineProps["teams"];
+}) {
 	const { t } = useTranslation(["game-misc"]);
+	const objectiveScores = matchScoresFromObjective(
+		(map.scoreboard?.objective ?? []).map((event) => ({
+			t: event.t,
+			score: event.data.score,
+		})),
+	);
 
 	return (
 		<div className={styles.mapEvent}>
@@ -219,6 +270,8 @@ function TimelineMapRow({ map }: { map: TimelineMap }) {
 				<SideResult
 					result={map.winner === "ALPHA" ? "WIN" : "LOSS"}
 					isKo={map.ko && map.winner === "ALPHA"}
+					scoreboardScore={map.scoreboard?.scores[0]}
+					objectiveScore={objectiveScores[0]}
 					weapons={map.weapons?.alpha}
 					isPicked={map.pickedBy === "ALPHA"}
 				/>
@@ -239,14 +292,19 @@ function TimelineMapRow({ map }: { map: TimelineMap }) {
 					<span>{shortStageName(t(`game-misc:STAGE_${map.stageId}`))}</span>
 				</div>
 			</div>
-			<div className={styles.mapSide}>
+			<div className={clsx(styles.mapSide, styles.mapSideBravo)}>
 				<SideResult
 					result={map.winner === "BRAVO" ? "WIN" : "LOSS"}
 					isKo={map.ko && map.winner === "BRAVO"}
+					scoreboardScore={map.scoreboard?.scores[1]}
+					objectiveScore={objectiveScores[1]}
 					weapons={map.weapons?.bravo}
 					isPicked={map.pickedBy === "BRAVO"}
 				/>
 			</div>
+			{map.scoreboard ? (
+				<TimelineScoreboardSection scoreboard={map.scoreboard} teams={teams} />
+			) : null}
 		</div>
 	);
 }
@@ -254,49 +312,268 @@ function TimelineMapRow({ map }: { map: TimelineMap }) {
 function SideResult({
 	result,
 	isKo,
+	scoreboardScore,
+	objectiveScore,
 	weapons,
 	isPicked,
 }: {
 	result: "WIN" | "LOSS";
 	isKo?: boolean;
-	weapons?: Array<MainWeaponId | null>;
+	/** ingested 0-100 team score (100 = knockout) */
+	scoreboardScore?: number | null;
+	/** 0-100 team score implied by the last objective-counter read */
+	objectiveScore?: number | null;
+	weapons?: WeaponPoolWeapon[];
 	isPicked?: boolean;
 }) {
 	const { t } = useTranslation(["q"]);
+	const score = resolveSideScore(scoreboardScore, objectiveScore);
 
 	return (
 		<div className={styles.sideResult}>
-			<div className={styles.resultHeader}>
-				{isPicked ? (
-					<ExplainerIcon
-						icon={
-							<MousePointerClick
-								size={14}
-								className={result === "WIN" ? "text-success" : "text-error"}
-							/>
-						}
-						description={t("q:match.timeline.explainer.picked")}
-					/>
-				) : null}
-				<span
-					className={clsx(
-						styles.resultLabel,
-						result === "WIN" ? "text-success" : "text-error",
-					)}
-				>
-					{result === "WIN"
-						? t("q:match.timeline.win")
-						: t("q:match.timeline.loss")}
-				</span>
-				{isKo ? (
-					<span className={styles.resultPoints}>{t("q:match.action.ko")}</span>
-				) : null}
+			<div className={styles.resultHeaderGroup}>
+				<div className={styles.resultHeader}>
+					{isPicked ? (
+						<ExplainerIcon
+							icon={
+								<MousePointerClick
+									size={14}
+									className={result === "WIN" ? "text-success" : "text-error"}
+								/>
+							}
+							description={t("q:match.timeline.explainer.picked")}
+						/>
+					) : null}
+					<span
+						className={clsx(
+							styles.resultLabel,
+							result === "WIN" ? "text-success" : "text-error",
+						)}
+					>
+						{result === "WIN"
+							? t("q:match.timeline.win")
+							: t("q:match.timeline.loss")}
+					</span>
+					{isKo && score === null ? (
+						<span className={styles.resultPoints}>
+							{t("q:match.action.ko")}
+						</span>
+					) : null}
+				</div>
+				{score ? <ResultPoints score={score} /> : null}
 			</div>
 			{weapons ? <WeaponPool weapons={weapons} /> : null}
 		</div>
 	);
 }
 
+interface SideScore {
+	/** 0-100 (100 = knockout) */
+	value: number;
+	/** read off the objective counter rather than the results screen */
+	fromObjective: boolean;
+}
+
+/**
+ * A knockout's loser is reported with no score of its own, so the count it
+ * took is only known from the objective counter — prefer that read over a
+ * scoreless 0, and mark it as the video-sourced value it is.
+ */
+function resolveSideScore(
+	scoreboardScore?: number | null,
+	objectiveScore?: number | null,
+): SideScore | null {
+	if (typeof scoreboardScore === "number" && scoreboardScore > 0) {
+		return { value: scoreboardScore, fromObjective: false };
+	}
+	if (typeof objectiveScore === "number") {
+		return { value: objectiveScore, fromObjective: true };
+	}
+	if (typeof scoreboardScore === "number") {
+		return { value: scoreboardScore, fromObjective: false };
+	}
+
+	return null;
+}
+
+function ResultPoints({ score }: { score: SideScore }) {
+	const { t } = useTranslation(["q"]);
+
+	if (score.value === SCOREBOARD_KO_SCORE) {
+		return (
+			<span className={styles.resultPoints}>{t("q:match.action.ko")}</span>
+		);
+	}
+
+	return (
+		<span className={styles.resultPoints}>
+			{score.fromObjective
+				? `(${score.value})`
+				: t("q:match.timeline.points", { points: score.value })}
+		</span>
+	);
+}
+
+function TimelineScoreboardSection({
+	scoreboard,
+	teams,
+}: {
+	scoreboard: NonNullable<TimelineMap["scoreboard"]>;
+	teams: MatchTimelineProps["teams"];
+}) {
+	const { t } = useTranslation(["q"]);
+	const [isExpanded, setIsExpanded] = useState(false);
+
+	return (
+		<div className={styles.scoreboard}>
+			<button
+				type="button"
+				className={styles.scoreboardToggle}
+				onClick={() => setIsExpanded(!isExpanded)}
+				aria-expanded={isExpanded}
+			>
+				{t("q:match.timeline.details")}
+				<ChevronDown
+					size={14}
+					className={clsx(styles.scoreboardChevron, {
+						[styles.scoreboardChevronOpen]: isExpanded,
+					})}
+				/>
+			</button>
+			{isExpanded ? (
+				<div className={styles.scoreboardPanel}>
+					{scoreboard.objective && scoreboard.objective.length > 0 ? (
+						<ObjectiveTimeline
+							events={scoreboard.objective}
+							teamLabels={[teams.alpha.name, teams.bravo.name]}
+						/>
+					) : null}
+					<div className={styles.scoreboardTables}>
+						<ScoreboardTable
+							name={teams.alpha.name}
+							players={scoreboard.alpha}
+						/>
+						<ScoreboardTable
+							name={teams.bravo.name}
+							players={scoreboard.bravo}
+						/>
+					</div>
+				</div>
+			) : null}
+		</div>
+	);
+}
+
+function ScoreboardTable({
+	name,
+	players,
+}: {
+	name: string;
+	players: TimelineScoreboardPlayer[];
+}) {
+	const { t } = useTranslation(["q"]);
+
+	return (
+		<table className={styles.scoreboardTable}>
+			<thead>
+				<tr className={styles.scoreboardHeaderRow}>
+					<th className={styles.scoreboardWeaponColumn} />
+					<th scope="col" className={styles.scoreboardTeamName}>
+						{name}
+					</th>
+					<th scope="col" className={styles.scoreboardStatHeader}>
+						{t("q:match.timeline.stats.paint")}
+					</th>
+					<th scope="col" className={styles.scoreboardStatHeader}>
+						{t("q:match.timeline.stats.kills")}
+					</th>
+					<th scope="col" className={styles.scoreboardStatHeader}>
+						{t("q:match.timeline.stats.deaths")}
+					</th>
+					<th scope="col" className={styles.scoreboardStatHeader}>
+						{t("q:match.timeline.stats.specials")}
+					</th>
+					<th className={styles.scoreboardBuildColumn} />
+				</tr>
+			</thead>
+			<tbody>
+				{players.map((player, i) => (
+					<tr key={i} className={styles.scoreboardPlayerRow}>
+						<td className={styles.scoreboardWeaponCell}>
+							{player.weaponSplId !== null ? (
+								<WeaponImage
+									weaponSplId={player.weaponSplId}
+									variant="badge"
+									size={28}
+								/>
+							) : (
+								<Image
+									path={abilityImageUrl("UNKNOWN")}
+									alt="?"
+									size={28}
+									className={styles.scoreboardUnknownWeapon}
+								/>
+							)}
+						</td>
+						<th scope="row" className={styles.scoreboardPlayerName}>
+							{player.name}
+						</th>
+						<td className={styles.scoreboardStat}>
+							{player.paint !== null
+								? t("q:match.timeline.points", { points: player.paint })
+								: "–"}
+						</td>
+						<td className={styles.scoreboardStat}>{player.ka ?? "–"}</td>
+						<td className={styles.scoreboardStat}>{player.d ?? "–"}</td>
+						<td className={styles.scoreboardStat}>{player.s ?? "–"}</td>
+						<td className={styles.scoreboardBuildCell}>
+							{player.abilities && player.abilities.length > 0 ? (
+								<ScoreboardBuildPopover abilities={player.abilities} />
+							) : null}
+						</td>
+					</tr>
+				))}
+			</tbody>
+		</table>
+	);
+}
+
+function ScoreboardBuildPopover({ abilities }: { abilities: string[][] }) {
+	const { t } = useTranslation(["common"]);
+
+	return (
+		<SendouPopover
+			trigger={
+				<SendouButton shape="circle" size="small" variant="minimal">
+					<Image
+						path={navIconUrl("builds")}
+						alt={t("common:pages.builds")}
+						size={18}
+					/>
+				</SendouButton>
+			}
+		>
+			<div className={styles.scoreboardAbilities}>
+				{abilities.map((row, i) => (
+					<div key={i} className={styles.scoreboardAbilityRow}>
+						{row.map((ability, j) => (
+							<Ability
+								key={j}
+								ability={toAbility(ability)}
+								size={j === 0 ? "MAIN" : "SUB"}
+							/>
+						))}
+					</div>
+				))}
+			</div>
+		</SendouPopover>
+	);
+}
+
+function toAbility(value: string): AbilityWithUnknown {
+	return ABILITY_NAMES.has(value) ? (value as AbilityWithUnknown) : "UNKNOWN";
+}
+
 function TimelineEventRow({
 	icon,
 	alphaContent,
diff --git a/app/components/match-page/WeaponPool.module.css b/app/components/match-page/WeaponPool.module.css
index 9b5e459ee..f91b85002 100644
--- a/app/components/match-page/WeaponPool.module.css
+++ b/app/components/match-page/WeaponPool.module.css
@@ -6,6 +6,13 @@
 	border-radius: var(--radius-full);
 	padding: var(--s-0-5) var(--s-1-5);
 	cursor: pointer;
+
+	@container weapon-pool (max-width: 150px) {
+		display: grid;
+		grid-template-columns: repeat(2, auto);
+		justify-items: center;
+		border-radius: var(--radius-box);
+	}
 }
 
 :global(html.light) .unknownWeapon {
@@ -25,3 +32,7 @@
 	font-size: var(--font-xs);
 	font-weight: var(--weight-semi);
 }
+
+.unverifiedWeapon {
+	opacity: 0.7;
+}
diff --git a/app/components/match-page/WeaponPool.tsx b/app/components/match-page/WeaponPool.tsx
index 100ede8df..12514a5fd 100644
--- a/app/components/match-page/WeaponPool.tsx
+++ b/app/components/match-page/WeaponPool.tsx
@@ -1,3 +1,4 @@
+import clsx from "clsx";
 import { Button } from "react-aria-components";
 import { useTranslation } from "react-i18next";
 import type { MainWeaponId } from "~/modules/in-game-lists/types";
@@ -6,26 +7,42 @@ import { SendouPopover } from "../elements/Popover";
 import { Image, WeaponImage } from "../Image";
 import styles from "./WeaponPool.module.css";
 
+export type WeaponPoolWeapon =
+	| MainWeaponId
+	| {
+			weaponSplId: MainWeaponId;
+			/** renders faded, e.g. an ingested weapon not yet linked to its user */
+			unverified?: boolean;
+	  }
+	| null;
+
 export function WeaponPool({
 	weapons,
-	size = 24,
+	size = 32,
 }: {
-	weapons: Array<MainWeaponId | null>;
+	weapons: WeaponPoolWeapon[];
 	size?: number;
 }) {
 	const { t } = useTranslation(["weapons"]);
 
+	const entries = weapons.map((weapon) =>
+		typeof weapon === "number" ? { weaponSplId: weapon } : weapon,
+	);
+
 	return (
 		<SendouPopover
 			trigger={
 				<Button className={styles.weaponRow}>
-					{weapons.map((weaponId, i) =>
-						weaponId !== null ? (
+					{entries.map((weapon, i) =>
+						weapon !== null ? (
 							<WeaponImage
 								key={i}
-								weaponSplId={weaponId}
+								weaponSplId={weapon.weaponSplId}
 								variant="badge"
 								size={size}
+								className={clsx({
+									[styles.unverifiedWeapon]: weapon.unverified,
+								})}
 							/>
 						) : (
 							<Image
@@ -41,11 +58,15 @@ export function WeaponPool({
 			}
 		>
 			<div className={styles.weaponPopover}>
-				{weapons.map((weaponId, i) =>
-					weaponId !== null ? (
+				{entries.map((weapon, i) =>
+					weapon !== null ? (
 						<div key={i} className={styles.weaponPopoverRow}>
-							<WeaponImage weaponSplId={weaponId} variant="badge" size={32} />
-							<span>{t(`weapons:MAIN_${weaponId}` as any)}</span>
+							<WeaponImage
+								weaponSplId={weapon.weaponSplId}
+								variant="badge"
+								size={32}
+							/>
+							<span>{t(`weapons:MAIN_${weapon.weaponSplId}`)}</span>
 						</div>
 					) : null,
 				)}
diff --git a/app/components/objective-timeline-utils.test.ts b/app/components/objective-timeline-utils.test.ts
new file mode 100644
index 000000000..03226fdcf
--- /dev/null
+++ b/app/components/objective-timeline-utils.test.ts
@@ -0,0 +1,105 @@
+import { describe, expect, it } from "vitest";
+import {
+	matchScoresFromObjective,
+	type ObjectiveScoreRead,
+	type PenaltyRead,
+	smoothPenalties,
+} from "./objective-timeline-utils";
+
+function reads(...pairs: Array<[t: number, penalty: number | null]>) {
+	return pairs.map(([t, penalty]): PenaltyRead => ({ t, penalty }));
+}
+
+function counterReads(
+	...entries: Array<[t: number, alpha: number | null, bravo: number | null]>
+) {
+	return entries.map(
+		([t, alpha, bravo]): ObjectiveScoreRead => ({ t, score: [alpha, bravo] }),
+	);
+}
+
+describe("smoothPenalties", () => {
+	it("passes steady reads through", () => {
+		expect(smoothPenalties(reads([0, 10], [2, 10], [4, 10]))).toEqual([
+			10, 10, 10,
+		]);
+	});
+
+	it("median-filters an isolated dropped-digit misread", () => {
+		expect(smoothPenalties(reads([0, 36], [2, 6], [4, 36]))).toEqual([
+			36, 36, 36,
+		]);
+	});
+
+	it("bridges a short null gap with the previous value", () => {
+		expect(smoothPenalties(reads([0, 12], [2, null], [4, 12]))).toEqual([
+			12, 12, 12,
+		]);
+	});
+
+	it("does not bridge a gap longer than the bridge window", () => {
+		expect(
+			smoothPenalties(reads([0, 12], [1, 12], [20, null], [40, 8], [41, 8])),
+		).toEqual([12, 12, null, 8, 8]);
+	});
+
+	it("drops one-off reads with no nearby confirmation", () => {
+		expect(smoothPenalties(reads([0, 5], [30, 12], [60, 7]))).toEqual([
+			null,
+			null,
+			null,
+		]);
+	});
+
+	it("does not extend past the last read", () => {
+		expect(smoothPenalties(reads([0, 10], [2, 10], [4, null]))).toEqual([
+			10,
+			10,
+			null,
+		]);
+	});
+
+	it("keeps all-null reads null", () => {
+		expect(smoothPenalties(reads([0, null], [2, null]))).toEqual([null, null]);
+	});
+});
+
+describe("matchScoresFromObjective", () => {
+	it("inverts the last counter read of each team", () => {
+		expect(
+			matchScoresFromObjective(
+				counterReads([0, 100, 100], [60, 80, 92], [120, 55, 0]),
+			),
+		).toEqual([45, 100]);
+	});
+
+	it("falls back to the latest readable count", () => {
+		expect(
+			matchScoresFromObjective(
+				counterReads([0, 100, 100], [60, 55, 40], [120, null, null]),
+			),
+		).toEqual([45, 60]);
+	});
+
+	it("ignores counts outside the counter's range", () => {
+		expect(
+			matchScoresFromObjective(counterReads([0, 100, 100], [60, 155, 40])),
+		).toEqual([0, 60]);
+	});
+
+	it("reads the last count regardless of the order given", () => {
+		expect(
+			matchScoresFromObjective(
+				counterReads([120, 55, 0], [0, 100, 100], [60, 80, 92]),
+			),
+		).toEqual([45, 100]);
+	});
+
+	it("reports nothing when no count was read", () => {
+		expect(matchScoresFromObjective(counterReads([0, null, null]))).toEqual([
+			null,
+			null,
+		]);
+		expect(matchScoresFromObjective([])).toEqual([null, null]);
+	});
+});
diff --git a/app/components/objective-timeline-utils.ts b/app/components/objective-timeline-utils.ts
new file mode 100644
index 000000000..ebee39873
--- /dev/null
+++ b/app/components/objective-timeline-utils.ts
@@ -0,0 +1,109 @@
+const PENALTY_BRIDGE_SECONDS = 6;
+
+/** The count a knockout wins at: the counter runs out and the team takes all of it. */
+const FULL_COUNT = 100;
+
+/** One penalty read: when it was made and the pill value seen (null = no pill or unreadable). */
+export interface PenaltyRead {
+	/** whole seconds into the source (video, stream or game) the read was made at */
+	t: number;
+	penalty: number | null;
+}
+
+/**
+ * The penalty pill is misread for a frame or two at a time: it flickers
+ * between a value and null, and occasionally drops a digit ("36" read as
+ * "6"). Median-filters isolated outlier values, drops one-off reads with no
+ * nearby confirmation and carries the previous value across short null gaps
+ * so the band renders as one steady shape instead of a picket fence.
+ *
+ * @param reads one team's penalty reads, sorted by `t` ascending
+ * @returns the smoothed penalty per read, index-aligned with the input
+ */
+export function smoothPenalties(
+	reads: readonly PenaltyRead[],
+): (number | null)[] {
+	const medianFiltered = medianFilterValues(reads.map((read) => read.penalty));
+	const kept = reads.map((read, i) => {
+		const value = medianFiltered[i]!;
+		if (value === null) return null;
+		const hasNearbyRead = reads.some(
+			(other, j) =>
+				j !== i &&
+				other.penalty !== null &&
+				Math.abs(other.t - read.t) <= PENALTY_BRIDGE_SECONDS,
+		);
+		return hasNearbyRead ? value : null;
+	});
+
+	const result = [...kept];
+	let prev = -1;
+	for (let i = 0; i < result.length; i++) {
+		if (result[i] !== null) {
+			prev = i;
+			continue;
+		}
+		if (prev === -1) continue;
+		const next = result.findIndex((value, j) => j > i && value !== null);
+		if (next === -1) continue;
+		if (reads[next]!.t - reads[prev]!.t <= PENALTY_BRIDGE_SECONDS) {
+			result[i] = result[prev];
+		}
+	}
+	return result;
+}
+
+/** One counter read: when it was made and the count displayed per team. */
+export interface ObjectiveScoreRead {
+	/** whole seconds into the source (video, stream or game) the read was made at */
+	t: number;
+	/** displayed count per team; null = unreadable */
+	score: readonly [number | null, number | null];
+}
+
+/**
+ * Match scores implied by each team's last readable counter read. The counter
+ * counts down from 100 while match scores run the other way (100 = knockout),
+ * so a read is inverted into the count the team took. Stands in where the
+ * results screen reports no score of its own — a knockout's loser — but the
+ * last read is only as late as the last frame the counter was seen in, so it
+ * can trail the count the team ended on.
+ *
+ * @param reads counter reads, in any order
+ * @returns per-team match score (0-100); null where nothing was read
+ */
+export function matchScoresFromObjective(
+	reads: readonly ObjectiveScoreRead[],
+): [number | null, number | null] {
+	const sorted = reads.toSorted((a, b) => a.t - b.t);
+	const lastCountTaken = (side: 0 | 1) => {
+		for (let i = sorted.length - 1; i >= 0; i--) {
+			const count = sorted[i]!.score[side];
+			// a count outside the counter's range is a misread, not a state
+			if (count !== null && count >= 0 && count <= FULL_COUNT) {
+				return FULL_COUNT - count;
+			}
+		}
+		return null;
+	};
+
+	return [lastCountTaken(0), lastCountTaken(1)];
+}
+
+function medianFilterValues(
+	values: readonly (number | null)[],
+): (number | null)[] {
+	const nonNullIndexes = values.flatMap((value, i) =>
+		value !== null ? [i] : [],
+	);
+	const result = [...values];
+	for (let k = 1; k < nonNullIndexes.length - 1; k++) {
+		const window = [
+			values[nonNullIndexes[k - 1]!]!,
+			values[nonNullIndexes[k]!]!,
+			values[nonNullIndexes[k + 1]!]!,
+		].sort((a, b) => a - b);
+		result[nonNullIndexes[k]!] = window[1]!;
+	}
+	return result;
+}
diff --git a/app/config.ts b/app/config.ts
index bae212fac..c2c2d98a1 100644
--- a/app/config.ts
+++ b/app/config.ts
@@ -42,6 +42,7 @@ const values = {
 	VITE_PROD_MODE: stringBool("VITE_PROD_MODE"),
 	VITE_SHOW_LUTI_NAV_ITEM: stringBool("VITE_SHOW_LUTI_NAV_ITEM"),
 	VITE_FUSE_ENABLED: stringBool("VITE_FUSE_ENABLED"),
+	VITE_SCANNER_ENABLED: stringBool("VITE_SCANNER_ENABLED"),
 	VITE_LEAGUE_GOOGLE_FORM_URL: env.VITE_LEAGUE_GOOGLE_FORM_URL,
 	VITE_SHOW_BANNER_FOR_SEASON: env.VITE_SHOW_BANNER_FOR_SEASON,
 	VITE_SENTRY_DSN: env.VITE_SENTRY_DSN,
@@ -66,6 +67,8 @@ export const Config = {
 	/** Whether to show the LUTI navigation item. */
 	showLutiNavItem: values.VITE_SHOW_LUTI_NAV_ITEM,
 	fuseEnabled: values.VITE_FUSE_ENABLED,
+	/** Whether the scanner is available to everyone. While false only the admin and devs can use the scanner page and its ingest endpoint. */
+	scannerEnabled: values.VITE_SCANNER_ENABLED,
 	/** Google Form URL for league registration, if configured. */
 	leagueGoogleFormUrl: values.VITE_LEAGUE_GOOGLE_FORM_URL,
 	/** Season identifier to show the registration banner for, if any. */
diff --git a/app/db/tables.ts b/app/db/tables.ts
index 76e053852..a161c054a 100644
--- a/app/db/tables.ts
+++ b/app/db/tables.ts
@@ -34,6 +34,7 @@ import type { CalendarEventTag } from "~/features/calendar/calendar-types";
 import type { LFGType } from "~/features/lfg/lfg-constants";
 import type { SkillTeamIdentifier } from "~/features/mmr/mmr-utils";
 import type { Notification as NotificationValue } from "~/features/notifications/notifications-types";
+import type { ScannerMatch } from "~/features/scanner/core/scanner-match";
 import type { SplatoonRotationType } from "~/features/splatoon-rotations/splatoon-rotations-constants";
 import type {
 	MemberRole,
@@ -505,6 +506,30 @@ export interface ReportedWeapon {
 	createdAt: Generated<number>;
 }
 
+export interface IngestedMatch {
+	id: GeneratedAlways<number>;
+	povUserId: number | null;
+	submitterUserId: number | null;
+	/** database timestamp (seconds) the match was played at, when known */
+	playedAt: number | null;
+	data: JSONColumnType<ScannerMatch>;
+	matchHash: string;
+	/** server-resolved tournament the match probably belongs to; aids future linking */
+	tournamentIdHint: number | null;
+	/** server-resolved SendouQ match the match probably belongs to; aids future linking */
+	groupMatchIdHint: number | null;
+	createdAt: Generated<number>;
+}
+
+/** Links an ingested match to the game result it describes (exactly one target). */
+export interface IngestedMatchLink {
+	id: GeneratedAlways<number>;
+	ingestedMatchId: number;
+	tournamentMatchGameResultId: number | null;
+	groupMatchMapId: number | null;
+	createdAt: Generated<number>;
+}
+
 export interface Skill {
 	groupMatchId: number | null;
 	id: GeneratedAlways<number>;
@@ -1286,6 +1311,8 @@ export interface DB {
 	GroupReadyCheck: GroupReadyCheck;
 	GroupReadyCheckConfirmation: GroupReadyCheckConfirmation;
 	GroupSuggestion: GroupSuggestion;
+	IngestedMatch: IngestedMatch;
+	IngestedMatchLink: IngestedMatchLink;
 	PrivateUserNote: PrivateUserNote;
 	LogInLink: LogInLink;
 	LFGPost: LFGPost;
diff --git a/app/features/calendar/components/BracketProgressionFormFields.tsx b/app/features/calendar/components/BracketProgressionFormFields.tsx
index b6a2e5fca..7a839c777 100644
--- a/app/features/calendar/components/BracketProgressionFormFields.tsx
+++ b/app/features/calendar/components/BracketProgressionFormFields.tsx
@@ -4,7 +4,7 @@ import { InfoPopover } from "~/components/InfoPopover";
 import { TOURNAMENT } from "~/features/tournament/tournament-constants";
 import * as Swiss from "~/features/tournament-bracket/core/engine/swiss/team-status";
 import { FormField } from "~/form/FormField";
-import { useFormFieldContext } from "~/form/SendouForm";
+import { useFormFieldContext, useFormValue } from "~/form/SendouForm";
 import type { ArrayItemRenderContext } from "~/form/types";
 import {
 	type BracketFormValue,
@@ -110,9 +110,10 @@ function BracketFields({
 	isDisabled: boolean;
 }) {
 	const { t } = useTranslation(["forms"]);
-	const { index, itemName, values, formValues, setItemField } = renderContext;
+	const { index, itemName, values, setItemField } = renderContext;
 	const bracket = values as unknown as BracketFormValue;
-	const progression = (formValues.progression ?? []) as ProgressionFormValue[];
+	const progression = (useFormValue("progression") ??
+		[]) as ProgressionFormValue[];
 
 	const isFollowUp = index > 0 && progression[index]?.source === "BRACKET";
 
@@ -226,9 +227,9 @@ function ProgressionEntryFields({
 	isSourceLocked: boolean;
 }) {
 	const { t } = useTranslation(["forms"]);
-	const { index, itemName, values, formValues, setItemField } = renderContext;
+	const { index, itemName, values, setItemField } = renderContext;
 	const entry = values as unknown as ProgressionFormValue;
-	const brackets = (formValues.brackets ?? []) as BracketFormValue[];
+	const brackets = (useFormValue("brackets") ?? []) as BracketFormValue[];
 	const sources = entry.sources ?? [];
 
 	const isFirstBracket = index === 0;
@@ -301,10 +302,11 @@ function SourceFields({
 	destinationBracketIdx: number;
 	isDisabled: boolean;
 }) {
-	const { index, itemName, values, formValues } = renderContext;
+	const { index, itemName, values } = renderContext;
 	const source = values as unknown as ProgressionSourceFormValue;
-	const brackets = (formValues.brackets ?? []) as BracketFormValue[];
-	const progression = (formValues.progression ?? []) as ProgressionFormValue[];
+	const brackets = (useFormValue("brackets") ?? []) as BracketFormValue[];
+	const progression = (useFormValue("progression") ??
+		[]) as ProgressionFormValue[];
 	const siblingSources = progression[destinationBracketIdx]?.sources ?? [];
 
 	// a bracket can be sourced only once, so the brackets taken by the other rows
diff --git a/app/features/img-export/components/Graphic.tsx b/app/features/img-export/components/Graphic.tsx
index e474eb492..6309fe5a4 100644
--- a/app/features/img-export/components/Graphic.tsx
+++ b/app/features/img-export/components/Graphic.tsx
@@ -149,19 +149,25 @@ export function GraphicTeamRow({
 					))}
 				</div>
 			</div>
-			<div className={styles.weapons}>
-				{team.weapons.map((weaponSplId, index) => (
-					<div key={`${weaponSplId}-${index}`} className={styles.weaponKit}>
-						<WeaponImage weaponSplId={weaponSplId} variant="badge" size={38} />
-						<SpecialWeaponImage
-							specialWeaponId={
-								weaponParams().weaponKits[weaponSplId].specialWeaponId
-							}
-							size={24}
-						/>
-					</div>
-				))}
-			</div>
+			{team.weapons.length > 0 ? (
+				<div className={styles.weapons}>
+					{team.weapons.map((weaponSplId, index) => (
+						<div key={`${weaponSplId}-${index}`} className={styles.weaponKit}>
+							<WeaponImage
+								weaponSplId={weaponSplId}
+								variant="badge"
+								size={38}
+							/>
+							<SpecialWeaponImage
+								specialWeaponId={
+									weaponParams().weaponKits[weaponSplId].specialWeaponId
+								}
+								size={24}
+							/>
+						</div>
+					))}
+				</div>
+			) : null}
 		</Element>
 	);
 }
diff --git a/app/features/img-export/components/SeasonSummaryGraphic.module.css b/app/features/img-export/components/SeasonSummaryGraphic.module.css
index db6bc5612..c0ab198e3 100644
--- a/app/features/img-export/components/SeasonSummaryGraphic.module.css
+++ b/app/features/img-export/components/SeasonSummaryGraphic.module.css
@@ -55,13 +55,7 @@
 }
 
 .bestStageRow {
-	background-image:
-		linear-gradient(to right, var(--graphic-row-bg) 35%, transparent 80%),
-		var(--best-stage-banner);
-	background-origin: border-box;
-	background-position: right center;
-	background-size: cover;
-	background-repeat: no-repeat;
+	--stage-banner-fade: var(--graphic-row-bg);
 }
 
 .bestStageName {
diff --git a/app/features/img-export/components/SeasonSummaryGraphic.tsx b/app/features/img-export/components/SeasonSummaryGraphic.tsx
index c28216ebd..edb1cc194 100644
--- a/app/features/img-export/components/SeasonSummaryGraphic.tsx
+++ b/app/features/img-export/components/SeasonSummaryGraphic.tsx
@@ -12,11 +12,12 @@ import { Avatar } from "~/components/Avatar";
 import { Flag } from "~/components/Flag";
 import { TierImage, WeaponImage } from "~/components/Image";
 import { LocaleTimeRange } from "~/components/LocaleTimeRange";
+import { StageBannerBox } from "~/components/StageBannerBox";
 import { TierPill } from "~/components/TierPill";
 import type { TierName } from "~/features/mmr/mmr-constants";
 import { useDateTimeFormat } from "~/hooks/intl/useDateTimeFormat";
 import type { MainWeaponId, StageId } from "~/modules/in-game-lists/types";
-import { stageBannerImageUrl, userSeasonsPage } from "~/utils/urls";
+import { userSeasonsPage } from "~/utils/urls";
 import {
 	GRAPHIC_DATE_FORMAT_OPTIONS,
 	GraphicContainer,
@@ -264,13 +265,9 @@ export function SeasonSummaryGraphic({
 				</div>
 			) : null}
 			{bestStage ? (
-				<div
+				<StageBannerBox
+					stageId={bestStage.stageId}
 					className={clsx(graphicStyles.box, styles.bestStageRow)}
-					style={
-						{
-							"--best-stage-banner": `url(${stageBannerImageUrl(bestStage.stageId)})`,
-						} as React.CSSProperties
-					}
 				>
 					<div className={graphicStyles.boxLabel}>
 						{t("user:seasons.summary.bestStage")}
@@ -281,7 +278,7 @@ export function SeasonSummaryGraphic({
 							{Math.round(bestStage.winratePercentage)}%
 						</span>
 					</div>
-				</div>
+				</StageBannerBox>
 			) : null}
 			<div className={styles.middleGrid}>
 				<div className={clsx(graphicStyles.box, styles.activityBox)}>
diff --git a/app/features/img-export/components/TournamentResultsGraphic.module.css b/app/features/img-export/components/TournamentResultsGraphic.module.css
index 98ddb4cea..9e8d05b29 100644
--- a/app/features/img-export/components/TournamentResultsGraphic.module.css
+++ b/app/features/img-export/components/TournamentResultsGraphic.module.css
@@ -1,3 +1,9 @@
+.tierPillContainer {
+	display: inline-flex;
+	vertical-align: middle;
+	margin-inline-start: var(--s-2);
+}
+
 .organizationName {
 	max-width: 12rem;
 	overflow: hidden;
diff --git a/app/features/img-export/components/TournamentResultsGraphic.tsx b/app/features/img-export/components/TournamentResultsGraphic.tsx
index fa7a1a455..8937ff465 100644
--- a/app/features/img-export/components/TournamentResultsGraphic.tsx
+++ b/app/features/img-export/components/TournamentResultsGraphic.tsx
@@ -90,7 +90,11 @@ export function TournamentGraphicHeader({
 			titleRow={
 				<>
 					<span className={graphicStyles.headerTitle}>{tournamentName}</span>
-					{typeof tier === "number" ? <TierPill tier={tier} /> : null}
+					{typeof tier === "number" ? (
+						<span className={styles.tierPillContainer}>
+							<TierPill tier={tier} />
+						</span>
+					) : null}
 				</>
 			}
 			subtitle={
diff --git a/app/features/img-export/core/RunComps.test.ts b/app/features/img-export/core/RunComps.test.ts
new file mode 100644
index 000000000..423e30922
--- /dev/null
+++ b/app/features/img-export/core/RunComps.test.ts
@@ -0,0 +1,118 @@
+import { describe, expect, it } from "vitest";
+import type { MainWeaponId } from "~/modules/in-game-lists/types";
+import * as RunComps from "./RunComps";
+
+const SHOOTER = 40 as MainWeaponId;
+const ROLLER = 1010 as MainWeaponId;
+const CHARGER = 2010 as MainWeaponId;
+/** a kit that runs Tacticooler as the special */
+const TACTICOOLER_WEAPON = 60 as MainWeaponId;
+
+const observation = (
+	playerKey: string,
+	weaponSplId: MainWeaponId,
+	mapOrder: number,
+): RunComps.CompObservation => ({ playerKey, weaponSplId, mapOrder });
+
+describe("buildComp", () => {
+	it("returns an empty comp for no observations", () => {
+		expect(RunComps.buildComp([])).toEqual([]);
+	});
+
+	it("picks each player's most played weapon", () => {
+		expect(
+			RunComps.buildComp([
+				observation("a", SHOOTER, 0),
+				observation("a", SHOOTER, 1),
+				observation("a", CHARGER, 2),
+			]),
+		).toEqual([SHOOTER]);
+	});
+
+	it("breaks a most played tie by the most recently played weapon", () => {
+		expect(
+			RunComps.buildComp([
+				observation("a", CHARGER, 0),
+				observation("a", SHOOTER, 1),
+			]),
+		).toEqual([SHOOTER]);
+	});
+
+	it("sorts the comp by weapon id with Tacticooler weapons last", () => {
+		expect(
+			RunComps.buildComp([
+				observation("a", ROLLER, 0),
+				observation("b", TACTICOOLER_WEAPON, 0),
+				observation("c", SHOOTER, 0),
+			]),
+		).toEqual([SHOOTER, ROLLER, TACTICOOLER_WEAPON]);
+	});
+
+	it("keeps the players that played the most maps when there are more than four", () => {
+		const fullSet = (playerKey: string, weaponSplId: MainWeaponId) => [
+			observation(playerKey, weaponSplId, 0),
+			observation(playerKey, weaponSplId, 1),
+		];
+
+		expect(
+			RunComps.buildComp([
+				...fullSet("a", SHOOTER),
+				...fullSet("b", ROLLER),
+				...fullSet("c", CHARGER),
+				...fullSet("d", TACTICOOLER_WEAPON),
+				observation("sub", 5010 as MainWeaponId, 1),
+			]),
+		).toEqual([SHOOTER, ROLLER, CHARGER, TACTICOOLER_WEAPON]);
+	});
+});
+
+describe("mapObservations", () => {
+	it("keeps reported weapons and ingested rows of other players", () => {
+		expect(
+			RunComps.mapObservations({
+				mapOrder: 3,
+				reported: [{ userId: 1, weaponSplId: SHOOTER }],
+				ingested: [{ name: "opponent", weaponSplId: ROLLER }],
+			}),
+		).toEqual([
+			observation("user-1", SHOOTER, 3),
+			observation("name-opponent", ROLLER, 3),
+		]);
+	});
+
+	it("drops an ingested row linked to a user that already reported", () => {
+		expect(
+			RunComps.mapObservations({
+				mapOrder: 0,
+				reported: [{ userId: 1, weaponSplId: SHOOTER }],
+				ingested: [{ name: "player", userId: 1, weaponSplId: ROLLER }],
+			}),
+		).toEqual([observation("user-1", SHOOTER, 0)]);
+	});
+
+	it("drops an unlinked ingested row whose weapon a report accounts for, counting duplicates as a multiset", () => {
+		expect(
+			RunComps.mapObservations({
+				mapOrder: 0,
+				reported: [{ userId: 1, weaponSplId: SHOOTER }],
+				ingested: [
+					{ name: "one", weaponSplId: SHOOTER },
+					{ name: "two", weaponSplId: SHOOTER },
+				],
+			}),
+		).toEqual([
+			observation("user-1", SHOOTER, 0),
+			observation("name-two", SHOOTER, 0),
+		]);
+	});
+
+	it("skips ingested rows without a weapon", () => {
+		expect(
+			RunComps.mapObservations({
+				mapOrder: 0,
+				reported: [],
+				ingested: [{ name: "unknown", weaponSplId: null }],
+			}),
+		).toEqual([]);
+	});
+});
diff --git a/app/features/img-export/core/RunComps.ts b/app/features/img-export/core/RunComps.ts
new file mode 100644
index 000000000..e88c8973d
--- /dev/null
+++ b/app/features/img-export/core/RunComps.ts
@@ -0,0 +1,132 @@
+import * as R from "remeda";
+import { weaponParams } from "~/features/build-analyzer/core/utils";
+import type { MainWeaponId } from "~/modules/in-game-lists/types";
+
+const TACTICOOLER_SPECIAL_WEAPON_ID = 15;
+const COMP_SIZE = 4;
+
+export interface CompObservation {
+	/** Identity of the player within the aggregated maps: user id when known, otherwise the ingested scoreboard name */
+	playerKey: string;
+	weaponSplId: MainWeaponId;
+	/** Chronological index of the map the weapon was played in */
+	mapOrder: number;
+}
+
+/**
+ * Builds a team's weapon comp from per map weapon observations. Each player
+ * contributes the weapon they played the most (ties broken by the most
+ * recently played one). The comp is in weapon id order, except weapons with
+ * Tacticooler as the special go last. When more than {@link COMP_SIZE}
+ * players were observed, the ones that played the most maps make the comp.
+ */
+export function buildComp(observations: CompObservation[]): MainWeaponId[] {
+	const byPlayer = new Map<string, CompObservation[]>();
+	for (const observation of observations) {
+		const playerObservations = byPlayer.get(observation.playerKey) ?? [];
+		playerObservations.push(observation);
+		byPlayer.set(observation.playerKey, playerObservations);
+	}
+
+	const compPlayers = R.sortBy(
+		[...byPlayer.values()],
+		[(playerObservations) => playerObservations.length, "desc"],
+		(playerObservations) =>
+			Math.min(...playerObservations.map((o) => o.mapOrder)),
+	).slice(0, COMP_SIZE);
+
+	return R.sortBy(
+		compPlayers.map(mostPlayedWeapon),
+		(weaponSplId) => (hasTacticooler(weaponSplId) ? 1 : 0),
+		(weaponSplId) => weaponSplId,
+	);
+}
+
+/**
+ * Converts one map's reported and ingested weapon rows of a team into comp
+ * observations. Ingested rows that duplicate a reported weapon are dropped:
+ * a row linked to a user that already reported, or an unlinked row whose
+ * weapon a report already accounts for (a multiset, matching how the match
+ * page timeline merges the two sources).
+ */
+export function mapObservations({
+	mapOrder,
+	reported,
+	ingested,
+}: {
+	mapOrder: number;
+	reported: Array<{ userId: number; weaponSplId: MainWeaponId }>;
+	ingested: Array<{
+		name: string;
+		userId?: number;
+		weaponSplId: MainWeaponId | null;
+	}>;
+}): CompObservation[] {
+	const reportedUserIds = new Set(reported.map((row) => row.userId));
+	const accountedForCounts = new Map<MainWeaponId, number>();
+	for (const row of reported) {
+		accountedForCounts.set(
+			row.weaponSplId,
+			(accountedForCounts.get(row.weaponSplId) ?? 0) + 1,
+		);
+	}
+
+	const observations: CompObservation[] = reported.map((row) => ({
+		playerKey: `user-${row.userId}`,
+		weaponSplId: row.weaponSplId,
+		mapOrder,
+	}));
+
+	for (const row of ingested) {
+		if (row.weaponSplId === null) continue;
+		if (row.userId !== undefined && reportedUserIds.has(row.userId)) continue;
+
+		if (row.userId === undefined) {
+			const accountedFor = accountedForCounts.get(row.weaponSplId) ?? 0;
+			if (accountedFor > 0) {
+				accountedForCounts.set(row.weaponSplId, accountedFor - 1);
+				continue;
+			}
+		}
+
+		observations.push({
+			playerKey:
+				row.userId !== undefined ? `user-${row.userId}` : `name-${row.name}`,
+			weaponSplId: row.weaponSplId,
+			mapOrder,
+		});
+	}
+
+	return observations;
+}
+
+function mostPlayedWeapon(playerObservations: CompObservation[]): MainWeaponId {
+	const counts = new Map<MainWeaponId, number>();
+	const lastPlayedAt = new Map<MainWeaponId, number>();
+	for (const observation of playerObservations) {
+		counts.set(
+			observation.weaponSplId,
+			(counts.get(observation.weaponSplId) ?? 0) + 1,
+		);
+		lastPlayedAt.set(
+			observation.weaponSplId,
+			Math.max(
+				lastPlayedAt.get(observation.weaponSplId) ?? -1,
+				observation.mapOrder,
+			),
+		);
+	}
+
+	return R.sortBy(
+		[...counts.keys()],
+		[(weaponSplId) => counts.get(weaponSplId)!, "desc"],
+		[(weaponSplId) => lastPlayedAt.get(weaponSplId)!, "desc"],
+	)[0];
+}
+
+function hasTacticooler(weaponSplId: MainWeaponId) {
+	return (
+		weaponParams().weaponKits[weaponSplId].specialWeaponId ===
+		TACTICOOLER_SPECIAL_WEAPON_ID
+	);
+}
diff --git a/app/features/match-page-test/routes/match-page-test.tsx b/app/features/match-page-test/routes/match-page-test.tsx
index 2938f2f79..d4222351e 100644
--- a/app/features/match-page-test/routes/match-page-test.tsx
+++ b/app/features/match-page-test/routes/match-page-test.tsx
@@ -22,9 +22,13 @@ import { MatchPageHeader } from "~/components/match-page/MatchPageHeader";
 import { MatchResultTab } from "~/components/match-page/MatchResultTab";
 import { MatchRosterTab } from "~/components/match-page/MatchRosterTab";
 import { MatchTabs } from "~/components/match-page/MatchTabs";
+import type { ObjectiveTimelineEvent } from "~/components/ObjectiveTimeline";
 import { logger } from "~/utils/logger";
 import type { SendouRouteHandle } from "~/utils/remix.server";
 
+/** Counter reads of a made-up zones game, for previewing the timeline chart. */
+const MOCK_OBJECTIVE_EVENTS = mockObjectiveEvents();
+
 type ActionVariant =
 	| "winner"
 	| "counterpick-stage"
@@ -693,6 +697,88 @@ export default function MatchPageTestRoute() {
 									alpha: [40, null, 1100, 3040],
 									bravo: [null, 210, null, 4010],
 								},
+								scoreboard: {
+									objective: MOCK_OBJECTIVE_EVENTS,
+									scores: [100, 0],
+									alpha: [
+										{
+											name: "Sendou",
+											weaponSplId: 40,
+											ka: 12,
+											d: 4,
+											s: 3,
+											paint: 1102,
+											abilities: [
+												["LDE", "IRU", "IRU", "SCU"],
+												["SPU", "ISM", "ISM", "SCU"],
+												["SCU", "QSJ", "SRU", "SCU"],
+											],
+										},
+										{
+											name: "Lean",
+											weaponSplId: 1100,
+											ka: 9,
+											d: 6,
+											s: 2,
+											paint: 987,
+										},
+										{
+											name: "Kiver",
+											weaponSplId: 3040,
+											ka: 7,
+											d: 5,
+											s: 4,
+											paint: 1345,
+										},
+										{
+											name: "Brian",
+											weaponSplId: null,
+											ka: null,
+											d: null,
+											s: null,
+											paint: null,
+										},
+									],
+									bravo: [
+										{
+											name: "Naga",
+											weaponSplId: 210,
+											ka: 8,
+											d: 7,
+											s: 1,
+											paint: 876,
+											abilities: [
+												["CB", "SPU", "SPU", "SPU"],
+												["SCU", "SCU", "SS", "SCU"],
+												["SJ", "SRU", "QSJ", "QSJ"],
+											],
+										},
+										{
+											name: "Grey",
+											weaponSplId: 4010,
+											ka: 5,
+											d: 8,
+											s: 2,
+											paint: 1204,
+										},
+										{
+											name: "Poppy",
+											weaponSplId: 50,
+											ka: 6,
+											d: 9,
+											s: 3,
+											paint: 743,
+										},
+										{
+											name: "Lime",
+											weaponSplId: 2010,
+											ka: 4,
+											d: 10,
+											s: 1,
+											paint: 654,
+										},
+									],
+								},
 								rosters: {
 									alpha: [
 										{
@@ -771,3 +857,58 @@ export default function MatchPageTestRoute() {
 		</Main>
 	);
 }
+
+/**
+ * Plays out a zones game second by second: the controlling side burns its
+ * penalty before its count moves, and losing the zone after counting hands
+ * the side a penalty to burn next time.
+ */
+function mockObjectiveEvents(): ObjectiveTimelineEvent[] {
+	const PHASES: Array<{ seconds: number; control: [boolean, boolean] }> = [
+		{ seconds: 12, control: [false, false] },
+		{ seconds: 30, control: [true, false] },
+		{ seconds: 14, control: [false, false] },
+		{ seconds: 44, control: [false, true] },
+		{ seconds: 10, control: [false, false] },
+		{ seconds: 80, control: [true, false] },
+	];
+	const PENALTY_ON_LOSING_ZONE = 12;
+	const SAMPLE_EVERY_SECONDS = 2;
+
+	const score: [number, number] = [100, 100];
+	const penalty: [number, number] = [0, 0];
+	const events: ObjectiveTimelineEvent[] = [];
+	let previousControl: [boolean, boolean] = [false, false];
+	let t = 0;
+
+	for (const phase of PHASES) {
+		for (const side of [0, 1] as const) {
+			if (previousControl[side] && !phase.control[side]) {
+				penalty[side] += PENALTY_ON_LOSING_ZONE;
+			}
+		}
+		previousControl = phase.control;
+
+		for (let second = 0; second < phase.seconds; second++) {
+			for (const side of [0, 1] as const) {
+				if (!phase.control[side]) continue;
+				if (penalty[side] > 0) penalty[side] -= 1;
+				else score[side] = Math.max(0, score[side] - 1);
+			}
+
+			t += 1;
+			if (t % SAMPLE_EVERY_SECONDS !== 0) continue;
+			events.push({
+				t,
+				data: {
+					time: 300 - t,
+					score: [score[0], score[1]],
+					penalty: [penalty[0] || null, penalty[1] || null],
+					control: [phase.control[0], phase.control[1]],
+				},
+			});
+		}
+	}
+
+	return events;
+}
diff --git a/app/features/scanner-ingest/ScannerIngestRepository.server.test.ts b/app/features/scanner-ingest/ScannerIngestRepository.server.test.ts
new file mode 100644
index 000000000..771119045
--- /dev/null
+++ b/app/features/scanner-ingest/ScannerIngestRepository.server.test.ts
@@ -0,0 +1,370 @@
+import { describe, expect, test } from "vitest";
+import * as SQMatchFactory from "~/db/seed/factories/SQMatchFactory";
+import * as TournamentFactory from "~/db/seed/factories/TournamentFactory";
+import * as UserFactory from "~/db/seed/factories/UserFactory";
+import { db } from "~/db/sql";
+import type {
+	ScannerMatch,
+	ScannerMatchPlayer,
+} from "~/features/scanner/core/scanner-match";
+import { FULL_GROUP_SIZE } from "~/features/sendouq/q-constants";
+import type { MainWeaponId } from "~/modules/in-game-lists/types";
+import * as Matches from "./core/Matches";
+import type { IngestableGame } from "./core/Scoreboards";
+import * as ScannerIngestRepository from "./ScannerIngestRepository.server";
+
+const NAMES = ["w1", "w2", "w3", "w4", "l1", "l2", "l3", "l4"];
+const WEAPONS: MainWeaponId[] = [10, 20, 30, 40, 50, 60, 70, 80];
+const PLAYED_AT = Date.UTC(2026, 7, 1, 18, 0, 0);
+/** enough teams for the bracket winner to play more than one match */
+const TOURNAMENT_TEAM_COUNT = 4;
+
+describe("addOrMergeMatches", () => {
+	test("inserts a fresh match with hash, hints and playedAt", async () => {
+		const user = await UserFactory.create();
+		const { match: groupMatch } = await setupSendouqMatch();
+
+		const result = await ScannerIngestRepository.addOrMergeMatches({
+			povUserId: user.id,
+			submitterUserId: user.id,
+			matches: [testMatch()],
+			context: { type: "sendouq", groupMatchId: groupMatch.id },
+		});
+
+		expect(result.insertedCount).toBe(1);
+		expect(result.mergedCount).toBe(0);
+		expect(result.effectiveMatches).toHaveLength(1);
+
+		const rows = await fetchIngestedMatches();
+		expect(rows).toHaveLength(1);
+		expect(rows[0].id).toBe(result.effectiveMatches[0].id);
+		expect(rows[0].povUserId).toBe(user.id);
+		expect(rows[0].submitterUserId).toBe(user.id);
+		expect(rows[0].playedAt).toBe(Math.floor(PLAYED_AT / 1000));
+		expect(rows[0].matchHash).toMatch(/^[0-9a-f]{64}$/);
+		expect(rows[0].groupMatchIdHint).toBe(groupMatch.id);
+		expect(rows[0].tournamentIdHint).toBeNull();
+		expect(rows[0].data).toEqual(Matches.canonicalMatch(testMatch()));
+	});
+
+	test("identical resend is a no-op that backfills missing hints", async () => {
+		const user = await UserFactory.create();
+		const { match: groupMatch } = await setupSendouqMatch();
+
+		const first = await ScannerIngestRepository.addOrMergeMatches({
+			povUserId: user.id,
+			submitterUserId: user.id,
+			matches: [testMatch()],
+			context: null,
+		});
+		expect((await fetchIngestedMatches())[0].groupMatchIdHint).toBeNull();
+
+		const second = await ScannerIngestRepository.addOrMergeMatches({
+			povUserId: user.id,
+			submitterUserId: user.id,
+			matches: [testMatch()],
+			context: { type: "sendouq", groupMatchId: groupMatch.id },
+		});
+
+		expect(second.insertedCount).toBe(0);
+		expect(second.mergedCount).toBe(0);
+		expect(second.effectiveMatches[0].id).toBe(first.effectiveMatches[0].id);
+
+		const rows = await fetchIngestedMatches();
+		expect(rows).toHaveLength(1);
+		expect(rows[0].groupMatchIdHint).toBe(groupMatch.id);
+	});
+
+	test("a fuller re-send of the same game merges into the stored partial", async () => {
+		const user = await UserFactory.create();
+		const partial = testMatch({
+			playedAt: PLAYED_AT + 5 * 60 * 1000,
+			mode: null,
+			matchScores: null,
+			teams: [{ players: [] }, { players: [] }],
+			winner: null,
+		});
+
+		const first = await ScannerIngestRepository.addOrMergeMatches({
+			povUserId: user.id,
+			submitterUserId: user.id,
+			matches: [partial],
+			context: null,
+		});
+		expect(first.insertedCount).toBe(1);
+		const storedHash = (await fetchIngestedMatches())[0].matchHash;
+
+		const second = await ScannerIngestRepository.addOrMergeMatches({
+			povUserId: user.id,
+			submitterUserId: user.id,
+			matches: [testMatch()],
+			context: null,
+		});
+
+		expect(second.insertedCount).toBe(0);
+		expect(second.mergedCount).toBe(1);
+		expect(second.effectiveMatches[0].id).toBe(first.effectiveMatches[0].id);
+		expect(second.effectiveMatches[0].data.mode).toBe("SZ");
+
+		const rows = await fetchIngestedMatches();
+		expect(rows).toHaveLength(1);
+		expect(rows[0].data.mode).toBe("SZ");
+		expect(rows[0].data.winner).toBe(0);
+		expect(rows[0].data.teams[0].players.map((p) => p.name)).toEqual(
+			NAMES.slice(0, 4),
+		);
+		expect(rows[0].playedAt).toBe(Math.floor(partial.playedAt! / 1000));
+		expect(rows[0].matchHash).not.toBe(storedHash);
+	});
+});
+
+describe("addLinks", () => {
+	test("creates link rows for group match maps", async () => {
+		const user = await UserFactory.create();
+		const { maps } = await setupSendouqMatch();
+
+		const { effectiveMatches } =
+			await ScannerIngestRepository.addOrMergeMatches({
+				povUserId: null,
+				submitterUserId: user.id,
+				matches: [
+					testMatch(),
+					testMatch({ playedAt: PLAYED_AT + 60 * 60 * 1000, stage: 1 }),
+				],
+				context: null,
+			});
+
+		const linkedCount = await ScannerIngestRepository.addLinks({
+			links: effectiveMatches.map((effective, i) => ({
+				ingestedMatchId: effective.id,
+				match: effective.data,
+				game: sendouqGame(maps[i]),
+			})),
+			povUserId: null,
+		});
+
+		expect(linkedCount).toBe(2);
+		const links = await fetchLinks();
+		expect(links).toHaveLength(2);
+		expect(links.map((link) => link.ingestedMatchId)).toEqual(
+			effectiveMatches.map((effective) => effective.id),
+		);
+		expect(links.map((link) => link.groupMatchMapId)).toEqual(
+			maps.slice(0, 2).map((map) => map.id),
+		);
+		expect(
+			links.every((link) => link.tournamentMatchGameResultId === null),
+		).toBe(true);
+		expect(await fetchReportedWeapons()).toHaveLength(0);
+	});
+
+	test("re-sends are no-ops and only newly created links are counted", async () => {
+		const user = await UserFactory.create();
+		const { maps } = await setupSendouqMatch();
+
+		const { effectiveMatches } =
+			await ScannerIngestRepository.addOrMergeMatches({
+				povUserId: null,
+				submitterUserId: user.id,
+				matches: [
+					testMatch(),
+					testMatch({ playedAt: PLAYED_AT + 60 * 60 * 1000, stage: 1 }),
+				],
+				context: null,
+			});
+		const links = effectiveMatches.map((effective, i) => ({
+			ingestedMatchId: effective.id,
+			match: effective.data,
+			game: sendouqGame(maps[i]),
+		}));
+
+		await ScannerIngestRepository.addLinks({
+			links: [links[0]],
+			povUserId: null,
+		});
+		const secondCount = await ScannerIngestRepository.addLinks({
+			links,
+			povUserId: null,
+		});
+
+		expect(secondCount).toBe(1);
+		expect(await fetchLinks()).toHaveLength(2);
+	});
+
+	test("reports the POV player's weapon once", async () => {
+		const povUser = await UserFactory.create();
+		const { match: groupMatch, maps } = await setupSendouqMatch();
+
+		const { effectiveMatches } =
+			await ScannerIngestRepository.addOrMergeMatches({
+				povUserId: povUser.id,
+				submitterUserId: povUser.id,
+				matches: [testMatch({ pov: { team: 0, index: 0 } })],
+				context: null,
+			});
+		const links = [
+			{
+				ingestedMatchId: effectiveMatches[0].id,
+				match: effectiveMatches[0].data,
+				game: sendouqGame(maps[0]),
+			},
+		];
+
+		await ScannerIngestRepository.addLinks({ links, povUserId: povUser.id });
+		await ScannerIngestRepository.addLinks({ links, povUserId: povUser.id });
+
+		const reportedWeapons = await fetchReportedWeapons();
+		expect(reportedWeapons).toHaveLength(1);
+		expect(reportedWeapons[0].groupMatchId).toBe(groupMatch.id);
+		expect(reportedWeapons[0].tournamentMatchId).toBeNull();
+		expect(reportedWeapons[0].mapIndex).toBe(maps[0].index);
+		expect(reportedWeapons[0].userId).toBe(povUser.id);
+		expect(reportedWeapons[0].weaponSplId).toBe(WEAPONS[0]);
+	});
+});
+
+describe("gamesInTournamentMatch", () => {
+	test("returns the match's own games only, leaving the rest of the tournament out", async () => {
+		const users = await UserFactory.createMany(TOURNAMENT_TEAM_COUNT);
+		const tournament = await TournamentFactory.createPlayed(
+			{ authorId: users[0]!.id, minMembersPerTeam: 1 },
+			{
+				teamRosters: users.map((user) => [user.id]),
+				playedOut: 0,
+			},
+		);
+		// the bracket winner plays every round on the same map list, so its
+		// earlier round's games are the ones a live send could wrongly take
+		const [firstMatch, ...laterMatches] = tournament.matches;
+		const winnerUserId = users.find(
+			(user) =>
+				tournament.teams.find((team) => team.id === firstMatch!.winnerTeamId)
+					?.memberUserIds[0] === user.id,
+		)!.id;
+
+		const games = await ScannerIngestRepository.gamesInTournamentMatch(
+			firstMatch!.id,
+		);
+
+		expect(games.length).toBeGreaterThan(0);
+		expect(
+			games.every(
+				(game) =>
+					game.target.type === "tournament" &&
+					game.target.tournamentMatchId === firstMatch!.id,
+			),
+		).toBe(true);
+
+		// the tournament-wide list is what the walk would otherwise see
+		const allGames =
+			await ScannerIngestRepository.gamesPlayedByUserInTournament({
+				userId: winnerUserId,
+				tournamentId: tournament.id,
+			});
+		expect(allGames.length).toBeGreaterThan(games.length);
+		expect(
+			allGames.some(
+				(game) =>
+					game.target.type === "tournament" &&
+					laterMatches.some(
+						(match) =>
+							game.target.type === "tournament" &&
+							game.target.tournamentMatchId === match.id,
+					),
+			),
+		).toBe(true);
+	});
+});
+
+function player(name: string, weaponId: MainWeaponId): ScannerMatchPlayer {
+	return {
+		name,
+		weaponId,
+		paint: 1000,
+		ka: 10,
+		d: 5,
+		s: 2,
+	};
+}
+
+function testMatch(partial: Partial<ScannerMatch> = {}): ScannerMatch {
+	return {
+		startsAt: 100,
+		endsAt: 400,
+		playedAt: PLAYED_AT,
+		lobby: "PRIVATE",
+		mode: "SZ",
+		stage: 0,
+		matchScores: [100, 52],
+		replayCode: null,
+		cast: false,
+		objective: null,
+		teams: [
+			{ players: NAMES.slice(0, 4).map((n, i) => player(n, WEAPONS[i]!)) },
+			{ players: NAMES.slice(4).map((n, i) => player(n, WEAPONS[4 + i]!)) },
+		],
+		winner: 0,
+		pov: null,
+		...partial,
+	};
+}
+
+async function setupSendouqMatch() {
+	const users = await UserFactory.createMany(FULL_GROUP_SIZE * 2);
+	const match = await SQMatchFactory.create({
+		alphaUserIds: users.slice(0, FULL_GROUP_SIZE).map((user) => user.id),
+		bravoUserIds: users.slice(FULL_GROUP_SIZE).map((user) => user.id),
+	});
+
+	const maps = await db
+		.selectFrom("GroupMatchMap")
+		.selectAll()
+		.where("matchId", "=", match.id)
+		.orderBy("index", "asc")
+		.execute();
+
+	return { match, maps };
+}
+
+function fetchIngestedMatches() {
+	return db
+		.selectFrom("IngestedMatch")
+		.selectAll()
+		.orderBy("id", "asc")
+		.execute();
+}
+
+function fetchLinks() {
+	return db
+		.selectFrom("IngestedMatchLink")
+		.selectAll()
+		.orderBy("id", "asc")
+		.execute();
+}
+
+function fetchReportedWeapons() {
+	return db.selectFrom("ReportedWeapon").selectAll().execute();
+}
+
+function sendouqGame(map: {
+	id: number;
+	matchId: number;
+	index: number;
+	mode: IngestableGame["mode"];
+	stageId: IngestableGame["stageId"];
+}): IngestableGame {
+	return {
+		target: {
+			type: "sendouq",
+			groupMatchMapId: map.id,
+			groupMatchId: map.matchId,
+		},
+		mapIndex: map.index,
+		mode: map.mode,
+		stageId: map.stageId,
+		winnerInGameNames: [],
+		loserInGameNames: [],
+		playedAt: Math.floor(PLAYED_AT / 1000),
+		linkedPlayerNames: null,
+	};
+}
diff --git a/app/features/scanner-ingest/ScannerIngestRepository.server.ts b/app/features/scanner-ingest/ScannerIngestRepository.server.ts
new file mode 100644
index 000000000..dd6ad735d
--- /dev/null
+++ b/app/features/scanner-ingest/ScannerIngestRepository.server.ts
@@ -0,0 +1,967 @@
+import { createHash } from "node:crypto";
+import { subDays } from "date-fns";
+import { sql, type Transaction } from "kysely";
+import { db } from "~/db/sql";
+import type { DB } from "~/db/tables";
+import type { ScannerMatch } from "~/features/scanner/core/scanner-match";
+import { dateToDatabaseTimestamp } from "~/utils/dates";
+import * as Matches from "./core/Matches";
+import type {
+	IngestableGame,
+	IngestableGameWithContext,
+	IngestContext,
+} from "./core/Scoreboards";
+import * as Scoreboards from "./core/Scoreboards";
+
+const opponentOneId = sql<number>`"TournamentMatch"."opponentOne" ->> '$.id'`;
+const opponentTwoId = sql<number>`"TournamentMatch"."opponentTwo" ->> '$.id'`;
+
+/**
+ * How far a stored match's playedAt may sit from an incoming one and still
+ * be loaded as a merge candidate (content contradictions are checked by
+ * Matches.isSameMatch; this only bounds the query).
+ */
+const MERGE_CANDIDATE_PLAYED_AT_WINDOW_DAYS = 1;
+/** How recently a playedAt-less stored match must have been created to be a candidate. */
+const MERGE_CANDIDATE_CREATED_AT_WINDOW_DAYS = 7;
+const MERGE_CANDIDATE_LIMIT = 50;
+
+/** How long before the events' timestamp their match may have started (long sets, swiss rounds get startedAt at creation). */
+const MATCH_WINDOW_BEFORE_SECONDS = 4 * 60 * 60;
+/** Event timestamps come from client clocks, so allow the match to have "started" a little after them. */
+const MATCH_WINDOW_AFTER_SECONDS = 60 * 60;
+
+/** SendouQ sets run well under this long; matches created further before the events cannot be theirs. */
+const GROUP_MATCH_WINDOW_BEFORE_SECONDS = 2 * 60 * 60;
+/** Event timestamps come from client clocks, so allow the match to have been created a little after them. */
+const GROUP_MATCH_WINDOW_AFTER_SECONDS = 60 * 60;
+
+/** Returns the games a user played in a tournament, in chronological order. */
+export function gamesPlayedByUserInTournament(params: {
+	userId: number;
+	tournamentId: number;
+}) {
+	return tournamentGames(params);
+}
+
+/**
+ * Returns the games a user played in any tournament since the given
+ * database timestamp, in chronological order — tournament candidates for
+ * content-based context resolution (Scoreboards.resolveContext).
+ */
+export function gamesPlayedByUserSince(params: {
+	userId: number;
+	/** database timestamp (seconds) */
+	since: number;
+}) {
+	return tournamentGames(params);
+}
+
+/**
+ * Returns the games of a tournament's casted sets (currently streamed ones
+ * plus the cast history), in chronological order — the candidate set for
+ * cast footage, whose submitter is staff rather than a player of the games.
+ */
+export async function castedGamesInTournament(tournamentId: number) {
+	const tournament = await db
+		.selectFrom("Tournament")
+		.select("castedMatchesInfo")
+		.where("Tournament.id", "=", tournamentId)
+		.executeTakeFirst();
+	const castedMatchesInfo = tournament?.castedMatchesInfo;
+
+	const tournamentMatchIds = [
+		...new Set([
+			...(castedMatchesInfo?.castedMatches ?? []).map(
+				(casted) => casted.matchId,
+			),
+			...(castedMatchesInfo?.castedMatchHistory ?? []).map(
+				(casted) => casted.matchId,
+			),
+		]),
+	];
+	if (tournamentMatchIds.length === 0) return [];
+
+	return tournamentGames({ tournamentId, tournamentMatchIds });
+}
+
+/**
+ * Returns the reported games of one tournament match, in chronological
+ * order — the candidate set for a live send, which carries no sequence of
+ * its own to anchor on and so must not see the rest of the tournament.
+ */
+export function gamesInTournamentMatch(tournamentMatchId: number) {
+	return tournamentGames({ tournamentMatchIds: [tournamentMatchId] });
+}
+
+/** Returns a SendouQ match's games (its whole map list), in map order. */
+export function gamesInGroupMatch(groupMatchId: number) {
+	return sendouqGames({ groupMatchId });
+}
+
+/**
+ * Returns the reported games of SendouQ matches a user played in since the
+ * given database timestamp, in chronological order — SendouQ candidates for
+ * content-based context resolution (Scoreboards.resolveContext).
+ */
+export function sendouqGamesPlayedByUserSince(params: {
+	userId: number;
+	/** database timestamp (seconds) */
+	since: number;
+}) {
+	return sendouqGames(params);
+}
+
+/**
+ * The tournament match the user was (probably) playing at the given
+ * wall-clock time: their team is in a match whose `startedAt` is close
+ * enough before `at`. When several qualify (rare) the latest-started one
+ * wins.
+ */
+export async function tournamentActivityAt({
+	userId,
+	at,
+}: {
+	userId: number;
+	/** wall-clock ms */
+	at: number;
+}) {
+	const atSeconds = toDbTimestamp(at)!;
+
+	const row = await db
+		.selectFrom("TournamentTeamMember")
+		.innerJoin(
+			"TournamentTeam",
+			"TournamentTeam.id",
+			"TournamentTeamMember.tournamentTeamId",
+		)
+		.innerJoin(
+			"TournamentStage",
+			"TournamentStage.tournamentId",
+			"TournamentTeam.tournamentId",
+		)
+		.innerJoin(
+			"TournamentMatch",
+			"TournamentMatch.stageId",
+			"TournamentStage.id",
+		)
+		.select(["TournamentTeam.tournamentId", "TournamentMatch.id as matchId"])
+		.where("TournamentTeamMember.userId", "=", userId)
+		.where((eb) =>
+			eb.or([
+				eb(opponentOneId, "=", eb.ref("TournamentTeam.id")),
+				eb(opponentTwoId, "=", eb.ref("TournamentTeam.id")),
+			]),
+		)
+		.where(
+			"TournamentMatch.startedAt",
+			"<=",
+			atSeconds + MATCH_WINDOW_AFTER_SECONDS,
+		)
+		.where(
+			"TournamentMatch.startedAt",
+			">=",
+			atSeconds - MATCH_WINDOW_BEFORE_SECONDS,
+		)
+		.orderBy("TournamentMatch.startedAt", "desc")
+		.executeTakeFirst();
+
+	return row
+		? { tournamentId: row.tournamentId, tournamentMatchId: row.matchId }
+		: null;
+}
+
+/**
+ * The SendouQ match the user was (probably) playing at the given wall-clock
+ * time: a group they are a member of is in a non-canceled match created
+ * close enough before `at`. When several qualify the latest-created wins.
+ */
+export async function groupMatchIdAt({
+	userId,
+	at,
+}: {
+	userId: number;
+	/** wall-clock ms */
+	at: number;
+}) {
+	const atSeconds = toDbTimestamp(at)!;
+
+	const row = await db
+		.selectFrom("GroupMatch")
+		.select("GroupMatch.id")
+		.where((eb) =>
+			eb.exists(
+				eb
+					.selectFrom("GroupMember")
+					.select("GroupMember.userId")
+					.where("GroupMember.userId", "=", userId)
+					.where((memberEb) =>
+						memberEb.or([
+							memberEb(
+								"GroupMember.groupId",
+								"=",
+								memberEb.ref("GroupMatch.alphaGroupId"),
+							),
+							memberEb(
+								"GroupMember.groupId",
+								"=",
+								memberEb.ref("GroupMatch.bravoGroupId"),
+							),
+						]),
+					),
+			),
+		)
+		.where(
+			"GroupMatch.createdAt",
+			"<=",
+			atSeconds + GROUP_MATCH_WINDOW_AFTER_SECONDS,
+		)
+		.where(
+			"GroupMatch.createdAt",
+			">=",
+			atSeconds - GROUP_MATCH_WINDOW_BEFORE_SECONDS,
+		)
+		.where("GroupMatch.cancelAcceptedByUserId", "is", null)
+		.orderBy("GroupMatch.createdAt", "desc")
+		.executeTakeFirst();
+
+	return row?.id ?? null;
+}
+
+/**
+ * Tournaments running a match around the given wall-clock time that the
+ * user helps run: they authored the event, are on its staff (organizer or
+ * streamer), or hold an admin/organizer/streamer role in its organization.
+ * The candidate contexts for cast footage.
+ */
+export async function staffTournamentIdsAt({
+	userId,
+	at,
+}: {
+	userId: number;
+	/** wall-clock ms */
+	at: number;
+}): Promise<number[]> {
+	const atSeconds = toDbTimestamp(at)!;
+
+	const rows = await db
+		.selectFrom("TournamentMatch")
+		.innerJoin(
+			"TournamentStage",
+			"TournamentStage.id",
+			"TournamentMatch.stageId",
+		)
+		.innerJoin(
+			"CalendarEvent",
+			"CalendarEvent.tournamentId",
+			"TournamentStage.tournamentId",
+		)
+		.select("TournamentStage.tournamentId")
+		.distinct()
+		.where(
+			"TournamentMatch.startedAt",
+			"<=",
+			atSeconds + MATCH_WINDOW_AFTER_SECONDS,
+		)
+		.where(
+			"TournamentMatch.startedAt",
+			">=",
+			atSeconds - MATCH_WINDOW_BEFORE_SECONDS,
+		)
+		.where((eb) =>
+			eb.or([
+				eb("CalendarEvent.authorId", "=", userId),
+				eb.exists(
+					eb
+						.selectFrom("TournamentStaff")
+						.select("TournamentStaff.userId")
+						.whereRef(
+							"TournamentStaff.tournamentId",
+							"=",
+							"TournamentStage.tournamentId",
+						)
+						.where("TournamentStaff.userId", "=", userId),
+				),
+				eb.exists(
+					eb
+						.selectFrom("TournamentOrganizationMember")
+						.select("TournamentOrganizationMember.userId")
+						.whereRef(
+							"TournamentOrganizationMember.organizationId",
+							"=",
+							"CalendarEvent.organizationId",
+						)
+						.where("TournamentOrganizationMember.userId", "=", userId)
+						.where("TournamentOrganizationMember.role", "in", [
+							"ADMIN",
+							"ORGANIZER",
+							"STREAMER",
+						]),
+				),
+			]),
+		)
+		.execute();
+
+	return rows.map((row) => row.tournamentId);
+}
+
+/**
+ * Returns a tournament match's ingested scoreboards with their 0-based map
+ * indexes, each derived from the game's linked ingested matches.
+ */
+export async function findScoreboardsByTournamentMatchId(
+	tournamentMatchId: number,
+) {
+	const rows = await db
+		.selectFrom("IngestedMatchLink")
+		.innerJoin(
+			"IngestedMatch",
+			"IngestedMatch.id",
+			"IngestedMatchLink.ingestedMatchId",
+		)
+		.innerJoin(
+			"TournamentMatchGameResult",
+			"TournamentMatchGameResult.id",
+			"IngestedMatchLink.tournamentMatchGameResultId",
+		)
+		.innerJoin(
+			"TournamentMatch",
+			"TournamentMatch.id",
+			"TournamentMatchGameResult.matchId",
+		)
+		.select([
+			"TournamentMatchGameResult.id as matchGameResultId",
+			"TournamentMatchGameResult.number",
+			"TournamentMatchGameResult.winnerTeamId",
+			opponentOneId.as("opponentOneId"),
+			opponentTwoId.as("opponentTwoId"),
+			"IngestedMatch.data",
+			"IngestedMatch.povUserId",
+		])
+		.where("TournamentMatchGameResult.matchId", "=", tournamentMatchId)
+		.orderBy("TournamentMatchGameResult.number", "asc")
+		.orderBy("IngestedMatchLink.createdAt", "asc")
+		.orderBy("IngestedMatchLink.id", "asc")
+		.execute();
+
+	const byGame = new Map<number, typeof rows>();
+	for (const row of rows) {
+		const gameRows = byGame.get(row.matchGameResultId) ?? [];
+		gameRows.push(row);
+		byGame.set(row.matchGameResultId, gameRows);
+	}
+
+	return [...byGame.values()].flatMap((gameRows) => {
+		const first = gameRows[0]!;
+		const loserTeamId =
+			first.winnerTeamId === first.opponentOneId
+				? first.opponentTwoId
+				: first.winnerTeamId === first.opponentTwoId
+					? first.opponentOneId
+					: null;
+
+		const data = Scoreboards.deriveScoreboardData({
+			linked: gameRows.map((row) => ({
+				data: row.data,
+				povUserId: row.povUserId,
+			})),
+			winnerTeamId: first.winnerTeamId,
+			loserTeamId,
+		});
+		if (!data) return [];
+
+		return [{ mapIndex: first.number - 1, data }];
+	});
+}
+
+/**
+ * Stores ingested matches, merging partials: a match that
+ * `Matches.isSameMatch` recognizes as an already stored one (same POV user
+ * scope) enriches that row instead of inserting. Identical resends are
+ * no-ops via the content hash. The resolved context is stamped onto the
+ * rows as tournamentIdHint/groupMatchIdHint (existing hints win; missing
+ * ones are backfilled even on no-op resends).
+ *
+ * @returns counts plus the post-merge rows (a partial arriving after an
+ * earlier richer send links downstream with the merged, fuller data)
+ */
+export async function addOrMergeMatches({
+	povUserId,
+	submitterUserId,
+	matches,
+	context,
+}: {
+	povUserId: number | null;
+	submitterUserId: number | null;
+	matches: ScannerMatch[];
+	context: IngestContext | null;
+}) {
+	const hints = {
+		tournamentIdHint:
+			context?.type === "tournament" ? context.tournamentId : null,
+		groupMatchIdHint: context?.type === "sendouq" ? context.groupMatchId : null,
+	};
+
+	return db.transaction().execute(async (trx) => {
+		let insertedCount = 0;
+		let mergedCount = 0;
+		const effectiveMatches: Array<{ id: number; data: ScannerMatch }> = [];
+
+		for (const match of matches) {
+			const effective = await addOrMergeMatch(trx, {
+				povUserId,
+				submitterUserId,
+				match,
+				hints,
+			});
+			if (effective.outcome === "inserted") insertedCount++;
+			if (effective.outcome === "merged") mergedCount++;
+			effectiveMatches.push({ id: effective.id, data: effective.data });
+		}
+
+		return { insertedCount, mergedCount, effectiveMatches };
+	});
+}
+
+/**
+ * Links ingested matches to the game results they were matched to. A row
+ * links to at most one game (re-sends are no-ops); one game may collect
+ * links from many rows (each POV's scan of it). When the row's POV player
+ * is known, their weapon is reported as a regular ReportedWeapon, unless
+ * the user already has one for that game.
+ *
+ * @returns count of newly created links
+ */
+export async function addLinks({
+	links,
+	povUserId,
+}: {
+	links: Array<{
+		ingestedMatchId: number;
+		match: ScannerMatch;
+		game: IngestableGame;
+	}>;
+	povUserId: number | null;
+}) {
+	return db.transaction().execute(async (trx) => {
+		let linkedCount = 0;
+
+		for (const link of links) {
+			const insertResult = await trx
+				.insertInto("IngestedMatchLink")
+				.values({
+					ingestedMatchId: link.ingestedMatchId,
+					tournamentMatchGameResultId:
+						link.game.target.type === "tournament"
+							? link.game.target.matchGameResultId
+							: null,
+					groupMatchMapId:
+						link.game.target.type === "sendouq"
+							? link.game.target.groupMatchMapId
+							: null,
+				})
+				.onConflict((oc) => oc.column("ingestedMatchId").doNothing())
+				.executeTakeFirst();
+
+			await reportPovWeapon(trx, link, povUserId);
+
+			if (Number(insertResult.numInsertedOrUpdatedRows ?? 0) > 0) {
+				linkedCount++;
+			}
+		}
+
+		return linkedCount;
+	});
+}
+
+async function addOrMergeMatch(
+	trx: Transaction<DB>,
+	{
+		povUserId,
+		submitterUserId,
+		match,
+		hints,
+	}: {
+		povUserId: number | null;
+		submitterUserId: number | null;
+		match: ScannerMatch;
+		hints: { tournamentIdHint: number | null; groupMatchIdHint: number | null };
+	},
+): Promise<{
+	id: number;
+	data: ScannerMatch;
+	outcome: "inserted" | "merged" | "unchanged";
+}> {
+	const canonical = Matches.canonicalMatch(match);
+	const hash = matchHash({ povUserId, match: canonical });
+
+	const identical = await trx
+		.selectFrom("IngestedMatch")
+		.select(["id", "data", "tournamentIdHint", "groupMatchIdHint"])
+		.where("matchHash", "=", hash)
+		.executeTakeFirst();
+	if (identical) {
+		await backfillHints(trx, identical, hints);
+		return { id: identical.id, data: identical.data, outcome: "unchanged" };
+	}
+
+	const stored = await findMergeCandidate(trx, {
+		povUserId,
+		match: canonical,
+	});
+	if (!stored) {
+		const inserted = await trx
+			.insertInto("IngestedMatch")
+			.values({
+				povUserId,
+				submitterUserId,
+				playedAt: toDbTimestamp(canonical.playedAt),
+				data: JSON.stringify(canonical),
+				matchHash: hash,
+				...hints,
+			})
+			.returning("id")
+			.executeTakeFirstOrThrow();
+		return { id: inserted.id, data: canonical, outcome: "inserted" };
+	}
+
+	const { merged, changed } = Matches.mergeMatches(stored.data, canonical);
+	if (!changed) {
+		await backfillHints(trx, stored, hints);
+		return { id: stored.id, data: stored.data, outcome: "unchanged" };
+	}
+
+	const mergedCanonical = Matches.canonicalMatch(merged);
+	await trx
+		.updateTable("IngestedMatch")
+		.set({
+			playedAt: toDbTimestamp(mergedCanonical.playedAt),
+			data: JSON.stringify(mergedCanonical),
+			matchHash: matchHash({ povUserId, match: mergedCanonical }),
+			tournamentIdHint: stored.tournamentIdHint ?? hints.tournamentIdHint,
+			groupMatchIdHint: stored.groupMatchIdHint ?? hints.groupMatchIdHint,
+		})
+		.where("id", "=", stored.id)
+		.execute();
+	return { id: stored.id, data: mergedCanonical, outcome: "merged" };
+}
+
+async function backfillHints(
+	trx: Transaction<DB>,
+	stored: {
+		id: number;
+		tournamentIdHint: number | null;
+		groupMatchIdHint: number | null;
+	},
+	hints: { tournamentIdHint: number | null; groupMatchIdHint: number | null },
+) {
+	const tournamentIdHint = stored.tournamentIdHint ?? hints.tournamentIdHint;
+	const groupMatchIdHint = stored.groupMatchIdHint ?? hints.groupMatchIdHint;
+	if (
+		tournamentIdHint === stored.tournamentIdHint &&
+		groupMatchIdHint === stored.groupMatchIdHint
+	) {
+		return;
+	}
+
+	await trx
+		.updateTable("IngestedMatch")
+		.set({ tournamentIdHint, groupMatchIdHint })
+		.where("id", "=", stored.id)
+		.execute();
+}
+
+/**
+ * The stored match the incoming one describes the same game as, if any:
+ * rows in the same POV user scope, near in play time (or recent when either
+ * side has none), content-checked by Matches.isSameMatch.
+ */
+async function findMergeCandidate(
+	trx: Transaction<DB>,
+	{
+		povUserId,
+		match,
+	}: {
+		povUserId: number | null;
+		match: ScannerMatch;
+	},
+) {
+	const createdAfter = dateToDatabaseTimestamp(
+		subDays(new Date(), MERGE_CANDIDATE_CREATED_AT_WINDOW_DAYS),
+	);
+
+	// one query per branch (playedAt window / playedAt-less recent rows)
+	// instead of an OR, so each can use the (povUserId, playedAt) index
+	const baseQuery = trx
+		.selectFrom("IngestedMatch")
+		.select(["id", "data", "tournamentIdHint", "groupMatchIdHint", "createdAt"])
+		.$if(povUserId === null, (qb) => qb.where("povUserId", "is", null))
+		.$if(povUserId !== null, (qb) => qb.where("povUserId", "=", povUserId!))
+		.orderBy("createdAt", "desc")
+		.limit(MERGE_CANDIDATE_LIMIT);
+
+	const candidates =
+		match.playedAt === null
+			? await baseQuery.where("createdAt", ">=", createdAfter).execute()
+			: newestFirst(
+					await baseQuery
+						.where(
+							"playedAt",
+							">=",
+							toDbTimestamp(
+								subDays(
+									match.playedAt,
+									MERGE_CANDIDATE_PLAYED_AT_WINDOW_DAYS,
+								).getTime(),
+							),
+						)
+						.where(
+							"playedAt",
+							"<=",
+							toDbTimestamp(match.playedAt)! +
+								MERGE_CANDIDATE_PLAYED_AT_WINDOW_DAYS * 24 * 60 * 60,
+						)
+						.execute(),
+					await baseQuery
+						.where("playedAt", "is", null)
+						.where("createdAt", ">=", createdAfter)
+						.execute(),
+				);
+
+	return (
+		candidates.find((candidate) =>
+			Matches.isSameMatch(candidate.data, match),
+		) ?? null
+	);
+}
+
+function newestFirst<T extends { createdAt: number }>(a: T[], b: T[]): T[] {
+	return [...a, ...b]
+		.sort((x, y) => y.createdAt - x.createdAt)
+		.slice(0, MERGE_CANDIDATE_LIMIT);
+}
+
+/** wall-clock ms → database timestamp (seconds) */
+function toDbTimestamp(ms: number | null): number | null {
+	return ms === null ? null : Math.floor(ms / 1000);
+}
+
+function matchHash({
+	povUserId,
+	match,
+}: {
+	povUserId: number | null;
+	match: ScannerMatch;
+}) {
+	return createHash("sha256")
+		.update(JSON.stringify([povUserId, match]))
+		.digest("hex");
+}
+
+async function tournamentGames({
+	userId,
+	tournamentId,
+	tournamentMatchIds,
+	since,
+}: {
+	userId?: number;
+	tournamentId?: number;
+	tournamentMatchIds?: number[];
+	since?: number;
+}): Promise<IngestableGameWithContext[]> {
+	const rows = await db
+		.selectFrom("TournamentMatchGameResult")
+		.innerJoin(
+			"TournamentMatch",
+			"TournamentMatch.id",
+			"TournamentMatchGameResult.matchId",
+		)
+		.innerJoin(
+			"TournamentStage",
+			"TournamentStage.id",
+			"TournamentMatch.stageId",
+		)
+		.select([
+			"TournamentMatchGameResult.id as matchGameResultId",
+			"TournamentMatchGameResult.matchId as tournamentMatchId",
+			"TournamentMatchGameResult.number",
+			"TournamentMatchGameResult.mode",
+			"TournamentMatchGameResult.stageId",
+			"TournamentMatchGameResult.winnerTeamId",
+			"TournamentMatchGameResult.createdAt as playedAt",
+			"TournamentStage.tournamentId",
+			opponentOneId.as("opponentOneId"),
+			opponentTwoId.as("opponentTwoId"),
+		])
+		// joined (not EXISTS) so the planner drives off the user's own
+		// participation index instead of scanning the whole createdAt window
+		.$if(userId !== undefined, (qb) =>
+			qb.innerJoin("TournamentMatchGameResultParticipant", (join) =>
+				join
+					.onRef(
+						"TournamentMatchGameResultParticipant.matchGameResultId",
+						"=",
+						"TournamentMatchGameResult.id",
+					)
+					.on("TournamentMatchGameResultParticipant.userId", "=", userId!),
+			),
+		)
+		.$if(tournamentId !== undefined, (qb) =>
+			qb.where("TournamentStage.tournamentId", "=", tournamentId!),
+		)
+		.$if(tournamentMatchIds !== undefined, (qb) =>
+			qb.where("TournamentMatchGameResult.matchId", "in", tournamentMatchIds!),
+		)
+		.$if(since !== undefined, (qb) =>
+			qb.where("TournamentMatchGameResult.createdAt", ">=", since!),
+		)
+		.orderBy("TournamentMatchGameResult.createdAt", "asc")
+		.orderBy("TournamentMatchGameResult.number", "asc")
+		.execute();
+
+	const inGameNamesByTeamId = await teamInGameNames(
+		rows.flatMap((row) => [row.opponentOneId, row.opponentTwoId]),
+	);
+	const linkedNames = await linkedPlayerNamesByTarget(
+		"tournamentMatchGameResultId",
+		rows.map((row) => row.matchGameResultId),
+	);
+
+	return rows.map((row) => {
+		const loserTeamId =
+			row.winnerTeamId === row.opponentOneId
+				? row.opponentTwoId
+				: row.winnerTeamId === row.opponentTwoId
+					? row.opponentOneId
+					: null;
+
+		return {
+			target: {
+				type: "tournament",
+				matchGameResultId: row.matchGameResultId,
+				tournamentMatchId: row.tournamentMatchId,
+			},
+			context: { type: "tournament", tournamentId: row.tournamentId },
+			mapIndex: row.number - 1,
+			mode: row.mode,
+			stageId: row.stageId,
+			winnerInGameNames: inGameNamesByTeamId.get(row.winnerTeamId) ?? [],
+			loserInGameNames:
+				(loserTeamId !== null
+					? inGameNamesByTeamId.get(loserTeamId)
+					: undefined) ?? [],
+			playedAt: row.playedAt,
+			linkedPlayerNames: linkedNames.get(row.matchGameResultId) ?? null,
+		};
+	});
+}
+
+async function teamInGameNames(teamIds: Array<number | null>) {
+	const uniqueTeamIds = [
+		...new Set(teamIds.filter((id): id is number => id !== null)),
+	];
+	if (uniqueTeamIds.length === 0) return new Map<number, string[]>();
+
+	const members = await db
+		.selectFrom("TournamentTeamMember")
+		.innerJoin("User", "User.id", "TournamentTeamMember.userId")
+		.select((eb) => [
+			"TournamentTeamMember.tournamentTeamId",
+			eb.fn
+				.coalesce("TournamentTeamMember.inGameName", "User.inGameName")
+				.as("inGameName"),
+		])
+		.where("TournamentTeamMember.tournamentTeamId", "in", uniqueTeamIds)
+		.execute();
+
+	const result = new Map<number, string[]>();
+	for (const member of members) {
+		if (!member.inGameName) continue;
+		const names = result.get(member.tournamentTeamId) ?? [];
+		names.push(member.inGameName);
+		result.set(member.tournamentTeamId, names);
+	}
+
+	return result;
+}
+
+async function sendouqGames({
+	groupMatchId,
+	userId,
+	since,
+}: {
+	groupMatchId?: number;
+	userId?: number;
+	since?: number;
+}): Promise<IngestableGameWithContext[]> {
+	const rows = await db
+		.selectFrom("GroupMatchMap")
+		.innerJoin("GroupMatch", "GroupMatch.id", "GroupMatchMap.matchId")
+		.select([
+			"GroupMatchMap.id as groupMatchMapId",
+			"GroupMatchMap.matchId as groupMatchId",
+			"GroupMatchMap.index as mapIndex",
+			"GroupMatchMap.mode",
+			"GroupMatchMap.stageId",
+			"GroupMatchMap.winnerGroupId",
+			"GroupMatch.alphaGroupId",
+			"GroupMatch.bravoGroupId",
+			"GroupMatch.createdAt as playedAt",
+		])
+		.$if(groupMatchId !== undefined, (qb) =>
+			qb.where("GroupMatchMap.matchId", "=", groupMatchId!),
+		)
+		// joined (not EXISTS) so the planner drives off the user's own
+		// membership index instead of scanning the whole createdAt window
+		.$if(userId !== undefined, (qb) =>
+			qb.innerJoin("GroupMember", (join) =>
+				join
+					.on("GroupMember.userId", "=", userId!)
+					.on((eb) =>
+						eb.or([
+							eb("GroupMember.groupId", "=", eb.ref("GroupMatch.alphaGroupId")),
+							eb("GroupMember.groupId", "=", eb.ref("GroupMatch.bravoGroupId")),
+						]),
+					),
+			),
+		)
+		// content resolution walks played games only; a current match's
+		// pre-generated unplayed maps would flood the candidate sequence
+		.$if(since !== undefined, (qb) =>
+			qb
+				.where("GroupMatch.createdAt", ">=", since!)
+				.where("GroupMatchMap.winnerGroupId", "is not", null),
+		)
+		.orderBy("GroupMatch.createdAt", "asc")
+		.orderBy("GroupMatchMap.index", "asc")
+		.execute();
+
+	const inGameNamesByGroupId = await groupInGameNames(
+		rows.flatMap((row) => [row.alphaGroupId, row.bravoGroupId]),
+	);
+	const linkedNames = await linkedPlayerNamesByTarget(
+		"groupMatchMapId",
+		rows.map((row) => row.groupMatchMapId),
+	);
+
+	return rows.map((row) => {
+		const loserGroupId =
+			row.winnerGroupId === row.alphaGroupId
+				? row.bravoGroupId
+				: row.winnerGroupId === row.bravoGroupId
+					? row.alphaGroupId
+					: null;
+
+		return {
+			target: {
+				type: "sendouq",
+				groupMatchMapId: row.groupMatchMapId,
+				groupMatchId: row.groupMatchId,
+			},
+			context: { type: "sendouq", groupMatchId: row.groupMatchId },
+			mapIndex: row.mapIndex,
+			mode: row.mode,
+			stageId: row.stageId,
+			winnerInGameNames:
+				(row.winnerGroupId !== null
+					? inGameNamesByGroupId.get(row.winnerGroupId)
+					: undefined) ?? [],
+			loserInGameNames:
+				(loserGroupId !== null
+					? inGameNamesByGroupId.get(loserGroupId)
+					: undefined) ?? [],
+			playedAt: row.playedAt,
+			linkedPlayerNames: linkedNames.get(row.groupMatchMapId) ?? null,
+		};
+	});
+}
+
+async function groupInGameNames(groupIds: number[]) {
+	const uniqueGroupIds = [...new Set(groupIds)];
+	if (uniqueGroupIds.length === 0) return new Map<number, string[]>();
+
+	const members = await db
+		.selectFrom("GroupMember")
+		.innerJoin("User", "User.id", "GroupMember.userId")
+		.select(["GroupMember.groupId", "User.inGameName"])
+		.where("GroupMember.groupId", "in", uniqueGroupIds)
+		.execute();
+
+	const result = new Map<number, string[]>();
+	for (const member of members) {
+		if (!member.inGameName) continue;
+		const names = result.get(member.groupId) ?? [];
+		names.push(member.inGameName);
+		result.set(member.groupId, names);
+	}
+
+	return result;
+}
+
+/**
+ * The winner-first player names of each game's earliest linked ingested
+ * match, keyed by the given link target column's value.
+ */
+async function linkedPlayerNamesByTarget(
+	column: "tournamentMatchGameResultId" | "groupMatchMapId",
+	targetIds: number[],
+) {
+	const result = new Map<number, string[]>();
+	if (targetIds.length === 0) return result;
+
+	const rows = await db
+		.selectFrom("IngestedMatchLink")
+		.innerJoin(
+			"IngestedMatch",
+			"IngestedMatch.id",
+			"IngestedMatchLink.ingestedMatchId",
+		)
+		.select([`IngestedMatchLink.${column} as targetId`, "IngestedMatch.data"])
+		.where(`IngestedMatchLink.${column}`, "in", targetIds)
+		.orderBy("IngestedMatchLink.createdAt", "asc")
+		.orderBy("IngestedMatchLink.id", "asc")
+		.execute();
+
+	for (const row of rows) {
+		if (row.targetId === null || result.has(row.targetId)) continue;
+		const names = Scoreboards.winnerFirstPlayerNames(row.data);
+		if (names) result.set(row.targetId, names);
+	}
+
+	return result;
+}
+
+async function reportPovWeapon(
+	trx: Transaction<DB>,
+	{ match, game }: { match: ScannerMatch; game: IngestableGame },
+	povUserId: number | null,
+) {
+	if (povUserId === null || match.pov === null) return;
+	const weaponSplId =
+		match.teams[match.pov.team]?.players[match.pov.index]?.weaponId ?? null;
+	if (weaponSplId === null) return;
+
+	await trx
+		.insertInto("ReportedWeapon")
+		.values({
+			tournamentMatchId:
+				game.target.type === "tournament"
+					? game.target.tournamentMatchId
+					: null,
+			groupMatchId:
+				game.target.type === "sendouq" ? game.target.groupMatchId : null,
+			mapIndex: game.mapIndex,
+			userId: povUserId,
+			weaponSplId,
+		})
+		.onConflict((oc) =>
+			oc
+				.columns(
+					game.target.type === "tournament"
+						? ["tournamentMatchId", "mapIndex", "userId"]
+						: ["groupMatchId", "mapIndex", "userId"],
+				)
+				.doNothing(),
+		)
+		.execute();
+}
diff --git a/app/features/scanner-ingest/actions/scanner-ingest.server.ts b/app/features/scanner-ingest/actions/scanner-ingest.server.ts
new file mode 100644
index 000000000..ba371fd0f
--- /dev/null
+++ b/app/features/scanner-ingest/actions/scanner-ingest.server.ts
@@ -0,0 +1,296 @@
+import { subDays } from "date-fns";
+import type { ActionFunction } from "react-router";
+import { Config } from "~/config";
+import { requireUser } from "~/features/auth/core/user.server";
+import type { ScannerMatch } from "~/features/scanner/core/scanner-match";
+import { isAdmin, isDev } from "~/modules/permissions/utils";
+import { dateToDatabaseTimestamp } from "~/utils/dates";
+import { logger } from "~/utils/logger";
+import { forbidden, parseBody } from "~/utils/remix.server";
+import * as Scoreboards from "../core/Scoreboards";
+import * as ScannerIngestRepository from "../ScannerIngestRepository.server";
+import {
+	type IngestedMatchLink,
+	type IngestResponse,
+	ingestBodySchema,
+} from "../scanner-ingest-schemas";
+
+/**
+ * How far back the POV user's reported games are considered as content-
+ * resolution candidates
+ */
+const CONTENT_RESOLUTION_WINDOW_DAYS = 365;
+
+export const action: ActionFunction = async ({ request }) => {
+	const user = requireUser();
+
+	if (!Config.scannerEnabled && !isAdmin(user) && !isDev(user)) {
+		forbidden();
+	}
+
+	const data = await parseBody({ request, schema: ingestBodySchema });
+
+	const povUserId = user.id;
+
+	const indexedMatches = data.matches
+		.map((match, requestIndex) => ({ match, requestIndex }))
+		.filter(({ match }) => match.lobby === null || match.lobby === "PRIVATE");
+	const matches = indexedMatches.map(({ match }) => match);
+	if (matches.length === 0) {
+		return {
+			storedMatchesCount: 0,
+			mergedMatchesCount: 0,
+			linkedGamesCount: 0,
+			linkedMatches: [],
+			contextResolved: false,
+		} satisfies IngestResponse;
+	}
+
+	const resolved = await resolveIngestContext({
+		matches,
+		povUserId,
+		casterUserId: user.id,
+	});
+
+	const { insertedCount, mergedCount, effectiveMatches } =
+		await ScannerIngestRepository.addOrMergeMatches({
+			povUserId,
+			submitterUserId: user.id,
+			matches,
+			context: resolved?.context ?? null,
+		});
+
+	let linkedGamesCount = 0;
+	let linkedMatches: IngestResponse["linkedMatches"] = [];
+	if (resolved) {
+		const matched = Scoreboards.matchedGames({
+			matches: effectiveMatches.map((effective) => effective.data),
+			games: resolved.games,
+		});
+
+		linkedGamesCount = await ScannerIngestRepository.addLinks({
+			links: matched.map(({ matchIndex, game }) => ({
+				ingestedMatchId: effectiveMatches[matchIndex]!.id,
+				match: effectiveMatches[matchIndex]!.data,
+				game,
+			})),
+			povUserId,
+		});
+
+		linkedMatches = matched.map(({ matchIndex, game }) => ({
+			matchIndex: indexedMatches[matchIndex]!.requestIndex,
+			link: ingestedMatchLink(resolved.context, game.target),
+		}));
+
+		logger.debug(
+			`ingest: ${Scoreboards.contextKey(resolved.context)} matched ${matched.length} games, ` +
+				`${linkedGamesCount} newly linked (stored ${insertedCount}, merged ${mergedCount})`,
+		);
+	} else {
+		logger.debug(
+			`ingest: stored ${insertedCount} matches (${mergedCount} merged) without a resolved context ` +
+				`(povUserId=${povUserId})`,
+		);
+	}
+
+	return {
+		storedMatchesCount: insertedCount,
+		mergedMatchesCount: mergedCount,
+		linkedGamesCount,
+		linkedMatches,
+		contextResolved: resolved !== null,
+	} satisfies IngestResponse;
+};
+
+function ingestedMatchLink(
+	context: Scoreboards.IngestContext,
+	target: Scoreboards.IngestableGameTarget,
+): IngestedMatchLink {
+	if (target.type === "tournament" && context.type === "tournament") {
+		return {
+			type: "tournament",
+			tournamentId: context.tournamentId,
+			matchId: target.tournamentMatchId,
+		};
+	}
+	if (target.type === "sendouq") {
+		return { type: "sendouq", groupMatchId: target.groupMatchId };
+	}
+	throw new Error("ingest link target does not match its resolved context");
+}
+
+interface ResolvedIngestContext {
+	context: Scoreboards.IngestContext;
+	games: Scoreboards.IngestableGameWithContext[];
+}
+
+interface IngestContextCandidate {
+	context: Scoreboards.IngestContext;
+	loadGames: () => Promise<Scoreboards.IngestableGameWithContext[]>;
+}
+
+/**
+ * Resolves the context (tournament or SendouQ match) a request's matches
+ * belong to.
+ *
+ * The user's activity around the time the matches were played is the strong
+ * signal: the SendouQ match resp. tournament match of theirs running then
+ * (for cast footage, the casted sets of tournaments the submitter helps
+ * run as author/organizer/streamer). Candidates are scored by how many
+ * matches would link to their games; a candidate is kept even when nothing links
+ * yet (a live minimap-only match still gets its hint). With no activity,
+ * the matches' content decides: the mode+stage sequence plus roster sides
+ * is near-unique in a user's reported-game history.
+ */
+async function resolveIngestContext({
+	matches,
+	povUserId,
+	casterUserId,
+}: {
+	matches: ScannerMatch[];
+	povUserId: number | null;
+	casterUserId: number | null;
+}): Promise<ResolvedIngestContext | null> {
+	const at = anchorTime(matches);
+	const hasPovMatches = matches.some((match) => !match.cast);
+	const hasCastMatches = matches.some((match) => match.cast);
+
+	const candidates: IngestContextCandidate[] = [];
+	const seenContexts = new Set<string>();
+	const addCandidate = (candidate: IngestContextCandidate) => {
+		const key = Scoreboards.contextKey(candidate.context);
+		if (seenContexts.has(key)) return;
+		seenContexts.add(key);
+		candidates.push(candidate);
+	};
+
+	if (povUserId && hasPovMatches) {
+		const groupMatchId = await ScannerIngestRepository.groupMatchIdAt({
+			userId: povUserId,
+			at,
+		});
+		if (groupMatchId) {
+			addCandidate({
+				context: { type: "sendouq", groupMatchId },
+				loadGames: () =>
+					ScannerIngestRepository.gamesInGroupMatch(groupMatchId),
+			});
+		}
+
+		const tournamentActivity =
+			await ScannerIngestRepository.tournamentActivityAt({
+				userId: povUserId,
+				at,
+			});
+		if (tournamentActivity) {
+			const { tournamentId, tournamentMatchId } = tournamentActivity;
+			addCandidate({
+				context: { type: "tournament", tournamentId },
+				loadGames: () =>
+					// a live send carries a single match, so the mode+stage order
+					// that anchors a whole scan is absent and the walk would take
+					// the first free game on that map anywhere in the tournament —
+					// some earlier round's. Only the set being played can be meant.
+					matches.length === 1
+						? ScannerIngestRepository.gamesInTournamentMatch(tournamentMatchId)
+						: ScannerIngestRepository.gamesPlayedByUserInTournament({
+								userId: povUserId,
+								tournamentId,
+							}),
+			});
+		}
+	}
+
+	if (casterUserId && hasCastMatches) {
+		const staffTournamentIds =
+			await ScannerIngestRepository.staffTournamentIdsAt({
+				userId: casterUserId,
+				at,
+			});
+		for (const tournamentId of staffTournamentIds) {
+			addCandidate({
+				context: { type: "tournament", tournamentId },
+				loadGames: () =>
+					ScannerIngestRepository.castedGamesInTournament(tournamentId),
+			});
+		}
+	}
+
+	let best: {
+		candidate: IngestContextCandidate;
+		games: Scoreboards.IngestableGameWithContext[];
+		matched: number;
+	} | null = null;
+	for (const candidate of candidates) {
+		const games = await candidate.loadGames();
+		const matched = Scoreboards.matchedGames({ matches, games }).length;
+		if (!best || matched > best.matched) {
+			best = { candidate, games, matched };
+		}
+	}
+	if (best) {
+		logger.debug(
+			`ingest: resolved ${Scoreboards.contextKey(best.candidate.context)} for user ${povUserId} ` +
+				`from activity at ${new Date(at).toISOString()} (${best.matched} matches aligned, ${candidates.length} candidates)`,
+		);
+		return {
+			context: best.candidate.context,
+			games: best.games,
+		};
+	}
+
+	if (povUserId && hasPovMatches && countAttachableMatches(matches) >= 2) {
+		const since = dateToDatabaseTimestamp(
+			subDays(new Date(), CONTENT_RESOLUTION_WINDOW_DAYS),
+		);
+		const games = (
+			await Promise.all([
+				ScannerIngestRepository.gamesPlayedByUserSince({
+					userId: povUserId,
+					since,
+				}),
+				ScannerIngestRepository.sendouqGamesPlayedByUserSince({
+					userId: povUserId,
+					since,
+				}),
+			])
+		).flat();
+		const context = Scoreboards.resolveContext({ matches, games });
+		if (context) {
+			const key = Scoreboards.contextKey(context);
+			logger.debug(
+				`ingest: resolved ${key} for user ${povUserId} from match contents ` +
+					`(${games.length} candidate games)`,
+			);
+			return {
+				context,
+				games: games.filter(
+					(game) => Scoreboards.contextKey(game.context) === key,
+				),
+			};
+		}
+	}
+
+	logger.debug(
+		`ingest: no context for user ${povUserId} at ${new Date(at).toISOString()}`,
+	);
+	return null;
+}
+
+/** Matches that could link to a reported game: their winner is known. */
+function countAttachableMatches(matches: ScannerMatch[]): number {
+	return matches.filter((match) => match.winner !== null).length;
+}
+
+/**
+ * The wall-clock time the request's matches were (probably) played: the
+ * latest match's playedAt, falling back to "now".
+ */
+function anchorTime(matches: ScannerMatch[]): number {
+	const playedAts = matches
+		.map((match) => match.playedAt)
+		.filter((playedAt): playedAt is number => playedAt !== null);
+	if (playedAts.length > 0) return Math.max(...playedAts);
+
+	return Date.now();
+}
diff --git a/app/features/scanner-ingest/core/Matches.test.ts b/app/features/scanner-ingest/core/Matches.test.ts
new file mode 100644
index 000000000..3138bbb75
--- /dev/null
+++ b/app/features/scanner-ingest/core/Matches.test.ts
@@ -0,0 +1,285 @@
+import { describe, expect, it } from "vitest";
+import type {
+	ScannerMatch,
+	ScannerMatchPlayer,
+} from "~/features/scanner/core/scanner-match";
+import type { MainWeaponId } from "~/modules/in-game-lists/types";
+import * as Matches from "./Matches";
+
+const NAMES = ["w1", "w2", "w3", "w4", "l1", "l2", "l3", "l4"];
+const WEAPONS: MainWeaponId[] = [10, 20, 30, 40, 50, 60, 70, 80];
+
+function player(
+	name: string | null,
+	weaponId: MainWeaponId | null,
+	partial: Partial<ScannerMatchPlayer> = {},
+): ScannerMatchPlayer {
+	return {
+		name,
+		weaponId,
+		paint: null,
+		ka: null,
+		d: null,
+		s: null,
+		...partial,
+	};
+}
+
+function testMatch(partial: Partial<ScannerMatch> = {}): ScannerMatch {
+	return {
+		startsAt: 100,
+		endsAt: 400,
+		playedAt: null,
+		lobby: "PRIVATE",
+		mode: "SZ",
+		stage: 0,
+		matchScores: [100, 52],
+		replayCode: null,
+		cast: false,
+		objective: null,
+		teams: [
+			{ players: NAMES.slice(0, 4).map((n, i) => player(n, WEAPONS[i]!)) },
+			{ players: NAMES.slice(4).map((n, i) => player(n, WEAPONS[4 + i]!)) },
+		],
+		winner: 0,
+		pov: null,
+		...partial,
+	};
+}
+
+/** The same rosters seen from the other side (e.g. a minimap alpha/bravo view). */
+function sideSwapped(match: ScannerMatch): ScannerMatch {
+	return {
+		...match,
+		teams: [match.teams[1], match.teams[0]],
+		winner: match.winner === null ? null : match.winner === 0 ? 1 : 0,
+		matchScores:
+			match.matchScores === null
+				? null
+				: [match.matchScores[1], match.matchScores[0]],
+	};
+}
+
+describe("canonicalMatch", () => {
+	it("serializes identically regardless of input key order", () => {
+		const match = testMatch({
+			objective: {
+				mode: "SZ",
+				samples: [
+					{
+						t: 120,
+						time: 215,
+						score: [95, 53],
+						penalty: [4, null],
+						control: [true, false],
+					},
+				],
+			},
+		});
+		const reordered = JSON.parse(
+			JSON.stringify({
+				winner: match.winner,
+				objective: match.objective,
+				teams: match.teams,
+				cast: match.cast,
+				replayCode: match.replayCode,
+				matchScores: match.matchScores,
+				stage: match.stage,
+				mode: match.mode,
+				lobby: match.lobby,
+				playedAt: match.playedAt,
+				endsAt: match.endsAt,
+				startsAt: match.startsAt,
+				pov: match.pov,
+			}),
+		) as ScannerMatch;
+
+		expect(JSON.stringify(Matches.canonicalMatch(reordered))).toBe(
+			JSON.stringify(Matches.canonicalMatch(match)),
+		);
+	});
+});
+
+describe("isSameMatch", () => {
+	it("recognizes an identical match", () => {
+		expect(Matches.isSameMatch(testMatch(), testMatch())).toBe(true);
+	});
+
+	it("matching replay codes are a strong key", () => {
+		const a = testMatch({
+			replayCode: "RABC-DEFG-HIJK-LMNO",
+			teams: testMatch().teams,
+		});
+		const b = testMatch({
+			replayCode: "RABC-DEFG-HIJK-LMNO",
+			matchScores: null,
+			teams: [{ players: [] }, { players: [] }],
+			winner: null,
+		});
+		expect(Matches.isSameMatch(a, b)).toBe(true);
+	});
+
+	it("tolerates OCR jitter in the replay code", () => {
+		const a = testMatch({ replayCode: "RABC-DEFG-HIJK-LMNO" });
+		const b = testMatch({ replayCode: "RA8C-DEFG-HIJK-LMN0" });
+		expect(Matches.isSameMatch(a, b)).toBe(true);
+	});
+
+	it("clearly different replay codes contradict identity", () => {
+		const a = testMatch({ replayCode: "RABC-DEFG-HIJK-LMNO" });
+		const b = testMatch({ replayCode: "RZYX-WVUT-SRQP-ONML" });
+		expect(Matches.isSameMatch(a, b)).toBe(false);
+	});
+
+	it("close play times identify a match", () => {
+		const a = testMatch({ playedAt: 1_700_000_000_000 });
+		const b = testMatch({
+			playedAt: 1_700_000_000_000 + 5 * 60 * 1000,
+			matchScores: null,
+			teams: [{ players: [] }, { players: [] }],
+			winner: null,
+		});
+		expect(Matches.isSameMatch(a, b)).toBe(true);
+	});
+
+	it("far-apart play times contradict identity even with equal rosters", () => {
+		const a = testMatch({ playedAt: 1_700_000_000_000 });
+		const b = testMatch({ playedAt: 1_700_000_000_000 + 60 * 60 * 1000 });
+		expect(Matches.isSameMatch(a, b)).toBe(false);
+	});
+
+	it("differing modes or stages contradict identity", () => {
+		expect(
+			Matches.isSameMatch(testMatch({ mode: "SZ" }), testMatch({ mode: "TC" })),
+		).toBe(false);
+		expect(
+			Matches.isSameMatch(testMatch({ stage: 0 }), testMatch({ stage: 1 })),
+		).toBe(false);
+	});
+
+	it("a null mode does not contradict a read one", () => {
+		expect(
+			Matches.isSameMatch(testMatch({ mode: null }), testMatch({ mode: "TC" })),
+		).toBe(true);
+	});
+
+	it("roster overlap identifies a match even side-swapped", () => {
+		expect(Matches.isSameMatch(testMatch(), sideSwapped(testMatch()))).toBe(
+			true,
+		);
+	});
+
+	it("roster overlap survives a couple of misread names", () => {
+		const b = testMatch();
+		b.teams[0].players[0] = player("misread", WEAPONS[0]!);
+		b.teams[1].players[3] = player(null, WEAPONS[7]!);
+		expect(Matches.isSameMatch(testMatch(), b)).toBe(true);
+	});
+
+	it("weapons alone identify a match when names are unread (minimap vs scoreboard)", () => {
+		const minimap = testMatch({
+			winner: null,
+			lobby: null,
+			matchScores: null,
+			teams: [
+				{ players: WEAPONS.slice(0, 4).map((w) => player(null, w)) },
+				{ players: WEAPONS.slice(4).map((w) => player(null, w)) },
+			],
+		});
+		expect(Matches.isSameMatch(testMatch(), minimap)).toBe(true);
+	});
+
+	it("unrelated matches are not the same", () => {
+		const other = testMatch({
+			matchScores: [88, 12],
+			teams: [
+				{
+					players: ["a", "b", "c", "d"].map((n, i) =>
+						player(n, (100 + 10 * i) as MainWeaponId),
+					),
+				},
+				{
+					players: ["e", "f", "g", "h"].map((n, i) =>
+						player(n, (200 + 10 * i) as MainWeaponId),
+					),
+				},
+			],
+		});
+		expect(Matches.isSameMatch(testMatch(), other)).toBe(false);
+	});
+});
+
+describe("mergeMatches", () => {
+	it("fills stored nulls and reports no change when nothing was added", () => {
+		const existing = testMatch({ mode: null, playedAt: null });
+		const incoming = testMatch({ mode: "SZ", playedAt: 1_700_000_000_000 });
+
+		const first = Matches.mergeMatches(existing, incoming);
+		expect(first.changed).toBe(true);
+		expect(first.merged.mode).toBe("SZ");
+		expect(first.merged.playedAt).toBe(1_700_000_000_000);
+
+		const second = Matches.mergeMatches(first.merged, incoming);
+		expect(second.changed).toBe(false);
+	});
+
+	it("stored values win on conflict", () => {
+		const existing = testMatch({ stage: 0 });
+		const incoming = testMatch({ stage: null });
+		incoming.teams[0].players[0] = player("other", 999 as MainWeaponId);
+
+		const { merged } = Matches.mergeMatches(existing, incoming);
+		expect(merged.stage).toBe(0);
+		expect(merged.teams[0].players[0]!.name).toBe("w1");
+	});
+
+	it("aligns a side-swapped incoming match before merging", () => {
+		const existing = testMatch({ winner: null, matchScores: null });
+		const incoming = sideSwapped(
+			testMatch({ matchScores: [84, 71], playedAt: 1_700_000_000_000 }),
+		);
+
+		const { merged } = Matches.mergeMatches(existing, incoming);
+		expect(merged.winner).toBe(0);
+		expect(merged.matchScores).toEqual([84, 71]);
+		expect(merged.teams[0].players.map((p) => p.name)).toEqual(
+			NAMES.slice(0, 4),
+		);
+	});
+
+	it("merges player rows by name, keeping stored stats and adding missing ones", () => {
+		const existing = testMatch();
+		existing.teams[1].players[1] = player("l2", null);
+		const incoming = testMatch();
+		incoming.teams[1].players = [
+			player("l2", WEAPONS[5]!, { ka: 12, abilities: [["ISM"]] }),
+			player("l1", WEAPONS[4]!),
+			player("l3", WEAPONS[6]!),
+			player("l4", WEAPONS[7]!),
+		];
+
+		const { merged } = Matches.mergeMatches(existing, incoming);
+		const l2 = merged.teams[1].players[1]!;
+		expect(l2.weaponId).toBe(WEAPONS[5]);
+		expect(l2.ka).toBe(12);
+		expect(l2.abilities).toEqual([["ISM"]]);
+	});
+
+	it("fills empty teams from the incoming match", () => {
+		const existing = testMatch({
+			winner: null,
+			matchScores: null,
+			teams: [{ players: [] }, { players: [] }],
+			replayCode: "RABC-DEFG-HIJK-LMNO",
+		});
+		const incoming = testMatch({ replayCode: "RABC-DEFG-HIJK-LMNO" });
+
+		const { merged, changed } = Matches.mergeMatches(existing, incoming);
+		expect(changed).toBe(true);
+		expect(merged.winner).toBe(0);
+		expect(merged.teams[0].players.map((p) => p.name)).toEqual(
+			NAMES.slice(0, 4),
+		);
+		expect(merged.matchScores).toEqual([100, 52]);
+	});
+});
diff --git a/app/features/scanner-ingest/core/Matches.ts b/app/features/scanner-ingest/core/Matches.ts
new file mode 100644
index 000000000..b3e090848
--- /dev/null
+++ b/app/features/scanner-ingest/core/Matches.ts
@@ -0,0 +1,375 @@
+/**
+ * Pure logic for stored scanner matches: canonical serialization (hashing),
+ * deciding whether two partial ScannerMatches describe the same game, and
+ * merging a newly ingested partial into a stored one.
+ */
+import type {
+	ScannerMatch,
+	ScannerMatchObjective,
+	ScannerMatchPlayer,
+	ScannerMatchTeam,
+} from "~/features/scanner/core/scanner-match";
+import { inGameNameWithoutDiscriminator } from "~/utils/strings";
+
+/**
+ * Replay codes are random enough that two different games share almost no
+ * positions; this many differing characters still reads as OCR jitter of
+ * the same code, at or above it as a different game.
+ */
+const REPLAY_CODE_MAX_OCR_ERRORS = 3;
+
+/** Two reads of one game land within this of each other (clock skew, retries). */
+const PLAYED_AT_AFFINITY_MS = 10 * 60 * 1000;
+/** Reads further apart than this cannot be the same few-minute game. */
+const PLAYED_AT_CONTRADICTION_MS = 20 * 60 * 1000;
+
+/** How many of the 8 rosters' readable names must align for identity. */
+const MIN_NAME_OVERLAP = 6;
+/** How many of the 8 weapon slots must align (with ≥7 read on both sides). */
+const MIN_WEAPON_OVERLAP = 7;
+const MIN_WEAPON_SLOTS_READ = 7;
+
+const PLAYERS_PER_TEAM = 4;
+
+/**
+ * Rebuilds a match with a fixed key order so `JSON.stringify` of the result
+ * is stable regardless of how the input was constructed — the hashing and
+ * change-detection representation.
+ */
+export function canonicalMatch(match: ScannerMatch): ScannerMatch {
+	return {
+		startsAt: match.startsAt,
+		endsAt: match.endsAt,
+		playedAt: match.playedAt,
+		lobby: match.lobby,
+		mode: match.mode,
+		stage: match.stage,
+		matchScores:
+			match.matchScores === null
+				? null
+				: [match.matchScores[0], match.matchScores[1]],
+		replayCode: match.replayCode,
+		cast: match.cast,
+		objective:
+			match.objective === null ? null : canonicalObjective(match.objective),
+		teams: [canonicalTeam(match.teams[0]), canonicalTeam(match.teams[1])],
+		winner: match.winner,
+		pov:
+			match.pov === null
+				? null
+				: { team: match.pov.team, index: match.pov.index },
+	};
+}
+
+/**
+ * Whether two (possibly partial) matches describe the same game. Callers
+ * pre-scope candidates to the same tournament + POV user; this checks the
+ * contents: contradicting mode/stage/replay-code/play-time rules identity
+ * out, then a matching replay code, close play times, or an aligning roster
+ * (names, or weapons when names are unread) rules it in.
+ */
+export function isSameMatch(a: ScannerMatch, b: ScannerMatch): boolean {
+	if (a.mode !== null && b.mode !== null && a.mode !== b.mode) return false;
+	if (a.stage !== null && b.stage !== null && a.stage !== b.stage) return false;
+
+	const codeDiff = replayCodeDiff(a.replayCode, b.replayCode);
+	if (codeDiff !== null && codeDiff > REPLAY_CODE_MAX_OCR_ERRORS) return false;
+
+	const playedDiff =
+		a.playedAt !== null && b.playedAt !== null
+			? Math.abs(a.playedAt - b.playedAt)
+			: null;
+	if (playedDiff !== null && playedDiff > PLAYED_AT_CONTRADICTION_MS) {
+		return false;
+	}
+
+	if (codeDiff !== null) return true;
+	if (playedDiff !== null && playedDiff <= PLAYED_AT_AFFINITY_MS) return true;
+
+	const aligned = bestAlignment(a, b);
+	if (aligned.nameOverlap >= MIN_NAME_OVERLAP) return true;
+	if (
+		aligned.weaponOverlap >= MIN_WEAPON_OVERLAP &&
+		weaponSlotsRead(a) >= MIN_WEAPON_SLOTS_READ &&
+		weaponSlotsRead(b) >= MIN_WEAPON_SLOTS_READ
+	) {
+		return true;
+	}
+	return false;
+}
+
+/**
+ * Merges a newly ingested partial into the stored match: the incoming teams
+ * are first aligned to the stored orientation (a scoreboard match's teams[0]
+ * is the winner side while a minimap match's is alpha), then every field
+ * fills stored nulls, stored values winning on conflict (mirroring the
+ * scoreboard attachment's first-ingest-wins). `changed` is false when the
+ * merge added nothing, so callers can skip the write.
+ */
+export function mergeMatches(
+	existing: ScannerMatch,
+	incoming: ScannerMatch,
+): { merged: ScannerMatch; changed: boolean } {
+	const oriented =
+		bestAlignment(existing, incoming).orientation === "swapped"
+			? swapSides(incoming)
+			: incoming;
+
+	const merged: ScannerMatch = {
+		startsAt: existing.startsAt ?? oriented.startsAt,
+		endsAt: existing.endsAt ?? oriented.endsAt,
+		playedAt: existing.playedAt ?? oriented.playedAt,
+		lobby: existing.lobby ?? oriented.lobby,
+		mode: existing.mode ?? oriented.mode,
+		stage: existing.stage ?? oriented.stage,
+		matchScores: mergeScorePair(existing.matchScores, oriented.matchScores),
+		replayCode: existing.replayCode ?? oriented.replayCode,
+		cast: existing.cast || oriented.cast,
+		// whole-series first-ingest-wins: interleaving two partial sample
+		// series from different scans is not attempted
+		objective: existing.objective ?? oriented.objective,
+		teams: [
+			mergeTeam(existing.teams[0], oriented.teams[0]),
+			mergeTeam(existing.teams[1], oriented.teams[1]),
+		],
+		winner: existing.winner ?? oriented.winner,
+		pov: existing.pov ?? oriented.pov,
+	};
+
+	return {
+		merged,
+		changed:
+			JSON.stringify(canonicalMatch(merged)) !==
+			JSON.stringify(canonicalMatch(existing)),
+	};
+}
+
+/** Lowercased, width-normalized in-game name without the #discriminator. */
+export function normalizeInGameName(name: string): string {
+	return inGameNameWithoutDiscriminator(name)
+		.normalize("NFKC")
+		.trim()
+		.toLowerCase();
+}
+
+function canonicalObjective(
+	objective: ScannerMatchObjective,
+): ScannerMatchObjective {
+	return {
+		mode: objective.mode,
+		samples: objective.samples.map((sample) => ({
+			t: sample.t,
+			time: sample.time,
+			score: [sample.score[0], sample.score[1]],
+			penalty: [sample.penalty[0], sample.penalty[1]],
+			control: [sample.control[0], sample.control[1]],
+		})),
+	};
+}
+
+function canonicalTeam(team: ScannerMatchTeam): ScannerMatchTeam {
+	return {
+		players: team.players.map(canonicalPlayer),
+	};
+}
+
+function canonicalPlayer(player: ScannerMatchPlayer): ScannerMatchPlayer {
+	return {
+		name: player.name,
+		weaponId: player.weaponId,
+		paint: player.paint,
+		ka: player.ka,
+		d: player.d,
+		s: player.s,
+		...(player.abilities ? { abilities: player.abilities } : null),
+	};
+}
+
+/**
+ * Positions at which two replay codes differ; null when either is unread.
+ * A length mismatch counts every position of the longer code.
+ */
+function replayCodeDiff(a: string | null, b: string | null): number | null {
+	if (a === null || b === null) return null;
+	const longer = Math.max(a.length, b.length);
+	let diff = longer - Math.min(a.length, b.length);
+	for (let i = 0; i < Math.min(a.length, b.length); i++) {
+		if (a[i] !== b[i]) diff++;
+	}
+	return diff;
+}
+
+interface Alignment {
+	orientation: "straight" | "swapped";
+	/** aligned readable-name matches across both team pairs (0-8) */
+	nameOverlap: number;
+	/** aligned weapon multiset overlap across both team pairs (0-8) */
+	weaponOverlap: number;
+}
+
+/**
+ * How `b`'s teams best map onto `a`'s: as-is or sides swapped, scored by
+ * name and weapon overlap. Ties keep "straight".
+ */
+function bestAlignment(a: ScannerMatch, b: ScannerMatch): Alignment {
+	const straight = pairScore(a, b.teams[0], b.teams[1]);
+	const swapped = pairScore(a, b.teams[1], b.teams[0]);
+	const straightTotal = straight.nameOverlap + straight.weaponOverlap;
+	const swappedTotal = swapped.nameOverlap + swapped.weaponOverlap;
+	return swappedTotal > straightTotal
+		? { orientation: "swapped", ...swapped }
+		: { orientation: "straight", ...straight };
+}
+
+function pairScore(
+	a: ScannerMatch,
+	bFirst: ScannerMatchTeam,
+	bSecond: ScannerMatchTeam,
+): { nameOverlap: number; weaponOverlap: number } {
+	return {
+		nameOverlap:
+			nameOverlap(a.teams[0], bFirst) + nameOverlap(a.teams[1], bSecond),
+		weaponOverlap:
+			weaponOverlap(a.teams[0], bFirst) + weaponOverlap(a.teams[1], bSecond),
+	};
+}
+
+function nameOverlap(a: ScannerMatchTeam, b: ScannerMatchTeam): number {
+	const bNames = new Set(
+		b.players
+			.map((player) => (player.name ? normalizeInGameName(player.name) : ""))
+			.filter(Boolean),
+	);
+	return a.players.filter(
+		(player) => player.name && bNames.has(normalizeInGameName(player.name)),
+	).length;
+}
+
+function weaponOverlap(a: ScannerMatchTeam, b: ScannerMatchTeam): number {
+	const pool = b.players
+		.map((player) => player.weaponId)
+		.filter((id) => id !== null);
+	let overlap = 0;
+	for (const player of a.players) {
+		if (player.weaponId === null) continue;
+		const i = pool.indexOf(player.weaponId);
+		if (i === -1) continue;
+		pool.splice(i, 1);
+		overlap++;
+	}
+	return overlap;
+}
+
+function weaponSlotsRead(match: ScannerMatch): number {
+	return match.teams.flatMap((team) =>
+		team.players.filter((player) => player.weaponId !== null),
+	).length;
+}
+
+function swapSides(match: ScannerMatch): ScannerMatch {
+	return {
+		...match,
+		teams: [match.teams[1], match.teams[0]],
+		winner: match.winner === null ? null : match.winner === 0 ? 1 : 0,
+		pov:
+			match.pov === null
+				? null
+				: { ...match.pov, team: match.pov.team === 0 ? 1 : 0 },
+		matchScores:
+			match.matchScores === null
+				? null
+				: [match.matchScores[1], match.matchScores[0]],
+		objective:
+			match.objective === null
+				? null
+				: {
+						mode: match.objective.mode,
+						samples: match.objective.samples.map((sample) => ({
+							...sample,
+							score: [sample.score[1], sample.score[0]],
+							penalty: [sample.penalty[1], sample.penalty[0]],
+							control: [sample.control[1], sample.control[0]],
+						})),
+					},
+	};
+}
+
+function mergeScorePair(
+	existing: [number | null, number | null] | null,
+	incoming: [number | null, number | null] | null,
+): [number | null, number | null] | null {
+	if (existing === null) return incoming;
+	if (incoming === null) return existing;
+	return [existing[0] ?? incoming[0], existing[1] ?? incoming[1]];
+}
+
+/**
+ * Merge one team's rows: each stored row takes its incoming counterpart —
+ * matched by readable name, then by a weapon unique among the unmatched,
+ * then by position — field-wise with stored values winning. Incoming rows
+ * no stored row claimed append while the team stays ≤4.
+ */
+function mergeTeam(
+	existing: ScannerMatchTeam,
+	incoming: ScannerMatchTeam,
+): ScannerMatchTeam {
+	const pool = incoming.players.map((player) => ({ player, used: false }));
+	const counterparts: (ScannerMatchPlayer | null)[] = existing.players.map(
+		(player) => {
+			const name = player.name ? normalizeInGameName(player.name) : "";
+			if (!name) return null;
+			const hit = pool.find(
+				(entry) =>
+					!entry.used &&
+					entry.player.name !== null &&
+					normalizeInGameName(entry.player.name) === name,
+			);
+			if (!hit) return null;
+			hit.used = true;
+			return hit.player;
+		},
+	);
+	for (const [i, player] of existing.players.entries()) {
+		if (counterparts[i] || player.weaponId === null) continue;
+		const hits = pool.filter(
+			(entry) => !entry.used && entry.player.weaponId === player.weaponId,
+		);
+		if (hits.length !== 1) continue;
+		hits[0]!.used = true;
+		counterparts[i] = hits[0]!.player;
+	}
+	for (const i of existing.players.keys()) {
+		if (counterparts[i]) continue;
+		const hit = pool[i]?.used === false ? pool[i]! : pool.find((e) => !e.used);
+		if (!hit) continue;
+		hit.used = true;
+		counterparts[i] = hit.player;
+	}
+
+	const players = existing.players.map((player, i) => {
+		const counterpart = counterparts[i];
+		return counterpart ? mergePlayer(player, counterpart) : player;
+	});
+	for (const entry of pool) {
+		if (entry.used || players.length >= PLAYERS_PER_TEAM) continue;
+		players.push(entry.player);
+	}
+
+	return { players };
+}
+
+function mergePlayer(
+	existing: ScannerMatchPlayer,
+	incoming: ScannerMatchPlayer,
+): ScannerMatchPlayer {
+	const abilities = existing.abilities ?? incoming.abilities;
+	return {
+		name: existing.name ?? incoming.name,
+		weaponId: existing.weaponId ?? incoming.weaponId,
+		paint: existing.paint ?? incoming.paint,
+		ka: existing.ka ?? incoming.ka,
+		d: existing.d ?? incoming.d,
+		s: existing.s ?? incoming.s,
+		...(abilities ? { abilities } : null),
+	};
+}
diff --git a/app/features/scanner-ingest/core/Scoreboards.test.ts b/app/features/scanner-ingest/core/Scoreboards.test.ts
new file mode 100644
index 000000000..f75d8041c
--- /dev/null
+++ b/app/features/scanner-ingest/core/Scoreboards.test.ts
@@ -0,0 +1,756 @@
+import { describe, expect, it } from "vitest";
+import type {
+	ScannerMatch,
+	ScannerMatchObjective,
+	ScannerMatchPlayer,
+} from "~/features/scanner/core/scanner-match";
+import type { ScannerLobby } from "~/features/scanner/scanner-types";
+import type {
+	AbilityWithUnknown,
+	MainWeaponId,
+	ModeShort,
+	StageId,
+} from "~/modules/in-game-lists/types";
+import * as Scoreboards from "./Scoreboards";
+
+const WINNER_TEAM_ID = 100;
+const LOSER_TEAM_ID = 200;
+
+function testGame(
+	partial: Partial<Scoreboards.IngestableGame> & {
+		matchGameResultId?: number;
+		tournamentMatchId?: number;
+	} = {},
+): Scoreboards.IngestableGame {
+	const { matchGameResultId = 11, tournamentMatchId = 1, ...rest } = partial;
+	return {
+		target: { type: "tournament", matchGameResultId, tournamentMatchId },
+		mapIndex: 0,
+		mode: "SZ",
+		stageId: 0 as StageId,
+		winnerInGameNames: [],
+		loserInGameNames: [],
+		playedAt: 1000,
+		linkedPlayerNames: null,
+		...rest,
+	};
+}
+
+function gameResultId(matched: Scoreboards.MatchedGame): number | null {
+	return matched.game.target.type === "tournament"
+		? matched.game.target.matchGameResultId
+		: null;
+}
+
+function tournamentMatchIdOf(matched: Scoreboards.MatchedGame): number | null {
+	return matched.game.target.type === "tournament"
+		? matched.game.target.tournamentMatchId
+		: null;
+}
+
+function testMatch({
+	t = 60,
+	mode = "SZ",
+	stage = 0,
+	lobby = "PRIVATE",
+	names = ["w1", "w2", "w3", "w4", "l1", "l2", "l3", "l4"],
+	weapons = [10, 10, 10, 10, 20, 20, 20, 20] as (MainWeaponId | null)[],
+	abilities = {},
+	povIndex = null,
+	objective = null,
+}: {
+	t?: number;
+	mode?: ModeShort | null;
+	stage?: StageId | null;
+	lobby?: ScannerLobby | null;
+	names?: string[];
+	weapons?: (MainWeaponId | null)[];
+	abilities?: Record<number, AbilityWithUnknown[][]>;
+	povIndex?: number | null;
+	objective?: ScannerMatchObjective | null;
+} = {}): ScannerMatch {
+	const players = names.map(
+		(name, i): ScannerMatchPlayer => ({
+			name: name || null,
+			weaponId: weapons[i]!,
+			paint: 1000,
+			ka: 10,
+			d: 5,
+			s: 2,
+			...(abilities[i] ? { abilities: abilities[i] } : null),
+		}),
+	);
+	return {
+		startsAt: t,
+		endsAt: t,
+		playedAt: null,
+		lobby,
+		mode,
+		stage,
+		matchScores: [100, 52],
+		replayCode: null,
+		cast: false,
+		objective,
+		teams: [{ players: players.slice(0, 4) }, { players: players.slice(4) }],
+		winner: 0,
+		pov:
+			povIndex === null
+				? null
+				: { team: povIndex < 4 ? 0 : 1, index: povIndex % 4 },
+	};
+}
+
+function testObjective(): ScannerMatchObjective {
+	return {
+		mode: "SZ",
+		samples: [
+			{
+				t: 600,
+				time: 300,
+				score: [100, 100],
+				penalty: [null, null],
+				control: [false, false],
+			},
+			{
+				t: 630,
+				time: 270,
+				score: [80, 100],
+				penalty: [null, 12],
+				control: [true, false],
+			},
+		],
+	};
+}
+
+/** The same game reported with sides in the other on-screen order. */
+function swapSides(match: ScannerMatch): ScannerMatch {
+	return {
+		...match,
+		teams: [match.teams[1], match.teams[0]],
+		objective:
+			match.objective === null
+				? null
+				: {
+						...match.objective,
+						samples: match.objective.samples.map((sample) => ({
+							...sample,
+							score: [sample.score[1], sample.score[0]],
+							penalty: [sample.penalty[1], sample.penalty[0]],
+							control: [sample.control[1], sample.control[0]],
+						})),
+					},
+		winner: match.winner === null ? null : match.winner === 0 ? 1 : 0,
+		matchScores:
+			match.matchScores === null
+				? null
+				: [match.matchScores[1], match.matchScores[0]],
+		pov:
+			match.pov === null
+				? null
+				: { ...match.pov, team: match.pov.team === 0 ? 1 : 0 },
+	};
+}
+
+describe("matchedGames", () => {
+	it("matches a game's match and reports its index", () => {
+		const matched = Scoreboards.matchedGames({
+			matches: [testMatch()],
+			games: [testGame()],
+		});
+
+		expect(matched).toHaveLength(1);
+		expect(matched[0]!.matchIndex).toBe(0);
+		expect(gameResultId(matched[0]!)).toBe(11);
+	});
+
+	it("skips matches without a known winner", () => {
+		const matched = Scoreboards.matchedGames({
+			matches: [{ ...testMatch(), winner: null }],
+			games: [testGame()],
+		});
+
+		expect(matched).toHaveLength(0);
+	});
+
+	it("skips matches whose teams were not fully seen", () => {
+		const partial = testMatch();
+		partial.teams[1].players.pop();
+		const matched = Scoreboards.matchedGames({
+			matches: [partial],
+			games: [testGame()],
+		});
+
+		expect(matched).toHaveLength(0);
+	});
+
+	it("skips a game whose linked scoreboard has different players", () => {
+		const matched = Scoreboards.matchedGames({
+			matches: [testMatch()],
+			games: [
+				testGame({
+					matchGameResultId: 11,
+					linkedPlayerNames: ["a", "b", "c", "d", "e", "f", "g", "h"],
+				}),
+				testGame({ matchGameResultId: 12, playedAt: 2000 }),
+			],
+		});
+
+		expect(matched.map(gameResultId)).toEqual([12]);
+	});
+
+	it("matches a re-detection of a linked scoreboard to the same game despite misread names", () => {
+		const matched = Scoreboards.matchedGames({
+			matches: [testMatch()],
+			games: [
+				testGame({
+					matchGameResultId: 11,
+					linkedPlayerNames: ["w1", "w2", "w3", "wA", "l1", "l2", "l3", "lB"],
+				}),
+				testGame({ matchGameResultId: 12, playedAt: 2000 }),
+			],
+		});
+
+		expect(matched.map(gameResultId)).toEqual([11]);
+	});
+
+	it("does not count unreadable names towards linked scoreboard re-detection", () => {
+		const matched = Scoreboards.matchedGames({
+			matches: [testMatch({ names: ["", "", "", "", "l1", "l2", "l3", "l4"] })],
+			games: [
+				testGame({
+					matchGameResultId: 11,
+					linkedPlayerNames: ["", "", "", "", "l1", "l2", "l3", "l4"],
+				}),
+				testGame({ matchGameResultId: 12, playedAt: 2000 }),
+			],
+		});
+
+		expect(matched.map(gameResultId)).toEqual([12]);
+	});
+
+	it("matches matches to games by mode and stage", () => {
+		const matched = Scoreboards.matchedGames({
+			matches: [testMatch({ mode: "RM", stage: 1, t: 60 })],
+			games: [
+				testGame({ mapIndex: 0, mode: "SZ", stageId: 0 as StageId }),
+				testGame({ mapIndex: 1, mode: "RM", stageId: 1 as StageId }),
+			],
+		});
+
+		expect(matched.map((m) => m.game.mapIndex)).toEqual([1]);
+	});
+
+	it("assigns two games on the same mode and stage in chronological order", () => {
+		const matched = Scoreboards.matchedGames({
+			matches: [
+				testMatch({
+					t: 60,
+					names: ["a", "b", "c", "d", "e", "f", "g", "h"],
+				}),
+				testMatch({
+					t: 5000,
+					names: ["i", "j", "k", "l", "m", "n", "o", "p"],
+				}),
+			],
+			games: [
+				testGame({ tournamentMatchId: 1, playedAt: 1000 }),
+				testGame({ tournamentMatchId: 2, playedAt: 2000 }),
+			],
+		});
+
+		expect(matched.map((m) => [m.matchIndex, tournamentMatchIdOf(m)])).toEqual([
+			[0, 1],
+			[1, 2],
+		]);
+	});
+
+	it("skips duplicate detections of the same game", () => {
+		const matched = Scoreboards.matchedGames({
+			matches: [testMatch({ t: 60 }), testMatch({ t: 65 })],
+			games: [
+				testGame({ tournamentMatchId: 1, playedAt: 1000 }),
+				testGame({ tournamentMatchId: 2, playedAt: 2000 }),
+			],
+		});
+
+		expect(matched).toHaveLength(1);
+		expect(tournamentMatchIdOf(matched[0]!)).toBe(1);
+	});
+
+	it("skips a duplicate detection despite a couple of OCR-misread names", () => {
+		const matched = Scoreboards.matchedGames({
+			matches: [
+				testMatch({ t: 60 }),
+				testMatch({
+					t: 65,
+					names: ["w1", "vv2", "w3", "w4", "l1", "l2", "l3", "I4"],
+				}),
+			],
+			games: [
+				testGame({ tournamentMatchId: 1, playedAt: 1000 }),
+				testGame({ tournamentMatchId: 2, playedAt: 2000 }),
+			],
+		});
+
+		expect(matched).toHaveLength(1);
+		expect(tournamentMatchIdOf(matched[0]!)).toBe(1);
+	});
+
+	it("skips matches from other lobbies", () => {
+		const matched = Scoreboards.matchedGames({
+			matches: [testMatch({ lobby: "X" })],
+			games: [testGame()],
+		});
+
+		expect(matched).toHaveLength(0);
+	});
+
+	it("skips matches with unreadable mode or stage", () => {
+		const matched = Scoreboards.matchedGames({
+			matches: [testMatch({ mode: null }), testMatch({ stage: null })],
+			games: [testGame()],
+		});
+
+		expect(matched).toHaveLength(0);
+	});
+
+	it("skips matches that have no matching game left", () => {
+		const matched = Scoreboards.matchedGames({
+			matches: [
+				testMatch({ t: 60 }),
+				testMatch({
+					t: 5000,
+					names: ["i", "j", "k", "l", "m", "n", "o", "p"],
+				}),
+			],
+			games: [testGame()],
+		});
+
+		expect(matched).toHaveLength(1);
+	});
+
+	it("skips a game whose known rosters contradict the match sides", () => {
+		const matched = Scoreboards.matchedGames({
+			matches: [testMatch()],
+			games: [
+				testGame({
+					tournamentMatchId: 1,
+					// match winners are w1-w4 but this game was won by the l* players
+					winnerInGameNames: ["l1#1234", "l2"],
+					loserInGameNames: ["w1", "w2"],
+					playedAt: 1000,
+				}),
+				testGame({
+					tournamentMatchId: 2,
+					winnerInGameNames: ["w1", "w2"],
+					loserInGameNames: ["l1#1234", "l2"],
+					playedAt: 2000,
+				}),
+			],
+		});
+
+		expect(matched.map(tournamentMatchIdOf)).toEqual([2]);
+	});
+
+	it("matches known in-game names ignoring discriminator, case and unicode width", () => {
+		const matched = Scoreboards.matchedGames({
+			matches: [
+				testMatch({
+					names: ["Ｗ１", "w2", "w3", "w4", "l1", "l2", "l3", "l4"],
+				}),
+			],
+			games: [
+				testGame({
+					winnerInGameNames: ["w1#1234"],
+					loserInGameNames: ["W3#5678"],
+				}),
+			],
+		});
+
+		// "Ｗ１" matches winner roster "w1#1234" straight (1) but "w3" on the
+		// winning side would match the loser roster flipped (1); straight wins ties
+		expect(matched).toHaveLength(1);
+	});
+
+	it("does not assign a game played before the previously assigned one", () => {
+		const matched = Scoreboards.matchedGames({
+			matches: [
+				testMatch({ t: 60, mode: "RM", stage: 1 }),
+				testMatch({ t: 1000, mode: "SZ", stage: 0 }),
+			],
+			games: [
+				testGame({
+					tournamentMatchId: 1,
+					mode: "SZ",
+					stageId: 0 as StageId,
+					playedAt: 1000,
+				}),
+				testGame({
+					tournamentMatchId: 2,
+					mode: "RM" as ModeShort,
+					stageId: 1 as StageId,
+					playedAt: 2000,
+				}),
+			],
+		});
+
+		expect(matched.map(tournamentMatchIdOf)).toEqual([2]);
+	});
+});
+
+describe("deriveScoreboardData", () => {
+	function derive(
+		linked: Array<{ data: ScannerMatch; povUserId: number | null }>,
+	) {
+		return Scoreboards.deriveScoreboardData({
+			linked,
+			winnerTeamId: WINNER_TEAM_ID,
+			loserTeamId: LOSER_TEAM_ID,
+		});
+	}
+
+	it("projects a match winner-first into scoreboard data", () => {
+		const data = derive([{ data: testMatch(), povUserId: null }]);
+
+		expect(data).toEqual({
+			scores: [100, 52],
+			players: ["w1", "w2", "w3", "w4", "l1", "l2", "l3", "l4"].map(
+				(name, i) => ({
+					name,
+					tournamentTeamId: i < 4 ? WINNER_TEAM_ID : LOSER_TEAM_ID,
+					weaponSplId: i < 4 ? 10 : 20,
+					ka: 10,
+					d: 5,
+					s: 2,
+					paint: 1000,
+				}),
+			),
+		});
+	});
+
+	it("a winner-1 match derives identically to its winner-0 mirror", () => {
+		const straight = derive([{ data: testMatch(), povUserId: null }]);
+		const swapped = derive([{ data: swapSides(testMatch()), povUserId: null }]);
+
+		expect(swapped).toEqual(straight);
+	});
+
+	it("returns null for a match that cannot form a scoreboard", () => {
+		expect(derive([])).toBe(null);
+		expect(
+			derive([{ data: { ...testMatch(), winner: null }, povUserId: null }]),
+		).toBe(null);
+	});
+
+	it("rebases counter samples to the game's first read", () => {
+		const data = derive([
+			{ data: testMatch({ objective: testObjective() }), povUserId: null },
+		]);
+
+		expect(data!.objective).toEqual({
+			mode: "SZ",
+			samples: [
+				{
+					t: 0,
+					time: 300,
+					score: [100, 100],
+					penalty: [null, null],
+					control: [false, false],
+				},
+				{
+					t: 30,
+					time: 270,
+					score: [80, 100],
+					penalty: [null, 12],
+					control: [true, false],
+				},
+			],
+		});
+	});
+
+	it("derives counter samples winner-first", () => {
+		const straight = derive([
+			{ data: testMatch({ objective: testObjective() }), povUserId: null },
+		]);
+		const swapped = derive([
+			{
+				data: swapSides(testMatch({ objective: testObjective() })),
+				povUserId: null,
+			},
+		]);
+
+		expect(swapped!.objective).toEqual(straight!.objective);
+	});
+
+	it("leaves out the objective of a match with no counter reads", () => {
+		const data = derive([{ data: testMatch(), povUserId: null }]);
+
+		expect(data!.objective).toBeUndefined();
+	});
+
+	it("carries ingested player abilities through", () => {
+		const build: AbilityWithUnknown[][] = [
+			["ISM", "ISS", "ISS", "ISS"],
+			["QR", "QSJ", "QSJ", "QSJ"],
+			["SSU", "RSU", "RSU", "RSU"],
+		];
+		const data = derive([
+			{ data: testMatch({ abilities: { 5: build } }), povUserId: null },
+		]);
+
+		expect(data!.players[5]!.abilities).toEqual(build);
+		expect(data!.players[0]!.abilities).toBeUndefined();
+	});
+
+	it("keeps players with unread weapon or empty name", () => {
+		const data = derive([
+			{
+				data: testMatch({
+					names: ["w1", "", "w3", "w4", "l1", "l2", "l3", "l4"],
+					weapons: [10, 10, null, 10, 20, 20, 20, 20],
+				}),
+				povUserId: null,
+			},
+		]);
+
+		expect(data!.players).toHaveLength(8);
+		expect(data!.players[1]!.name).toBe("");
+		expect(data!.players[1]!.weaponSplId).toBe(10);
+		expect(data!.players[2]!.weaponSplId).toBe(null);
+		expect(data!.players[2]!.ka).toBe(10);
+	});
+
+	it("keeps players whose name appears twice on the same side", () => {
+		const data = derive([
+			{
+				data: testMatch({
+					names: ["dupe", "dupe", "w3", "w4", "l1", "l2", "l3", "dupe"],
+				}),
+				povUserId: null,
+			},
+		]);
+
+		expect(data!.players.filter((p) => p.name === "dupe")).toHaveLength(3);
+	});
+
+	it("attributes the POV seat's row to the POV user", () => {
+		const data = derive([{ data: testMatch({ povIndex: 2 }), povUserId: 42 }]);
+
+		expect(data!.players[2]!.userId).toBe(42);
+		expect(data!.players.filter((p) => p.userId !== undefined)).toHaveLength(1);
+	});
+
+	it("attributes a losing-side POV of a winner-1 match to the right row", () => {
+		const data = derive([
+			{ data: swapSides(testMatch({ povIndex: 6 })), povUserId: 42 },
+		]);
+
+		expect(data!.players[6]!.userId).toBe(42);
+	});
+
+	it("attributes each linked POV onto the merged scoreboard", () => {
+		const data = derive([
+			{ data: testMatch({ povIndex: 0 }), povUserId: 42 },
+			{ data: swapSides(testMatch({ povIndex: 5 })), povUserId: 43 },
+		]);
+
+		expect(data!.players[0]!.userId).toBe(42);
+		expect(data!.players[5]!.userId).toBe(43);
+	});
+
+	it("does not attribute the same row twice", () => {
+		const data = derive([
+			{ data: testMatch({ povIndex: 2 }), povUserId: 42 },
+			{ data: testMatch({ povIndex: 2 }), povUserId: 43 },
+		]);
+
+		expect(data!.players[2]!.userId).toBe(42);
+	});
+
+	it("does not attribute a POV whose read name contradicts its seat's merged row", () => {
+		const data = derive([
+			{ data: testMatch(), povUserId: null },
+			{
+				data: testMatch({
+					povIndex: 2,
+					names: ["w1", "w2", "x9", "w4", "l1", "l2", "l3", "l4"],
+				}),
+				povUserId: 42,
+			},
+		]);
+
+		expect(data!.players.some((p) => p.userId === 42)).toBe(false);
+	});
+
+	it("merges a later partial's fields under the first link's values", () => {
+		const withoutScores: ScannerMatch = {
+			...testMatch(),
+			matchScores: null,
+		};
+		const data = derive([
+			{ data: withoutScores, povUserId: null },
+			{ data: testMatch(), povUserId: null },
+		]);
+
+		expect(data!.scores).toEqual([100, 52]);
+	});
+});
+
+describe("winnerFirstPlayerNames", () => {
+	it("returns names winner-first with unread names empty", () => {
+		const names = Scoreboards.winnerFirstPlayerNames(
+			swapSides(
+				testMatch({ names: ["w1", "", "w3", "w4", "l1", "l2", "l3", "l4"] }),
+			),
+		);
+
+		expect(names).toEqual(["w1", "", "w3", "w4", "l1", "l2", "l3", "l4"]);
+	});
+
+	it("returns null for a match without a linkable scoreboard", () => {
+		expect(
+			Scoreboards.winnerFirstPlayerNames({ ...testMatch(), winner: null }),
+		).toBe(null);
+	});
+});
+
+describe("resolveContext", () => {
+	/** A tournament's reported games as an ordered (mode, stageId) sequence. */
+	function tournamentGames(
+		tournamentId: number,
+		sequence: [ModeShort, number][],
+		partial: Partial<Scoreboards.IngestableGame> = {},
+	): Scoreboards.IngestableGameWithContext[] {
+		return sequence.map(([mode, stageId], i) => ({
+			...testGame({
+				matchGameResultId: tournamentId * 1000 + i,
+				tournamentMatchId: tournamentId * 100,
+				mapIndex: i,
+				mode,
+				stageId: stageId as StageId,
+				playedAt: 1000 + i,
+				...partial,
+			}),
+			context: { type: "tournament", tournamentId },
+		}));
+	}
+
+	/** A SendouQ match's reported games as an ordered (mode, stageId) sequence. */
+	function sendouqGames(
+		groupMatchId: number,
+		sequence: [ModeShort, number][],
+	): Scoreboards.IngestableGameWithContext[] {
+		return sequence.map(([mode, stageId], i) => ({
+			...testGame({
+				mapIndex: i,
+				mode,
+				stageId: stageId as StageId,
+				playedAt: 1000 + i,
+			}),
+			target: {
+				type: "sendouq",
+				groupMatchMapId: groupMatchId * 1000 + i,
+				groupMatchId,
+			},
+			context: { type: "sendouq", groupMatchId },
+		}));
+	}
+
+	const seenSequence = [
+		testMatch({ t: 60, mode: "SZ", stage: 0 }),
+		testMatch({ t: 600, mode: "TC", stage: 1 }),
+	];
+
+	it("resolves the tournament whose games match the seen sequence", () => {
+		const context = Scoreboards.resolveContext({
+			matches: seenSequence,
+			games: [
+				...tournamentGames(1, [
+					["SZ", 0],
+					["TC", 1],
+				]),
+				...tournamentGames(2, [
+					["SZ", 3],
+					["TC", 2],
+				]),
+			],
+		});
+
+		expect(context).toEqual({ type: "tournament", tournamentId: 1 });
+	});
+
+	it("resolves a SendouQ match over a tournament when its games match better", () => {
+		const context = Scoreboards.resolveContext({
+			matches: seenSequence,
+			games: [
+				...tournamentGames(1, [
+					["SZ", 3],
+					["TC", 2],
+				]),
+				...sendouqGames(7, [
+					["SZ", 0],
+					["TC", 1],
+				]),
+			],
+		});
+
+		expect(context).toEqual({ type: "sendouq", groupMatchId: 7 });
+	});
+
+	it("does not resolve from a single matching match", () => {
+		const context = Scoreboards.resolveContext({
+			matches: [seenSequence[0]!],
+			games: tournamentGames(1, [
+				["SZ", 0],
+				["TC", 1],
+			]),
+		});
+
+		expect(context).toBe(null);
+	});
+
+	it("lets roster sides break a map-sequence tie", () => {
+		const sharedMaplist: [ModeShort, number][] = [
+			["SZ", 0],
+			["TC", 1],
+		];
+		const context = Scoreboards.resolveContext({
+			matches: seenSequence,
+			games: [
+				...tournamentGames(1, sharedMaplist, {
+					winnerInGameNames: ["w1", "w2", "w3", "w4"],
+					loserInGameNames: ["l1", "l2", "l3", "l4"],
+				}),
+				// the other tournament's rosters contradict the match sides
+				...tournamentGames(2, sharedMaplist, {
+					winnerInGameNames: ["l1", "l2", "l3", "l4"],
+					loserInGameNames: ["w1", "w2", "w3", "w4"],
+				}),
+			],
+		});
+
+		expect(context).toEqual({ type: "tournament", tournamentId: 1 });
+	});
+
+	it("skips unreadable matches but resolves from the rest", () => {
+		const context = Scoreboards.resolveContext({
+			matches: [
+				seenSequence[0]!,
+				testMatch({ t: 300, stage: null }),
+				seenSequence[1]!,
+			],
+			games: [
+				...tournamentGames(1, [
+					["SZ", 0],
+					["TC", 1],
+				]),
+				...tournamentGames(2, [
+					["SZ", 3],
+					["TC", 2],
+				]),
+			],
+		});
+
+		expect(context).toEqual({ type: "tournament", tournamentId: 1 });
+	});
+});
diff --git a/app/features/scanner-ingest/core/Scoreboards.ts b/app/features/scanner-ingest/core/Scoreboards.ts
new file mode 100644
index 000000000..c481fae0c
--- /dev/null
+++ b/app/features/scanner-ingest/core/Scoreboards.ts
@@ -0,0 +1,502 @@
+import type {
+	ScannerMatch,
+	ScannerMatchObjective,
+} from "~/features/scanner/core/scanner-match";
+import type { ScannerLobby } from "~/features/scanner/scanner-types";
+import type {
+	AbilityWithUnknown,
+	MainWeaponId,
+	ModeShort,
+	StageId,
+} from "~/modules/in-game-lists/types";
+import * as Matches from "./Matches";
+
+/** Lobby header value scoreboards of tournament/SendouQ games are expected to have. */
+const TOURNAMENT_LOBBY = "PRIVATE";
+
+/**
+ * How many of the 8 player rows must carry the same readable name in the
+ * same position for a match to count as a re-detection of a game's
+ * already linked scoreboard (allows a couple of OCR misreads).
+ */
+const MIN_LINKED_DUPLICATE_NAME_MATCHES = 6;
+
+/** How many players on the winning (first) resp. losing side of a scoreboard. */
+const PLAYERS_PER_TEAM = 4;
+
+/**
+ * How many matches must align with one context's games for content
+ * resolution to trust it. A single game's (mode, stage, sides) is common
+ * across a user's history; two already carry order.
+ */
+const MIN_RESOLVED_SCOREBOARDS = 2;
+
+/** The match context an ingest request was resolved to belong to. */
+export type IngestContext =
+	| { type: "tournament"; tournamentId: number }
+	| { type: "sendouq"; groupMatchId: number };
+
+/** The reported game result an ingested match can link to. */
+export type IngestableGameTarget =
+	| {
+			type: "tournament";
+			matchGameResultId: number;
+			tournamentMatchId: number;
+	  }
+	| { type: "sendouq"; groupMatchMapId: number; groupMatchId: number };
+
+/** A game of a tournament or SendouQ match that ingested matches can be linked to. */
+export interface IngestableGame {
+	target: IngestableGameTarget;
+	/** 0-based index of the game within its match */
+	mapIndex: number;
+	mode: ModeShort;
+	stageId: StageId;
+	/** known in-game names of the winning team's roster, used to validate scoreboard sides */
+	winnerInGameNames: string[];
+	/** known in-game names of the losing team's roster, used to validate scoreboard sides */
+	loserInGameNames: string[];
+	/** database timestamp used to order games chronologically across matches */
+	playedAt: number;
+	/**
+	 * player names (winner-first, in scoreboard row order) of an already
+	 * linked ingested match of the game; null when the game has none yet.
+	 * Lets matching skip taken games across requests while recognizing
+	 * re-detections of the same scoreboard.
+	 */
+	linkedPlayerNames: string[] | null;
+}
+
+/** A candidate game for content resolution, tagged with its context. */
+export interface IngestableGameWithContext extends IngestableGame {
+	context: IngestContext;
+}
+
+export interface MatchedGame {
+	/** index into the input `matches` array */
+	matchIndex: number;
+	game: IngestableGame;
+}
+
+/** Stable grouping/equality key for an {@link IngestContext}. */
+export function contextKey(context: IngestContext): string {
+	return context.type === "tournament"
+		? `tournament:${context.tournamentId}`
+		: `sendouq:${context.groupMatchId}`;
+}
+
+/**
+ * Resolves which context (tournament or SendouQ match) a request's matches
+ * belong to from their content alone: the candidate games (the POV user's
+ * reported games) are grouped by context and each context is scored by how
+ * many matches `matchedGames` aligns with its games — the same mode+stage
+ * sequence walk and roster-side validation that decides what would actually
+ * be linked.
+ */
+export function resolveContext({
+	matches,
+	games,
+}: {
+	matches: ScannerMatch[];
+	games: IngestableGameWithContext[];
+}): IngestContext | null {
+	const byContext = new Map<string, IngestableGameWithContext[]>();
+	for (const game of games) {
+		const key = contextKey(game.context);
+		const contextGames = byContext.get(key) ?? [];
+		contextGames.push(game);
+		byContext.set(key, contextGames);
+	}
+
+	let best: { context: IngestContext; matched: number } | null = null;
+	for (const contextGames of byContext.values()) {
+		const matched = matchedGames({
+			matches,
+			games: contextGames,
+		}).length;
+		if (!best || matched > best.matched) {
+			best = { context: contextGames[0]!.context, matched };
+		}
+	}
+
+	if (!best || best.matched < MIN_RESOLVED_SCOREBOARDS) return null;
+	return best.context;
+}
+
+/**
+ * Matches ingested matches against a context's games, deciding which game
+ * result each match should link to.
+ *
+ * Only matches whose winner is known with two full teams qualify (a
+ * minimap-only match can never link — its winner and stats are unread).
+ * Matches and games are both walked in chronological order: each match is
+ * assigned to the next not-yet-assigned game with the same mode and stage
+ * whose sides don't contradict the teams' known in-game names (the winning
+ * rows should overlap the game winner's roster, not the loser's). Matches
+ * from other lobbies, with unreadable mode/stage or duplicated detections
+ * of the same game are skipped.
+ *
+ * One session's matches may arrive over many requests (one per game), so
+ * games another ingest already linked to are skipped — unless the incoming
+ * match is a re-detection of the linked one, which is matched to the same
+ * game so re-sends stay idempotent and another POV's scan of the same game
+ * lands on it too.
+ */
+export function matchedGames({
+	matches,
+	games,
+}: {
+	matches: ScannerMatch[];
+	games: IngestableGame[];
+}): MatchedGame[] {
+	const views = dedupeViews(
+		matches
+			.map((match, matchIndex) => {
+				const view = winnerFirstView(match, matchIndex);
+				return view ? { ...view, matchIndex } : null;
+			})
+			.filter((view): view is IndexedView => view !== null)
+			.filter((view) => !view.lobby || view.lobby === TOURNAMENT_LOBBY)
+			.sort((a, b) => a.order - b.order),
+	);
+	const orderedGames = games.toSorted(
+		(a, b) => a.playedAt - b.playedAt || a.mapIndex - b.mapIndex,
+	);
+
+	const result: MatchedGame[] = [];
+
+	let nextGameIdx = 0;
+	for (const view of views) {
+		if (view.mode === null || view.stage === null) continue;
+
+		for (let i = nextGameIdx; i < orderedGames.length; i++) {
+			const game = orderedGames[i]!;
+			if (game.mode !== view.mode || game.stageId !== view.stage) continue;
+			if (game.linkedPlayerNames) {
+				if (!isLinkedDuplicate(view, game.linkedPlayerNames)) {
+					continue;
+				}
+			} else if (!sidesMatchKnownPlayers(view, game)) {
+				continue;
+			}
+
+			result.push({ matchIndex: view.matchIndex, game });
+			nextGameIdx = i + 1;
+			break;
+		}
+	}
+
+	return result;
+}
+
+export interface IngestedScoreboardPlayer {
+	name: string;
+	tournamentTeamId: number | null;
+	weaponSplId: MainWeaponId | null;
+	ka: number | null;
+	d: number | null;
+	s: number | null;
+	paint: number | null;
+	/** [head, clothes, shoes] ability rows gathered from the match's death screens */
+	abilities?: AbilityWithUnknown[][];
+	/** set via POV attribution of a linked ingested match */
+	userId?: number;
+}
+
+/**
+ * The scoreboard of a game derived from its linked ingested matches — the
+ * shape match pages render. Derived at read time, not stored.
+ */
+export interface IngestedScoreboardData {
+	/** game scores [winner, loser] (0-100; a knockout's winner is 100) */
+	scores: [number | null, number | null];
+	/** in scoreboard order: rows 0-3 winning team, rows 4-7 losing team */
+	players: IngestedScoreboardPlayer[];
+	/**
+	 * objective-counter progress of the game, per-team values [winner, loser]
+	 * and sample `t` in seconds since the game's first read (the source video
+	 * the raw values are offsets into is not stored). Absent when no counter
+	 * was read.
+	 */
+	objective?: ScannerMatchObjective;
+}
+
+/**
+ * Derives a game's scoreboard from its linked ingested matches: the earliest
+ * link is the base and later ones enrich it (first-ingest-wins field-wise,
+ * via Matches.mergeMatches), the merged match is projected winner-first, and
+ * every linked POV seat attributes its player row to the POV user.
+ *
+ * `winnerTeamId`/`loserTeamId` are the game result's sides (tournament team
+ * or SendouQ group ids), stamped onto the rows for the reader.
+ */
+export function deriveScoreboardData({
+	linked,
+	winnerTeamId,
+	loserTeamId,
+}: {
+	/** in link order, earliest first */
+	linked: Array<{ data: ScannerMatch; povUserId: number | null }>;
+	winnerTeamId: number;
+	loserTeamId: number | null;
+}): IngestedScoreboardData | null {
+	const [first, ...rest] = linked;
+	if (!first) return null;
+
+	let merged = first.data;
+	for (const other of rest) {
+		merged = Matches.mergeMatches(merged, other.data).merged;
+	}
+
+	const view = winnerFirstView(merged, 0);
+	if (!view) return null;
+
+	const players = view.players.map(
+		(player, playerIdx): IngestedScoreboardPlayer => ({
+			name: player.name.trim(),
+			tournamentTeamId:
+				playerIdx < PLAYERS_PER_TEAM ? winnerTeamId : loserTeamId,
+			weaponSplId: player.weaponId,
+			ka: player.ka,
+			d: player.d,
+			s: player.s,
+			paint: player.paint,
+			...(player.abilities ? { abilities: player.abilities } : null),
+		}),
+	);
+
+	attributePovUsers(players, linked);
+
+	return {
+		scores: view.scores,
+		players,
+		...(view.objective ? { objective: view.objective } : null),
+	};
+}
+
+/**
+ * A match's players winner-first in scoreboard row order (unread names as
+ * empty strings), or null when the match has no such view — the
+ * `linkedPlayerNames` a game's already linked ingest contributes.
+ */
+export function winnerFirstPlayerNames(match: ScannerMatch): string[] | null {
+	const view = winnerFirstView(match, 0);
+	return view ? view.players.map((player) => player.name.trim()) : null;
+}
+
+/**
+ * A match's players in linked-scoreboard order — winning team's rows first —
+ * with unread names as empty strings. Null when the match can't link: its
+ * winner is unknown or either team wasn't fully seen.
+ */
+interface WinnerFirstView {
+	lobby: ScannerLobby | null;
+	mode: ModeShort | null;
+	stage: StageId | null;
+	/** game scores [winner, loser] from the match's "Score:" banner */
+	scores: [number | null, number | null];
+	players: WinnerFirstPlayer[];
+	/** counter progress with both the sides and `t` already winner-first */
+	objective: ScannerMatchObjective | null;
+	povIndex: number | null;
+	/** chronological walk key: wall-clock, else video time, else input order */
+	order: number;
+}
+
+interface IndexedView extends WinnerFirstView {
+	matchIndex: number;
+}
+
+interface WinnerFirstPlayer {
+	name: string;
+	weaponId: MainWeaponId | null;
+	paint: number | null;
+	ka: number | null;
+	d: number | null;
+	s: number | null;
+	abilities?: AbilityWithUnknown[][];
+}
+
+function winnerFirstView(
+	match: ScannerMatch,
+	index: number,
+): WinnerFirstView | null {
+	if (match.winner === null) return null;
+	const winners = match.teams[match.winner];
+	const losers = match.teams[match.winner === 0 ? 1 : 0];
+	if (
+		winners.players.length !== PLAYERS_PER_TEAM ||
+		losers.players.length !== PLAYERS_PER_TEAM
+	) {
+		return null;
+	}
+
+	return {
+		lobby: match.lobby,
+		mode: match.mode,
+		stage: match.stage,
+		scores: [
+			match.matchScores?.[match.winner] ?? null,
+			match.matchScores?.[match.winner === 0 ? 1 : 0] ?? null,
+		],
+		players: [...winners.players, ...losers.players].map((player) => ({
+			...player,
+			name: player.name ?? "",
+		})),
+		objective: winnerFirstObjective(match.objective, match.winner),
+		povIndex:
+			match.pov === null
+				? null
+				: match.pov.team === match.winner
+					? match.pov.index
+					: PLAYERS_PER_TEAM + match.pov.index,
+		order: match.playedAt ?? match.startsAt ?? index,
+	};
+}
+
+/**
+ * Puts a match's counter samples in derived-scoreboard shape: per-team
+ * values winner-first like `scores` and `players`, and `t` rebased to the
+ * game's first read so the samples stay meaningful without the source video.
+ */
+function winnerFirstObjective(
+	objective: ScannerMatchObjective | null,
+	winner: 0 | 1,
+): ScannerMatchObjective | null {
+	if (!objective || objective.samples.length === 0) return null;
+
+	const winnerFirst = <T>(pair: [T, T]): [T, T] =>
+		winner === 0 ? [pair[0], pair[1]] : [pair[1], pair[0]];
+	const firstT = Math.min(...objective.samples.map((sample) => sample.t));
+
+	return {
+		mode: objective.mode,
+		samples: objective.samples.map((sample) => ({
+			t: sample.t - firstT,
+			time: sample.time,
+			score: winnerFirst(sample.score),
+			penalty: winnerFirst(sample.penalty),
+			control: winnerFirst(sample.control),
+		})),
+	};
+}
+
+/**
+ * Attributes each linked match's POV seat to its POV user on the merged
+ * rows: the seat's read name picks the row (unique name match), falling
+ * back to the seat's own winner-first position when the names don't
+ * contradict. A row already attributed, or a user already present, is left
+ * alone (first link wins).
+ */
+function attributePovUsers(
+	players: IngestedScoreboardPlayer[],
+	linked: Array<{ data: ScannerMatch; povUserId: number | null }>,
+) {
+	for (const { data, povUserId } of linked) {
+		if (povUserId === null || data.pov === null) continue;
+		const view = winnerFirstView(data, 0);
+		if (!view || view.povIndex === null) continue;
+		if (players.some((player) => player.userId === povUserId)) continue;
+
+		const povName = Matches.normalizeInGameName(
+			view.players[view.povIndex]!.name,
+		);
+		const index = attributionIndex(players, povName, view.povIndex);
+		if (index === null || players[index]!.userId !== undefined) continue;
+
+		players[index] = { ...players[index]!, userId: povUserId };
+	}
+}
+
+function attributionIndex(
+	players: IngestedScoreboardPlayer[],
+	povName: string,
+	fallbackIndex: number,
+): number | null {
+	if (povName) {
+		const hits = players.flatMap((player, index) =>
+			Matches.normalizeInGameName(player.name) === povName ? [index] : [],
+		);
+		if (hits.length === 1) return hits[0]!;
+	}
+
+	const fallback = players[fallbackIndex];
+	if (!fallback) return null;
+	const fallbackName = Matches.normalizeInGameName(fallback.name);
+	if (povName && fallbackName && fallbackName !== povName) return null;
+	return fallbackIndex;
+}
+
+/**
+ * Drops re-detections of the same game within one request: same mode and
+ * stage with enough player rows carrying the same readable name in the same
+ * position — the same OCR-jitter tolerance as the cross-request duplicate
+ * check (isLinkedDuplicate).
+ */
+function dedupeViews(sorted: IndexedView[]): IndexedView[] {
+	const result: IndexedView[] = [];
+
+	for (const view of sorted) {
+		const isDuplicate = result.some(
+			(other) =>
+				other.mode === view.mode &&
+				other.stage === view.stage &&
+				isLinkedDuplicate(
+					view,
+					other.players.map((player) => player.name),
+				),
+		);
+		if (!isDuplicate) result.push(view);
+	}
+
+	return result;
+}
+
+/**
+ * Checks that the view's sides don't contradict the teams' known rosters:
+ * the winning rows should overlap the game winner's in-game names at least
+ * as well as the losing team's (and vice versa). A contradiction means the
+ * match belongs to some other game. No overlap at all (e.g. no in-game
+ * names set) counts as a pass.
+ */
+function sidesMatchKnownPlayers(view: WinnerFirstView, game: IngestableGame) {
+	const winnerSide = view.players
+		.slice(0, PLAYERS_PER_TEAM)
+		.map((player) => Matches.normalizeInGameName(player.name));
+	const loserSide = view.players
+		.slice(PLAYERS_PER_TEAM)
+		.map((player) => Matches.normalizeInGameName(player.name));
+
+	const knownWinners = game.winnerInGameNames.map(Matches.normalizeInGameName);
+	const knownLosers = game.loserInGameNames.map(Matches.normalizeInGameName);
+
+	const straight =
+		nameOverlap(winnerSide, knownWinners) + nameOverlap(loserSide, knownLosers);
+	const flipped =
+		nameOverlap(winnerSide, knownLosers) + nameOverlap(loserSide, knownWinners);
+
+	return straight >= flipped;
+}
+
+function nameOverlap(names: string[], knownNames: string[]) {
+	const known = new Set(knownNames.filter(Boolean));
+	return names.filter((name) => name && known.has(name)).length;
+}
+
+/**
+ * Checks whether a match is a re-detection of a game's already linked
+ * scoreboard: enough player rows carry the same readable name in the same
+ * position. Positional comparison keeps two games between the same eight
+ * players apart — their row orders and sides practically always differ.
+ */
+function isLinkedDuplicate(view: WinnerFirstView, linkedPlayerNames: string[]) {
+	const matches = view.players.filter((player, i) => {
+		const name = Matches.normalizeInGameName(player.name);
+		const linkedName = linkedPlayerNames[i]
+			? Matches.normalizeInGameName(linkedPlayerNames[i]!)
+			: "";
+		return name !== "" && name === linkedName;
+	}).length;
+
+	return matches >= MIN_LINKED_DUPLICATE_NAME_MATCHES;
+}
diff --git a/app/features/scanner-ingest/core/VodMatches.test.ts b/app/features/scanner-ingest/core/VodMatches.test.ts
new file mode 100644
index 000000000..9ec1e2279
--- /dev/null
+++ b/app/features/scanner-ingest/core/VodMatches.test.ts
@@ -0,0 +1,82 @@
+import { describe, expect, it } from "vitest";
+import { vodsNewSearchParams } from "~/features/vods/vods-search-params";
+import {
+	type IngestVodMatchInput,
+	ingestVodPrefillSchema,
+} from "../scanner-ingest-vod-schemas";
+import { prefillVodMatches } from "./VodMatches";
+
+// 8 real main weapon ids (4v4): Splattershot etc.
+const WEAPONS: IngestVodMatchInput["weapons"] = [
+	40, 40, 40, 40, 20, 20, 20, 20,
+];
+
+function testMatch(
+	partial: Partial<IngestVodMatchInput> = {},
+): IngestVodMatchInput {
+	return {
+		startsAt: 30,
+		mode: "SZ",
+		stage: 0,
+		weapons: WEAPONS,
+		...partial,
+	};
+}
+
+describe("prefillVodMatches", () => {
+	it("maps validated match rows into the form's prefill shape", () => {
+		const prefilled = prefillVodMatches([testMatch({ povWeapon: 20 })]);
+
+		expect(prefilled).toHaveLength(1);
+		expect(prefilled[0]).toEqual({
+			startsAt: 30,
+			mode: "SZ",
+			stageId: 0,
+			weapons: [40, 40, 40, 40, 20, 20, 20, 20],
+			povWeapon: 20,
+		});
+	});
+
+	it("keeps unread (null) fields for the user to fill in the form", () => {
+		const prefilled = prefillVodMatches([
+			testMatch({
+				mode: null,
+				stage: null,
+				weapons: [...WEAPONS.slice(0, 7), null],
+			}),
+		]);
+
+		expect(prefilled).toHaveLength(1);
+		expect(prefilled[0]).toEqual({
+			startsAt: 30,
+			mode: null,
+			stageId: null,
+			weapons: [40, 40, 40, 40, 20, 20, 20, null],
+			povWeapon: null,
+		});
+	});
+
+	it("rejects rows that are not sendou ids", () => {
+		const parsed = ingestVodPrefillSchema.safeParse({
+			matches: [{ ...testMatch(), stage: "Scorch Gorge" }],
+		});
+		expect(parsed.success).toBe(false);
+	});
+
+	it("accepts the `ingest` search param the scanner VoD tab sends", () => {
+		// what the scanner VoD tab's "Add VoD" button puts in the URL
+		// (~/features/scanner/components/sendou-upload.ts): a { type?, matches }
+		// payload in the compressed `ingest` param
+		const href = vodsNewSearchParams.href("/vods/new", {
+			ingest: { type: "CAST", matches: [testMatch()] },
+		});
+
+		const { ingest } = vodsNewSearchParams.parse(
+			new URL(href, "https://sendou.ink"),
+		);
+
+		expect(ingest).not.toBeNull();
+		expect(ingest!.type).toBe("CAST");
+		expect(prefillVodMatches(ingest!.matches)).toHaveLength(1);
+	});
+});
diff --git a/app/features/scanner-ingest/core/VodMatches.ts b/app/features/scanner-ingest/core/VodMatches.ts
new file mode 100644
index 000000000..95d01a8dd
--- /dev/null
+++ b/app/features/scanner-ingest/core/VodMatches.ts
@@ -0,0 +1,32 @@
+import type {
+	MainWeaponId,
+	ModeShort,
+	StageId,
+} from "~/modules/in-game-lists/types";
+import type { IngestVodMatchInput } from "../scanner-ingest-vod-schemas";
+
+export interface PrefillVodMatch {
+	startsAt: number;
+	mode: ModeShort | null;
+	stageId: StageId | null;
+	weapons: (MainWeaponId | null)[];
+	/** the POV player's weapon, when the scan identified their seat */
+	povWeapon: MainWeaponId | null;
+}
+
+/**
+ * Turns the per-match rows a scanner VoD scan sends into prefill data for the
+ * /vods/new form. The rows already carry sendou ids (validated by
+ * ingestVodPrefillSchema); this only renames fields into the form's shape.
+ */
+export function prefillVodMatches(
+	matches: IngestVodMatchInput[],
+): PrefillVodMatch[] {
+	return matches.map((match) => ({
+		startsAt: match.startsAt,
+		mode: match.mode,
+		stageId: match.stage,
+		weapons: match.weapons,
+		povWeapon: match.povWeapon ?? null,
+	}));
+}
diff --git a/app/features/scanner-ingest/routes/scanner-ingest.ts b/app/features/scanner-ingest/routes/scanner-ingest.ts
new file mode 100644
index 000000000..e5c0e76e1
--- /dev/null
+++ b/app/features/scanner-ingest/routes/scanner-ingest.ts
@@ -0,0 +1 @@
+export { action } from "../actions/scanner-ingest.server";
diff --git a/app/features/scanner-ingest/scanner-ingest-schemas.ts b/app/features/scanner-ingest/scanner-ingest-schemas.ts
new file mode 100644
index 000000000..fafca3589
--- /dev/null
+++ b/app/features/scanner-ingest/scanner-ingest-schemas.ts
@@ -0,0 +1,33 @@
+import { z } from "zod";
+import { scannerMatchSchema } from "~/features/scanner/scanner-schemas";
+
+const MAX_MATCHES_PER_REQUEST = 50;
+
+/**
+ * The ScannerMatch shape comes from the producer
+ * (~/features/scanner/scanner-schemas — the single source of truth for the
+ * scanner domain); this module only adds the ingest-specific envelope. The
+ * POV user is always the session user, never client-supplied.
+ */
+export const ingestBodySchema = z.object({
+	matches: z.array(scannerMatchSchema).min(1).max(MAX_MATCHES_PER_REQUEST),
+});
+
+/** The sendou.ink match an ingested match's scoreboard was linked to. */
+export type IngestedMatchLink =
+	| { type: "tournament"; tournamentId: number; matchId: number }
+	| { type: "sendouq"; groupMatchId: number };
+
+export interface IngestResponse {
+	storedMatchesCount: number;
+	mergedMatchesCount: number;
+	linkedGamesCount: number;
+	/** per request match (by its index in the body's `matches`), the match it linked to */
+	linkedMatches: Array<{ matchIndex: number; link: IngestedMatchLink }>;
+	/**
+	 * whether the request's matches were resolved to a tournament or SendouQ
+	 * match. A match that stayed unlinked despite one is waiting for its game
+	 * to be reported, so resending it later can still link it.
+	 */
+	contextResolved: boolean;
+}
diff --git a/app/features/scanner-ingest/scanner-ingest-vod-schemas.ts b/app/features/scanner-ingest/scanner-ingest-vod-schemas.ts
new file mode 100644
index 000000000..9e6d653a2
--- /dev/null
+++ b/app/features/scanner-ingest/scanner-ingest-vod-schemas.ts
@@ -0,0 +1,47 @@
+import { z } from "zod";
+import {
+	mainWeaponIdSchema,
+	modeShortSchema,
+	stageIdSchema,
+} from "~/features/scanner/scanner-schemas";
+import { videoMatchTypes } from "~/features/vods/vods-constants";
+
+/** One detected match of a scanner VoD scan, projected from a ScannerMatch (~/features/scanner/components/sendou-upload.ts). */
+const ingestVodMatchSchema = z.object({
+	/** whole seconds into the video the match starts at */
+	startsAt: z.number().int().min(0),
+	/** null when no source read it */
+	mode: modeShortSchema.nullable(),
+	/**
+	 * true when `mode` is the scanner's fabricated PoC default (SZ) rather
+	 * than a real read. Currently informational only — assumed modes are
+	 * still stored, since casted footage never exposes the mode.
+	 */
+	modeAssumed: z.boolean().optional(),
+	/** null when no source read it */
+	stage: stageIdSchema.nullable(),
+	/** sendou main-weapon ids; null for a slot that never read */
+	weapons: z.array(mainWeaponIdSchema.nullable()).max(16),
+	/**
+	 * the POV player's weapon, prefilling a non-CAST VoD's single weapon
+	 * select. Absent when no scoreboard identified the POV seat (or it read
+	 * no weapon) — including on casted footage, which has no POV.
+	 */
+	povWeapon: mainWeaponIdSchema.optional(),
+});
+
+/**
+ * The scanner VoD tab's "Add VoD" button packs this into /vods/new's
+ * `ingest` search param (an `SP.json` param, compressed by the search-params
+ * module) to prefill the form: the detected match rows, minus the submission
+ * fields (YouTube URL, title, date) the user fills in the form. `type` is
+ * sent only when the scan auto-detected it (spectator map screens → CAST);
+ * absent means the form's default.
+ */
+export const ingestVodPrefillSchema = z.object({
+	type: z.enum(videoMatchTypes).optional(),
+	matches: z.array(ingestVodMatchSchema).min(1).max(100),
+});
+
+export type IngestVodMatchInput = z.infer<typeof ingestVodMatchSchema>;
+export type IngestVodPrefill = z.infer<typeof ingestVodPrefillSchema>;
diff --git a/app/features/scanner/README.md b/app/features/scanner/README.md
new file mode 100644
index 000000000..6c9b21810
--- /dev/null
+++ b/app/features/scanner/README.md
@@ -0,0 +1,176 @@
+# Scanner — Splatoon match-event detection
+
+Browser app (route `/scanner`, dev-only until promoted) that watches OBS
+Virtual Camera footage, VoD files, or screenshots, detects Splatoon 3 UI
+screens with OpenCV.js in a Web Worker, and parses them into events speaking
+sendou.ink ids (`ModeShort`/`StageId`/weapon ids/`Ability`). Events aggregate
+client-side into `ScannerMatch` objects (`core/scanner-match.ts`) — one
+detected game per object, every field nullable — which feed `/ingest`
+(features/scanner-ingest) and the `/vods/new` prefill. Imported from the
+emberz repo; see `MIGRATION.md` there.
+
+Deliberate convention exceptions (dev tool, ported wholesale): the UI is
+English-only (no i18next) and styled by one global `components/styles.css`
+instead of per-component CSS modules; `tests/node-test-compat.ts` uses a
+default export to stay a `node:test` drop-in.
+
+## Commands
+
+```sh
+pnpm test:scanner                       # golden-file suite over tests/fixtures/ (Vitest, Node)
+pnpm scanner:report                     # accuracy table + name character error rate across fixtures
+pnpm scanner:fixtures [name-substring]  # run detectors over matching fixtures, verbose
+pnpm scanner:replay <dir> <startT> <fps> # replay ffmpeg-extracted frames through the scheduler+detectors
+pnpm scanner:bootstrap-atlas            # harvest labeled fixture crops into the glyph atlases
+pnpm scanner:build-glyph-atlas          # add the font-rendered charset (fonts required, see below)
+pnpm scanner:build-localized-entries    # regen localized closed sets from ../splat3
+pnpm scanner:build-planner-signatures   # regen the minimap stage-ID atlas from the assets repo
+```
+
+Scanner scripts run through `vite-node -c scripts/scanner/vite-node.config.ts`:
+the root vite config pre-bundles `@techstark/opencv-js` for the browser worker
+and vite-node must not consume that prebundle. The package is pnpm-patched
+(`patches/`) to wrap its thenable CJS export as `{ cvReadyPromise }`,
+unwrapped in `core/cv.ts`.
+
+## Architecture
+
+```mermaid
+sequenceDiagram
+  participant Cap as capture (sampler / vod-frames)
+  participant W as analyzer.worker (OpenCV)
+  participant TL as TimelineBuilder
+  participant MB as match-builder
+  participant UI as Live/VoD tab
+  participant ING as /ingest (scanner-ingest)
+  participant DB as IngestedMatch / IngestedMatchLink
+  Cap->>W: frame + t (live/screenshot/seek) — VoD: worker decodes its own slice
+  W->>W: scheduler dueDetectors() → gate() → parse()
+  W-->>TL: DetectedEvents
+  TL-->>UI: deduped timeline (IndexedDB on Live)
+  UI->>MB: buildScannerMatches(events)
+  MB-->>UI: ScannerMatch[] + source events
+  UI->>ING: POST { matches } (Live: on match close / scan end, VoD: whole scan)
+  ING->>ING: resolve context (current tournament/SendouQ activity, casts via staff roles, else content sequence ≥2)
+  ING->>DB: merge-store IngestedMatch (matchHash, isSameMatch + merge, context hints)
+  ING->>DB: link matches to game results → IngestedMatchLink (POV weapon → ReportedWeapon; scoreboards derived at read time)
+  Note over UI: VoD "Add VoD": ScannerMatch → slim prefill param → /vods/new
+```
+
+- `core/` is pure (mats in, events/matches out) and runs in the worker, the
+  Screenshot tab, and Node tests. No DOM/browser APIs; Node-only helpers live
+  in `node/`. Pure data/type imports from `~/modules` and
+  `~/features/build-analyzer/data` are fine — zod and the app config graph
+  are not (schemas live in `scanner-schemas.ts`; core only `import type`s
+  the shapes).
+- `core/match-builder.ts` turns a timeline into `ScannerMatch`es: a MapStart
+  opens a match, a scoreboard closes one (claiming the last 8 min of deaths
+  when the intro was missed), minimaps group per map by confirmed stage
+  change and >5 min gap. An event belongs to at most one match; deaths
+  reveal enemy builds (`ability-harvest.ts`). Partial matches are fine —
+  scanner-ingest merges them server-side. Senders filter with
+  `ingestSkipReasons`: private/unread lobby only, and no games a disconnect
+  cut short (scoreless + counter left more time than the footage did, or
+  replayed right after on the same map — the latter is a VoD-scan filter in
+  practice since it only resolves after the fact).
+- The route (`routes/scanner.tsx`) is SSR-guarded: the client tree loads via
+  `React.lazy` after `useHydrated`; nothing from `core/worker/capture/store`
+  may be imported at route-module top level.
+- Eight detectors: `scoreboard` (results screen),
+  `scoreboard-battle-log-replay` (replay-browser detail),
+  `scoreboard-battle-log` (Recent Battles detail — same data sans replay
+  code, panels stacked), `scoreboard-own` (personal results), `death`
+  (respawn overlay), `map-start` (match intro), `minimap` (in-match overlay
+  + casted 8-player spectator variant), `objective` (ranked counter overlay:
+  counts, penalties, holder, match timer — a mode-discriminated union with
+  only the SZ member so far). Objective reads land on `ScannerMatch` as
+  progress samples anchored to the game clock. Reads grouping into a match
+  whose detected mode is not SZ are lookalike misreads: the builder nulls
+  that match's `objective` and callers discard the events
+  (`invalidObjectiveEvents`; Live also stops collecting once a MapStart
+  reveals a non-SZ mode). Parsing details are in each detector's module
+  header; accuracy-critical matching internals in `core/glyphs.ts` and
+  `core/detectors/scoreboard/weapons.ts` — read those before touching
+  recognition code.
+- Scheduling (`core/detectors/scheduler.ts`): the per-session
+  DetectorScheduler decides which detectors see a frame. Failing gates are
+  re-checked every `searchIntervalS` (0.25s — produced VoDs cut screens to
+  ~1s, and gates are ~ms-cheap); a passing gate drops to the dense refine
+  cadence (`refineIntervalS` overrides for expensive parses). Suppression
+  ends a refinement streak on parse-count stagnation AND ~3s elapsed (the
+  floor spans entry animations), or immediately at `sufficientConfidence`
+  (set just under each detector's measured clean-read floor); death adds
+  `rearmCooldownS`. Battle-log/replay gates return a content `signature` so
+  browsing distinct entries re-parses once per battle instead of dropping
+  the gate. `checkIntervalS` hard-caps both phases; `attachFrame: false`
+  keeps continuously-firing events from storing a frame PNG each. Frames no
+  detector is due for skip canvas readback, and everything is counted in
+  `core/detectors/telemetry.ts` (VoD tab's telemetry panel). A match's
+  objective reads render as one step-line timeline
+  (`~/components/ObjectiveTimeline.tsx`, shared with the match page).
+- VoD scans (`components/VodPage.tsx`): on the WebCodecs path each worker
+  demuxes + decodes its own contiguous slice (mediabunny in the worker — no
+  frames cross the main thread). When the scheduler reports calm (no gate
+  pass for a quiet period, no open match), the worker skims
+  keyframe-to-keyframe (hop capped at 2.5s so short screens can't hide),
+  snapping back to dense decode on any gate pass. The seek fallback drives
+  one worker and widens its stride over calm footage the same way.
+- Recognition is language-agnostic: OCR output snaps against every game
+  language at once (`core/localized-entries.ts`, generated) and events carry
+  sendou ids. English display names come from `components/labels.ts`.
+- ROI coordinates live in each detector's `rois.ts`, in canonical 1920×1080
+  space; every frame is normalized to that size first.
+- New event types implement `Detector` (`core/detectors/types.ts`): a cheap
+  `gate(mat)` at sample rate plus `parse(mat, t)` when the gate fires.
+  Register in `core/detectors/registry.ts`.
+
+## Assets (CDN) and fonts
+
+Weapon/ability/special/sub template sources are the site's shared game icons
+in the **sendou-ink/assets repo** under `assets/img/**` (`.avif`; ids from
+`~/modules/in-game-lists`, plus the scanner-only `UNKNOWN` ability badge —
+`toAbilityWithUnknown` narrows template ids back to sendou ids).
+Scanner-specific sets — glyph atlases and the planner signature atlas — live
+here under `public/scanner/v1/**` (override with `SCANNER_ASSETS_DIR`; the
+version segment bumps on breaking atlas-format changes). xxx: the atlases are
+in `public/` only while the feature is in development — move them to the
+assets repo (and the worker back to the CDN base) later.
+
+- Browser/worker: icons from `Config.staticAssetsUrl` at `img/**` (base URL
+  rides the worker init message; the DO Space needs CORS for GET from
+  sendou.ink + localhost); atlases same-origin from `/scanner/v1/**`. Local
+  dev against fresh icon regens:
+  `npx serve /Users/kalle/Developer/assets/assets -l 9100 --cors` and
+  `VITE_STATIC_ASSETS_URL=http://localhost:9100` in `.env`.
+- Node (tests/scripts): atlases from `public/scanner/v1`, icons from the
+  `../assets` checkout, never the CDN. AVIF decodes through `sharp`
+  (`node/image-io.ts`) — `@napi-rs/canvas` mis-decodes AVIF partial-alpha.
+- Atlas regens overwrite `public/scanner/v1` in place and ship with the app
+  build.
+
+Fonts are proprietary and gitignored: `BlitzMain.otf`, `BlitzBold.otf`,
+`FOT-RowdyStd-EB.otf`, `FOT-KurokaneStd-EB.otf` in `assets/fonts/` (repo
+root; from the splatoon3-fonts repo). Atlas builders fail loudly without
+them. Names and row digits use BlitzMain; team totals BlitzBold; the replay
+code line and VICTORY/DEFEAT tags FOT-RowdyStd-EB; the JP death message mixes
+condensed Kurokane and Rowdy (`death-weapon-ja`). Regeneration order:
+`scanner:bootstrap-atlas` (fixture crops win via tie-break) →
+`scanner:build-glyph-atlas`; localized sets via
+`scanner:build-localized-entries` (expects a splat3 checkout at `../splat3`)
+then the atlas rebuild; planner atlas via `scanner:build-planner-signatures`
+(reads the assets repo's `assets/planner-maps/`, MINI variant).
+
+## Fixtures
+
+A test case is a directory `tests/fixtures/<detector>/<case-name>/` with
+`frame.png|jpg` (raw capture, never re-encoded) and `expected.json` (partial
+expectations, sendou ids; `stageLabel`/`weaponLabel` are informational for
+the human corrector — tests compare only ids). Negative cases
+(`{ "event": "none" }`) go in the shared `tests/fixtures/negative/`; every
+detector's suite sweeps them. Every live misread should become a fixture —
+the live app's "Save fixture" button exports the byte-exact analyzed frame
+plus a prefilled `expected.json`. **Fixture ground-truth labels are
+hand-corrected by the user (the Splatoon domain authority) — treat them as
+definitive over any matcher output.** Fixtures are committed as plain blobs
+(no LFS for now); keep additions deliberate — fixture IO is isolated in
+`node/fixtures.ts` if a retreat to LFS/an external corpus is needed.
diff --git a/app/features/scanner/capture/sampler.ts b/app/features/scanner/capture/sampler.ts
new file mode 100644
index 000000000..883891ddf
--- /dev/null
+++ b/app/features/scanner/capture/sampler.ts
@@ -0,0 +1,75 @@
+/**
+ * Capture layer: OBS Virtual Camera in via getUserMedia, frames out as
+ * ImageBitmaps at a low sample rate. The interface downstream is just
+ * (bitmap, t) — a WHIP/MediaMTX transport can replace this file later.
+ */
+
+export async function openVirtualCamera(
+	deviceId?: string,
+): Promise<MediaStream> {
+	return navigator.mediaDevices.getUserMedia({
+		video: {
+			deviceId: deviceId ? { exact: deviceId } : undefined,
+			width: { ideal: 1920 },
+			height: { ideal: 1080 },
+		},
+		audio: false,
+	});
+}
+
+export async function listVideoInputs(): Promise<MediaDeviceInfo[]> {
+	const devices = await navigator.mediaDevices.enumerateDevices();
+	return devices.filter((d) => d.kind === "videoinput");
+}
+
+export type FrameHandler = (bitmap: ImageBitmap, t: number) => void;
+
+// xxx: hidden tabs can still be frozen/discarded outright, which suspends the
+// workers too. A silent looping <audio> marks the page as playing audio and
+// exempts it from both intensive throttling and freezing — measure whether we
+// need it before adding it.
+
+/**
+ * Sample frames from a playing video element at ~fps. The clock is a
+ * setInterval in a dedicated worker (ticker.worker.ts): rAF and
+ * requestVideoFrameCallback pause entirely in hidden tabs, but worker timers
+ * keep firing and the camera stream keeps decoding, so capture continues
+ * while the user is in another tab or window. Timestamps come from
+ * performance.now() (monotonic, which the timeline's merge windows rely on)
+ * rather than mediaTime, which Firefox never advances for MediaStream-backed
+ * videos anyway. Returns a stop function.
+ */
+export function startSampler(
+	video: HTMLVideoElement,
+	fps: number,
+	onFrame: FrameHandler,
+): () => void {
+	const ticker = new Worker(new URL("./ticker.worker.ts", import.meta.url), {
+		type: "module",
+	});
+	ticker.postMessage(1000 / fps);
+	let stopped = false;
+	let sampling = false;
+
+	ticker.onmessage = async () => {
+		if (stopped || sampling) return;
+		sampling = true;
+		try {
+			const bitmap = await createImageBitmap(video);
+			if (stopped) {
+				bitmap.close();
+				return;
+			}
+			onFrame(bitmap, performance.now() / 1000);
+		} catch {
+			// video not ready — skip this frame
+		} finally {
+			sampling = false;
+		}
+	};
+
+	return () => {
+		stopped = true;
+		ticker.terminate();
+	};
+}
diff --git a/app/features/scanner/capture/ticker.worker.ts b/app/features/scanner/capture/ticker.worker.ts
new file mode 100644
index 000000000..7d4f4af42
--- /dev/null
+++ b/app/features/scanner/capture/ticker.worker.ts
@@ -0,0 +1,9 @@
+/**
+ * Interval clock for the frame sampler. Lives in a worker because worker
+ * timers keep firing while the tab is hidden, unlike main-thread rAF /
+ * requestVideoFrameCallback / throttled setInterval. Receives the interval
+ * in ms, then posts a tick forever.
+ */
+self.onmessage = (e: MessageEvent<number>) => {
+	setInterval(() => self.postMessage(0), e.data);
+};
diff --git a/app/features/scanner/capture/vod-frames.ts b/app/features/scanner/capture/vod-frames.ts
new file mode 100644
index 000000000..564b1883f
--- /dev/null
+++ b/app/features/scanner/capture/vod-frames.ts
@@ -0,0 +1,95 @@
+/**
+ * VoD scan entry points. The primary path probes whether WebCodecs (via
+ * mediabunny) can decode the file — if so, the analyzer workers each demux
+ * and decode their own time slice of it (worker/analyzer.worker.ts) and no
+ * frames cross the main thread at all. When the container/codec can't be
+ * read that way, the fallback seek-steps a <video> element, which handles
+ * anything the browser can play at the cost of per-seek latency; its stride
+ * is supplied per step so the caller can widen it over calm footage.
+ */
+import { ALL_FORMATS, BlobSource, Input } from "mediabunny";
+
+interface VodFrame {
+	/** the consumer owns the frame and must close() it */
+	frame: ImageBitmap;
+	/** seconds into the video */
+	t: number;
+}
+
+/**
+ * Whether mediabunny + WebCodecs can decode `file`, and its duration if so.
+ */
+export async function probeWebCodecs(
+	file: File,
+): Promise<{ duration: number } | null> {
+	const input = new Input({
+		formats: ALL_FORMATS,
+		source: new BlobSource(file),
+	});
+	try {
+		const track = await input.getPrimaryVideoTrack();
+		if (track && (await track.canDecode())) {
+			return { duration: await input.computeDuration([track]) };
+		}
+		return null;
+	} catch {
+		return null;
+	} finally {
+		input.dispose();
+	}
+}
+
+/**
+ * Open a seek-stepping scan over `video` (which must already have the file
+ * loaded; metadata is awaited here). `nextStrideS` is consulted after every
+ * yielded frame, so analysis feedback can adjust the step on the fly.
+ */
+export async function openSeekScan(
+	video: HTMLVideoElement,
+	nextStrideS: () => number,
+): Promise<{ duration: number; frames: AsyncGenerator<VodFrame> }> {
+	await loadMetadata(video);
+	if (!Number.isFinite(video.duration)) {
+		throw new Error("video has no known duration — cannot scan by seeking");
+	}
+	return { duration: video.duration, frames: seekFrames(video, nextStrideS) };
+}
+
+async function* seekFrames(
+	video: HTMLVideoElement,
+	nextStrideS: () => number,
+): AsyncGenerator<VodFrame> {
+	for (let t = 0; t < video.duration; ) {
+		await seekTo(video, t);
+		yield { frame: await createImageBitmap(video), t };
+		t += Math.max(0.01, nextStrideS());
+	}
+}
+
+function loadMetadata(video: HTMLVideoElement): Promise<void> {
+	return new Promise((resolve, reject) => {
+		if (video.readyState >= HTMLMediaElement.HAVE_METADATA) return resolve();
+		video.addEventListener("loadedmetadata", () => resolve(), { once: true });
+		video.addEventListener(
+			"error",
+			() =>
+				reject(
+					new Error(video.error?.message || "cannot decode this file as video"),
+				),
+			{ once: true },
+		);
+	});
+}
+
+function seekTo(video: HTMLVideoElement, t: number): Promise<void> {
+	return new Promise((resolve) => {
+		if (
+			video.currentTime === t &&
+			video.readyState >= HTMLMediaElement.HAVE_CURRENT_DATA
+		) {
+			return resolve();
+		}
+		video.addEventListener("seeked", () => resolve(), { once: true });
+		video.currentTime = t;
+	});
+}
diff --git a/app/features/scanner/components/AbilityGrid.tsx b/app/features/scanner/components/AbilityGrid.tsx
new file mode 100644
index 000000000..5134145e3
--- /dev/null
+++ b/app/features/scanner/components/AbilityGrid.tsx
@@ -0,0 +1,61 @@
+/**
+ * Gear-ability grid (3 rows: head/clothes/shoes, each [main, sub, sub, sub])
+ * shared by the death card and the scoreboard player popover.
+ */
+
+import { Button } from "react-aria-components";
+import { Ability } from "~/components/Ability";
+import { SendouPopover } from "~/components/elements/Popover";
+import type { AbilityWithUnknown } from "~/modules/in-game-lists/types";
+
+const ROW_LABELS = ["head", "clothes", "shoes"] as const;
+
+export function AbilityGrid({
+	abilities,
+}: {
+	abilities: AbilityWithUnknown[][];
+}) {
+	return (
+		<table className="players">
+			<tbody>
+				{abilities.map((row, i) => (
+					<tr key={i}>
+						<td>{ROW_LABELS[i]}</td>
+						{row.map((id, j) => (
+							<td key={j}>
+								<Ability ability={id} size={j === 0 ? "SUBTINY" : "TINY"} />
+							</td>
+						))}
+					</tr>
+				))}
+			</tbody>
+		</table>
+	);
+}
+
+/**
+ * Click-to-toggle popover showing a player's ability grid; the trigger is
+ * the head-main ability icon.
+ */
+export function AbilityPopover({
+	abilities,
+}: {
+	abilities: AbilityWithUnknown[][];
+}) {
+	const trigger = abilities[0]?.[0];
+	if (!trigger) return null;
+	return (
+		<SendouPopover
+			trigger={
+				<Button
+					className="ability-trigger"
+					aria-label="Show abilities (from death events)"
+				>
+					<Ability ability={trigger} size="TINY" />
+				</Button>
+			}
+		>
+			<AbilityGrid abilities={abilities} />
+		</SendouPopover>
+	);
+}
diff --git a/app/features/scanner/components/App.tsx b/app/features/scanner/components/App.tsx
new file mode 100644
index 000000000..01126b1ae
--- /dev/null
+++ b/app/features/scanner/components/App.tsx
@@ -0,0 +1,56 @@
+import { Link } from "react-router";
+import { useUser } from "~/features/auth/core/user";
+import { useSearchParam } from "~/modules/search-params/hooks";
+import { SCANNER_PAGE } from "~/utils/urls";
+import {
+	SCANNER_TABS,
+	type ScannerTab,
+	scannerSearchParams,
+} from "../scanner-search-params";
+import { LivePage } from "./LivePage";
+import { ScreenshotPage } from "./ScreenshotPage";
+import type { SendouUser } from "./sendou-ingest";
+import { VodPage } from "./VodPage";
+import "./styles.css";
+
+const TAB_LABELS: Record<ScannerTab, string> = {
+	live: "Live",
+	screenshot: "Screenshot",
+	vod: "VoD",
+};
+
+export function App() {
+	const [tab] = useSearchParam(scannerSearchParams, "tab");
+	const rootUser = useUser();
+	const sendouUser: SendouUser | null = rootUser
+		? { id: rootUser.id, username: rootUser.username }
+		: null;
+
+	const page =
+		tab === "screenshot" ? (
+			<ScreenshotPage />
+		) : tab === "vod" ? (
+			<VodPage sendouUser={sendouUser} />
+		) : (
+			<LivePage sendouUser={sendouUser} />
+		);
+
+	return (
+		<div className="scanner-app">
+			<header className="topbar">
+				<nav>
+					{SCANNER_TABS.map((tabOption) => (
+						<Link
+							key={tabOption}
+							to={scannerSearchParams.href(SCANNER_PAGE, { tab: tabOption })}
+							className={tab === tabOption ? "active" : ""}
+						>
+							{TAB_LABELS[tabOption]}
+						</Link>
+					))}
+				</nav>
+			</header>
+			{page}
+		</div>
+	);
+}
diff --git a/app/features/scanner/components/DeathCard.tsx b/app/features/scanner/components/DeathCard.tsx
new file mode 100644
index 000000000..8570ccc9c
--- /dev/null
+++ b/app/features/scanner/components/DeathCard.tsx
@@ -0,0 +1,79 @@
+import { Ability } from "~/components/Ability";
+import { WeaponImage } from "~/components/Image";
+import type { MainWeaponId } from "~/modules/in-game-lists/types";
+import {
+	DEATH_EVENT_TYPE,
+	type DeathData,
+} from "../core/detectors/death/index";
+import { FrameThumb } from "./FrameThumb";
+import { useEventTimeFormatter } from "./format";
+import { weaponLabel } from "./labels";
+import { MetaPills } from "./MetaChips";
+
+export function DeathCard(props: {
+	t: number;
+	confidence: number;
+	data: DeathData;
+	thumbnail?: string;
+	detectedAt?: number;
+	/** lazy loader for the exact analyzed frame — enables fixture export */
+	getFrame?: () => Promise<Blob | null | undefined>;
+	onInspect?: () => void;
+}) {
+	const { t, confidence, data, thumbnail, detectedAt, getFrame, onInspect } =
+		props;
+	const weaponName = weaponLabel(data.weaponType, data.weaponId);
+	const formatDetectedAt = useEventTimeFormatter();
+	return (
+		<div className="card">
+			<div className="meta">
+				<MetaPills
+					t={t}
+					confidence={confidence}
+					type={DEATH_EVENT_TYPE}
+					label="death"
+				/>
+				{detectedAt ? <span>{formatDetectedAt(detectedAt)}</span> : null}
+				<FrameThumb
+					thumbnail={thumbnail}
+					getFrame={getFrame}
+					onInspect={onInspect}
+					fixture={{ data, type: "Death" }}
+				/>
+			</div>
+			<div className="teams death">
+				<div className="team">
+					<div className="death-body">
+						{data.weaponId !== null && data.weaponType === "MAIN" ? (
+							<WeaponImage
+								weaponSplId={data.weaponId as MainWeaponId}
+								variant="build"
+								size={28}
+								className="weapon-icon"
+							/>
+						) : null}
+						<div className="death-info">
+							<span className="death-name">
+								splatted by <b>{data.name ?? "?"}</b>
+							</span>
+							<span className="death-weapon">{weaponName ?? "?"}</span>
+						</div>
+						<div className="death-abilities">
+							{data.abilities.map((row, i) => (
+								<div key={i} className="gear">
+									{row.map((id, j) => (
+										<Ability
+											key={j}
+											ability={id}
+											size={j === 0 ? "SUBTINY" : "TINY"}
+										/>
+									))}
+								</div>
+							))}
+						</div>
+					</div>
+				</div>
+			</div>
+		</div>
+	);
+}
diff --git a/app/features/scanner/components/EventCard.tsx b/app/features/scanner/components/EventCard.tsx
new file mode 100644
index 000000000..73583c07e
--- /dev/null
+++ b/app/features/scanner/components/EventCard.tsx
@@ -0,0 +1,158 @@
+/**
+ * Single dispatch point from a detected event to its card component, shared
+ * by the live feed and the VoD feed. Frames are loaded lazily through
+ * `getFrame` (IndexedDB keeps them out of the listed records); the Inspect
+ * action (open the frame in the screenshot page in a new browser tab, so
+ * the running scan is left undisturbed) is derived from it here so pages
+ * don't duplicate the wiring.
+ */
+
+import clsx from "clsx";
+import { SCANNER_PAGE } from "~/utils/urls";
+import type { PlayerAbilityMap } from "../core/ability-harvest";
+import {
+	DEATH_EVENT_TYPE,
+	type DeathData,
+} from "../core/detectors/death/index";
+import {
+	MAP_START_EVENT_TYPE,
+	type MapStartData,
+} from "../core/detectors/map-start/index";
+import {
+	MINIMAP_EVENT_TYPE,
+	type MinimapData,
+} from "../core/detectors/minimap/index";
+import {
+	OBJECTIVE_EVENT_TYPE,
+	type ObjectiveData,
+} from "../core/detectors/objective/index";
+import type { ScoreboardData } from "../core/detectors/scoreboard/index";
+import {
+	SCOREBOARD_OWN_EVENT_TYPE,
+	type ScoreboardOwnData,
+} from "../core/detectors/scoreboard-own/index";
+import { scannerSearchParams } from "../scanner-search-params";
+import type { SendStatus } from "../store/events";
+import { newInspectKey, putInspectFrame } from "../store/inspect";
+import { DeathCard } from "./DeathCard";
+import type { FixtureData } from "./fixture-export";
+import { useEventTimeFormatter } from "./format";
+import { MapStartCard } from "./MapStartCard";
+import { MinimapCard } from "./MinimapCard";
+import { ObjectiveCard } from "./ObjectiveCard";
+import { ScoreboardCard } from "./ScoreboardCard";
+import { ScoreboardOwnCard } from "./ScoreboardOwnCard";
+
+export type GetFrame = () => Promise<Blob | null | undefined>;
+
+export function EventCard(props: {
+	type: string;
+	t: number;
+	confidence: number;
+	data: FixtureData;
+	thumbnail?: string;
+	detectedAt?: number;
+	/** lazy loader for the exact analyzed frame; enables Inspect + fixture export */
+	getFrame?: GetFrame;
+	/** Scoreboard only: abilities harvested from the match's death events */
+	abilities?: PlayerAbilityMap;
+	/** sendou.ink /ingest status of this event; absent = never attempted */
+	send?: SendStatus;
+	/** when set, shows a Send/Retry button that sends this event's match batch */
+	onSend?: () => void;
+}) {
+	const { type, t, confidence, data, thumbnail, detectedAt, getFrame } = props;
+	// window.open must run synchronously in the click gesture (popup blockers);
+	// the frame write catches up and the new tab polls for it
+	const onInspect = getFrame
+		? () => {
+				const key = newInspectKey();
+				window.open(
+					scannerSearchParams.href(SCANNER_PAGE, {
+						tab: "screenshot",
+						inspect: key,
+					}),
+					"_blank",
+				);
+				void getFrame().then((frame) => {
+					if (frame) void putInspectFrame(key, frame);
+				});
+			}
+		: undefined;
+	const shared = { t, confidence, thumbnail, detectedAt, getFrame, onInspect };
+
+	const card = renderCard(type, data, shared, props.abilities);
+	if (!props.send && !props.onSend) return card;
+	return (
+		<div className="send-wrap">
+			{card}
+			<SendStrip send={props.send} onSend={props.onSend} />
+		</div>
+	);
+}
+
+const SEND_LABELS: Record<SendStatus["state"], string> = {
+	queued: "queued",
+	sending: "sending…",
+	sent: "sent",
+	unlinked: "waiting for report",
+	failed: "failed",
+};
+
+function SendStrip({
+	send,
+	onSend,
+}: {
+	send?: SendStatus;
+	onSend?: () => void;
+}) {
+	const state = send?.state;
+	const formatSentAt = useEventTimeFormatter();
+	return (
+		<div className={clsx("send-strip", state ?? "unsent")}>
+			<span>
+				sendou.ink: {state ? SEND_LABELS[state] : "not sent"}
+				{state === "sent" && send ? ` ${formatSentAt(send.at)}` : null}
+			</span>
+			{send?.error ? <span className="error">{send.error}</span> : null}
+			{onSend && state !== "sent" && state !== "sending" ? (
+				<button type="button" onClick={onSend}>
+					{state === "failed" ? "Retry" : "Send"}
+				</button>
+			) : null}
+		</div>
+	);
+}
+
+function renderCard(
+	type: string,
+	data: FixtureData,
+	shared: {
+		t: number;
+		confidence: number;
+		thumbnail?: string;
+		detectedAt?: number;
+		getFrame?: GetFrame;
+		onInspect?: () => void;
+	},
+	abilities?: PlayerAbilityMap,
+) {
+	return type === DEATH_EVENT_TYPE ? (
+		<DeathCard {...shared} data={data as DeathData} />
+	) : type === MAP_START_EVENT_TYPE ? (
+		<MapStartCard {...shared} data={data as MapStartData} />
+	) : type === SCOREBOARD_OWN_EVENT_TYPE ? (
+		<ScoreboardOwnCard {...shared} data={data as ScoreboardOwnData} />
+	) : type === MINIMAP_EVENT_TYPE ? (
+		<MinimapCard {...shared} data={data as MinimapData} />
+	) : type === OBJECTIVE_EVENT_TYPE ? (
+		<ObjectiveCard {...shared} data={data as ObjectiveData} />
+	) : (
+		<ScoreboardCard
+			{...shared}
+			eventType={type}
+			data={data as ScoreboardData}
+			abilities={abilities}
+		/>
+	);
+}
diff --git a/app/features/scanner/components/EventTypeIcon.tsx b/app/features/scanner/components/EventTypeIcon.tsx
new file mode 100644
index 000000000..e52156ce5
--- /dev/null
+++ b/app/features/scanner/components/EventTypeIcon.tsx
@@ -0,0 +1,47 @@
+/**
+ * Shared lucide glyph per detected-event type, so the events summary line
+ * and the event cards mark each type with the same icon.
+ */
+
+import {
+	CircleHelp,
+	History,
+	type LucideIcon,
+	Map as MapIcon,
+	Play,
+	RotateCcw,
+	Skull,
+	Target,
+	Trophy,
+	User,
+} from "lucide-react";
+import { DEATH_EVENT_TYPE } from "../core/detectors/death/index";
+import { MAP_START_EVENT_TYPE } from "../core/detectors/map-start/index";
+import { MINIMAP_EVENT_TYPE } from "../core/detectors/minimap/index";
+import { OBJECTIVE_EVENT_TYPE } from "../core/detectors/objective/index";
+import { SCOREBOARD_EVENT_TYPE } from "../core/detectors/scoreboard/index";
+import { SCOREBOARD_BATTLE_LOG_EVENT_TYPE } from "../core/detectors/scoreboard-battle-log/index";
+import { SCOREBOARD_BATTLE_LOG_REPLAY_EVENT_TYPE } from "../core/detectors/scoreboard-battle-log-replay/index";
+import { SCOREBOARD_OWN_EVENT_TYPE } from "../core/detectors/scoreboard-own/index";
+
+const EVENT_TYPE_ICONS: Record<string, LucideIcon> = {
+	[MAP_START_EVENT_TYPE]: Play,
+	[DEATH_EVENT_TYPE]: Skull,
+	[MINIMAP_EVENT_TYPE]: MapIcon,
+	[OBJECTIVE_EVENT_TYPE]: Target,
+	[SCOREBOARD_EVENT_TYPE]: Trophy,
+	[SCOREBOARD_BATTLE_LOG_REPLAY_EVENT_TYPE]: RotateCcw,
+	[SCOREBOARD_BATTLE_LOG_EVENT_TYPE]: History,
+	[SCOREBOARD_OWN_EVENT_TYPE]: User,
+};
+
+export function EventTypeIcon({
+	type,
+	size = 12,
+}: {
+	type: string;
+	size?: number;
+}) {
+	const Icon = EVENT_TYPE_ICONS[type] ?? CircleHelp;
+	return <Icon size={size} aria-hidden className="event-type-icon" />;
+}
diff --git a/app/features/scanner/components/EventsSummary.tsx b/app/features/scanner/components/EventsSummary.tsx
new file mode 100644
index 000000000..c7adcf78e
--- /dev/null
+++ b/app/features/scanner/components/EventsSummary.tsx
@@ -0,0 +1,64 @@
+/**
+ * One light line summarizing raw detections as per-type counts, with a
+ * toggle for their event card feed. Callers pass only events not covered
+ * by a match card — a fallback for detections not yet grouped, hidden
+ * entirely once everything lives in a match.
+ */
+
+import * as R from "remeda";
+import { DEATH_EVENT_TYPE } from "../core/detectors/death/index";
+import { MAP_START_EVENT_TYPE } from "../core/detectors/map-start/index";
+import { MINIMAP_EVENT_TYPE } from "../core/detectors/minimap/index";
+import { OBJECTIVE_EVENT_TYPE } from "../core/detectors/objective/index";
+import { SCOREBOARD_EVENT_TYPE } from "../core/detectors/scoreboard/index";
+import { SCOREBOARD_BATTLE_LOG_EVENT_TYPE } from "../core/detectors/scoreboard-battle-log/index";
+import { SCOREBOARD_BATTLE_LOG_REPLAY_EVENT_TYPE } from "../core/detectors/scoreboard-battle-log-replay/index";
+import { SCOREBOARD_OWN_EVENT_TYPE } from "../core/detectors/scoreboard-own/index";
+import { EventTypeIcon } from "./EventTypeIcon";
+
+const EVENT_TYPE_LABELS: Record<string, string> = {
+	[MAP_START_EVENT_TYPE]: "map start",
+	[DEATH_EVENT_TYPE]: "death",
+	[MINIMAP_EVENT_TYPE]: "minimap",
+	[OBJECTIVE_EVENT_TYPE]: "objective",
+	[SCOREBOARD_EVENT_TYPE]: "scoreboard",
+	[SCOREBOARD_BATTLE_LOG_REPLAY_EVENT_TYPE]: "replay scoreboard",
+	[SCOREBOARD_BATTLE_LOG_EVENT_TYPE]: "battle log",
+	[SCOREBOARD_OWN_EVENT_TYPE]: "own result",
+};
+
+export function EventsSummary({
+	events,
+	open,
+	onToggle,
+}: {
+	events: ReadonlyArray<{ type: string }>;
+	open: boolean;
+	onToggle: () => void;
+}) {
+	const counts = R.countBy(events, (event) => event.type);
+	const sorted = Object.entries(counts).toSorted((a, b) => b[1] - a[1]);
+
+	return (
+		<div className="events-summary">
+			{sorted.map(([type, count]) => {
+				const label = EVENT_TYPE_LABELS[type] ?? type;
+				return (
+					<span
+						key={type}
+						className="events-summary-type"
+						title={`${count} ${label}${count === 1 ? "" : "s"}`}
+					>
+						<span className="events-summary-icon">
+							<EventTypeIcon type={type} />
+						</span>
+						×{count}
+					</span>
+				);
+			})}
+			<button type="button" className="events-toggle" onClick={onToggle}>
+				{open ? "Hide events" : "Show events"}
+			</button>
+		</div>
+	);
+}
diff --git a/app/features/scanner/components/FrameThumb.tsx b/app/features/scanner/components/FrameThumb.tsx
new file mode 100644
index 000000000..5b8364c5a
--- /dev/null
+++ b/app/features/scanner/components/FrameThumb.tsx
@@ -0,0 +1,108 @@
+/**
+ * Analyzed-frame preview in an event card's meta row. Clicking it opens the
+ * frame big in a dialog — the exact lossless frame once its lazy loader
+ * resolves, the thumbnail as a stand-in until then. The frame actions
+ * (Inspect, Save fixture) live under the dialog image.
+ */
+
+import { ExternalLink, FlaskConical } from "lucide-react";
+import { useEffect, useRef, useState } from "react";
+import { SendouButton } from "~/components/elements/Button";
+import { SendouDialog } from "~/components/elements/Dialog";
+import { type FixtureData, saveFixtureFromEvent } from "./fixture-export";
+
+export function FrameThumb({
+	thumbnail,
+	getFrame,
+	onInspect,
+	fixture,
+}: {
+	thumbnail?: string;
+	getFrame?: () => Promise<Blob | null | undefined>;
+	/** opens the frame in the screenshot page in a new browser tab */
+	onInspect?: () => void;
+	/** enables Save fixture: the event's payload and fixture type label */
+	fixture?: { data: FixtureData; type: string };
+}) {
+	const [open, setOpen] = useState(false);
+	const [frameUrl, setFrameUrl] = useState<string | null>(null);
+	const frameUrlRef = useRef<string | null>(null);
+
+	useEffect(
+		() => () => {
+			if (frameUrlRef.current) URL.revokeObjectURL(frameUrlRef.current);
+		},
+		[],
+	);
+
+	if (!thumbnail) return null;
+
+	const show = () => {
+		setOpen(true);
+		if (!getFrame || frameUrlRef.current) return;
+		void getFrame().then((frame) => {
+			if (!frame || frameUrlRef.current) return;
+			frameUrlRef.current = URL.createObjectURL(frame);
+			setFrameUrl(frameUrlRef.current);
+		});
+	};
+
+	const onSaveFixture =
+		getFrame && fixture
+			? () =>
+					void getFrame().then(
+						(frame) =>
+							frame && saveFixtureFromEvent(frame, fixture.data, fixture.type),
+					)
+			: undefined;
+
+	return (
+		<>
+			<button
+				type="button"
+				className="thumb-button"
+				title="View frame"
+				onClick={show}
+			>
+				<img className="thumb" src={thumbnail} alt="analyzed frame" />
+			</button>
+			{open ? (
+				<SendouDialog
+					isDismissable
+					aria-label="Analyzed frame"
+					className="scanner-frame-dialog"
+					onClose={() => setOpen(false)}
+				>
+					<img
+						className="frame-full"
+						src={frameUrl ?? thumbnail}
+						alt="analyzed frame"
+					/>
+					{onInspect || onSaveFixture ? (
+						<div className="frame-actions">
+							{onInspect ? (
+								<SendouButton
+									size="small"
+									icon={<ExternalLink />}
+									onPress={onInspect}
+								>
+									Inspect
+								</SendouButton>
+							) : null}
+							{onSaveFixture ? (
+								<SendouButton
+									size="small"
+									variant="outlined"
+									icon={<FlaskConical />}
+									onPress={onSaveFixture}
+								>
+									Save fixture
+								</SendouButton>
+							) : null}
+						</div>
+					) : null}
+				</SendouDialog>
+			) : null}
+		</>
+	);
+}
diff --git a/app/features/scanner/components/LivePage.tsx b/app/features/scanner/components/LivePage.tsx
new file mode 100644
index 000000000..6469744b3
--- /dev/null
+++ b/app/features/scanner/components/LivePage.tsx
@@ -0,0 +1,558 @@
+import clsx from "clsx";
+import { Camera, Ellipsis, FileText, Send, Trash2 } from "lucide-react";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { SendouButton } from "~/components/elements/Button";
+import { SendouMenu, SendouMenuItem } from "~/components/elements/Menu";
+import { ObjectiveTimeline } from "~/components/ObjectiveTimeline";
+import {
+	listVideoInputs,
+	openVirtualCamera,
+	startSampler,
+} from "../capture/sampler";
+import { connectAbilities } from "../core/ability-harvest";
+import { DEATH_EVENT_TYPE } from "../core/detectors/death/index";
+import {
+	MAP_START_EVENT_TYPE,
+	type MapStartData,
+} from "../core/detectors/map-start/index";
+import { MINIMAP_EVENT_TYPE } from "../core/detectors/minimap/index";
+import {
+	OBJECTIVE_EVENT_TYPE,
+	type ObjectiveData,
+} from "../core/detectors/objective/index";
+import { SCOREBOARD_EVENT_TYPES } from "../core/detectors/registry";
+import type { DetectedEvent, GateResult } from "../core/detectors/types";
+import type { BuiltMatch } from "../core/match-builder";
+import {
+	buildScannerMatches,
+	ingestSkipReasons,
+	invalidObjectiveEvents,
+} from "../core/match-builder";
+import { TimelineBuilder } from "../core/timeline/index";
+import {
+	clearEvents,
+	deleteEvents,
+	listEvents,
+	loadEventFrame,
+	type StoredEvent,
+	saveEvent,
+	updateEventsSend,
+} from "../store/events";
+import { AnalyzerClient } from "../worker/client";
+import { withoutRepeatEvents } from "./dedupe-events";
+import { EventCard } from "./EventCard";
+import { EventsSummary } from "./EventsSummary";
+import { downloadEventsCsv } from "./events-csv";
+import { type FixtureData, saveFixture } from "./fixture-export";
+import { MatchCard } from "./MatchCard";
+import { MatchLobbyTabs } from "./MatchLobbyTabs";
+import {
+	aggregateSendStatus,
+	matchContaining,
+	retryableUnlinkedMatches,
+	type SendouUser,
+	sendMatches,
+	unsentMatches,
+} from "./sendou-ingest";
+import { thumbnailFromBlob } from "./thumbnail";
+
+const SAMPLE_FPS = 2;
+
+/**
+ * How often a running capture rechecks whether a match sendou.ink could not
+ * link yet is due for another attempt (the backoff itself lives in
+ * sendou-ingest.ts).
+ */
+const UNLINKED_RETRY_TICK_MS = 15_000;
+
+/** The scan knows the on-screen sides only, not who is playing. */
+const SCANNER_TEAM_LABELS = ["Alpha", "Bravo"] as const;
+
+/** Event types the ingested matches are built from — the only ones with a send status. */
+const INGESTABLE_TYPES = [
+	MAP_START_EVENT_TYPE,
+	DEATH_EVENT_TYPE,
+	MINIMAP_EVENT_TYPE,
+	...SCOREBOARD_EVENT_TYPES,
+];
+
+type Status = "idle" | "loading" | "watching" | "detected" | "error";
+
+export function LivePage({
+	sendouUser,
+}: {
+	/** sendou.ink login shown in the header; undefined = probing, null = not logged in */
+	sendouUser: SendouUser | null | undefined;
+}) {
+	const videoRef = useRef<HTMLVideoElement>(null);
+	const clientRef = useRef<AnalyzerClient | null>(null);
+	const timelineRef = useRef(new TimelineBuilder());
+	const storedIdsRef = useRef(new WeakMap<DetectedEvent, number>());
+	const latestParseRef = useRef<{ type: string; data: FixtureData } | null>(
+		null,
+	);
+	const gatesRef = useRef(new Map<string, GateResult>());
+	const stopRef = useRef<(() => void) | null>(null);
+	const retryTimerRef = useRef<ReturnType<typeof setInterval> | null>(null);
+	// the open match is known to be a non-SZ mode, so counter reads are
+	// misreads of another mode's overlay and are not collected at all
+	const objectiveBlockedRef = useRef(false);
+
+	const [devices, setDevices] = useState<MediaDeviceInfo[]>([]);
+	const [deviceId, setDeviceId] = useState<string>("");
+	const [status, setStatus] = useState<Status>("idle");
+	const [gateScore, setGateScore] = useState<number | null>(null);
+	const [error, setError] = useState<string | null>(null);
+	const [feed, setFeed] = useState<StoredEvent[]>([]);
+	const [running, setRunning] = useState(false);
+	const [sendouError, setSendouError] = useState<string | null>(null);
+	const [eventsOpen, setEventsOpen] = useState(false);
+	const [liveSend, setLiveSend] = useState(false);
+	const liveSendRef = useRef(false);
+	const sendingRef = useRef(false);
+
+	const refreshFeed = useCallback(() => {
+		void (async () => {
+			const events = await listEvents();
+			// objective reads grouped into a known non-SZ match slipped past the
+			// live block (e.g. the mode read arrived after them) — delete them
+			const invalid = new Set(
+				invalidObjectiveEvents(buildScannerMatches(events)),
+			);
+			if (invalid.size > 0) {
+				await deleteEvents(
+					[...invalid]
+						.map((event) => event.id)
+						.filter((id): id is number => id !== undefined),
+				);
+			}
+			setFeed(
+				events
+					.filter((event) => !invalid.has(event))
+					.sort(
+						(a, b) => b.detectedAt - a.detectedAt || (b.id ?? 0) - (a.id ?? 0),
+					),
+			);
+		})();
+	}, []);
+
+	useEffect(() => {
+		refreshFeed();
+		return () => {
+			stopRef.current?.();
+			if (retryTimerRef.current) clearInterval(retryTimerRef.current);
+			clientRef.current?.dispose();
+		};
+	}, [refreshFeed]);
+
+	/** Sends the matches `include` selects; serialized so sends never overlap. */
+	const send = async (
+		include: (built: BuiltMatch<StoredEvent>) => boolean,
+		{ manual = false } = {},
+	) => {
+		if (sendingRef.current) return;
+		sendingRef.current = true;
+		if (manual) setSendouError(null);
+		try {
+			const events = await listEvents();
+			const { sentMatches, failedMatches } = await sendMatches({
+				events,
+				include,
+				onStatus: refreshFeed,
+			});
+			if (manual && sentMatches + failedMatches === 0) {
+				setSendouError("nothing to send — no complete match selected");
+			}
+		} finally {
+			sendingRef.current = false;
+			refreshFeed();
+		}
+	};
+
+	/** `withLiveSend`: send each match to sendou.ink as it closes. */
+	const start = async (withLiveSend: boolean) => {
+		setError(null);
+		setSendouError(null);
+		setStatus("loading");
+		liveSendRef.current = withLiveSend;
+		setLiveSend(withLiveSend);
+		// a restart may land mid-another-match; collect until its mode is known
+		objectiveBlockedRef.current = false;
+		try {
+			const video = videoRef.current!;
+			const stream = await openVirtualCamera(deviceId || undefined);
+			video.srcObject = stream;
+			await video.play();
+			setDevices(await listVideoInputs());
+
+			clientRef.current ??= new AnalyzerClient(
+				(result) => {
+					// one result arrives per detector per frame; status reflects
+					// whether any of them fired
+					gatesRef.current.set(result.detector, result.gate);
+					const gates = [...gatesRef.current.values()];
+					setGateScore(Math.max(...gates.map((g) => g.score)));
+					if (!result.gate.pass) {
+						if (!gates.some((g) => g.pass)) setStatus("watching");
+						return;
+					}
+					setStatus("detected");
+					for (const event of result.events as DetectedEvent<FixtureData>[]) {
+						latestParseRef.current = { type: event.type, data: event.data };
+						if (
+							event.type === OBJECTIVE_EVENT_TYPE &&
+							objectiveBlockedRef.current
+						) {
+							continue;
+						}
+						const action = timelineRef.current.push(event);
+						if (action.action === "added" || action.action === "replaced") {
+							if (event.type === MAP_START_EVENT_TYPE) {
+								const mode = (event.data as MapStartData).mode;
+								objectiveBlockedRef.current = mode !== null && mode !== "SZ";
+							} else if (SCOREBOARD_EVENT_TYPES.includes(event.type)) {
+								objectiveBlockedRef.current = false;
+							}
+							const stale =
+								action.action === "replaced"
+									? storedIdsRef.current.get(action.replaced)
+									: undefined;
+							void (async () => {
+								const thumbnail = result.frame
+									? await thumbnailFromBlob(result.frame)
+									: undefined;
+								// reusing the replaced event's id keeps match card keys
+								// stable, so repeat detections don't remount the cards
+								const id = await saveEvent(
+									event,
+									thumbnail,
+									result.frame,
+									stale,
+								);
+								storedIdsRef.current.set(event, id);
+								if (
+									liveSendRef.current &&
+									INGESTABLE_TYPES.includes(event.type)
+								) {
+									if (SCOREBOARD_EVENT_TYPES.includes(event.type)) {
+										// a scoreboard closes its match — send it
+										refreshFeed();
+										await send(
+											(built) =>
+												matchContaining(id)(built) && unsentMatches(built),
+										);
+									} else {
+										await updateEventsSend([id], {
+											state: "queued",
+											at: Date.now(),
+										});
+									}
+								}
+								refreshFeed();
+							})();
+						}
+					}
+				},
+				(message) => {
+					setError(message);
+					setStatus("error");
+				},
+			);
+			await clientRef.current.whenReady();
+
+			stopRef.current = startSampler(video, SAMPLE_FPS, (bitmap, t) => {
+				clientRef.current?.analyze(bitmap, t);
+			});
+			// a match sent the moment its scoreboard closed usually beats the
+			// players to reporting the game, so sendou.ink had nothing to link
+			// it to; give those another go while the capture runs
+			retryTimerRef.current ??= setInterval(() => {
+				if (liveSendRef.current) void send(retryableUnlinkedMatches);
+			}, UNLINKED_RETRY_TICK_MS);
+			setStatus("watching");
+			setRunning(true);
+		} catch (e) {
+			setError(String(e));
+			setStatus("error");
+		}
+	};
+
+	const builtMatches = buildScannerMatches(feed);
+	const skipReasons = ingestSkipReasons(builtMatches);
+	const groupedEvents = new Set(builtMatches.flatMap((b) => b.sources));
+	const ungroupedFeed = feed.filter((e) => !groupedEvents.has(e));
+	const abilityMap = connectAbilities(feed);
+
+	const stop = () => {
+		stopRef.current?.();
+		stopRef.current = null;
+		if (retryTimerRef.current) clearInterval(retryTimerRef.current);
+		retryTimerRef.current = null;
+		const video = videoRef.current;
+		if (video?.srcObject instanceof MediaStream) {
+			for (const track of video.srcObject.getTracks()) track.stop();
+			video.srcObject = null;
+		}
+		setRunning(false);
+		setStatus("idle");
+		// the scan ending is the last match boundary — flush what's unsent
+		// (partials are safe: the server merges them into fuller resends)
+		if (liveSendRef.current) void send(unsentMatches);
+		liveSendRef.current = false;
+		setLiveSend(false);
+	};
+
+	return (
+		<div>
+			<div className="controls">
+				{!running ? (
+					<>
+						<button
+							type="button"
+							disabled={!sendouUser}
+							title={sendouUser ? undefined : "Log in on sendou.ink first"}
+							onClick={() => void start(true)}
+						>
+							<Send aria-hidden />
+							Start capture
+						</button>
+						<button
+							type="button"
+							className="outlined"
+							onClick={() => void start(false)}
+						>
+							Start capture (no sending)
+						</button>
+					</>
+				) : (
+					<>
+						<button type="button" onClick={stop}>
+							Stop
+						</button>
+						<button
+							type="button"
+							className="outlined"
+							disabled={!sendouUser}
+							title={sendouUser ? undefined : "Log in on sendou.ink first"}
+							onClick={() => {
+								liveSendRef.current = !liveSend;
+								setLiveSend(!liveSend);
+							}}
+						>
+							<Send aria-hidden />
+							{liveSend ? "Stop sending" : "Start sending"}
+						</button>
+					</>
+				)}
+				<select value={deviceId} onChange={(e) => setDeviceId(e.target.value)}>
+					<option value="">Default camera (OBS Virtual Camera)</option>
+					{devices.map((d) => (
+						<option key={d.deviceId} value={d.deviceId}>
+							{d.label || d.deviceId.slice(0, 8)}
+						</option>
+					))}
+				</select>
+				<span
+					className={clsx("status", {
+						detected: status === "detected",
+						watching: status === "watching",
+						idle: status !== "detected" && status !== "watching",
+					})}
+				>
+					{status}
+					{gateScore !== null ? ` · gate ${gateScore.toFixed(2)}` : null}
+				</span>
+				{liveSend ? (
+					<span className="status watching">sending matches live</span>
+				) : null}
+				<LiveMenu
+					canSaveFixture={running}
+					canSend={Boolean(sendouUser) && feed.length > 0}
+					hasEvents={feed.length > 0}
+					onSaveFixture={() =>
+						void saveFixture(videoRef.current!, latestParseRef.current)
+					}
+					onDownloadCsv={() =>
+						downloadEventsCsv(
+							`live-events-${new Date().toISOString().slice(0, 19).replaceAll(":", "-")}.csv`,
+							// feed is newest-first for display; export in chronological order
+							feed.toSorted(
+								(a, b) =>
+									a.detectedAt - b.detectedAt || (a.id ?? 0) - (b.id ?? 0),
+							),
+						)
+					}
+					onSendUnsent={() => void send(unsentMatches, { manual: true })}
+					onClearFeed={() => {
+						if (!window.confirm("Clear all detected events?")) return;
+						void clearEvents().then(refreshFeed);
+					}}
+				/>
+			</div>
+			{error ? <p className="error">{error}</p> : null}
+			{sendouError ? <p className="error">{sendouError}</p> : null}
+			<div className="live-layout">
+				<video ref={videoRef} className="preview" muted playsInline />
+				<div className="feed">
+					{feed.length === 0 ? (
+						<p className="score">No detections yet.</p>
+					) : null}
+					<MatchLobbyTabs
+						matches={builtMatches}
+						keyOf={(built) => built.sources[0]!.id!}
+						renderMatch={(built, justFormed) => {
+							const id = built.sources[0]!.id!;
+							const skipReason = skipReasons.get(built);
+							// counter reads render as one timeline chart, not a card each;
+							// a non-SZ match's reads (objective null) are never shown
+							const objectiveEvents = built.match.objective
+								? built.sources
+										.filter((e) => e.type === OBJECTIVE_EVENT_TYPE)
+										.map((e) => ({ t: e.t, data: e.data as ObjectiveData }))
+								: [];
+							const cardEvents = withoutRepeatEvents(built.sources).filter(
+								(e) => e.type !== OBJECTIVE_EVENT_TYPE,
+							);
+							const newest = built === builtMatches.at(-1);
+							return (
+								<MatchCard
+									match={built.match}
+									live={running && newest && built.match.winner === null}
+									inProgress={newest && built.match.winner === null}
+									skipReason={skipReason}
+									justFormed={justFormed}
+									send={aggregateSendStatus(built.sources)}
+									onSend={
+										sendouUser && !skipReason
+											? () => void send(matchContaining(id), { manual: true })
+											: undefined
+									}
+								>
+									{objectiveEvents.length > 0 ? (
+										<ObjectiveTimeline
+											events={objectiveEvents}
+											teamLabels={SCANNER_TEAM_LABELS}
+										/>
+									) : null}
+									{cardEvents.map((e) => (
+										<EventCard
+											key={e.id}
+											type={e.type}
+											t={e.t}
+											confidence={e.confidence}
+											data={e.data as FixtureData}
+											abilities={abilityMap.get(e)}
+											thumbnail={e.thumbnail}
+											detectedAt={e.detectedAt}
+											getFrame={
+												e.hasFrame && e.id !== undefined
+													? () => loadEventFrame(e.id!)
+													: undefined
+											}
+										/>
+									))}
+								</MatchCard>
+							);
+						}}
+					/>
+					{ungroupedFeed.length > 0 ? (
+						<EventsSummary
+							events={ungroupedFeed}
+							open={eventsOpen}
+							onToggle={() => setEventsOpen(!eventsOpen)}
+						/>
+					) : null}
+					{eventsOpen
+						? ungroupedFeed.map((e) => (
+								<EventCard
+									key={e.id}
+									type={e.type}
+									t={e.t}
+									confidence={e.confidence}
+									data={e.data as FixtureData}
+									abilities={abilityMap.get(e)}
+									thumbnail={e.thumbnail}
+									detectedAt={e.detectedAt}
+									getFrame={
+										e.hasFrame && e.id !== undefined
+											? () => loadEventFrame(e.id!)
+											: undefined
+									}
+									send={e.send}
+									onSend={
+										sendouUser &&
+										e.id !== undefined &&
+										INGESTABLE_TYPES.includes(e.type)
+											? () =>
+													void send(matchContaining(e.id!), { manual: true })
+											: undefined
+									}
+								/>
+							))
+						: null}
+				</div>
+			</div>
+		</div>
+	);
+}
+
+/** The capture's occasional actions, behind one icon-only menu. */
+function LiveMenu({
+	canSaveFixture,
+	canSend,
+	hasEvents,
+	onSaveFixture,
+	onDownloadCsv,
+	onSendUnsent,
+	onClearFeed,
+}: {
+	canSaveFixture: boolean;
+	canSend: boolean;
+	hasEvents: boolean;
+	onSaveFixture: () => void;
+	onDownloadCsv: () => void;
+	onSendUnsent: () => void;
+	onClearFeed: () => void;
+}) {
+	return (
+		<SendouMenu
+			trigger={
+				<SendouButton
+					icon={<Ellipsis />}
+					className="icon-menu"
+					aria-label="More actions"
+				/>
+			}
+		>
+			<SendouMenuItem
+				icon={<Camera />}
+				isDisabled={!canSaveFixture}
+				onAction={onSaveFixture}
+			>
+				Save frame as fixture
+			</SendouMenuItem>
+			<SendouMenuItem
+				icon={<FileText />}
+				isDisabled={!hasEvents}
+				onAction={onDownloadCsv}
+			>
+				CSV
+			</SendouMenuItem>
+			<SendouMenuItem
+				icon={<Send />}
+				isDisabled={!canSend}
+				onAction={onSendUnsent}
+			>
+				Send unsent to sendou.ink
+			</SendouMenuItem>
+			<SendouMenuItem
+				icon={<Trash2 />}
+				isDestructive
+				isDisabled={!hasEvents}
+				onAction={onClearFeed}
+			>
+				Clear feed
+			</SendouMenuItem>
+		</SendouMenu>
+	);
+}
diff --git a/app/features/scanner/components/MapStartCard.tsx b/app/features/scanner/components/MapStartCard.tsx
new file mode 100644
index 000000000..d0a65c363
--- /dev/null
+++ b/app/features/scanner/components/MapStartCard.tsx
@@ -0,0 +1,45 @@
+import {
+	MAP_START_EVENT_TYPE,
+	type MapStartData,
+} from "../core/detectors/map-start/index";
+import { FrameThumb } from "./FrameThumb";
+import { useEventTimeFormatter } from "./format";
+import { modeLabel, stageLabel } from "./labels";
+import { MetaPills } from "./MetaChips";
+
+export function MapStartCard(props: {
+	t: number;
+	confidence: number;
+	data: MapStartData;
+	thumbnail?: string;
+	detectedAt?: number;
+	/** lazy loader for the exact analyzed frame — enables fixture export */
+	getFrame?: () => Promise<Blob | null | undefined>;
+	onInspect?: () => void;
+}) {
+	const { t, confidence, data, thumbnail, detectedAt, getFrame, onInspect } =
+		props;
+	const formatDetectedAt = useEventTimeFormatter();
+	return (
+		<div className="card">
+			<div className="meta">
+				<MetaPills
+					t={t}
+					confidence={confidence}
+					type={MAP_START_EVENT_TYPE}
+					label="map start"
+				/>
+				<span>
+					<b>{modeLabel(data.mode) ?? "?"}</b> · {stageLabel(data.stage) ?? "?"}
+				</span>
+				{detectedAt ? <span>{formatDetectedAt(detectedAt)}</span> : null}
+				<FrameThumb
+					thumbnail={thumbnail}
+					getFrame={getFrame}
+					onInspect={onInspect}
+					fixture={{ data, type: "MapStart" }}
+				/>
+			</div>
+		</div>
+	);
+}
diff --git a/app/features/scanner/components/MatchCard.tsx b/app/features/scanner/components/MatchCard.tsx
new file mode 100644
index 000000000..b0acf8f18
--- /dev/null
+++ b/app/features/scanner/components/MatchCard.tsx
@@ -0,0 +1,344 @@
+/**
+ * Glanceable card for one ScannerMatch in the live feed: stage banner
+ * background, mode + stage, score, team weapons, and the match's /ingest
+ * status. Expanding the card reveals the source event cards below it,
+ * so the raw per-event view stays one click away.
+ */
+
+import clsx from "clsx";
+import { ChevronDown } from "lucide-react";
+import type * as React from "react";
+import { useState } from "react";
+import { SendouButton } from "~/components/elements/Button";
+import { ModeImage, WeaponImage } from "~/components/Image";
+import { matchScoresFromObjective } from "~/components/objective-timeline-utils";
+import { StageBannerBox } from "~/components/StageBannerBox";
+import type { IngestedMatchLink } from "~/features/scanner-ingest/scanner-ingest-schemas";
+import type { MainWeaponId } from "~/modules/in-game-lists/types";
+import { sendouQMatchPage, tournamentMatchPage } from "~/utils/urls";
+import type { IngestSkipReason } from "../core/match-builder";
+import type { ScannerMatch } from "../core/scanner-match";
+import type { SendStatus } from "../store/events";
+import { formatTime, useEventTimeFormatter } from "./format";
+import { lobbyLabel, modeLabel, stageLabel } from "./labels";
+
+/** the game score a knockout wins at */
+const KO_MATCH_SCORE = 100;
+
+const SEND_CHIP_LABELS: Record<Exclude<SendStatus["state"], "sent">, string> = {
+	queued: "queued",
+	sending: "sending…",
+	unlinked: "waiting for report",
+	failed: "failed",
+};
+
+export function MatchCard({
+	match,
+	send,
+	onSend,
+	live = false,
+	inProgress = false,
+	skipReason,
+	justFormed = false,
+	children,
+}: {
+	match: ScannerMatch;
+	/** the match's /ingest status, aggregated from its source events */
+	send?: SendStatus;
+	/** when set, shows a Send/Retry button for this match */
+	onSend?: () => void;
+	/** still being played: no closing scoreboard yet and the scan is running */
+	live?: boolean;
+	/**
+	 * the newest match, still being formulated (no result yet) — shows an
+	 * "in progress" chip in the score slot; at most one card should get this
+	 */
+	inProgress?: boolean;
+	/** set = ingestSkipReasons held the match back from /ingest */
+	skipReason?: IngestSkipReason;
+	/** the scan just formed this match — play the enter animation */
+	justFormed?: boolean;
+	/** expandable detail content, typically the source event cards */
+	children?: React.ReactNode;
+}) {
+	const [expanded, setExpanded] = useState(false);
+	// fixed at mount: re-rendering must not cut the animation short, and a card
+	// remounting for another reason (switching lobby tabs) must not replay it
+	const [enter] = useState(justFormed);
+
+	// one-shot flash animations only on a state *change*, so already-sent
+	// matches don't replay the glow on every mount
+	const [prevSendState, setPrevSendState] = useState(send?.state);
+	const [flash, setFlash] = useState<"sent" | "failed" | null>(null);
+	if (prevSendState !== send?.state) {
+		setPrevSendState(send?.state);
+		setFlash(
+			send?.state === "sent" || send?.state === "failed" ? send.state : null,
+		);
+	}
+
+	const meta = [
+		modeLabel(match.mode),
+		skipReason === "lobby" ? lobbyLabel(match.lobby) : null,
+		match.startsAt !== null ? timeRangeLabel(match) : null,
+		match.replayCode,
+		match.cast ? "cast" : null,
+	]
+		.filter(Boolean)
+		.join(" · ");
+
+	const inner = (
+		<>
+			<div className="match-card-main">
+				{match.mode !== null ? (
+					<ModeImage mode={match.mode} size={30} className="match-mode" />
+				) : null}
+				<div className="match-headline">
+					<div className="match-title">
+						<div className="match-stage">
+							{stageLabel(match.stage) ?? "Unknown stage"}
+						</div>
+						<StatusChip send={send} skipReason={skipReason} live={live} />
+					</div>
+					{meta ? <div className="match-meta">{meta}</div> : null}
+					<TeamWeapons match={match} />
+				</div>
+				<div className="match-side">
+					{live ? (
+						<span className="match-chip live">
+							<span className="dot" />
+							live
+						</span>
+					) : (
+						<Score match={match} inProgress={inProgress} />
+					)}
+					{onSend && send?.state !== "sent" && send?.state !== "sending" ? (
+						<button type="button" onClick={onSend}>
+							{send?.state === "failed" || send?.state === "unlinked"
+								? "Retry"
+								: "Send"}
+						</button>
+					) : null}
+					{children ? (
+						<SendouButton
+							variant="minimal"
+							size="small"
+							shape="circle"
+							icon={<ChevronDown />}
+							className={clsx("match-expand", { expanded })}
+							aria-expanded={expanded}
+							aria-label={expanded ? "Hide events" : "Show events"}
+							onPress={() => setExpanded(!expanded)}
+						/>
+					) : null}
+				</div>
+			</div>
+			{send?.state === "failed" && send.error ? (
+				<div className="match-error">{send.error}</div>
+			) : null}
+		</>
+	);
+
+	const className = clsx("match-card", send?.state, {
+		enter,
+		live,
+		"flash-sent": flash === "sent",
+		"flash-failed": flash === "failed",
+	});
+
+	const card =
+		match.stage !== null ? (
+			<StageBannerBox stageId={match.stage} className={className}>
+				{inner}
+			</StageBannerBox>
+		) : (
+			<div className={className}>{inner}</div>
+		);
+
+	if (!children) return card;
+	return (
+		<div className="match-card-group">
+			{card}
+			{expanded ? <div className="match-events">{children}</div> : null}
+		</div>
+	);
+}
+
+/** Labeled rule above the newest card of each set in the feed. */
+export function SetDivider({ number }: { number: number }) {
+	return <div className="set-divider">Set {number}</div>;
+}
+
+function timeRangeLabel(match: ScannerMatch): string {
+	const start = formatTime(match.startsAt!);
+	return match.endsAt !== null && match.endsAt !== match.startsAt
+		? `${start}–${formatTime(match.endsAt)}`
+		: start;
+}
+
+function Score({
+	match,
+	inProgress,
+}: {
+	match: ScannerMatch;
+	inProgress: boolean;
+}) {
+	if (match.matchScores === null) {
+		if (!inProgress) return null;
+		return (
+			<span className="match-chip in-progress">
+				<span className="dot" />
+				in progress
+			</span>
+		);
+	}
+	const [alpha, bravo] = match.matchScores;
+	const objectiveScores = matchScoresFromObjective(
+		match.objective?.samples ?? [],
+	);
+
+	// scoreboard-sourced matches list the winners first
+	const winnerKnown = match.winner !== null;
+	return (
+		<div className="match-score">
+			<span className={winnerKnown ? "win" : undefined}>
+				{scoreLabel(alpha, objectiveScores[0])}
+			</span>
+			<span className="sep"> – </span>
+			<span className={winnerKnown ? "lose" : undefined}>
+				{scoreLabel(bravo, objectiveScores[1])}
+			</span>
+		</div>
+	);
+}
+
+/**
+ * A 100 only happens on a knockout, shown the way players say it. A knockout's
+ * loser gets no score of its own, so the objective counter's last read stands
+ * in — parenthesized, since the scan read it off the video and may have lost
+ * sight of the counter before the game ended.
+ */
+function scoreLabel(
+	score: number | null,
+	objectiveScore: number | null,
+): string {
+	if (score !== null && score > 0) {
+		return score === KO_MATCH_SCORE ? "KO" : String(score);
+	}
+	if (objectiveScore !== null) {
+		return objectiveScore === KO_MATCH_SCORE ? "(KO)" : `(${objectiveScore})`;
+	}
+
+	return score === null ? "?" : String(score);
+}
+
+interface TeamWeapon {
+	weaponId: MainWeaponId;
+	/** the scan's own player — highlighted among the eight */
+	pov: boolean;
+}
+
+function TeamWeapons({ match }: { match: ScannerMatch }) {
+	const weaponsOf = (team: 0 | 1): TeamWeapon[] =>
+		match.teams[team].players
+			.map((player, index) => ({
+				weaponId: player.weaponId,
+				pov: match.pov?.team === team && match.pov.index === index,
+			}))
+			.filter((weapon): weapon is TeamWeapon => weapon.weaponId !== null);
+	const alpha = weaponsOf(0);
+	const bravo = weaponsOf(1);
+	if (alpha.length + bravo.length === 0) return null;
+
+	return (
+		<div className="match-weapons">
+			{alpha.length > 0 ? <WeaponRow weapons={alpha} /> : null}
+			{alpha.length > 0 && bravo.length > 0 ? (
+				<span className="vs">vs</span>
+			) : null}
+			{bravo.length > 0 ? <WeaponRow weapons={bravo} /> : null}
+		</div>
+	);
+}
+
+/** One team's weapons, kept together when the card is too narrow for both. */
+function WeaponRow({ weapons }: { weapons: TeamWeapon[] }) {
+	return (
+		<div className="weapon-row">
+			{weapons.map((weapon, i) => (
+				<WeaponImage
+					key={i}
+					weaponSplId={weapon.weaponId}
+					variant="build"
+					size={22}
+					className={clsx("weapon-icon", { pov: weapon.pov })}
+				/>
+			))}
+		</div>
+	);
+}
+
+function StatusChip({
+	send,
+	skipReason,
+	live,
+}: {
+	send?: SendStatus;
+	skipReason?: IngestSkipReason;
+	live: boolean;
+}) {
+	const formatSentAt = useEventTimeFormatter();
+	if (skipReason) {
+		return (
+			<span className="match-chip">
+				{skipReason === "disconnect" ? "disconnect" : "not ingested"}
+			</span>
+		);
+	}
+	if (send?.state === "sent") {
+		return (
+			<span
+				className="match-chip sent"
+				title={`ingested ${formatSentAt(send.at)}`}
+			>
+				✓
+				{send.link ? (
+					<a
+						href={ingestedMatchUrl(send.link)}
+						target="_blank"
+						rel="noreferrer"
+					>
+						{ingestedMatchLabel(send.link)}
+					</a>
+				) : null}
+			</span>
+		);
+	}
+	if (send) {
+		return (
+			<span className={clsx("match-chip", send.state)} title={send.error}>
+				{send.state === "queued" || send.state === "sending" ? (
+					<span className="dot" />
+				) : null}
+				{SEND_CHIP_LABELS[send.state]}
+			</span>
+		);
+	}
+	if (live) return null;
+	return <span className="match-chip">not sent</span>;
+}
+
+function ingestedMatchUrl(link: IngestedMatchLink): string {
+	return link.type === "tournament"
+		? tournamentMatchPage({
+				tournamentId: link.tournamentId,
+				matchId: link.matchId,
+			})
+		: sendouQMatchPage(link.groupMatchId);
+}
+
+function ingestedMatchLabel(link: IngestedMatchLink): string {
+	return link.type === "tournament"
+		? `Match ID #${link.matchId}`
+		: `SQ Match ID #${link.groupMatchId}`;
+}
diff --git a/app/features/scanner/components/MatchLobbyTabs.tsx b/app/features/scanner/components/MatchLobbyTabs.tsx
new file mode 100644
index 000000000..5b4d1d1c6
--- /dev/null
+++ b/app/features/scanner/components/MatchLobbyTabs.tsx
@@ -0,0 +1,137 @@
+/**
+ * Lobby tabs over the match feed: private battles (the games /ingest cares
+ * about) split from X Battles and everything else, so a scan that picked up
+ * ranked play between tournament sets stays readable. Sets are a private
+ * battle concept — consecutive games between the same two teams — so only
+ * that tab gets set dividers, and set numbers are assigned within the tab.
+ */
+
+import { Fragment, useEffect, useRef } from "react";
+import {
+	SendouTab,
+	SendouTabList,
+	SendouTabPanel,
+	SendouTabs,
+} from "~/components/elements/Tabs";
+import type { DetectedEvent } from "../core/detectors/types";
+import type { BuiltMatch } from "../core/match-builder";
+import { assignMatchSets } from "../core/match-sets";
+import type { ScannerLobby } from "../scanner-types";
+import { SetDivider } from "./MatchCard";
+
+type LobbyGroup = "private" | "x" | "other";
+
+const LOBBY_GROUPS: LobbyGroup[] = ["private", "x", "other"];
+
+const LOBBY_GROUP_LABELS: Record<LobbyGroup, string> = {
+	private: "Private Battle",
+	x: "X Battle",
+	other: "Other",
+};
+
+const NO_KEYS: ReadonlySet<React.Key> = new Set();
+
+export function MatchLobbyTabs<E extends DetectedEvent>({
+	matches,
+	keyOf,
+	renderMatch,
+}: {
+	/** built matches in chronological order (oldest first) */
+	matches: readonly BuiltMatch<E>[];
+	/** stable render key for one match, typically its first source event's id */
+	keyOf: (built: BuiltMatch<E>) => React.Key;
+	/** `justFormed`: the match appeared while the page was open (enter animation) */
+	renderMatch: (built: BuiltMatch<E>, justFormed: boolean) => React.ReactNode;
+}) {
+	const justFormedKeys = useJustFormedKeys(matches.map(keyOf));
+
+	const groups = LOBBY_GROUPS.map((group) => ({
+		group,
+		matches: matches.filter((built) => lobbyGroup(built.match.lobby) === group),
+	})).filter(({ matches: groupMatches }) => groupMatches.length > 0);
+
+	if (groups.length === 0) return null;
+
+	return (
+		<SendouTabs>
+			<SendouTabList>
+				{groups.map(({ group, matches: groupMatches }) => (
+					<SendouTab key={group} id={group} number={groupMatches.length}>
+						{LOBBY_GROUP_LABELS[group]}
+					</SendouTab>
+				))}
+			</SendouTabList>
+			{groups.map(({ group, matches: groupMatches }) => (
+				<SendouTabPanel key={group} id={group} className="match-list">
+					<MatchList
+						matches={groupMatches}
+						sets={group === "private"}
+						keyOf={keyOf}
+						justFormedKeys={justFormedKeys}
+						renderMatch={renderMatch}
+					/>
+				</SendouTabPanel>
+			))}
+		</SendouTabs>
+	);
+}
+
+function lobbyGroup(lobby: ScannerLobby | null): LobbyGroup {
+	if (lobby === "PRIVATE") return "private";
+	if (lobby === "X") return "x";
+	return "other";
+}
+
+/**
+ * Keys of the matches that showed up since the previous render — the ones a
+ * scan just formed. A list arriving whole (the live feed loaded from storage,
+ * a saved VoD opened) is not "just formed": every card would animate in at
+ * once for something the user did not watch happen.
+ */
+function useJustFormedKeys(keys: React.Key[]): ReadonlySet<React.Key> {
+	const seenRef = useRef<Set<React.Key> | null>(null);
+	const seen = seenRef.current;
+
+	// after commit, not during render: under StrictMode the render runs twice
+	// and the second pass would find every key already seen
+	useEffect(() => {
+		seenRef.current = new Set(keys);
+	});
+
+	if (seen === null) return NO_KEYS;
+	const justFormed = keys.filter((key) => !seen.has(key));
+	return justFormed.length === keys.length && keys.length > 1
+		? NO_KEYS
+		: new Set(justFormed);
+}
+
+function MatchList<E extends DetectedEvent>({
+	matches,
+	sets,
+	keyOf,
+	justFormedKeys,
+	renderMatch,
+}: {
+	matches: readonly BuiltMatch<E>[];
+	sets: boolean;
+	keyOf: (built: BuiltMatch<E>) => React.Key;
+	justFormedKeys: ReadonlySet<React.Key>;
+	renderMatch: (built: BuiltMatch<E>, justFormed: boolean) => React.ReactNode;
+}) {
+	const setNumbers = sets ? assignMatchSets(matches.map((b) => b.match)) : [];
+	const showSetDividers = (setNumbers.at(-1) ?? 1) > 1;
+
+	// newest match on top; the builder keeps ascending time order
+	return [...matches].reverse().map((built, reverseIndex) => {
+		const index = matches.length - 1 - reverseIndex;
+		const key = keyOf(built);
+		return (
+			<Fragment key={key}>
+				{showSetDividers && setNumbers[index + 1] !== setNumbers[index] ? (
+					<SetDivider number={setNumbers[index]!} />
+				) : null}
+				{renderMatch(built, justFormedKeys.has(key))}
+			</Fragment>
+		);
+	});
+}
diff --git a/app/features/scanner/components/MetaChips.tsx b/app/features/scanner/components/MetaChips.tsx
new file mode 100644
index 000000000..a881c97de
--- /dev/null
+++ b/app/features/scanner/components/MetaChips.tsx
@@ -0,0 +1,38 @@
+/**
+ * The pill group every event card's meta row opens with: video timestamp,
+ * detection confidence and the event type, kept tight together so the free-form
+ * detail text that follows reads as a separate group.
+ */
+
+import { Clock, Gauge } from "lucide-react";
+import { EventTypeIcon } from "./EventTypeIcon";
+import { formatTime } from "./format";
+
+export function MetaPills({
+	t,
+	confidence,
+	type,
+	label,
+}: {
+	t: number;
+	confidence: number;
+	type: string;
+	label: string;
+}) {
+	return (
+		<div className="meta-pills">
+			<span className="meta-chip" title="Video timestamp">
+				<Clock size={12} aria-hidden className="meta-chip-icon" />
+				{formatTime(t)}
+			</span>
+			<span className="meta-chip" title="Detection confidence">
+				<Gauge size={12} aria-hidden className="meta-chip-icon" />
+				{(confidence * 100).toFixed(0)}%
+			</span>
+			<span className="status detected">
+				<EventTypeIcon type={type} />
+				{label}
+			</span>
+		</div>
+	);
+}
diff --git a/app/features/scanner/components/MinimapCard.tsx b/app/features/scanner/components/MinimapCard.tsx
new file mode 100644
index 000000000..50c38489d
--- /dev/null
+++ b/app/features/scanner/components/MinimapCard.tsx
@@ -0,0 +1,140 @@
+import { ChevronUp } from "lucide-react";
+import type { ReactNode } from "react";
+import { Ability } from "~/components/Ability";
+import { WeaponImage } from "~/components/Image";
+import type { AbilityWithUnknown } from "~/modules/in-game-lists/types";
+import {
+	MINIMAP_EVENT_TYPE,
+	type MinimapData,
+	type MinimapEnemy,
+	type MinimapTeammate,
+} from "../core/detectors/minimap/index";
+import type { CardSlot } from "../core/detectors/minimap/rois";
+import { FrameThumb } from "./FrameThumb";
+import { useEventTimeFormatter } from "./format";
+import { stageLabel } from "./labels";
+import { MetaPills } from "./MetaChips";
+
+const ENEMY_SLOT_LETTERS = ["A", "B", "X", "Y"] as const;
+
+function AbilityRow({
+	abilities,
+}: {
+	abilities: (AbilityWithUnknown | null)[];
+}) {
+	return (
+		<>
+			{abilities.map((id, i) =>
+				id ? (
+					<Ability key={i} ability={id} size="TINY" />
+				) : (
+					<span key={i} title="unreadable badge">
+						?
+					</span>
+				),
+			)}
+		</>
+	);
+}
+
+function TeammateMarker({ slot }: { slot: CardSlot }) {
+	if (slot === "self") {
+		return <span className="slot-marker">●</span>;
+	}
+	return (
+		<span className={`slot-marker ${slot}`}>
+			<ChevronUp strokeWidth={3.5} aria-label={slot} role="img" />
+		</span>
+	);
+}
+
+function PlayerRow({
+	marker,
+	player,
+}: {
+	marker: ReactNode;
+	player: MinimapTeammate | MinimapEnemy;
+}) {
+	return (
+		<div className="minimap-player">
+			{marker}
+			{player.weaponId !== null ? (
+				<WeaponImage
+					weaponSplId={player.weaponId}
+					variant="build"
+					size={24}
+					className="weapon-icon"
+				/>
+			) : (
+				<span className="weapon-missing">?</span>
+			)}
+			<span className="name">{player.name ?? ""}</span>
+			<span className="abilities">
+				<AbilityRow abilities={player.abilities} />
+			</span>
+		</div>
+	);
+}
+
+export function MinimapCard(props: {
+	t: number;
+	confidence: number;
+	data: MinimapData;
+	thumbnail?: string;
+	detectedAt?: number;
+	/** lazy loader for the exact analyzed frame — enables fixture export */
+	getFrame?: () => Promise<Blob | null | undefined>;
+	onInspect?: () => void;
+}) {
+	const { t, confidence, data, thumbnail, detectedAt, getFrame, onInspect } =
+		props;
+	const formatDetectedAt = useEventTimeFormatter();
+	return (
+		<div className="card">
+			<div className="meta">
+				<MetaPills
+					t={t}
+					confidence={confidence}
+					type={MINIMAP_EVENT_TYPE}
+					label="minimap"
+				/>
+				{data.stage !== null ? <span>{stageLabel(data.stage)}</span> : null}
+				{detectedAt ? <span>{formatDetectedAt(detectedAt)}</span> : null}
+				<FrameThumb
+					thumbnail={thumbnail}
+					getFrame={getFrame}
+					onInspect={onInspect}
+					fixture={{ data, type: "Minimap" }}
+				/>
+			</div>
+			<div className="teams">
+				<div className="team">
+					<h3>Team</h3>
+					{data.teammates.map((p) => (
+						<PlayerRow
+							key={p.slot}
+							marker={<TeammateMarker slot={p.slot} />}
+							player={p}
+						/>
+					))}
+				</div>
+				{data.enemies.length > 0 ? (
+					<div className="team">
+						<h3>Enemies</h3>
+						{data.enemies.map((p, i) => (
+							<PlayerRow
+								key={i}
+								marker={
+									<span className="slot-marker">
+										{ENEMY_SLOT_LETTERS[i] ?? i + 1}
+									</span>
+								}
+								player={p}
+							/>
+						))}
+					</div>
+				) : null}
+			</div>
+		</div>
+	);
+}
diff --git a/app/features/scanner/components/ObjectiveCard.tsx b/app/features/scanner/components/ObjectiveCard.tsx
new file mode 100644
index 000000000..478562971
--- /dev/null
+++ b/app/features/scanner/components/ObjectiveCard.tsx
@@ -0,0 +1,57 @@
+import {
+	OBJECTIVE_EVENT_TYPE,
+	type ObjectiveData,
+} from "../core/detectors/objective/index";
+import { FrameThumb } from "./FrameThumb";
+import { formatClock, useEventTimeFormatter } from "./format";
+import { MetaPills } from "./MetaChips";
+
+export function ObjectiveCard(props: {
+	t: number;
+	confidence: number;
+	data: ObjectiveData;
+	thumbnail?: string;
+	detectedAt?: number;
+	/** lazy loader for the exact analyzed frame — enables fixture export */
+	getFrame?: () => Promise<Blob | null | undefined>;
+	onInspect?: () => void;
+}) {
+	const { t, confidence, data, thumbnail, detectedAt, getFrame, onInspect } =
+		props;
+	const side = (index: 0 | 1) => {
+		const score = data.score[index] ?? "?";
+		const penalty =
+			data.penalty[index] !== null ? ` (+${data.penalty[index]})` : "";
+		return `${score}${penalty}`;
+	};
+	const holder = data.control.findIndex(Boolean);
+	const formatDetectedAt = useEventTimeFormatter();
+	return (
+		<div className="card">
+			<div className="meta">
+				<MetaPills
+					t={t}
+					confidence={confidence}
+					type={OBJECTIVE_EVENT_TYPE}
+					label="objective"
+				/>
+				<span>
+					{data.time !== null ? `${formatClock(data.time)} · ` : null}
+					<b>
+						{side(0)} – {side(1)}
+					</b>
+					{holder >= 0
+						? ` · ${holder === 0 ? "alpha" : "bravo"} in control`
+						: null}
+				</span>
+				{detectedAt ? <span>{formatDetectedAt(detectedAt)}</span> : null}
+				<FrameThumb
+					thumbnail={thumbnail}
+					getFrame={getFrame}
+					onInspect={onInspect}
+					fixture={{ data, type: OBJECTIVE_EVENT_TYPE }}
+				/>
+			</div>
+		</div>
+	);
+}
diff --git a/app/features/scanner/components/ScoreboardCard.tsx b/app/features/scanner/components/ScoreboardCard.tsx
new file mode 100644
index 000000000..eaaf1d8aa
--- /dev/null
+++ b/app/features/scanner/components/ScoreboardCard.tsx
@@ -0,0 +1,142 @@
+import { WeaponImage } from "~/components/Image";
+import type { PlayerAbilityMap } from "../core/ability-harvest";
+import type {
+	ScoreboardData,
+	ScoreboardPlayer,
+} from "../core/detectors/scoreboard/index";
+import { SCOREBOARD_BATTLE_LOG_EVENT_TYPE } from "../core/detectors/scoreboard-battle-log/index";
+import { SCOREBOARD_BATTLE_LOG_REPLAY_EVENT_TYPE } from "../core/detectors/scoreboard-battle-log-replay/index";
+import { AbilityPopover } from "./AbilityGrid";
+import { FrameThumb } from "./FrameThumb";
+import type { CardData } from "./fixture-export";
+import { useEventTimeFormatter } from "./format";
+import { lobbyLabel, modeLabel, stageLabel } from "./labels";
+import { MetaPills } from "./MetaChips";
+
+function PlayerRows({
+	players,
+	offset,
+	abilities,
+}: {
+	players: ScoreboardPlayer[];
+	/** index of the first row within the full 8-player list */
+	offset: number;
+	abilities?: PlayerAbilityMap;
+}) {
+	return (
+		<table className="players">
+			<tbody>
+				{players.map((p, i) => (
+					<tr key={i}>
+						<td>
+							<span className="weapon-cell">
+								{p.weaponId !== null ? (
+									<WeaponImage
+										weaponSplId={p.weaponId}
+										variant="build"
+										size={28}
+										className="weapon-icon"
+									/>
+								) : null}
+								{abilities?.has(offset + i) ? (
+									<AbilityPopover abilities={abilities.get(offset + i)!} />
+								) : null}
+							</span>
+						</td>
+						<td>{p.name || "?"}</td>
+						<td className="num">{p.paint ?? "?"}p</td>
+						<td className="num">
+							{p.ka ?? "?"}/{p.d ?? "?"}/{p.s ?? "?"}
+						</td>
+					</tr>
+				))}
+			</tbody>
+		</table>
+	);
+}
+
+function teamHeading(label: string, data: CardData, side: 0 | 1): string {
+	const score = data.matchScores[side];
+	return score !== null ? `${label} — ${score}` : label;
+}
+
+export function ScoreboardCard(props: {
+	t: number;
+	confidence: number;
+	data: ScoreboardData;
+	/** DetectedEvent type; replay cards add timestamp/code details */
+	eventType?: string;
+	thumbnail?: string;
+	detectedAt?: number;
+	/** lazy loader for the exact analyzed frame — enables fixture export */
+	getFrame?: () => Promise<Blob | null | undefined>;
+	/** when set, shows an Inspect button (open this match in the screenshot page) */
+	onInspect?: () => void;
+	/** abilities harvested from this match's death events, by player index */
+	abilities?: PlayerAbilityMap;
+}) {
+	const { t, confidence, thumbnail, detectedAt, getFrame, onInspect } = props;
+	const eventType = props.eventType ?? "Scoreboard";
+	const data = props.data as CardData;
+	const isReplay = eventType === SCOREBOARD_BATTLE_LOG_REPLAY_EVENT_TYPE;
+	const isScoreboardBattleLog = eventType === SCOREBOARD_BATTLE_LOG_EVENT_TYPE;
+	const formatDetectedAt = useEventTimeFormatter();
+	return (
+		<div className="card">
+			<div className="meta">
+				<MetaPills
+					t={t}
+					confidence={confidence}
+					type={eventType}
+					label={
+						isReplay
+							? "replay scoreboard"
+							: isScoreboardBattleLog
+								? "battle log"
+								: "scoreboard"
+					}
+				/>
+				{data.mode !== null || data.stage !== null ? (
+					<span>
+						{[
+							lobbyLabel(data.lobby),
+							modeLabel(data.mode),
+							stageLabel(data.stage),
+						]
+							.filter(Boolean)
+							.join(" · ")}
+					</span>
+				) : null}
+				{data.timestamp ? <span>{data.timestamp}</span> : null}
+				{data.replayCode ? (
+					<span className="score">{data.replayCode}</span>
+				) : null}
+				{detectedAt ? <span>{formatDetectedAt(detectedAt)}</span> : null}
+				<FrameThumb
+					thumbnail={thumbnail}
+					getFrame={getFrame}
+					onInspect={onInspect}
+					fixture={{ data, type: eventType }}
+				/>
+			</div>
+			<div className="teams">
+				<div className="team win">
+					<h3>{teamHeading("Victory", data, 0)}</h3>
+					<PlayerRows
+						players={data.players.slice(0, 4)}
+						offset={0}
+						abilities={props.abilities}
+					/>
+				</div>
+				<div className="team lose">
+					<h3>{teamHeading("Defeat", data, 1)}</h3>
+					<PlayerRows
+						players={data.players.slice(4, 8)}
+						offset={4}
+						abilities={props.abilities}
+					/>
+				</div>
+			</div>
+		</div>
+	);
+}
diff --git a/app/features/scanner/components/ScoreboardOwnCard.tsx b/app/features/scanner/components/ScoreboardOwnCard.tsx
new file mode 100644
index 000000000..9056266ab
--- /dev/null
+++ b/app/features/scanner/components/ScoreboardOwnCard.tsx
@@ -0,0 +1,69 @@
+import { WeaponImage } from "~/components/Image";
+import {
+	SCOREBOARD_OWN_EVENT_TYPE,
+	type ScoreboardOwnData,
+} from "../core/detectors/scoreboard-own/index";
+import { AbilityGrid } from "./AbilityGrid";
+import { FrameThumb } from "./FrameThumb";
+import { useEventTimeFormatter } from "./format";
+import { lobbyLabel, mainWeaponLabel, modeLabel, stageLabel } from "./labels";
+import { MetaPills } from "./MetaChips";
+
+export function ScoreboardOwnCard(props: {
+	t: number;
+	confidence: number;
+	data: ScoreboardOwnData;
+	thumbnail?: string;
+	detectedAt?: number;
+	/** lazy loader for the exact analyzed frame — enables fixture export */
+	getFrame?: () => Promise<Blob | null | undefined>;
+	onInspect?: () => void;
+}) {
+	const { t, confidence, data, thumbnail, detectedAt, getFrame, onInspect } =
+		props;
+	const formatDetectedAt = useEventTimeFormatter();
+	return (
+		<div className="card">
+			<div className="meta">
+				<MetaPills
+					t={t}
+					confidence={confidence}
+					type={SCOREBOARD_OWN_EVENT_TYPE}
+					label="own results"
+				/>
+				<span>
+					{[
+						lobbyLabel(data.lobby),
+						modeLabel(data.mode),
+						stageLabel(data.stage),
+					]
+						.map((v) => v ?? "?")
+						.join(" · ")}
+				</span>
+				<span>
+					weapon <b>{mainWeaponLabel(data.weaponId) ?? "?"}</b>
+				</span>
+				{detectedAt ? <span>{formatDetectedAt(detectedAt)}</span> : null}
+				<FrameThumb
+					thumbnail={thumbnail}
+					getFrame={getFrame}
+					onInspect={onInspect}
+					fixture={{ data, type: "ScoreboardOwn" }}
+				/>
+			</div>
+			<div className="teams solo">
+				<div className="team">
+					{data.weaponId !== null ? (
+						<WeaponImage
+							weaponSplId={data.weaponId}
+							variant="build"
+							size={28}
+							className="weapon-icon"
+						/>
+					) : null}
+					<AbilityGrid abilities={data.abilities} />
+				</div>
+			</div>
+		</div>
+	);
+}
diff --git a/app/features/scanner/components/ScreenshotPage.tsx b/app/features/scanner/components/ScreenshotPage.tsx
new file mode 100644
index 000000000..b5866277d
--- /dev/null
+++ b/app/features/scanner/components/ScreenshotPage.tsx
@@ -0,0 +1,729 @@
+import clsx from "clsx";
+import { useCallback, useEffect, useRef, useState } from "react";
+import type { MainWeaponId } from "~/modules/in-game-lists/types";
+import { useSearchParam } from "~/modules/search-params/hooks";
+import { mainWeaponImageUrl } from "~/utils/urls";
+import { CANONICAL_HEIGHT, CANONICAL_WIDTH, type Roi } from "../core/canonical";
+import type { DeathData } from "../core/detectors/death/index";
+import * as death from "../core/detectors/death/rois";
+import type { MapStartData } from "../core/detectors/map-start/index";
+import * as mapStart from "../core/detectors/map-start/rois";
+import type { MinimapData } from "../core/detectors/minimap/index";
+import * as minimap from "../core/detectors/minimap/rois";
+import type { ScoreboardRowDebug } from "../core/detectors/scoreboard/index";
+import * as sb from "../core/detectors/scoreboard/rois";
+import * as bl from "../core/detectors/scoreboard-battle-log/rois";
+import * as replay from "../core/detectors/scoreboard-battle-log-replay/rois";
+import type { ScoreboardOwnData } from "../core/detectors/scoreboard-own/index";
+import * as own from "../core/detectors/scoreboard-own/rois";
+import type { DetectedEvent } from "../core/detectors/types";
+import { scannerSearchParams } from "../scanner-search-params";
+import { claimInspectFrame } from "../store/inspect";
+import { AnalyzerClient } from "../worker/client";
+import type { WorkerResponse } from "../worker/protocol";
+import { downloadEventsCsv } from "./events-csv";
+import { type CardData, downloadExpectedJson } from "./fixture-export";
+import {
+	lobbyLabel,
+	mainWeaponLabel,
+	modeLabel,
+	stageLabel,
+	weaponLabel,
+} from "./labels";
+
+type Result = Extract<WorkerResponse, { kind: "result" }>;
+
+/** Draw a ROI crop from the normalized frame, scaled up. */
+function RoiCrop(props: {
+	frame: HTMLCanvasElement;
+	roi: Roi;
+	scale?: number;
+}) {
+	const { frame, roi, scale = 1.5 } = props;
+	const ref = useRef<HTMLCanvasElement>(null);
+	useEffect(() => {
+		const canvas = ref.current!;
+		canvas.width = Math.round(roi.w * scale);
+		canvas.height = Math.round(roi.h * scale);
+		const ctx = canvas.getContext("2d")!;
+		ctx.imageSmoothingEnabled = false;
+		ctx.drawImage(
+			frame,
+			roi.x,
+			roi.y,
+			roi.w,
+			roi.h,
+			0,
+			0,
+			canvas.width,
+			canvas.height,
+		);
+	}, [frame, roi.x, roi.y, roi.w, roi.h, scale]);
+	return <canvas ref={ref} />;
+}
+
+/** Per-row parse ROIs, in the same order as the event's players array. */
+interface RowRois {
+	weapon: Roi;
+	name: Roi;
+	paint: Roi;
+	stats: [Roi, Roi, Roi];
+}
+
+function scoreboardRows(): RowRois[] {
+	return sb.ROW_CENTERS.map((cy) => ({
+		weapon: sb.weaponRoi(cy),
+		name: sb.nameRoi(cy),
+		paint: sb.paintRoi(cy),
+		stats: [sb.statRoi(cy, 0), sb.statRoi(cy, 1), sb.statRoi(cy, 2)],
+	}));
+}
+
+/** winnerSide comes from the event debug: players are ordered winners-first. */
+function battleLogRows(winnerSide: string): RowRois[] {
+	const panels = winnerSide === "bottom" ? [bl.PANEL_DY, 0] : [0, bl.PANEL_DY];
+	return panels.flatMap((dy) =>
+		bl.ROW_CENTERS.map((base) => {
+			const cy = base + dy;
+			return {
+				weapon: bl.weaponRoi(cy),
+				name: bl.nameRoi(cy),
+				paint: bl.paintRoi(cy),
+				stats: [bl.statRoi(cy, 0), bl.statRoi(cy, 1), bl.statRoi(cy, 2)] as [
+					Roi,
+					Roi,
+					Roi,
+				],
+			};
+		}),
+	);
+}
+
+/** winnerSide comes from the event debug: players are ordered winners-first. */
+function replayRows(winnerSide: string): RowRois[] {
+	const panels =
+		winnerSide === "right" ? [replay.PANEL_DX, 0] : [0, replay.PANEL_DX];
+	return panels.flatMap((dx) =>
+		replay.ROW_CENTERS.map((cy) => ({
+			weapon: replay.weaponRoi(cy, dx),
+			name: replay.nameRoi(cy, dx),
+			paint: replay.paintRoi(cy, dx),
+			stats: [
+				replay.statRoi(cy, dx, 0),
+				replay.statRoi(cy, dx, 1),
+				replay.statRoi(cy, dx, 2),
+			] as [Roi, Roi, Roi],
+		})),
+	);
+}
+
+function drawOverlay(ctx: CanvasRenderingContext2D, detector: string) {
+	const rect = (roi: Roi, color: string) => {
+		ctx.strokeStyle = color;
+		ctx.lineWidth = 2;
+		ctx.strokeRect(roi.x, roi.y, roi.w, roi.h);
+	};
+	if (detector === "death") {
+		rect(death.SPLAT_LINE1_ROI, "#34d399");
+		rect(death.WEAPON_LINE_ROI, "#f87171");
+		for (let row = 0; row < death.ABILITY_ROWS; row++) {
+			rect(death.abilityMainRoi(row), "#60a5fa");
+			for (const slot of [0, 1, 2])
+				rect(death.abilitySubRoi(row, slot), "#e879f9");
+		}
+		rect(death.TAG_NAME_OUTER, "#4ade80");
+		for (const roi of [
+			...death.GATE_BURST_PROBES,
+			...death.GATE_PANEL_PROBES,
+		]) {
+			rect(roi, "#facc15");
+		}
+		return;
+	}
+	if (detector === "map-start") {
+		rect(mapStart.MODE_LABEL_ROI, "#34d399");
+		rect(mapStart.MODE_BLOCK_ROI, "#f87171");
+		rect(mapStart.STAGE_ROI, "#60a5fa");
+		rect(mapStart.GATE_INK_BAND, "#e879f9");
+		for (const roi of mapStart.GATE_DARK_PROBES) rect(roi, "#facc15");
+		return;
+	}
+	if (detector === "scoreboard-own") {
+		rect(own.WEAPON_TITLE_BAND, "#f87171");
+		for (let row = 0; row < own.GEAR_ROWS; row++) {
+			rect(own.gearMainRoi(row), "#60a5fa");
+			for (const slot of [0, 1, 2]) rect(own.gearSubRoi(row, slot), "#e879f9");
+			rect(own.gateStripProbe(row), "#facc15");
+		}
+		for (const roi of [
+			...own.GATE_PANEL_PROBES,
+			...own.GATE_TITLE_TEXT_PROBES,
+		]) {
+			rect(roi, "#facc15");
+		}
+		rect(sb.HEADER_LOBBY_BAND, "#34d399");
+		rect(sb.HEADER_LINE_BAND, "#34d399");
+		return;
+	}
+	if (detector === "minimap") {
+		for (const card of minimap.CARD_LAYOUTS) {
+			rect(card.name, "#4ade80");
+			rect(card.weapon, "#f87171");
+			rect(card.subTile, "#22d3ee");
+			for (const [cx, cy] of card.badges)
+				rect(minimap.badgeRoi(cx, cy), "#60a5fa");
+			rect(card.cross, "#e879f9");
+		}
+		for (const cy of minimap.ENEMY_ROW_CYS) {
+			rect(minimap.enemyWeaponRoi(cy), "#f87171");
+			rect(minimap.enemySubTileRoi(cy), "#22d3ee");
+			for (const cx of minimap.ENEMY_BADGE_XS)
+				rect(minimap.badgeRoi(cx, cy), "#60a5fa");
+			rect(minimap.enemyCrossRoi(cy), "#e879f9");
+		}
+		for (const roi of [
+			...minimap.GATE_CLOSE_X_BRIGHT,
+			minimap.GATE_SPAWN_BRIGHT,
+			...minimap.GATE_CLOSE_DARK_PROBES,
+			...minimap.GATE_CLOSE_X_DARK,
+			...minimap.GATE_SPAWN_DARK_PROBES,
+		]) {
+			rect(roi, "#facc15");
+		}
+		return;
+	}
+	if (detector === "scoreboard-battle-log") {
+		for (const dy of bl.PANEL_DYS) {
+			for (const base of bl.ROW_CENTERS) {
+				const cy = base + dy;
+				rect(bl.weaponRoi(cy), "#f87171");
+				rect(bl.nameRoi(cy), "#4ade80");
+				rect(bl.paintRoi(cy), "#60a5fa");
+				for (const i of [0, 1, 2] as const) rect(bl.statRoi(cy, i), "#e879f9");
+				rect(bl.gateDarkProbe(cy), "#facc15");
+			}
+			rect(bl.teamScoreRoi(dy), "#60a5fa");
+			rect(bl.resultTagRoi(dy), "#fb923c");
+		}
+		for (const roi of bl.MATCH_SCORE_ROIS) rect(roi, "#60a5fa");
+		for (const roi of bl.GATE_COLOR_PROBES) rect(roi, "#facc15");
+		rect(bl.HEADER_TOP_BAND, "#34d399");
+		rect(bl.HEADER_BOTTOM_BAND, "#34d399");
+		return;
+	}
+	if (detector === "scoreboard-battle-log-replay") {
+		for (const dx of replay.PANEL_XS) {
+			for (const cy of replay.ROW_CENTERS) {
+				rect(replay.weaponRoi(cy, dx), "#f87171");
+				rect(replay.nameRoi(cy, dx), "#4ade80");
+				rect(replay.paintRoi(cy, dx), "#60a5fa");
+				for (const i of [0, 1, 2] as const)
+					rect(replay.statRoi(cy, dx, i), "#e879f9");
+				rect(replay.gateFlatProbe(cy, dx), "#facc15");
+			}
+			rect(replay.teamScoreRoi(dx), "#60a5fa");
+			rect(replay.resultTagRoi(dx), "#fb923c");
+		}
+		for (const roi of replay.MATCH_SCORE_ROIS) rect(roi, "#60a5fa");
+		for (const roi of replay.GATE_GAP_PROBES) rect(roi, "#facc15");
+		rect(replay.HEADER_TOP_BAND, "#34d399");
+		rect(replay.HEADER_BOTTOM_BAND, "#34d399");
+		rect(replay.REPLAY_CODE_ROI, "#34d399");
+		return;
+	}
+	for (const cy of sb.ROW_CENTERS) {
+		rect(sb.weaponRoi(cy), "#f87171");
+		rect(sb.nameRoi(cy), "#4ade80");
+		rect(sb.paintRoi(cy), "#60a5fa");
+		for (const i of [0, 1, 2] as const) rect(sb.statRoi(cy, i), "#e879f9");
+		rect(sb.gateDarkProbe(cy), "#facc15");
+	}
+	for (const roi of sb.TEAM_SCORE_ROIS) rect(roi, "#60a5fa");
+	for (const roi of sb.MATCH_SCORE_ROIS) rect(roi, "#fb923c");
+	for (const roi of sb.GATE_PANEL_PROBES) rect(roi, "#facc15");
+	rect(sb.HEADER_LOBBY_BAND, "#34d399");
+	rect(sb.HEADER_LINE_BAND, "#34d399");
+}
+
+export function ScreenshotPage() {
+	const displayRef = useRef<HTMLCanvasElement>(null);
+	const clientRef = useRef<AnalyzerClient | null>(null);
+	const resultRef = useRef<(r: Result) => void>(() => {});
+	const doneRef = useRef<() => void>(() => {});
+
+	const [frame, setFrame] = useState<HTMLCanvasElement | null>(null);
+	const [results, setResults] = useState<Record<string, Result>>({});
+	const [busy, setBusy] = useState(false);
+	const busyRef = useRef(false);
+	const [over, setOver] = useState(false);
+	const [error, setError] = useState<string | null>(null);
+
+	useEffect(() => {
+		clientRef.current = new AnalyzerClient(
+			(r) => resultRef.current(r),
+			(message) => {
+				setError(message);
+				setBusy(false);
+			},
+			() => doneRef.current(),
+			// one-shot analyses: re-running the same screenshot must always parse
+			{ suppressSteadyFrames: false },
+		);
+		return () => clientRef.current?.dispose();
+	}, []);
+
+	// the detector whose inspector/overlay is shown: the one that fired
+	const active = Object.values(results).find((r) => r.events.length > 0);
+	const activeDetector = active?.detector ?? "scoreboard";
+
+	useEffect(() => {
+		if (!frame) return;
+		const display = displayRef.current!;
+		display.width = CANONICAL_WIDTH;
+		display.height = CANONICAL_HEIGHT;
+		const ctx = display.getContext("2d")!;
+		ctx.drawImage(frame, 0, 0);
+		drawOverlay(ctx, activeDetector);
+	}, [frame, activeDetector]);
+
+	const analyze = useCallback(async (file: File | Blob) => {
+		// one file at a time: in-flight worker results would land in the next
+		// file's state through the shared resultRef otherwise
+		if (busyRef.current) return;
+		busyRef.current = true;
+		setError(null);
+		setBusy(true);
+		setResults({});
+		try {
+			const bitmap = await createImageBitmap(file);
+
+			// normalized frame for local crop display, same as the pipeline does
+			const norm = document.createElement("canvas");
+			norm.width = CANONICAL_WIDTH;
+			norm.height = CANONICAL_HEIGHT;
+			norm
+				.getContext("2d")!
+				.drawImage(bitmap, 0, 0, CANONICAL_WIDTH, CANONICAL_HEIGHT);
+			setFrame(norm);
+
+			resultRef.current = (r) => {
+				setResults((prev) => ({ ...prev, [r.detector]: r }));
+			};
+			doneRef.current = () => {
+				busyRef.current = false;
+				setBusy(false);
+			};
+			const client = clientRef.current!;
+			await client.whenReady();
+			if (!client.analyze(bitmap, 0)) {
+				busyRef.current = false;
+				setBusy(false);
+			}
+		} catch (e) {
+			setError(String(e));
+			busyRef.current = false;
+			setBusy(false);
+		}
+	}, []);
+
+	// frame handed off from an Inspect click in another browser tab; the
+	// handoff write races this tab's load, so the claim polls briefly
+	const [inspectKey, setInspectKey] = useSearchParam(
+		scannerSearchParams,
+		"inspect",
+	);
+	useEffect(() => {
+		if (!inspectKey) return;
+		setInspectKey(null);
+		claimInspectFrame(inspectKey).then(
+			(frame) => {
+				if (frame) void analyze(frame);
+				else
+					setError(
+						"Inspected frame did not arrive — go back to the other tab and press Inspect again",
+					);
+			},
+			(e) => setError(String(e)),
+		);
+	}, [inspectKey, setInspectKey, analyze]);
+
+	const event = active?.events[0] as DetectedEvent<CardData> | undefined;
+	const rows = (event?.debug?.rows ?? []) as ScoreboardRowDebug[];
+	const isReplay = activeDetector === "scoreboard-battle-log-replay";
+	const isScoreboardBattleLog = activeDetector === "scoreboard-battle-log";
+	const isDeath = activeDetector === "death";
+	const isMapStart = activeDetector === "map-start";
+	const isOwn = activeDetector === "scoreboard-own";
+	const isMinimap = activeDetector === "minimap";
+	const winnerSide = String(event?.debug?.winnerSide ?? "left");
+	const rowRois = isReplay
+		? replayRows(winnerSide)
+		: isScoreboardBattleLog
+			? battleLogRows(winnerSide)
+			: scoreboardRows();
+
+	return (
+		<div>
+			{/* biome-ignore lint/a11y/noStaticElementInteractions: drag-and-drop target; the file input inside is the accessible path */}
+			<div
+				className={clsx("dropzone", { over })}
+				onDragOver={(e) => {
+					e.preventDefault();
+					setOver(true);
+				}}
+				onDragLeave={() => setOver(false)}
+				onDrop={(e) => {
+					e.preventDefault();
+					setOver(false);
+					const file = e.dataTransfer.files[0];
+					if (file) void analyze(file);
+				}}
+			>
+				Drop a frame (PNG/JPEG) here, or{" "}
+				<label>
+					pick a file
+					<input
+						type="file"
+						accept="image/png,image/jpeg"
+						style={{ display: "none" }}
+						onChange={(e) => {
+							const file = e.target.files?.[0];
+							e.target.value = ""; // allow re-picking the same file
+							if (file) void analyze(file);
+						}}
+					/>
+				</label>
+				{busy ? " — analyzing…" : null}
+			</div>
+			{error ? <p className="error">{error}</p> : null}
+
+			<div
+				className="screenshot-frame"
+				style={{ display: frame ? "block" : "none" }}
+			>
+				<canvas ref={displayRef} />
+			</div>
+
+			{frame && !busy ? (
+				<p>
+					<button
+						type="button"
+						onClick={() =>
+							downloadExpectedJson(event?.data ?? null, event?.type)
+						}
+					>
+						Download expected.json
+					</button>{" "}
+					<button
+						type="button"
+						disabled={!event}
+						onClick={() =>
+							downloadEventsCsv(
+								"screenshot-events.csv",
+								Object.values(results).flatMap((r) => r.events),
+							)
+						}
+					>
+						Download CSV
+					</button>
+				</p>
+			) : null}
+
+			{Object.values(results).map((result) => (
+				<p key={result.detector}>
+					{result.detector} gate:{" "}
+					<b>{result.gate.pass ? "fired" : "no fire"}</b> (score{" "}
+					{result.gate.score.toFixed(3)})
+					{result.events[0] && result.detector === "death" ? (
+						<>
+							{" · "}confidence{" "}
+							{((result.events[0].confidence ?? 0) * 100).toFixed(1)}%{" · "}
+							{(() => {
+								const data = result.events[0].data as DeathData;
+								return `splatted by ${weaponLabel(data.weaponType, data.weaponId) ?? "?"} (${data.name ?? "?"})`;
+							})()}
+						</>
+					) : null}
+					{result.events[0] && result.detector === "map-start" ? (
+						<>
+							{" · "}confidence{" "}
+							{((result.events[0].confidence ?? 0) * 100).toFixed(1)}%{" · "}
+							{(() => {
+								const data = result.events[0].data as MapStartData;
+								return `${modeLabel(data.mode) ?? "?"} · ${stageLabel(data.stage) ?? "?"}`;
+							})()}
+						</>
+					) : null}
+					{result.events[0] && result.detector === "scoreboard-own" ? (
+						<>
+							{" · "}confidence{" "}
+							{((result.events[0].confidence ?? 0) * 100).toFixed(1)}%{" · "}
+							{(() => {
+								const data = result.events[0].data as ScoreboardOwnData;
+								return `${[lobbyLabel(data.lobby), modeLabel(data.mode), stageLabel(data.stage)].map((v) => v ?? "?").join(" · ")} · ${mainWeaponLabel(data.weaponId) ?? "?"}`;
+							})()}
+						</>
+					) : null}
+					{result.events[0] && result.detector === "minimap" ? (
+						<>
+							{" · "}confidence{" "}
+							{((result.events[0].confidence ?? 0) * 100).toFixed(1)}%{" · "}
+							{(() => {
+								const data = result.events[0].data as MinimapData;
+								const players = data.teammates
+									.map((p) => p.name ?? "?")
+									.join(", ");
+								return `${data.stage ?? "?"} · ${players}`;
+							})()}
+						</>
+					) : null}
+					{result.events[0] &&
+					result.detector !== "death" &&
+					result.detector !== "map-start" &&
+					result.detector !== "scoreboard-own" &&
+					result.detector !== "minimap" ? (
+						<>
+							{" · "}confidence{" "}
+							{((result.events[0].confidence ?? 0) * 100).toFixed(1)}% · scores{" "}
+							{JSON.stringify((result.events[0].data as CardData).matchScores)}
+							{" · "}
+							{(() => {
+								const data = result.events[0].data as CardData;
+								return [
+									lobbyLabel(data.lobby),
+									modeLabel(data.mode),
+									stageLabel(data.stage),
+								]
+									.map((v) => v ?? "?")
+									.join(" · ");
+							})()}
+						</>
+					) : null}
+				</p>
+			))}
+
+			{frame && event && isReplay ? (
+				<p>
+					timestamp <b>{event.data.timestamp ?? "?"}</b>
+					{" · "}code <b>{event.data.replayCode ?? "?"}</b>{" "}
+					<span className="score">
+						(raw: {String(event.debug?.codeRaw ?? "")})
+					</span>
+					{" · "}match scores {JSON.stringify(event.data.matchScores)}
+					{" · "}winner panel <b>{winnerSide}</b>
+					<br />
+					<RoiCrop frame={frame} roi={replay.HEADER_TOP_BAND} />{" "}
+					<RoiCrop frame={frame} roi={replay.REPLAY_CODE_ROI} />
+				</p>
+			) : null}
+
+			{frame && event && isScoreboardBattleLog ? (
+				<p>
+					timestamp <b>{event.data.timestamp ?? "?"}</b>
+					{" · "}match scores {JSON.stringify(event.data.matchScores)}
+					{" · "}winner panel <b>{winnerSide}</b>
+					<br />
+					<RoiCrop frame={frame} roi={bl.HEADER_TOP_BAND} />{" "}
+					<RoiCrop frame={frame} roi={bl.HEADER_BOTTOM_BAND} />
+				</p>
+			) : null}
+
+			{frame && event && isDeath ? (
+				<p>
+					{(() => {
+						const data = event.data as unknown as DeathData;
+						return (
+							<>
+								weapon{" "}
+								<b>{weaponLabel(data.weaponType, data.weaponId) ?? "?"}</b>{" "}
+								<span className="score">
+									(raw: {String(event.debug?.weaponRaw ?? "")})
+								</span>
+								{" · "}name <b>{data.name ?? "?"}</b>{" "}
+								<span className="score">
+									(raw: {String(event.debug?.nameRaw ?? "")})
+								</span>
+								{" · "}abilities{" "}
+								{data.abilities.map((row) => row.join(" ")).join(" | ")}
+								<br />
+								<RoiCrop frame={frame} roi={death.WEAPON_LINE_ROI} />{" "}
+								<RoiCrop frame={frame} roi={death.TAG_NAME_OUTER} />
+							</>
+						);
+					})()}
+				</p>
+			) : null}
+
+			{frame && event && isMapStart ? (
+				<p>
+					{(() => {
+						const data = event.data as unknown as MapStartData;
+						return (
+							<>
+								mode <b>{modeLabel(data.mode) ?? "?"}</b>{" "}
+								<span className="score">
+									(raw: {String(event.debug?.modeReading ?? "")})
+								</span>
+								{" · "}stage <b>{stageLabel(data.stage) ?? "?"}</b>{" "}
+								<span className="score">
+									(raw: {String(event.debug?.stageReading ?? "")})
+								</span>
+								<br />
+								<RoiCrop
+									frame={frame}
+									roi={mapStart.MODE_BLOCK_ROI}
+									scale={0.75}
+								/>{" "}
+								<RoiCrop frame={frame} roi={mapStart.STAGE_ROI} />
+							</>
+						);
+					})()}
+				</p>
+			) : null}
+
+			{frame && event && isOwn ? (
+				<p>
+					{(() => {
+						const data = event.data as unknown as ScoreboardOwnData;
+						return (
+							<>
+								weapon <b>{mainWeaponLabel(data.weaponId) ?? "?"}</b>{" "}
+								<span className="score">
+									(raw: {String(event.debug?.weaponReading ?? "")})
+								</span>
+								{" · "}abilities{" "}
+								{data.abilities.map((row) => row.join(" ")).join(" | ")}
+								<br />
+								<RoiCrop frame={frame} roi={own.WEAPON_TITLE_BAND} />{" "}
+								{[0, 1, 2].map((row) => (
+									<RoiCrop
+										key={row}
+										frame={frame}
+										roi={{
+											x: own.GEAR_MAIN_CXS[row]! - 36,
+											y: own.GEAR_BADGE_CY - 32,
+											w: 200,
+											h: 64,
+										}}
+									/>
+								))}
+							</>
+						);
+					})()}
+				</p>
+			) : null}
+
+			{frame && event && isMinimap ? (
+				<p>
+					{(() => {
+						const data = event.data as unknown as MinimapData;
+						return (
+							<>
+								stage <b>{stageLabel(data.stage) ?? "?"}</b>
+								{" · "}
+								{data.spectator ? "spectator map" : "POV overlay"}
+								{" · "}team{" "}
+								<b>
+									{data.teammates
+										.map(
+											(p) =>
+												`${p.slot}: ${p.name ?? "?"} (${mainWeaponLabel(p.weaponId) ?? "?"})`,
+										)
+										.join(", ") || "—"}
+								</b>
+								{data.enemies.length > 0 ? (
+									<>
+										{" · "}enemies{" "}
+										<b>
+											{data.enemies
+												.map(
+													(p) =>
+														`${p.name ?? "?"} (${mainWeaponLabel(p.weaponId) ?? "?"})`,
+												)
+												.join(", ")}
+										</b>
+									</>
+								) : null}
+								{!data.spectator ? (
+									<>
+										<br />
+										{minimap.CARD_LAYOUTS.map((card) => (
+											<RoiCrop key={card.slot} frame={frame} roi={card.name} />
+										))}
+									</>
+								) : null}
+							</>
+						);
+					})()}
+				</p>
+			) : null}
+
+			{frame && event && !isDeath && !isMapStart && !isOwn && !isMinimap ? (
+				<table className="inspector">
+					<thead>
+						<tr>
+							<th>row</th>
+							<th>weapon crop</th>
+							<th>top candidates</th>
+							<th>name</th>
+							<th>paint</th>
+							<th>stats (splats / deaths / specials)</th>
+						</tr>
+					</thead>
+					<tbody>
+						{rowRois.map((roi, i) => {
+							const player = event.data.players[i];
+							const dbg = rows[i];
+							return (
+								<tr key={i}>
+									<td>{i}</td>
+									<td>
+										<RoiCrop frame={frame} roi={roi.weapon} />
+									</td>
+									<td>
+										<div className="candidates weapon-candidates">
+											{dbg?.weapon?.top.map((c) => (
+												<span className="cand" key={c.id}>
+													<img
+														className="weapon-icon"
+														src={`${mainWeaponImageUrl(Number(c.id) as MainWeaponId)}.avif`}
+														alt={c.id}
+													/>
+													{c.id}
+													<span className="score">{c.score.toFixed(3)}</span>
+												</span>
+											))}
+										</div>
+									</td>
+									<td>
+										<RoiCrop frame={frame} roi={roi.name} />
+										<b>{player?.name || "—"}</b>{" "}
+										<span className="score">{dbg?.nameScore.toFixed(3)}</span>
+									</td>
+									<td>
+										<RoiCrop frame={frame} roi={roi.paint} />
+										<b>{player?.paint ?? "—"}</b>{" "}
+										<span className="score">{dbg?.paintScore.toFixed(3)}</span>
+									</td>
+									<td>
+										<div className="candidates">
+											{([0, 1, 2] as const).map((s) => (
+												<span className="cand" key={s}>
+													<RoiCrop frame={frame} roi={roi.stats[s]} scale={2} />
+													<b>{[player?.ka, player?.d, player?.s][s] ?? "—"}</b>
+													<span className="score">
+														{dbg?.statScores[s].toFixed(2)}
+													</span>
+												</span>
+											))}
+										</div>
+									</td>
+								</tr>
+							);
+						})}
+					</tbody>
+				</table>
+			) : null}
+		</div>
+	);
+}
diff --git a/app/features/scanner/components/VodPage.tsx b/app/features/scanner/components/VodPage.tsx
new file mode 100644
index 000000000..3172c753d
--- /dev/null
+++ b/app/features/scanner/components/VodPage.tsx
@@ -0,0 +1,911 @@
+/**
+ * VoD tab: load a video file and scan it for scoreboard matches as fast as
+ * decoding allows — no real-time playback. On the primary (WebCodecs) path
+ * the file's duration is split into one contiguous slice per analyzer
+ * worker and each worker demuxes, decodes, schedules and analyzes its slice
+ * by itself (worker/analyzer.worker.ts): no frames cross the main thread,
+ * scheduling state is exact per slice, and calm stretches are skimmed by
+ * keyframe hops instead of decoded frame-by-frame. The seek fallback drives
+ * a <video> element through a single worker, widening its stride over calm
+ * footage. Each match can be opened in the screenshot page with the exact
+ * frame that was analyzed.
+ *
+ * Completed scans are persisted to IndexedDB keyed by file name
+ * (src/store/vods.ts); the default view lists them for reinspection.
+ */
+import clsx from "clsx";
+import { Download, FileText, Send, Trash2, Video } from "lucide-react";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { Link } from "react-router";
+import * as R from "remeda";
+import { SendouButton } from "~/components/elements/Button";
+import { SendouMenu, SendouMenuItem } from "~/components/elements/Menu";
+import { FormWithConfirm } from "~/components/FormWithConfirm";
+import { ObjectiveTimeline } from "~/components/ObjectiveTimeline";
+import { openSeekScan, probeWebCodecs } from "../capture/vod-frames";
+import { connectAbilities } from "../core/ability-harvest";
+import {
+	OBJECTIVE_EVENT_TYPE,
+	type ObjectiveData,
+} from "../core/detectors/objective/index";
+import {
+	mergeScanTelemetry,
+	type ScanTelemetry,
+} from "../core/detectors/telemetry";
+import type { DetectedEvent } from "../core/detectors/types";
+import {
+	buildScannerMatches,
+	ingestSkipReasons,
+	invalidObjectiveEvents,
+} from "../core/match-builder";
+import { TimelineBuilder } from "../core/timeline/index";
+import type { SendStatus } from "../store/events";
+import {
+	deleteVod,
+	listVods,
+	loadVodEventFrame,
+	loadVodEvents,
+	saveVod,
+	saveVodResultsSend,
+	type VodResultsSend,
+	type VodSummary,
+} from "../store/vods";
+import {
+	AnalyzerClient,
+	type DoneInfo,
+	defaultScanWorkerCount,
+} from "../worker/client";
+import { withoutRepeatEvents } from "./dedupe-events";
+import { EventCard, type GetFrame } from "./EventCard";
+import { EventsSummary } from "./EventsSummary";
+import { downloadEventsCsv } from "./events-csv";
+import type { FixtureData } from "./fixture-export";
+import { formatTime, useEventDateTimeFormatter } from "./format";
+import { MatchCard } from "./MatchCard";
+import { MatchLobbyTabs } from "./MatchLobbyTabs";
+import {
+	countIngestableMatches,
+	type SendouUser,
+	sendVodResults,
+} from "./sendou-ingest";
+import { sendouUpload } from "./sendou-upload";
+import { thumbnailFromBlob } from "./thumbnail";
+
+/** The scan knows the on-screen sides only, not who is playing. */
+const SCANNER_TEAM_LABELS = ["Alpha", "Bravo"] as const;
+
+/** seek-fallback stride while the worker reports activity */
+const SEEK_ACTIVE_STRIDE_S = 0.25;
+/**
+ * seek-fallback stride over calm footage (nothing detected for a while, no
+ * match open) — small enough that the screens that can start activity from
+ * dead air (results ~10s, match intro ~7s) still get sampled
+ */
+const SEEK_CALM_STRIDE_S = 2.5;
+
+type Status = "idle" | "scanning" | "done" | "error";
+
+interface VodMatch {
+	event: DetectedEvent<FixtureData>;
+	/**
+	 * render identity — inherited when a better read replaces the event, so
+	 * match cards keyed on it don't remount (replaying the enter animation)
+	 */
+	key: number;
+	thumbnail?: string;
+	/** lossless PNG of the exact frame the detector analyzed (live scan) */
+	frame?: Blob;
+	/** stored VoD: id to load the frame from the vod-frames store */
+	frameId?: number;
+}
+
+interface Progress {
+	t: number;
+	duration: number;
+	/** scan speed as a multiple of realtime */
+	rate: number;
+}
+
+/** "Send results" progress/outcome shown next to the button. */
+type ResultsSend =
+	| { state: "sending"; sent: number; total: number }
+	| ({ state: "done" } & VodResultsSend);
+
+export function VodPage({
+	sendouUser,
+}: {
+	/** sendou.ink login shown in the header; undefined = probing, null = not logged in */
+	sendouUser: SendouUser | null | undefined;
+}) {
+	const videoRef = useRef<HTMLVideoElement>(null);
+	const previewRef = useRef<HTMLCanvasElement>(null);
+	const clientsRef = useRef<AnalyzerClient[]>([]);
+	// cancels the in-flight chunk scans of the previous scan, if any
+	const abortScanRef = useRef<(() => void) | null>(null);
+	// seek fallback: latest per-frame done info + the waiter for the next one
+	const doneInfoRef = useRef<DoneInfo | null>(null);
+	const frameDoneRef = useRef<(() => void) | null>(null);
+	const timelineRef = useRef(new TimelineBuilder());
+	// latest gate score from any worker; flushed to state on the UI throttle
+	const gateScoreRef = useRef<number | null>(null);
+	const abortRef = useRef({ aborted: false });
+	const urlRef = useRef<string | null>(null);
+	// source of truth for matches (state mirrors it) so the scan loop can
+	// persist the final list without waiting on React
+	const matchesRef = useRef<VodMatch[]>([]);
+	// in-flight thumbnail work; awaited before persisting a finished scan
+	const sideWorkRef = useRef<Promise<void>[]>([]);
+	const nextMatchKeyRef = useRef(0);
+
+	const [fileName, setFileName] = useState<string | null>(null);
+	/** live scan vs. reopened saved VoD (no video element for the latter) */
+	const [source, setSource] = useState<"scan" | "stored">("scan");
+	const [status, setStatus] = useState<Status>("idle");
+	const [method, setMethod] = useState<string | null>(null);
+	const [gateScore, setGateScore] = useState<number | null>(null);
+	const [progress, setProgress] = useState<Progress | null>(null);
+	const [matches, setMatches] = useState<VodMatch[]>([]);
+	const [vods, setVods] = useState<VodSummary[]>([]);
+	const [error, setError] = useState<string | null>(null);
+	const [telemetry, setTelemetry] = useState<ScanTelemetry | null>(null);
+	const [over, setOver] = useState(false);
+	const [eventsOpen, setEventsOpen] = useState(false);
+	const [resultsSend, setResultsSend] = useState<ResultsSend | null>(null);
+
+	const formatSavedAt = useEventDateTimeFormatter();
+
+	const abilityMap = connectAbilities(matches.map((m) => m.event));
+
+	const builtMatches = buildScannerMatches(matches.map((m) => m.event));
+	const skipReasons = ingestSkipReasons(builtMatches);
+	// mirrors sendVodResults' ingestable-match order, which the send outcome's
+	// links are keyed by
+	const ingestableBuilt = builtMatches.filter((b) => !skipReasons.has(b));
+	const linkByIngestableIndex = new Map(
+		(resultsSend?.state === "done" ? (resultsSend.links ?? []) : []).map(
+			(linked) => [linked.matchIndex, linked.link] as const,
+		),
+	);
+	const vodMatchByEvent = new Map(matches.map((m) => [m.event, m] as const));
+	const groupedEvents = new Set(builtMatches.flatMap((b) => b.sources));
+	const ungroupedMatches = matches.filter((m) => !groupedEvents.has(m.event));
+
+	// "Send results" sends the whole scan in one go, so its outcome maps
+	// onto every ingestable card; a partial failure (some chunks sent, some
+	// not) can't be attributed per match — the bulk status text covers it
+	const bulkSend: SendStatus | undefined =
+		resultsSend?.state === "sending"
+			? { state: "sending", at: 0 }
+			: resultsSend?.state === "done" && resultsSend.error === null
+				? { state: "sent", at: resultsSend.at }
+				: resultsSend?.state === "done" && resultsSend.sent === 0
+					? { state: "failed", at: resultsSend.at }
+					: undefined;
+
+	// only offered once the whole VoD has been processed (a stored VoD is a
+	// completed scan by construction)
+	const upload =
+		status === "done" ? sendouUpload(matches.map((m) => m.event)) : null;
+
+	// "Send results" — the /ingest counterpart of live sending: the
+	// scan's ingestable ScannerMatches POSTed in one go
+	const resultsMatchCount =
+		status === "done" ? countIngestableMatches(matches.map((m) => m.event)) : 0;
+
+	const refreshVods = useCallback(async () => {
+		try {
+			setVods(await listVods());
+		} catch {
+			// listing failures are non-fatal; the scan UI still works
+		}
+	}, []);
+
+	const uploadResults = async () => {
+		const events = matchesRef.current.map((m) => m.event);
+		setResultsSend({
+			state: "sending",
+			sent: 0,
+			total: countIngestableMatches(events),
+		});
+		const report = await sendVodResults(events, (sent, total) =>
+			setResultsSend({ state: "sending", sent, total }),
+		);
+		const outcome: VodResultsSend = {
+			sent: report.sentMatches,
+			total: report.totalMatches,
+			error: report.error,
+			at: Date.now(),
+			links: report.links,
+		};
+		setResultsSend({ state: "done", ...outcome });
+		// the scan is saved under its file name, so its send outcome can be
+		// restored when the VoD is reopened
+		if (fileName) {
+			await saveVodResultsSend(fileName, outcome);
+			await refreshVods();
+		}
+	};
+
+	useEffect(() => {
+		void refreshVods();
+		return () => {
+			abortRef.current.aborted = true;
+			abortScanRef.current?.();
+			for (const client of clientsRef.current) client.dispose();
+			clientsRef.current = [];
+			if (urlRef.current) URL.revokeObjectURL(urlRef.current);
+		};
+	}, [refreshVods]);
+
+	const scan = async (file: File) => {
+		abortRef.current.aborted = true;
+		abortScanRef.current?.();
+		const abort = { aborted: false };
+		abortRef.current = abort;
+
+		setError(null);
+		setTelemetry(null);
+		setMatches([]);
+		setResultsSend(null);
+		setEventsOpen(false);
+		setProgress(null);
+		setGateScore(null);
+		setMethod(null);
+		setFileName(file.name);
+		setSource("scan");
+		setStatus("scanning");
+
+		try {
+			// the element is used by the seek fallback and for post-scan review
+			const video = videoRef.current!;
+			if (urlRef.current) URL.revokeObjectURL(urlRef.current);
+			urlRef.current = URL.createObjectURL(file);
+			video.src = urlRef.current;
+
+			if (clientsRef.current.length === 0) {
+				clientsRef.current = Array.from(
+					{ length: defaultScanWorkerCount() },
+					() =>
+						new AnalyzerClient(
+							(result) => {
+								gateScoreRef.current = result.gate.score;
+								if (!result.gate.pass) return;
+								for (const event of result.events as DetectedEvent<FixtureData>[]) {
+									const action = timelineRef.current.push(event);
+									if (action.action !== "added" && action.action !== "replaced")
+										continue;
+									const frame = result.frame;
+									sideWorkRef.current.push(
+										(async () => {
+											const thumbnail = frame
+												? await thumbnailFromBlob(frame)
+												: undefined;
+											const replaced =
+												action.action === "replaced"
+													? matchesRef.current.find(
+															(m) => m.event === action.replaced,
+														)
+													: undefined;
+											const next = matchesRef.current.filter(
+												(m) => m !== replaced,
+											);
+											next.push({
+												event,
+												key: replaced?.key ?? nextMatchKeyRef.current++,
+												thumbnail,
+												frame,
+											});
+											next.sort((a, b) => a.event.t - b.event.t);
+											matchesRef.current = next;
+											setMatches(next);
+										})().catch(() => {}),
+									);
+								}
+							},
+							(message) => {
+								frameDoneRef.current?.();
+								frameDoneRef.current = null;
+								setError(message);
+								setStatus("error");
+							},
+							(_t, info: DoneInfo) => {
+								doneInfoRef.current = info;
+								frameDoneRef.current?.();
+								frameDoneRef.current = null;
+							},
+						),
+				);
+			}
+			const clients = clientsRef.current;
+			await Promise.all(clients.map((c) => c.whenReady()));
+			// let work still in flight from an aborted scan finish before the
+			// timeline resets, so its results can't bleed into this scan
+			await Promise.all(clients.map((c) => c.whenIdle()));
+			if (abort.aborted) return;
+			matchesRef.current = [];
+			sideWorkRef.current = [];
+			timelineRef.current = new TimelineBuilder();
+
+			const started = performance.now();
+			const finalize = async (duration: number) => {
+				await Promise.all(sideWorkRef.current);
+				if (abort.aborted) return;
+				matchesRef.current = withoutInvalidObjectives(matchesRef.current);
+				setMatches(matchesRef.current);
+				setProgress((p) => (p ? { ...p, t: duration } : p));
+				setStatus("done");
+				await saveVod(
+					{ name: file.name, savedAt: Date.now(), duration },
+					matchesRef.current.map((m) => ({
+						type: m.event.type,
+						t: m.event.t,
+						confidence: m.event.confidence,
+						data: m.event.data,
+						thumbnail: m.thumbnail,
+						frame: m.frame,
+					})),
+				);
+				await refreshVods();
+			};
+
+			const probe = await probeWebCodecs(file);
+			if (abort.aborted) return;
+
+			if (probe) {
+				// each worker demuxes, decodes and analyzes its own slice of
+				// the file; the main thread only aggregates progress
+				setMethod("webcodecs");
+				const { duration } = probe;
+				const chunkSpan = duration / clients.length;
+				const chunks = clients.map((client, i) => ({
+					client,
+					tStart: i * chunkSpan,
+					tEnd: i === clients.length - 1 ? duration : (i + 1) * chunkSpan,
+					t: i * chunkSpan,
+					done: false,
+					telemetry: null as ScanTelemetry | null,
+				}));
+				abortScanRef.current = () => {
+					for (const client of clients) client.abortChunk();
+				};
+				const mergedTelemetry = () =>
+					mergeScanTelemetry(
+						chunks.flatMap((c) => (c.telemetry ? [c.telemetry] : [])),
+					);
+				let lastUiUpdate = Number.NEGATIVE_INFINITY;
+				const pushUiUpdate = () => {
+					const now = performance.now();
+					if (now - lastUiUpdate < 250) return;
+					lastUiUpdate = now;
+					const covered = R.sumBy(
+						chunks,
+						(c) => Math.min(c.t, c.tEnd) - c.tStart,
+					);
+					const elapsed = (now - started) / 1000;
+					setGateScore(gateScoreRef.current);
+					setProgress({
+						t: covered,
+						duration,
+						rate: elapsed > 0 ? covered / elapsed : 0,
+					});
+					setTelemetry(mergedTelemetry());
+				};
+				await Promise.all(
+					chunks.map((chunk, chunkIndex) =>
+						chunk.client
+							.scanChunk(
+								{ file, chunkIndex, tStart: chunk.tStart, tEnd: chunk.tEnd },
+								(progress) => {
+									chunk.t = progress.t;
+									chunk.telemetry = progress.telemetry;
+									if (progress.preview) {
+										// show one chunk at a time: the earliest still running
+										if (chunks.find((c) => !c.done) === chunk) {
+											drawPreview(previewRef.current, progress.preview);
+										}
+										progress.preview.close();
+									}
+									pushUiUpdate();
+								},
+							)
+							.then((chunkTelemetry) => {
+								chunk.done = true;
+								chunk.t = chunk.tEnd;
+								chunk.telemetry = chunkTelemetry;
+							}),
+					),
+				);
+				if (abort.aborted) return;
+				setTelemetry(mergedTelemetry());
+				await finalize(duration);
+				return;
+			}
+
+			// seek fallback: one worker, one frame in flight; the worker's calm
+			// signal widens the stride over dead air
+			setMethod("seek");
+			const strideRef = { current: SEEK_ACTIVE_STRIDE_S };
+			const vod = await openSeekScan(video, () => strideRef.current);
+			if (abort.aborted) return;
+			const client = clients[0]!;
+			let lastUiUpdate = Number.NEGATIVE_INFINITY;
+			for await (const { frame, t } of vod.frames) {
+				if (abort.aborted) {
+					frame.close();
+					break;
+				}
+				const now = performance.now();
+				if (now - lastUiUpdate >= 250) {
+					lastUiUpdate = now;
+					// the preview draw must precede analyze — transferring the
+					// frame to the worker detaches it
+					drawPreview(previewRef.current, frame);
+					setGateScore(gateScoreRef.current);
+					const elapsed = (now - started) / 1000;
+					setProgress({
+						t,
+						duration: vod.duration,
+						rate: elapsed > 0 ? t / elapsed : 0,
+					});
+					if (doneInfoRef.current) setTelemetry(doneInfoRef.current.telemetry);
+				}
+				await new Promise<void>((resolve) => {
+					frameDoneRef.current = resolve;
+					if (!client.analyze(frame, t)) resolve();
+				});
+				strideRef.current = doneInfoRef.current?.calm
+					? SEEK_CALM_STRIDE_S
+					: SEEK_ACTIVE_STRIDE_S;
+			}
+			if (doneInfoRef.current) setTelemetry(doneInfoRef.current.telemetry);
+			await finalize(vod.duration);
+		} catch (e) {
+			if (!abort.aborted) {
+				abortScanRef.current?.();
+				setError(String(e));
+				setStatus("error");
+			}
+		}
+	};
+
+	const openStored = async (vod: VodSummary) => {
+		const name = vod.name;
+		abortRef.current.aborted = true;
+		abortScanRef.current?.();
+		setTelemetry(null);
+		try {
+			const events = await loadVodEvents(name);
+			// VoDs saved before objective reads were mode-gated may carry them
+			const loaded = withoutInvalidObjectives(
+				events.map((e) => ({
+					event: {
+						type: e.type,
+						t: e.t,
+						confidence: e.confidence,
+						data: e.data as FixtureData,
+					},
+					key: nextMatchKeyRef.current++,
+					thumbnail: e.thumbnail,
+					frameId: e.hasFrame ? e.id : undefined,
+				})),
+			);
+			matchesRef.current = loaded;
+			setMatches(loaded);
+			setResultsSend(
+				vod.resultsSend ? { state: "done", ...vod.resultsSend } : null,
+			);
+			setEventsOpen(false);
+			setFileName(name);
+			setSource("stored");
+			setStatus("done");
+			setError(null);
+			setProgress(null);
+			setGateScore(null);
+			setMethod(null);
+		} catch (e) {
+			setError(String(e));
+		}
+	};
+
+	const removeVod = async (name: string) => {
+		await deleteVod(name);
+		await refreshVods();
+	};
+
+	const backToList = () => {
+		abortRef.current.aborted = true;
+		abortScanRef.current?.();
+		setTelemetry(null);
+		matchesRef.current = [];
+		setMatches([]);
+		setResultsSend(null);
+		setEventsOpen(false);
+		setFileName(null);
+		setStatus("idle");
+		setError(null);
+		setProgress(null);
+		setGateScore(null);
+		setMethod(null);
+		void refreshVods();
+	};
+
+	const showVodView = fileName !== null;
+
+	return (
+		<div>
+			{/* biome-ignore lint/a11y/noStaticElementInteractions: drag-and-drop target; the file input inside is the accessible path */}
+			<div
+				className={clsx("dropzone", { over })}
+				onDragOver={(e) => {
+					e.preventDefault();
+					setOver(true);
+				}}
+				onDragLeave={() => setOver(false)}
+				onDrop={(e) => {
+					e.preventDefault();
+					setOver(false);
+					const file = e.dataTransfer.files[0];
+					if (file) void scan(file);
+				}}
+			>
+				Drop a VoD (video file) here, or{" "}
+				<label>
+					pick a file
+					<input
+						type="file"
+						accept="video/*"
+						style={{ display: "none" }}
+						onChange={(e) => {
+							const file = e.target.files?.[0];
+							e.target.value = ""; // allow re-picking the same file
+							if (file) void scan(file);
+						}}
+					/>
+				</label>
+			</div>
+			<div className="controls">
+				{showVodView ? (
+					<>
+						<button type="button" onClick={backToList}>
+							← All VoDs
+						</button>
+						<span
+							className={clsx("status", {
+								watching: status === "scanning",
+								detected: status === "done",
+								idle: status !== "scanning" && status !== "done",
+							})}
+						>
+							{source === "stored" ? "saved" : status}
+							{fileName ? ` · ${fileName}` : null}
+							{method ? ` · ${method}` : null}
+							{gateScore !== null && status === "scanning"
+								? ` · gate ${gateScore.toFixed(2)}`
+								: null}
+						</span>
+						{progress ? (
+							<span className="score">
+								{formatTime(progress.t)} / {formatTime(progress.duration)}
+								{progress.duration > 0
+									? ` (${Math.round((progress.t / progress.duration) * 100)}%)`
+									: null}
+								{progress.rate > 0
+									? ` · ${progress.rate.toFixed(0)}× realtime`
+									: null}
+							</span>
+						) : null}
+						{upload?.url ? (
+							<Link to={upload.url} className="link-button">
+								<Video aria-hidden />
+								Add VoD
+							</Link>
+						) : null}
+						{upload?.problem ? (
+							<span className="score">
+								upload unavailable: {upload.problem}
+							</span>
+						) : null}
+						{resultsMatchCount > 0 ? (
+							<button
+								type="button"
+								disabled={!sendouUser || resultsSend?.state === "sending"}
+								title={sendouUser ? undefined : "Log in on sendou.ink first"}
+								onClick={() => void uploadResults()}
+							>
+								<Send aria-hidden />
+								Send results
+							</button>
+						) : null}
+						{resultsSend ? (
+							<span
+								className={clsx("score", {
+									error:
+										resultsSend.state === "done" && Boolean(resultsSend.error),
+								})}
+							>
+								{resultsSend.state === "sending"
+									? `sending match ${Math.min(resultsSend.sent + 1, resultsSend.total)}/${resultsSend.total}…`
+									: resultsSend.error
+										? `sent ${resultsSend.sent}/${resultsSend.total} matches — ${resultsSend.error}`
+										: `sent ${resultsSend.sent}/${resultsSend.total} matches to sendou.ink`}
+							</span>
+						) : null}
+						{matches.length > 0 ? (
+							<ExportMenu
+								fileName={fileName}
+								events={matches.map((m) => m.event)}
+							/>
+						) : null}
+					</>
+				) : null}
+			</div>
+			{error ? <p className="error">{error}</p> : null}
+			{showVodView && telemetry ? (
+				<TelemetryPanel telemetry={telemetry} />
+			) : null}
+			{!showVodView ? (
+				<div className="vod-list">
+					{vods.length === 0 ? (
+						<p className="score">
+							No saved VoDs yet — scan one and it will show up here.
+						</p>
+					) : null}
+					{vods.map((vod) => (
+						<div key={vod.name} className="vod-item">
+							<span className="name">{vod.name}</span>
+							<span className="score">
+								{vod.eventCount} event{vod.eventCount === 1 ? "" : "s"} ·{" "}
+								{formatTime(vod.duration)} · {formatSavedAt(vod.savedAt)}
+							</span>
+							<button type="button" onClick={() => void openStored(vod)}>
+								Open
+							</button>
+							<FormWithConfirm
+								dialogHeading={`Delete saved analysis of "${vod.name}"?`}
+								onConfirm={() => void removeVod(vod.name)}
+							>
+								<SendouButton
+									variant="destructive"
+									size="small"
+									shape="square"
+									className="vod-delete"
+									icon={<Trash2 />}
+									aria-label="Delete"
+								/>
+							</FormWithConfirm>
+						</div>
+					))}
+				</div>
+			) : null}
+			<div
+				className="live-layout"
+				style={{
+					display: showVodView ? undefined : "none",
+					// a reopened saved VoD has no video to review — give the feed the full width
+					gridTemplateColumns: source === "stored" ? "1fr" : undefined,
+				}}
+			>
+				<div style={{ display: source === "scan" ? undefined : "none" }}>
+					<canvas
+						ref={previewRef}
+						className="preview"
+						style={{ display: status === "scanning" ? "block" : "none" }}
+					/>
+					<video
+						ref={videoRef}
+						className="preview"
+						muted
+						playsInline
+						controls
+						style={{
+							display: fileName && status !== "scanning" ? "block" : "none",
+						}}
+					/>
+				</div>
+				<div className="feed">
+					{matches.length === 0 ? (
+						<p className="score">
+							{status === "scanning"
+								? "Scanning — matches appear here as scoreboards are detected."
+								: "No matches found in this VoD."}
+						</p>
+					) : null}
+					<MatchLobbyTabs
+						matches={builtMatches}
+						keyOf={(built) => vodMatchByEvent.get(built.sources[0]!)!.key}
+						renderMatch={(built, justFormed) => {
+							const skipReason = skipReasons.get(built);
+							const link = linkByIngestableIndex.get(
+								ingestableBuilt.indexOf(built),
+							);
+							const send = skipReason ? undefined : bulkSend;
+							// counter reads render as one timeline chart, not a card each;
+							// a non-SZ match's reads (objective null) are never shown
+							const objectiveEvents = built.match.objective
+								? built.sources
+										.filter((e) => e.type === OBJECTIVE_EVENT_TYPE)
+										.map((e) => ({ t: e.t, data: e.data as ObjectiveData }))
+								: [];
+							const cardEvents = withoutRepeatEvents(built.sources).filter(
+								(e) => e.type !== OBJECTIVE_EVENT_TYPE,
+							);
+							return (
+								<MatchCard
+									match={built.match}
+									inProgress={
+										status === "scanning" &&
+										built === builtMatches.at(-1) &&
+										built.match.winner === null
+									}
+									skipReason={skipReason}
+									justFormed={justFormed}
+									send={
+										send?.state === "sent" && link ? { ...send, link } : send
+									}
+								>
+									{objectiveEvents.length > 0 ? (
+										<ObjectiveTimeline
+											events={objectiveEvents}
+											teamLabels={SCANNER_TEAM_LABELS}
+										/>
+									) : null}
+									{cardEvents.map((e) => {
+										const vodMatch = vodMatchByEvent.get(e);
+										return (
+											<EventCard
+												key={vodMatch?.key ?? `${e.type}-${e.t}`}
+												type={e.type}
+												t={e.t}
+												confidence={e.confidence}
+												data={e.data}
+												abilities={abilityMap.get(e)}
+												thumbnail={vodMatch?.thumbnail}
+												getFrame={vodMatch ? frameLoader(vodMatch) : undefined}
+											/>
+										);
+									})}
+								</MatchCard>
+							);
+						}}
+					/>
+					{ungroupedMatches.length > 0 ? (
+						<EventsSummary
+							events={ungroupedMatches.map((m) => m.event)}
+							open={eventsOpen}
+							onToggle={() => setEventsOpen(!eventsOpen)}
+						/>
+					) : null}
+					{/* newest detection on top; storage keeps ascending video-time order */}
+					{eventsOpen
+						? ungroupedMatches
+								.toReversed()
+								.map((m) => (
+									<EventCard
+										key={m.key}
+										type={m.event.type}
+										t={m.event.t}
+										confidence={m.event.confidence}
+										data={m.event.data}
+										abilities={abilityMap.get(m.event)}
+										thumbnail={m.thumbnail}
+										getFrame={frameLoader(m)}
+									/>
+								))
+						: null}
+				</div>
+			</div>
+		</div>
+	);
+}
+
+/** Export formats of the scanned events, behind one icon-only menu. */
+function ExportMenu({
+	fileName,
+	events,
+}: {
+	fileName: string;
+	events: DetectedEvent<FixtureData>[];
+}) {
+	return (
+		<SendouMenu
+			trigger={
+				<SendouButton
+					icon={<Download />}
+					className="icon-menu"
+					aria-label="Export"
+				/>
+			}
+		>
+			<SendouMenuItem
+				icon={<FileText />}
+				onAction={() =>
+					downloadEventsCsv(
+						`${fileName.replace(/\.[^.]+$/, "")}-events.csv`,
+						events,
+					)
+				}
+			>
+				CSV
+			</SendouMenuItem>
+		</SendouMenu>
+	);
+}
+
+/** Drops objective reads that grouped into a known non-SZ match (misreads). */
+function withoutInvalidObjectives(matches: VodMatch[]): VodMatch[] {
+	const invalid = new Set(
+		invalidObjectiveEvents(buildScannerMatches(matches.map((m) => m.event))),
+	);
+	return invalid.size > 0
+		? matches.filter((m) => !invalid.has(m.event))
+		: matches;
+}
+
+function frameLoader(m: VodMatch): GetFrame | undefined {
+	return m.frame
+		? () => Promise.resolve(m.frame)
+		: m.frameId !== undefined
+			? () => loadVodEventFrame(m.frameId!)
+			: undefined;
+}
+
+function TelemetryPanel({ telemetry }: { telemetry: ScanTelemetry }) {
+	const detectors = Object.entries(telemetry.detectors).sort(([a], [b]) =>
+		a.localeCompare(b),
+	);
+	const coveredS = telemetry.activeVideoS + telemetry.skimVideoS;
+	return (
+		<details className="telemetry">
+			<summary>
+				telemetry · analyzed {telemetry.analyzedFrames}/
+				{telemetry.decodedFrames} decoded frames
+				{coveredS > 0
+					? ` · skimmed ${formatTime(telemetry.skimVideoS)} of ${formatTime(coveredS)}`
+					: null}
+				{telemetry.wallMs > 0
+					? ` · ${formatTime(telemetry.wallMs / 1000)} cpu`
+					: null}
+			</summary>
+			<table>
+				<thead>
+					<tr>
+						<th>detector</th>
+						<th>checks</th>
+						<th>gate pass</th>
+						<th>gate ms</th>
+						<th>parses</th>
+						<th>parse ms</th>
+						<th>suppressed</th>
+					</tr>
+				</thead>
+				<tbody>
+					{detectors.map(([id, d]) => (
+						<tr key={id}>
+							<td>{id}</td>
+							<td>{d.checks}</td>
+							<td>{d.gatePasses}</td>
+							<td>{Math.round(d.gateMs)}</td>
+							<td>{d.parses}</td>
+							<td>{Math.round(d.parseMs)}</td>
+							<td>{d.suppressedParses}</td>
+						</tr>
+					))}
+				</tbody>
+			</table>
+		</details>
+	);
+}
+
+function drawPreview(
+	canvas: HTMLCanvasElement | null,
+	frame: ImageBitmap | VideoFrame,
+): void {
+	if (!canvas) return;
+	const width = "displayWidth" in frame ? frame.displayWidth : frame.width;
+	const height = "displayHeight" in frame ? frame.displayHeight : frame.height;
+	if (canvas.width !== width || canvas.height !== height) {
+		canvas.width = width;
+		canvas.height = height;
+	}
+	canvas.getContext("2d")!.drawImage(frame, 0, 0);
+}
diff --git a/app/features/scanner/components/dedupe-events.ts b/app/features/scanner/components/dedupe-events.ts
new file mode 100644
index 000000000..f968d93a8
--- /dev/null
+++ b/app/features/scanner/components/dedupe-events.ts
@@ -0,0 +1,42 @@
+/**
+ * Display-side cleanup for a match card's source event list: a long map-open
+ * can fragment into several minimap events (the timeline's merge window
+ * tracks a drifting `t`, and VoD results arrive out of order), so a minimap
+ * that shows nothing new versus the previous one is pure noise. Names are
+ * ignored in the comparison — OCR wobbles on them while the actual content
+ * (stage, weapons, ability reads) is unchanged. Stored events are untouched;
+ * this only filters what gets rendered.
+ */
+
+import { isDeepEqual, omit } from "remeda";
+import {
+	MINIMAP_EVENT_TYPE,
+	type MinimapData,
+} from "../core/detectors/minimap/index";
+
+export function withoutRepeatEvents<T extends { type: string; data: unknown }>(
+	events: readonly T[],
+): T[] {
+	const result: T[] = [];
+	let previousMinimap: MinimapData | null = null;
+	for (const event of events) {
+		if (event.type === MINIMAP_EVENT_TYPE) {
+			const data = event.data as MinimapData;
+			const repeat =
+				previousMinimap !== null &&
+				isDeepEqual(comparable(previousMinimap), comparable(data));
+			previousMinimap = data;
+			if (repeat) continue;
+		}
+		result.push(event);
+	}
+	return result;
+}
+
+function comparable(data: MinimapData) {
+	return {
+		...data,
+		teammates: data.teammates.map((player) => omit(player, ["name"])),
+		enemies: data.enemies.map((player) => omit(player, ["name"])),
+	};
+}
diff --git a/app/features/scanner/components/events-csv.ts b/app/features/scanner/components/events-csv.ts
new file mode 100644
index 000000000..bcc8cc556
--- /dev/null
+++ b/app/features/scanner/components/events-csv.ts
@@ -0,0 +1,259 @@
+/**
+ * Flatten detected events into a single CSV for download. One row per event;
+ * the six event types share columns where they overlap (lobby/mode/stage,
+ * weapon/name/abilities) and a scoreboard's eight player rows — or the
+ * minimap's teammates+enemies — are packed into one cell, matching the
+ * compact per-event view of the live feed.
+ */
+
+import type { MainWeaponId } from "~/modules/in-game-lists/types";
+import {
+	DEATH_EVENT_TYPE,
+	type DeathData,
+} from "../core/detectors/death/index";
+import {
+	MAP_START_EVENT_TYPE,
+	type MapStartData,
+} from "../core/detectors/map-start/index";
+import {
+	MINIMAP_EVENT_TYPE,
+	type MinimapData,
+} from "../core/detectors/minimap/index";
+import {
+	OBJECTIVE_EVENT_TYPE,
+	type ObjectiveData,
+} from "../core/detectors/objective/index";
+import type { ScoreboardData } from "../core/detectors/scoreboard/index";
+import type { ScoreboardBattleLogReplayData } from "../core/detectors/scoreboard-battle-log-replay/index";
+import {
+	SCOREBOARD_OWN_EVENT_TYPE,
+	type ScoreboardOwnData,
+} from "../core/detectors/scoreboard-own/index";
+import { formatClock, formatTime } from "./format";
+import {
+	lobbyLabel,
+	mainWeaponLabel,
+	modeLabel,
+	stageLabel,
+	weaponLabel,
+} from "./labels";
+
+export interface CsvEvent {
+	type: string;
+	/** video/stream time in seconds */
+	t: number;
+	/** wall-clock time of detection (live capture only) */
+	detectedAt?: number;
+	confidence: number;
+	data: unknown;
+}
+
+const HEADER = [
+	"type",
+	"time",
+	"t_seconds",
+	"detected_at",
+	"confidence",
+	"lobby",
+	"mode",
+	"stage",
+	"winner_score",
+	"loser_score",
+	"pov",
+	"weapon",
+	"name",
+	"abilities",
+	"players",
+	"replay_code",
+	"replay_timestamp",
+];
+
+type Cell = string | number | null | undefined;
+
+function csvCell(value: Cell): string {
+	if (value === null || value === undefined) return "";
+	const s = String(value);
+	return /[",\n\r]/.test(s) ? `"${s.replaceAll('"', '""')}"` : s;
+}
+
+/** [head, clothes, shoes] rows of [main, sub, sub, sub] ability ids */
+function formatAbilities(rows: string[][]): string {
+	return rows.map((row) => row.join("+")).join(" | ");
+}
+
+/** the minimap's flat [head, clothes, shoes] main-ability row */
+function formatMinimapAbilities(abilities: (string | null)[]): string {
+	return abilities.map((a) => a ?? "?").join("+");
+}
+
+function formatMinimapPlayers(data: MinimapData): string {
+	const fmt = (
+		label: string,
+		p: {
+			name: string | null;
+			weaponId: number | null;
+			abilities: (string | null)[];
+		},
+	) =>
+		`${label} ${p.name ?? "?"} · ${mainWeaponLabel(p.weaponId as MainWeaponId | null) ?? "?"} · ${formatMinimapAbilities(p.abilities)}`;
+	return [
+		...data.teammates.map((p) => fmt(p.slot, p)),
+		...data.enemies.map((p, i) => fmt(`enemy${i + 1}`, p)),
+	].join("; ");
+}
+
+function formatPlayers(data: ScoreboardData): string {
+	return data.players
+		.map(
+			(p, i) =>
+				`${i < 4 ? "W" : "L"} ${p.name} · ${p.weaponId ?? "?"} · ${p.paint ?? "?"}p ` +
+				`${p.ka ?? "?"}/${p.d ?? "?"}/${p.s ?? "?"}`,
+		)
+		.join("; ");
+}
+
+function eventCells(event: CsvEvent): Cell[] {
+	const base: Cell[] = [
+		event.type,
+		formatTime(event.t),
+		Math.round(event.t * 1000) / 1000,
+		event.detectedAt === undefined
+			? ""
+			: new Date(event.detectedAt).toISOString(),
+		Math.round(event.confidence * 1000) / 1000,
+	];
+	switch (event.type) {
+		case DEATH_EVENT_TYPE: {
+			const d = event.data as DeathData;
+			return [
+				...base,
+				"",
+				"",
+				"",
+				"",
+				"",
+				"",
+				weaponLabel(d.weaponType, d.weaponId),
+				d.name,
+				formatAbilities(d.abilities),
+				"",
+				"",
+				"",
+			];
+		}
+		case MAP_START_EVENT_TYPE: {
+			const d = event.data as MapStartData;
+			return [
+				...base,
+				"",
+				modeLabel(d.mode),
+				stageLabel(d.stage),
+				"",
+				"",
+				"",
+				"",
+				"",
+				"",
+				"",
+				"",
+				"",
+			];
+		}
+		case SCOREBOARD_OWN_EVENT_TYPE: {
+			const d = event.data as ScoreboardOwnData;
+			return [
+				...base,
+				lobbyLabel(d.lobby),
+				modeLabel(d.mode),
+				stageLabel(d.stage),
+				"",
+				"",
+				"",
+				mainWeaponLabel(d.weaponId),
+				"",
+				formatAbilities(d.abilities),
+				"",
+				"",
+				"",
+			];
+		}
+		case OBJECTIVE_EVENT_TYPE: {
+			const d = event.data as ObjectiveData;
+			const sideText = (side: 0 | 1) =>
+				`${d.score[side] ?? "?"}${d.penalty[side] !== null ? ` (+${d.penalty[side]})` : ""}${d.control[side] ? " ctrl" : ""}`;
+			const clock = d.time === null ? "" : `${formatClock(d.time)} · `;
+			return [
+				...base,
+				"",
+				modeLabel(d.mode),
+				"",
+				"",
+				"",
+				"",
+				"",
+				"",
+				"",
+				`${clock}${sideText(0)} vs ${sideText(1)}`,
+				"",
+				"",
+			];
+		}
+		case MINIMAP_EVENT_TYPE: {
+			const d = event.data as MinimapData;
+			const self = d.teammates.find((p) => p.slot === "self");
+			return [
+				...base,
+				"", // lobby
+				"", // mode (not readable from the minimap)
+				stageLabel(d.stage), // stage (planner-signature match)
+				"", // winner_score
+				"", // loser_score
+				self?.name,
+				self ? mainWeaponLabel(self.weaponId) : "",
+				"",
+				self ? formatMinimapAbilities(self.abilities) : "",
+				formatMinimapPlayers(d),
+				"",
+				"",
+			];
+		}
+		default: {
+			// Scoreboard, ScoreboardBattleLogReplay and ScoreboardBattleLog share
+			// the base shape
+			const d = event.data as ScoreboardData &
+				Partial<ScoreboardBattleLogReplayData>;
+			return [
+				...base,
+				lobbyLabel(d.lobby),
+				modeLabel(d.mode),
+				stageLabel(d.stage),
+				d.matchScores[0],
+				d.matchScores[1],
+				d.povIndex === null ? "" : d.players[d.povIndex]?.name,
+				"",
+				"",
+				"",
+				formatPlayers(d),
+				d.replayCode ?? "",
+				d.timestamp ?? "",
+			];
+		}
+	}
+}
+
+function eventsToCsv(events: CsvEvent[]): string {
+	const lines = [HEADER.join(",")];
+	for (const event of events)
+		lines.push(eventCells(event).map(csvCell).join(","));
+	return `${lines.join("\r\n")}\r\n`;
+}
+
+export function downloadEventsCsv(filename: string, events: CsvEvent[]): void {
+	const blob = new Blob([eventsToCsv(events)], { type: "text/csv" });
+	const url = URL.createObjectURL(blob);
+	const a = document.createElement("a");
+	a.href = url;
+	a.download = filename;
+	a.click();
+	URL.revokeObjectURL(url);
+}
diff --git a/app/features/scanner/components/fixture-export.ts b/app/features/scanner/components/fixture-export.ts
new file mode 100644
index 000000000..7451567a2
--- /dev/null
+++ b/app/features/scanner/components/fixture-export.ts
@@ -0,0 +1,252 @@
+/**
+ * "Save as fixture": download the raw captured frame as PNG plus an
+ * expected.json prefilled from the detector's own output, so labeling a new
+ * fixture is review-and-correct instead of data entry.
+ */
+
+import {
+	DEATH_EVENT_TYPE,
+	type DeathData,
+} from "../core/detectors/death/index";
+import {
+	MAP_START_EVENT_TYPE,
+	type MapStartData,
+} from "../core/detectors/map-start/index";
+import {
+	MINIMAP_EVENT_TYPE,
+	type MinimapData,
+} from "../core/detectors/minimap/index";
+import {
+	OBJECTIVE_EVENT_TYPE,
+	type ObjectiveData,
+} from "../core/detectors/objective/index";
+import type { ScoreboardData } from "../core/detectors/scoreboard/index";
+import type { ScoreboardBattleLogReplayData } from "../core/detectors/scoreboard-battle-log-replay/index";
+import {
+	SCOREBOARD_OWN_EVENT_TYPE,
+	type ScoreboardOwnData,
+} from "../core/detectors/scoreboard-own/index";
+import { mainWeaponLabel, stageLabel, weaponLabel } from "./labels";
+
+/** Scoreboard data with the replay extras present when the event has them. */
+export type CardData = ScoreboardData &
+	Partial<Pick<ScoreboardBattleLogReplayData, "timestamp" | "replayCode">>;
+
+/** Any detector's event payload that can prefill a fixture. */
+export type FixtureData =
+	| CardData
+	| DeathData
+	| MapStartData
+	| ScoreboardOwnData
+	| MinimapData
+	| ObjectiveData;
+
+function isDeath(_data: FixtureData, eventType: string): _data is DeathData {
+	return eventType === DEATH_EVENT_TYPE;
+}
+
+function download(name: string, blob: Blob): void {
+	const url = URL.createObjectURL(blob);
+	const a = document.createElement("a");
+	a.href = url;
+	a.download = name;
+	a.click();
+	URL.revokeObjectURL(url);
+}
+
+function buildExpectedJson(
+	data: FixtureData | null,
+	eventType = "Scoreboard",
+): string {
+	if (!data) {
+		return `${JSON.stringify({ event: "none" }, null, 2)}\n`;
+	}
+	if (isDeath(data, eventType)) {
+		const label = weaponLabel(data.weaponType, data.weaponId);
+		return `${JSON.stringify(
+			{
+				event: eventType,
+				data: {
+					...(label !== null && { weaponLabel: label }),
+					...(data.weaponId !== null && { weaponId: data.weaponId }),
+					...(data.weaponType !== null && { weaponType: data.weaponType }),
+					abilities: data.abilities,
+					...(data.name !== null && { name: data.name }),
+				},
+			},
+			null,
+			2,
+		)}\n`;
+	}
+	if (eventType === SCOREBOARD_OWN_EVENT_TYPE) {
+		const own = data as ScoreboardOwnData;
+		return `${JSON.stringify(
+			{
+				event: eventType,
+				data: {
+					...(own.lobby !== null && { lobby: own.lobby }),
+					...(own.mode !== null && { mode: own.mode }),
+					...(own.stage !== null && {
+						stage: own.stage,
+						stageLabel: stageLabel(own.stage),
+					}),
+					...(own.weaponId !== null && {
+						weaponLabel: mainWeaponLabel(own.weaponId),
+						weaponId: own.weaponId,
+					}),
+					abilities: own.abilities,
+				},
+			},
+			null,
+			2,
+		)}\n`;
+	}
+	if (eventType === MINIMAP_EVENT_TYPE) {
+		const minimap = data as MinimapData;
+		return `${JSON.stringify(
+			{
+				event: eventType,
+				data: {
+					...(minimap.stage !== null && {
+						stage: minimap.stage,
+						stageLabel: stageLabel(minimap.stage),
+					}),
+					...(minimap.spectator && { spectator: true }),
+					teammates: minimap.teammates.map((p) => ({
+						slot: p.slot,
+						name: p.name,
+						weaponLabel: mainWeaponLabel(p.weaponId),
+						weaponId: p.weaponId,
+						abilities: p.abilities,
+					})),
+					enemies: minimap.enemies.map((p) => ({
+						...(minimap.spectator && { name: p.name }),
+						weaponLabel: mainWeaponLabel(p.weaponId),
+						weaponId: p.weaponId,
+						abilities: p.abilities,
+					})),
+				},
+			},
+			null,
+			2,
+		)}\n`;
+	}
+	if (eventType === OBJECTIVE_EVENT_TYPE) {
+		const objective = data as ObjectiveData;
+		return `${JSON.stringify(
+			{
+				event: eventType,
+				data: {
+					mode: objective.mode,
+					time: objective.time,
+					score: objective.score,
+					penalty: objective.penalty,
+					control: objective.control,
+				},
+			},
+			null,
+			2,
+		)}\n`;
+	}
+	// NB: not a type-predicate helper — CardData is structurally assignable to
+	// MapStartData, so a predicate would narrow the fall-through case to never
+	if (eventType === MAP_START_EVENT_TYPE) {
+		const mapStart = data as MapStartData;
+		return `${JSON.stringify(
+			{
+				event: eventType,
+				data: {
+					...(mapStart.mode !== null && { mode: mapStart.mode }),
+					...(mapStart.stage !== null && {
+						stage: mapStart.stage,
+						stageLabel: stageLabel(mapStart.stage),
+					}),
+				},
+			},
+			null,
+			2,
+		)}\n`;
+	}
+	const card = data as CardData;
+	return `${JSON.stringify(
+		{
+			event: eventType,
+			data: {
+				...(card.lobby !== null && { lobby: card.lobby }),
+				...(card.mode !== null && { mode: card.mode }),
+				...(card.stage !== null && {
+					stage: card.stage,
+					stageLabel: stageLabel(card.stage),
+				}),
+				...(card.timestamp != null && { timestamp: card.timestamp }),
+				...(card.replayCode != null && { replayCode: card.replayCode }),
+				matchScores: card.matchScores,
+				players: card.players.map((p) => ({
+					name: p.name,
+					weaponId: p.weaponId,
+					paint: p.paint,
+					ka: p.ka,
+					d: p.d,
+					s: p.s,
+				})),
+			},
+		},
+		null,
+		2,
+	)}\n`;
+}
+
+/**
+ * expected.json alone, for a frame the user already has on disk (Screenshot
+ * page). Null data produces the negative-fixture form.
+ */
+export function downloadExpectedJson(
+	data: FixtureData | null,
+	eventType?: string,
+): void {
+	download(
+		"expected.json",
+		new Blob([buildExpectedJson(data, eventType)], {
+			type: "application/json",
+		}),
+	);
+}
+
+/**
+ * Fixture export for a live detection: the stored PNG is the byte-exact
+ * frame the detector analyzed, paired with that event's own parse output.
+ */
+export function saveFixtureFromEvent(
+	frame: Blob,
+	data: FixtureData,
+	eventType: string,
+): void {
+	download("frame.png", frame);
+	download(
+		"expected.json",
+		new Blob([buildExpectedJson(data, eventType)], {
+			type: "application/json",
+		}),
+	);
+}
+
+export async function saveFixture(
+	video: HTMLVideoElement,
+	latest: { type: string; data: FixtureData } | null,
+): Promise<void> {
+	const canvas = document.createElement("canvas");
+	canvas.width = video.videoWidth;
+	canvas.height = video.videoHeight;
+	canvas.getContext("2d")!.drawImage(video, 0, 0);
+	const blob = await new Promise<Blob | null>((resolve) =>
+		canvas.toBlob(resolve, "image/png"),
+	);
+	if (!blob) throw new Error("could not encode frame");
+	download("frame.png", blob);
+	download(
+		"expected.json",
+		new Blob([buildExpectedJson(latest?.data ?? null, latest?.type)], {
+			type: "application/json",
+		}),
+	);
+}
diff --git a/app/features/scanner/components/format.ts b/app/features/scanner/components/format.ts
new file mode 100644
index 000000000..0c5a23699
--- /dev/null
+++ b/app/features/scanner/components/format.ts
@@ -0,0 +1,37 @@
+import { useDateTimeFormat } from "~/hooks/intl/useDateTimeFormat";
+
+/** hh:mm:ss for feed rows, CSV cells, and scan progress. */
+export function formatTime(t: number): string {
+	const h = Math.floor(t / 3600);
+	const m = Math.floor((t % 3600) / 60);
+	const s = Math.floor(t % 60);
+	return `${String(h).padStart(2, "0")}:${String(m).padStart(2, "0")}:${String(s).padStart(2, "0")}`;
+}
+
+/** the match timer's M:SS (215 → "3:35") */
+export function formatClock(seconds: number): string {
+	const m = Math.floor(seconds / 60);
+	const s = Math.floor(seconds % 60);
+	return `${m}:${String(s).padStart(2, "0")}`;
+}
+
+/**
+ * Locale-aware time-of-day formatter for detection timestamps (epoch ms)
+ * shown in scanner cards, in place of a raw `toLocaleTimeString()` call.
+ */
+export function useEventTimeFormatter(): (ms: number) => string {
+	const { formatter } = useDateTimeFormat({ timeStyle: "medium" });
+	return (ms: number) => formatter.format(new Date(ms));
+}
+
+/**
+ * Locale-aware date+time formatter for absolute timestamps (epoch ms), e.g.
+ * a saved VoD's scan time, in place of a raw `toLocaleString()` call.
+ */
+export function useEventDateTimeFormatter(): (ms: number) => string {
+	const { formatter } = useDateTimeFormat({
+		dateStyle: "medium",
+		timeStyle: "medium",
+	});
+	return (ms: number) => formatter.format(new Date(ms));
+}
diff --git a/app/features/scanner/components/labels.ts b/app/features/scanner/components/labels.ts
new file mode 100644
index 000000000..2d0148be9
--- /dev/null
+++ b/app/features/scanner/components/labels.ts
@@ -0,0 +1,59 @@
+/**
+ * English display labels for the ids scanner events carry. UI-only: events and
+ * detectors speak sendou ids (§ scanner-types.ts); these helpers turn them back
+ * into human-readable names for cards, CSV export, and the fixture
+ * exporter's informational *Label fields.
+ */
+
+import type {
+	MainWeaponId,
+	ModeShort,
+	SpecialWeaponId,
+	StageId,
+	SubWeaponId,
+} from "~/modules/in-game-lists/types";
+import gameMisc from "../../../../locales/en/game-misc.json";
+import {
+	ALL_WEAPON_ENTRIES,
+	type WeaponType,
+} from "../core/detectors/death/weapon-names";
+import type { ScannerLobby } from "../scanner-types";
+
+const MISC = gameMisc as Record<string, string>;
+
+const WEAPON_NAME_BY_KIND_AND_ID = new Map(
+	ALL_WEAPON_ENTRIES.map((e) => [`${e.type}:${e.id}`, e.name]),
+);
+
+export function weaponLabel(
+	type: WeaponType | null,
+	id: MainWeaponId | SubWeaponId | SpecialWeaponId | null,
+): string | null {
+	if (type === null || id === null) return null;
+	return WEAPON_NAME_BY_KIND_AND_ID.get(`${type}:${id}`) ?? String(id);
+}
+
+export function mainWeaponLabel(id: MainWeaponId | null): string | null {
+	return id === null ? null : weaponLabel("MAIN", id);
+}
+
+export function stageLabel(stageId: StageId | null): string | null {
+	return stageId === null
+		? null
+		: (MISC[`STAGE_${stageId}`] ?? String(stageId));
+}
+
+export function modeLabel(mode: ModeShort | null): string | null {
+	return mode === null ? null : (MISC[`MODE_LONG_${mode}`] ?? mode);
+}
+
+const LOBBY_LABELS: Record<ScannerLobby, string> = {
+	X: "X Battle",
+	SERIES: "Anarchy Battle (Series)",
+	OPEN: "Anarchy Battle (Open)",
+	PRIVATE: "Private Battle",
+};
+
+export function lobbyLabel(lobby: ScannerLobby | null): string | null {
+	return lobby === null ? null : LOBBY_LABELS[lobby];
+}
diff --git a/app/features/scanner/components/sendou-ingest.ts b/app/features/scanner/components/sendou-ingest.ts
new file mode 100644
index 000000000..6be20bd81
--- /dev/null
+++ b/app/features/scanner/components/sendou-ingest.ts
@@ -0,0 +1,281 @@
+/**
+ * Browser client for sendou.ink's /ingest. The scanner pages run inside
+ * sendou.ink itself, so requests are same-origin: the session cookie rides
+ * along automatically and the logged-in user comes from the root loader
+ * (useUser) instead of an identity probe. sendou.ink authenticates the
+ * session user and resolves the tournament/match server-side.
+ *
+ * The send unit is one ScannerMatch (core/match-builder.ts); every source
+ * event's IndexedDB record tracks the outcome (the `send` status the feed
+ * cards display). Resends are safe: sendou.ink dedupes matches by content
+ * hash, merges partials, and scoreboards first-ingest-wins.
+ */
+
+import * as R from "remeda";
+import type {
+	IngestedMatchLink,
+	IngestResponse,
+} from "~/features/scanner-ingest/scanner-ingest-schemas";
+import type { DetectedEvent } from "../core/detectors/types";
+import type { BuiltMatch } from "../core/match-builder";
+import { buildScannerMatches, ingestSkipReasons } from "../core/match-builder";
+import type { ScannerMatch } from "../core/scanner-match";
+import {
+	type SendStatus,
+	type StoredEvent,
+	updateEventsSend,
+} from "../store/events";
+
+const INGEST_URL = "/ingest";
+
+/** /ingest accepts at most 50 matches per request (mirrors the server cap) */
+const MAX_MATCHES_PER_REQUEST = 50;
+
+/**
+ * How long after each unlinked send to try again. A live send usually beats
+ * the players to reporting the game, so the first attempts find nothing to
+ * link to; these delays cover the reporting lag without hammering. Running
+ * out of them gives up — the capture ending still makes one last attempt.
+ */
+const UNLINKED_RETRY_DELAYS_MS = [30_000, 2 * 60_000, 5 * 60_000];
+
+export interface SendouUser {
+	id: number;
+	username: string;
+}
+
+export interface SendResult {
+	sentMatches: number;
+	failedMatches: number;
+}
+
+/**
+ * Builds the stored events into matches, POSTs the ingestable ones `include`
+ * selects, and records the outcome on every source event's `send` status
+ * (calling `onStatus` after each store write so the feed can refresh).
+ */
+export async function sendMatches({
+	events,
+	include,
+	onStatus,
+}: {
+	events: readonly StoredEvent[];
+	include: (built: BuiltMatch<StoredEvent>) => boolean;
+	onStatus: () => void;
+}): Promise<SendResult> {
+	const allBuilt = ingestableBuilt(
+		buildScannerMatches(events.filter((e) => e.id !== undefined)),
+	);
+	const selected = allBuilt.filter(include);
+	await clearOrphanedQueued(events, allBuilt);
+
+	const result: SendResult = { sentMatches: 0, failedMatches: 0 };
+	for (const built of selected) {
+		const ids = built.sources.map((e) => e.id!);
+		await updateEventsSend(ids, { state: "sending", at: Date.now() });
+		onStatus();
+		try {
+			const response = await postIngestMatches([built.match]);
+			const link = response.linkedMatches?.find(
+				(linked) => linked.matchIndex === 0,
+			)?.link;
+			// stored but not linked, and sendou.ink knows which tournament or
+			// SendouQ match this is: the game is just not reported yet, so a
+			// later resend can still land it. Without a context there is nothing
+			// to wait for and the match is as done as it will get.
+			const unlinked = !link && response.contextResolved;
+			await updateEventsSend(ids, {
+				state: unlinked ? "unlinked" : "sent",
+				at: Date.now(),
+				...(link ? { link } : null),
+				...(unlinked
+					? {
+							attempts: (aggregateSendStatus(built.sources)?.attempts ?? 0) + 1,
+						}
+					: null),
+			});
+			result.sentMatches++;
+		} catch (err) {
+			await updateEventsSend(ids, {
+				state: "failed",
+				at: Date.now(),
+				error: err instanceof Error ? err.message : String(err),
+			});
+			result.failedMatches++;
+		}
+		onStatus();
+	}
+	return result;
+}
+
+export interface VodResultsSendReport {
+	sentMatches: number;
+	totalMatches: number;
+	/** last failure's message; null when every request went through */
+	error: string | null;
+	/** links /ingest reported, keyed by index into the scan's ingestable matches */
+	links: Array<{ matchIndex: number; link: IngestedMatchLink }>;
+}
+
+/**
+ * One-go sender for the VoD tab's "Send results": builds a completed
+ * scan's events into matches and POSTs as many per request as the server
+ * cap allows — usually the whole scan in one request, so sendou.ink's
+ * content-based tournament resolution sees the full match sequence (its
+ * mode+stage order plus roster sides is near-unique in the user's history).
+ * No per-event status bookkeeping — VoD events don't live in the live feed
+ * store. Resending is safe (server-side dedupe/merge), so a partial failure
+ * can simply be retried whole.
+ */
+export async function sendVodResults(
+	events: readonly DetectedEvent[],
+	onProgress?: (sentMatches: number, totalMatches: number) => void,
+): Promise<VodResultsSendReport> {
+	const matches = ingestableMatches(events);
+
+	let sentMatches = 0;
+	let error: string | null = null;
+	const links: VodResultsSendReport["links"] = [];
+	const chunks = R.chunk(matches, MAX_MATCHES_PER_REQUEST);
+	for (const [chunkIndex, request] of chunks.entries()) {
+		const offset = chunkIndex * MAX_MATCHES_PER_REQUEST;
+		try {
+			const response = await postIngestMatches(request);
+			for (const linked of response.linkedMatches ?? []) {
+				links.push({
+					matchIndex: offset + linked.matchIndex,
+					link: linked.link,
+				});
+			}
+			sentMatches += request.length;
+			onProgress?.(sentMatches, matches.length);
+		} catch (err) {
+			error = err instanceof Error ? err.message : String(err);
+		}
+	}
+	return { sentMatches, totalMatches: matches.length, error, links };
+}
+
+/** The number of matches a set of events would send to /ingest. */
+export function countIngestableMatches(
+	events: readonly DetectedEvent[],
+): number {
+	return ingestableMatches(events).length;
+}
+
+/** Match selector: the match built from the given stored event. */
+export function matchContaining(
+	id: number,
+): (built: BuiltMatch<StoredEvent>) => boolean {
+	return (built) => built.sources.some((e) => e.id === id);
+}
+
+/**
+ * The single send status a match displays, folded from its source events:
+ * an in-flight send wins, then a failure, then success, then queued. Within
+ * a state the most recent change is shown.
+ */
+export function aggregateSendStatus(
+	sources: readonly StoredEvent[],
+): SendStatus | undefined {
+	const statuses = sources
+		.map((e) => e.send)
+		.filter((status) => status !== undefined);
+	for (const state of [
+		"sending",
+		"failed",
+		"unlinked",
+		"sent",
+		"queued",
+	] as const) {
+		const ofState = statuses.filter((status) => status.state === state);
+		if (ofState.length > 0) {
+			return ofState.reduce((a, b) => (a.at >= b.at ? a : b));
+		}
+	}
+	return undefined;
+}
+
+/** Match selector: matches not yet sent (nor currently sending). */
+export function unsentMatches(built: BuiltMatch<StoredEvent>): boolean {
+	return !built.sources.some(
+		(e) => e.send?.state === "sent" || e.send?.state === "sending",
+	);
+}
+
+/**
+ * Match selector: matches sendou.ink stored without a game to link them to,
+ * whose next attempt is due. Exhausting the backoff stops the retries.
+ */
+export function retryableUnlinkedMatches(
+	built: BuiltMatch<StoredEvent>,
+): boolean {
+	const status = aggregateSendStatus(built.sources);
+	if (status?.state !== "unlinked") return false;
+
+	const delay = UNLINKED_RETRY_DELAYS_MS[(status.attempts ?? 1) - 1];
+	return delay !== undefined && Date.now() - status.at >= delay;
+}
+
+function ingestableMatches(events: readonly DetectedEvent[]): ScannerMatch[] {
+	return ingestableBuilt(buildScannerMatches(events)).map(
+		(built) => built.match,
+	);
+}
+
+function ingestableBuilt<E extends DetectedEvent>(
+	built: BuiltMatch<E>[],
+): BuiltMatch<E>[] {
+	const skipped = ingestSkipReasons(built);
+	return built.filter((match) => !skipped.has(match));
+}
+
+async function postIngestMatches(
+	matches: ScannerMatch[],
+): Promise<IngestResponse> {
+	const res = await fetch(INGEST_URL, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({ matches }),
+	});
+	if (!res.ok) {
+		throw new Error(
+			res.status === 401 ? "not logged in to sendou.ink" : await errorText(res),
+		);
+	}
+	return res.json();
+}
+
+/**
+ * Live sending marks events "queued" as they arrive; ones the match builder
+ * later leaves out (non-private match, older than the fallback window) would
+ * sit "queued" forever. Once a match boundary has passed them they can
+ * never join a future match, so clear their status back to "not sent".
+ */
+async function clearOrphanedQueued(
+	events: readonly StoredEvent[],
+	allBuilt: BuiltMatch<StoredEvent>[],
+): Promise<void> {
+	const lastBoundaryT = Math.max(
+		...allBuilt.map((built) => built.sources.at(-1)!.t),
+		Number.NEGATIVE_INFINITY,
+	);
+	const builtIds = new Set(
+		allBuilt.flatMap((built) => built.sources.map((e) => e.id)),
+	);
+	const orphaned = events
+		.filter(
+			(e) =>
+				e.send?.state === "queued" &&
+				e.id !== undefined &&
+				!builtIds.has(e.id) &&
+				e.t <= lastBoundaryT,
+		)
+		.map((e) => e.id!);
+	if (orphaned.length > 0) await updateEventsSend(orphaned, undefined);
+}
+
+async function errorText(res: Response): Promise<string> {
+	const text = await res.text().catch(() => "");
+	return `POST /ingest -> ${res.status}${text ? `: ${text.slice(0, 200)}` : ""}`;
+}
diff --git a/app/features/scanner/components/sendou-upload.ts b/app/features/scanner/components/sendou-upload.ts
new file mode 100644
index 000000000..4d6ac19ac
--- /dev/null
+++ b/app/features/scanner/components/sendou-upload.ts
@@ -0,0 +1,89 @@
+/**
+ * "Upload to sendou.ink" link for a fully processed VoD: the detected events
+ * are built into ScannerMatches (core/match-builder.ts), projected onto the
+ * slim per-match rows the `ingest` search param of sendou.ink's /vods/new
+ * form carries (an `SP.json` param the search-params module compresses),
+ * which prefills a new VoD from them (the user adds the YouTube
+ * URL/title/date and fixes any misreads before submitting).
+ *
+ * The VoD type is auto-detected: footage containing the casted 8-player
+ * spectator map screen is a CAST VoD; anything else leaves the form's default
+ * type untouched. A match without a mode read prefills the form's SZ default,
+ * flagged `modeAssumed` — the fabricated default lives here, not on
+ * ScannerMatch.
+ */
+import type {
+	IngestVodMatchInput,
+	IngestVodPrefill,
+} from "~/features/scanner-ingest/scanner-ingest-vod-schemas";
+import { vodsNewSearchParams } from "~/features/vods/vods-search-params";
+import type { MainWeaponId, ModeShort } from "~/modules/in-game-lists/types";
+import { newVodPage } from "~/utils/urls";
+import type { DetectedEvent } from "../core/detectors/types";
+import { buildScannerMatches } from "../core/match-builder";
+import type { ScannerMatch } from "../core/scanner-match";
+
+/**
+ * GET query params ride the request line, and servers/proxies commonly cap
+ * that around 8-16 KB. A VoD long enough to blow past this needs a POST
+ * flow, which /vods/new doesn't offer yet — surface that instead of
+ * emitting a URL the server would reject with an opaque error.
+ */
+const MAX_URL_LENGTH = 8000;
+
+/** The prefill default for a match whose mode no source read. */
+const DEFAULT_VOD_MODE = "SZ" satisfies ModeShort;
+
+export interface SendouUpload {
+	/** prefilled /vods/new path (same-origin); null when nothing usable to send */
+	url: string | null;
+	/** set when matches exist but no usable URL could be built */
+	problem: string | null;
+}
+
+/** Builds the prefilled /vods/new link for a completed scan's events. */
+export function sendouUpload(events: readonly DetectedEvent[]): SendouUpload {
+	const matches = buildScannerMatches(events)
+		.map((built) => built.match)
+		.filter((match) => match.teams.some((team) => team.players.length > 0));
+	if (matches.length === 0) return { url: null, problem: null };
+
+	const isCast = matches.some((match) => match.cast);
+
+	const payload: IngestVodPrefill = {
+		...(isCast ? { type: "CAST" as const } : null),
+		matches: matches.map(toPrefillMatch),
+	};
+	const result = vodsNewSearchParams.href(newVodPage(), { ingest: payload });
+	if (result.length > MAX_URL_LENGTH) {
+		return {
+			url: null,
+			problem:
+				`prefill URL is ${result.length} chars (limit ~${MAX_URL_LENGTH}) — ` +
+				"too many matches for a GET query param.",
+		};
+	}
+	return { url: result, problem: null };
+}
+
+function toPrefillMatch(match: ScannerMatch): IngestVodMatchInput {
+	return {
+		startsAt: match.startsAt ?? 0,
+		mode: match.mode ?? DEFAULT_VOD_MODE,
+		modeAssumed: match.mode === null,
+		stage: match.stage,
+		// /vods/new splits this at a fixed 4 slots per team, so pad short rosters
+		weapons: match.teams.flatMap((team) =>
+			Array.from({ length: 4 }, (_, i) => team.players[i]?.weaponId ?? null),
+		),
+		povWeapon: povWeaponId(match),
+	};
+}
+
+function povWeaponId(match: ScannerMatch): MainWeaponId | undefined {
+	if (!match.pov) return undefined;
+
+	return (
+		match.teams[match.pov.team].players[match.pov.index]?.weaponId ?? undefined
+	);
+}
diff --git a/app/features/scanner/components/styles.css b/app/features/scanner/components/styles.css
new file mode 100644
index 000000000..ac8070c8c
--- /dev/null
+++ b/app/features/scanner/components/styles.css
@@ -0,0 +1,1218 @@
+/*
+Scanner feature styles, ported from emberz. Scoped under .scanner-app so nothing
+leaks into the host app; design tokens come from sendou.ink's own
+app/styles/vars.css (the emberz copies of those tokens were dropped).
+*/
+.scanner-app {
+	container: scanner / inline-size;
+}
+
+.scanner-app .topbar {
+	display: flex;
+	align-items: center;
+	gap: var(--s-6);
+	padding-bottom: var(--s-3);
+	border-bottom: var(--border-width) solid var(--color-bg-high);
+	margin-bottom: var(--s-4);
+}
+
+.scanner-app .topbar nav {
+	display: flex;
+	gap: var(--s-2);
+}
+
+.scanner-app .topbar nav a {
+	color: var(--color-text-high);
+	font-size: var(--font-xs);
+	font-weight: var(--weight-bold);
+	text-decoration: none;
+	padding: var(--s-1) var(--s-2-5);
+	border-radius: var(--radius-field);
+}
+
+.scanner-app .topbar nav a:hover {
+	color: var(--color-text);
+}
+
+.scanner-app .topbar nav a:focus-visible {
+	outline: var(--focus-ring);
+	outline-offset: 1px;
+}
+
+.scanner-app .topbar nav a.active {
+	color: var(--color-text-accent);
+	background: var(--color-bg-high);
+}
+
+.scanner-app button {
+	display: inline-flex;
+	align-items: center;
+	justify-content: center;
+	gap: var(--s-1-5);
+	border: var(--border-style-accent);
+	border-radius: var(--radius-field);
+	appearance: none;
+	background: var(--color-text-accent);
+	color: var(--color-text-inverse);
+	cursor: pointer;
+	font-family: inherit;
+	font-size: var(--font-xs);
+	font-weight: var(--weight-bold);
+	padding: 0 var(--field-padding);
+	height: var(--field-size-sm);
+	white-space: nowrap;
+	user-select: none;
+
+	& > svg {
+		width: 16px;
+		height: 16px;
+	}
+}
+
+.scanner-app button.outlined {
+	background: transparent;
+	color: var(--color-text-accent);
+}
+
+.scanner-app button:focus-visible {
+	outline: var(--focus-ring);
+	outline-offset: 1px;
+}
+
+.scanner-app button:active {
+	transform: translateY(1px);
+}
+
+.scanner-app button:disabled {
+	cursor: not-allowed;
+	opacity: 0.5;
+	transform: initial;
+}
+
+/* the global select is full width, which would break the controls row */
+.scanner-app select {
+	appearance: none;
+	width: auto;
+	max-width: 20rem;
+	border: var(--border-style);
+	border-radius: var(--radius-field);
+	background-color: var(--color-bg);
+	background-image: var(--field-icon-chevron);
+	background-position: center right var(--field-padding);
+	background-size: var(--field-size-icon) auto;
+	background-repeat: no-repeat;
+	color: var(--color-text);
+	cursor: pointer;
+	font-family: inherit;
+	font-size: var(--font-xs);
+	height: var(--field-size-sm);
+	padding: 0 calc(var(--field-size-icon) + var(--field-padding) + var(--s-2)) 0
+		var(--field-padding);
+	text-overflow: ellipsis;
+	white-space: nowrap;
+	overflow: hidden;
+	outline: none;
+}
+
+.scanner-app select:focus-within {
+	outline: var(--focus-ring);
+	outline-offset: 1px;
+}
+
+.scanner-app select:disabled {
+	cursor: not-allowed;
+	opacity: 0.5;
+}
+
+.scanner-app .controls {
+	display: flex;
+	gap: var(--s-2);
+	align-items: center;
+	margin-bottom: var(--s-3);
+	flex-wrap: wrap;
+}
+
+.scanner-app .status {
+	padding: var(--s-0-5) var(--s-3);
+	border-radius: var(--radius-full);
+	font-size: var(--font-2xs);
+	font-weight: var(--weight-bold);
+	border: var(--border-style);
+}
+
+.scanner-app .status.idle {
+	color: var(--color-text-high);
+}
+
+.scanner-app .status.watching {
+	color: var(--color-info-high);
+	border-color: var(--color-info-low);
+	background: var(--color-info-low);
+}
+
+.scanner-app .status.detected {
+	display: inline-flex;
+	align-items: center;
+	gap: 5px;
+	color: var(--color-success-high);
+	border-color: var(--color-success-low);
+	background: var(--color-success-low);
+}
+
+.scanner-app .live-layout {
+	display: grid;
+	grid-template-columns: minmax(320px, 640px) minmax(0, 1fr);
+	gap: var(--s-4);
+	align-items: start;
+}
+
+.scanner-app video.preview,
+.scanner-app canvas.preview {
+	width: 100%;
+	background: #000;
+	border-radius: var(--radius-box);
+	border: var(--border-width) solid var(--color-bg-high);
+}
+
+.scanner-app .feed {
+	display: flex;
+	flex-direction: column;
+	gap: var(--s-3);
+}
+
+.scanner-app .match-list {
+	display: flex;
+	flex-direction: column;
+	gap: var(--s-3);
+}
+
+.scanner-app .card {
+	background: var(--color-bg-high);
+	border-radius: var(--radius-box);
+	padding: var(--s-4);
+}
+
+.scanner-app .card .meta {
+	display: flex;
+	flex-wrap: wrap;
+	gap: var(--s-2) var(--s-4);
+	color: var(--color-text-high);
+	font-size: var(--font-2xs);
+	font-weight: var(--weight-semi);
+	font-variant-numeric: tabular-nums;
+	margin-bottom: var(--s-2);
+	align-items: center;
+
+	/* time + confidence + event type read as one unit, the detail text after it
+	   sits further away */
+	& .meta-pills {
+		display: flex;
+		flex-wrap: wrap;
+		align-items: center;
+		gap: var(--s-1);
+	}
+
+	/* event-type chip: neutral like the match chips, the icon carries the accent */
+	& .status.detected {
+		gap: 5px;
+		padding: var(--s-0-5) var(--s-2-5);
+		color: var(--color-text);
+		border-color: var(--color-border);
+		background: var(--color-bg);
+
+		& .event-type-icon {
+			color: var(--color-text-accent);
+		}
+	}
+
+	/* time + confidence chips share the event-type chip look; icon documents
+	   the value, full label on hover via title */
+	& .meta-chip {
+		display: inline-flex;
+		align-items: center;
+		gap: 5px;
+		padding: var(--s-0-5) var(--s-2-5);
+		border-radius: var(--radius-full);
+		border: var(--border-style);
+		background: var(--color-bg);
+		color: var(--color-text);
+		font-weight: var(--weight-bold);
+
+		& .meta-chip-icon {
+			color: var(--color-text-accent);
+		}
+	}
+}
+
+.scanner-app .card img.thumb {
+	display: block;
+	height: 40px;
+	width: auto;
+	border-radius: var(--radius-field);
+}
+
+.scanner-app .teams {
+	display: grid;
+	grid-template-columns: repeat(auto-fit, minmax(min(100%, 260px), 1fr));
+	gap: var(--s-2);
+
+	/* single hug-content box (own-results cards) */
+	&.solo {
+		grid-template-columns: max-content;
+	}
+
+	/* single full-width box (death cards) */
+	&.death {
+		grid-template-columns: 1fr;
+	}
+}
+
+/* sendou.ink send status strip under a feed card */
+.scanner-app .send-wrap {
+	display: flex;
+	flex-direction: column;
+	gap: var(--s-0-5);
+}
+
+.scanner-app .send-strip {
+	display: flex;
+	gap: var(--s-3);
+	align-items: center;
+	padding: var(--s-1) var(--s-4);
+	border-radius: var(--radius-box);
+	background: var(--color-bg-high);
+	font-size: var(--font-2xs);
+	font-weight: var(--weight-semi);
+	color: var(--color-text-high);
+}
+
+.scanner-app .send-strip.sent {
+	color: var(--color-success-high);
+	background: var(--color-success-low);
+}
+
+.scanner-app .send-strip.failed {
+	color: var(--color-error-high);
+	background: var(--color-error-low);
+}
+
+.scanner-app .send-strip.queued,
+.scanner-app .send-strip.sending {
+	color: var(--color-info-high);
+	background: var(--color-info-low);
+}
+
+.scanner-app .score {
+	color: var(--color-text-high);
+	font-size: var(--font-2xs);
+}
+
+.scanner-app .error {
+	color: var(--color-error);
+}
+
+.scanner-app .send-strip .error {
+	color: inherit;
+	font-weight: var(--weight-body);
+}
+
+/* lighter than a solid slab: translucent fill + hairline so the boxes read
+   as grouping, not chrome */
+.scanner-app .team {
+	border-radius: var(--radius-field);
+	padding: var(--s-2) var(--s-2-5);
+	background: color-mix(in oklab, var(--color-bg) 45%, transparent);
+	border: 1px solid color-mix(in oklab, var(--color-border) 55%, transparent);
+	min-width: 0;
+	overflow-x: auto;
+}
+
+.scanner-app .minimap-player {
+	display: flex;
+	align-items: center;
+	gap: var(--s-2);
+	padding-block: 3px;
+	font-size: var(--font-xs);
+
+	& .weapon-missing {
+		flex-shrink: 0;
+		width: 24px;
+		text-align: center;
+		color: var(--color-text-high);
+	}
+
+	& .name {
+		flex: 1 1 0;
+		min-width: 0;
+		overflow: hidden;
+		text-overflow: ellipsis;
+		white-space: nowrap;
+	}
+
+	& .abilities {
+		display: flex;
+		align-items: center;
+		gap: var(--s-0-5);
+		flex-shrink: 0;
+	}
+}
+
+/* d-pad chevron / face-button pucks, same round-solid language as weapon icons */
+.scanner-app .slot-marker {
+	flex-shrink: 0;
+	display: inline-flex;
+	align-items: center;
+	justify-content: center;
+	width: 20px;
+	height: 20px;
+	border-radius: var(--radius-full);
+	background: var(--color-bg-badge);
+	color: #fff;
+	font-size: var(--font-2xs);
+	font-weight: var(--weight-bold);
+	line-height: 1;
+
+	& svg {
+		width: 13px;
+		height: 13px;
+	}
+
+	&.right svg {
+		transform: rotate(90deg);
+	}
+
+	&.down svg {
+		transform: rotate(180deg);
+	}
+
+	&.left svg {
+		transform: rotate(-90deg);
+	}
+}
+
+.scanner-app .death-body {
+	display: flex;
+	align-items: center;
+	gap: var(--s-3);
+	padding-block: var(--s-0-5);
+
+	& .death-info {
+		display: flex;
+		flex-direction: column;
+		gap: var(--s-0-5);
+		min-width: 0;
+
+		& .death-name {
+			font-size: var(--font-xs);
+			overflow: hidden;
+			text-overflow: ellipsis;
+			white-space: nowrap;
+		}
+
+		& .death-weapon {
+			font-size: var(--font-2xs);
+			font-weight: var(--weight-semi);
+			color: var(--color-text-high);
+		}
+	}
+
+	& .death-abilities {
+		display: flex;
+		align-items: center;
+		gap: var(--s-2-5);
+		margin-inline-start: auto;
+		flex-wrap: wrap;
+
+		& .gear {
+			display: flex;
+			align-items: center;
+			gap: var(--s-0-5);
+		}
+	}
+}
+
+.scanner-app .team h3 {
+	margin: 0 0 var(--s-1-5);
+	font-size: var(--font-2xs);
+	font-weight: var(--weight-bold);
+	text-transform: uppercase;
+	letter-spacing: 0.06em;
+	color: var(--color-text-high);
+}
+
+.scanner-app .team.win h3 {
+	color: var(--color-error-high);
+}
+
+.scanner-app .team.lose h3 {
+	color: var(--color-info-high);
+}
+
+.scanner-app table.players {
+	width: 100%;
+	border-collapse: collapse;
+	font-size: var(--font-xs);
+}
+
+.scanner-app table.players td {
+	padding: var(--s-0-5) var(--s-1-5);
+	white-space: nowrap;
+}
+
+.scanner-app table.players td.num {
+	text-align: right;
+	font-variant-numeric: tabular-nums;
+}
+
+.scanner-app .teams.solo table.players {
+	width: auto;
+}
+
+/* round black pucks, same language as the match header weapon row */
+.scanner-app img.weapon-icon {
+	width: 28px;
+	height: 28px;
+	vertical-align: middle;
+	background: var(--color-bg-badge);
+	border-radius: var(--radius-full);
+	padding: var(--s-0-5);
+}
+
+.scanner-app .minimap-player img.weapon-icon {
+	flex-shrink: 0;
+	width: 24px;
+	height: 24px;
+}
+
+.scanner-app .weapon-cell {
+	display: inline-flex;
+	align-items: center;
+	gap: var(--s-1);
+}
+
+.scanner-app button.ability-trigger {
+	height: auto;
+	padding: var(--s-0-5);
+	background: var(--color-bg-higher);
+	border: 1px solid var(--color-border-high);
+	border-radius: var(--radius-selector);
+}
+
+.scanner-app button.ability-trigger img {
+	display: block;
+	width: var(--field-size-icon);
+	height: var(--field-size-icon);
+}
+
+.scanner-app .vod-list {
+	display: flex;
+	flex-direction: column;
+	gap: var(--s-2);
+}
+
+.scanner-app .vod-item {
+	display: flex;
+	align-items: center;
+	gap: var(--s-3);
+	background: var(--color-bg-high);
+	border-radius: var(--radius-box);
+	padding: var(--s-3) var(--s-4);
+}
+
+.scanner-app .vod-item .name {
+	font-size: var(--font-sm);
+	font-weight: var(--weight-bold);
+	overflow: hidden;
+	text-overflow: ellipsis;
+	white-space: nowrap;
+}
+
+.scanner-app .vod-item .score {
+	flex: 1;
+}
+
+/* the shared destructive variant loses to `.scanner-app button` on specificity */
+.scanner-app button.vod-delete {
+	width: var(--field-size-sm);
+	padding: 0;
+	border-color: var(--color-error);
+	background: var(--color-error);
+	outline-color: var(--color-error);
+}
+
+.scanner-app .dropzone {
+	border: var(--border-width) dashed var(--color-border-high);
+	border-radius: var(--radius-box);
+	padding: var(--s-8);
+	text-align: center;
+	color: var(--color-text-high);
+	font-size: var(--font-sm);
+	font-weight: var(--weight-semi);
+	margin-bottom: var(--s-4);
+}
+
+.scanner-app .dropzone label {
+	display: inline;
+	font-size: inherit;
+	font-weight: inherit;
+	margin-block-end: 0;
+	text-decoration: underline;
+	cursor: pointer;
+}
+
+.scanner-app .dropzone.over {
+	border-color: var(--color-text-accent);
+	color: var(--color-text-accent);
+}
+
+.scanner-app .screenshot-frame {
+	position: relative;
+	margin-bottom: var(--s-4);
+}
+
+.scanner-app .screenshot-frame canvas {
+	width: 100%;
+	border-radius: var(--radius-box);
+	border: var(--border-width) solid var(--color-bg-high);
+}
+
+.scanner-app table.inspector {
+	width: 100%;
+	border-collapse: collapse;
+	font-size: var(--font-xs);
+}
+
+.scanner-app table.inspector th {
+	text-align: left;
+	color: var(--color-text-high);
+	font-size: var(--font-2xs);
+	font-weight: var(--weight-bold);
+	padding: var(--s-1-5);
+	border-bottom: var(--border-style);
+}
+
+.scanner-app table.inspector td {
+	padding: var(--s-1-5);
+	border-bottom: 1px solid var(--color-bg-high);
+	vertical-align: middle;
+}
+
+.scanner-app table.inspector canvas {
+	display: block;
+	background: #000;
+	border-radius: var(--radius-selector);
+}
+
+.scanner-app .candidates {
+	display: flex;
+	gap: var(--s-2);
+	align-items: center;
+}
+
+.scanner-app .candidates .cand {
+	display: flex;
+	flex-direction: column;
+	align-items: center;
+	gap: var(--s-0-5);
+	font-size: var(--font-2xs);
+	color: var(--color-text-high);
+}
+
+.scanner-app .weapon-candidates .cand:first-child {
+	color: var(--color-success);
+}
+
+/* internal navigation styled like the sibling action buttons */
+.scanner-app .link-button {
+	display: inline-flex;
+	align-items: center;
+	justify-content: center;
+	gap: var(--s-1-5);
+	padding: 0 var(--field-padding);
+	height: var(--field-size-sm);
+	border: var(--border-style-accent);
+	border-radius: var(--radius-field);
+	background: var(--color-text-accent);
+	color: var(--color-text-inverse);
+	font-size: var(--font-xs);
+	font-weight: var(--weight-bold);
+	white-space: nowrap;
+	text-decoration: none;
+
+	& > svg {
+		width: 16px;
+		height: 16px;
+	}
+
+	&:active {
+		transform: translateY(1px);
+	}
+
+	&:focus-visible {
+		outline: var(--focus-ring);
+		outline-offset: 1px;
+	}
+}
+
+/* secondary actions live behind this icon-only trigger, pushed to the row's end */
+.scanner-app button.icon-menu {
+	margin-inline-start: auto;
+	width: var(--field-size-sm);
+	padding: 0;
+	border: var(--border-style);
+	background: var(--color-bg-higher);
+	color: var(--color-text);
+
+	&:hover {
+		color: var(--color-text-accent);
+	}
+
+	& > svg {
+		width: var(--field-size-icon);
+		height: var(--field-size-icon);
+		margin: 0;
+	}
+}
+
+/* ── ingested matches feed ─────────────────────────────────────────── */
+
+.scanner-app .set-divider {
+	display: flex;
+	align-items: center;
+	gap: var(--s-2-5);
+	margin-top: var(--s-1-5);
+	color: var(--color-text-high);
+	font-size: var(--font-2xs);
+	font-weight: var(--weight-semi);
+	text-transform: uppercase;
+	letter-spacing: 0.08em;
+
+	&::before,
+	&::after {
+		content: "";
+		flex: 1;
+		height: var(--border-width);
+		background-color: var(--color-border);
+	}
+}
+
+.scanner-app .match-card {
+	container: match-card / inline-size;
+	position: sticky;
+	top: var(--layout-sticky-top);
+	z-index: 1;
+	overflow: hidden;
+	border-radius: var(--radius-box);
+	background-color: var(--color-bg-high);
+
+	/* only cards the scan just formed animate in — see MatchCard's `enter` */
+	&.enter {
+		animation: scanner-card-in 0.4s cubic-bezier(0.16, 1, 0.3, 1) both;
+	}
+
+	/* one overlay element all send-state effects draw on */
+	&::after {
+		content: "";
+		position: absolute;
+		inset: 0;
+		border-radius: inherit;
+		pointer-events: none;
+	}
+
+	&.sending {
+		box-shadow: inset 0 0 0 1px var(--color-info-low);
+	}
+
+	&.sending::after {
+		background-image: linear-gradient(
+			105deg,
+			transparent 40%,
+			rgb(255 255 255 / 0.09) 50%,
+			transparent 60%
+		);
+		background-size: 250% 100%;
+		animation: scanner-sheen 1.4s linear infinite;
+	}
+
+	&.flash-sent::after {
+		animation: scanner-sent-pop 0.8s ease-out both;
+	}
+
+	&.live {
+		box-shadow: inset 0 0 0 1px var(--color-info-low);
+	}
+}
+
+@keyframes scanner-card-in {
+	from {
+		opacity: 0;
+		transform: translateY(10px) scale(0.98);
+	}
+}
+
+@keyframes scanner-sheen {
+	from {
+		background-position: 130% 0;
+	}
+	to {
+		background-position: -130% 0;
+	}
+}
+
+@keyframes scanner-sent-pop {
+	0% {
+		opacity: 1;
+		box-shadow:
+			inset 0 0 0 2px var(--color-success),
+			inset 0 0 32px var(--color-success-low);
+	}
+	100% {
+		opacity: 0;
+		box-shadow:
+			inset 0 0 0 2px var(--color-success),
+			inset 0 0 32px var(--color-success-low);
+	}
+}
+
+.scanner-app .match-card-main {
+	display: flex;
+	align-items: center;
+	flex-wrap: wrap;
+	gap: var(--s-2) var(--s-3);
+	padding: var(--s-3) var(--s-4);
+	min-height: 66px;
+}
+
+.scanner-app .match-card.flash-failed .match-card-main {
+	animation: scanner-shake 0.35s ease;
+}
+
+@keyframes scanner-shake {
+	20% {
+		transform: translateX(-4px);
+	}
+	50% {
+		transform: translateX(4px);
+	}
+	80% {
+		transform: translateX(-2px);
+	}
+}
+
+.scanner-app .match-mode {
+	flex-shrink: 0;
+	filter: drop-shadow(0 1px 2px rgb(0 0 0 / 0.5));
+}
+
+.scanner-app .match-headline {
+	display: flex;
+	flex-direction: column;
+	gap: var(--s-1);
+	/* claims row space so the score/chips can never crush the stage name
+	   out of view in a narrow feed column; wraps instead */
+	flex: 1 1 0;
+	min-width: 150px;
+}
+
+.scanner-app .match-title {
+	display: flex;
+	align-items: center;
+	flex-wrap: wrap;
+	gap: var(--s-1) var(--s-2);
+}
+
+.scanner-app .match-stage {
+	font-size: var(--font-sm);
+	font-weight: var(--weight-extra);
+	line-height: 1.1;
+}
+
+.scanner-app .match-meta {
+	font-size: var(--font-2xs);
+	font-weight: var(--weight-semi);
+	color: var(--color-text-high);
+}
+
+.scanner-app .match-weapons {
+	display: flex;
+	align-items: center;
+	flex-wrap: wrap;
+	gap: var(--s-0-5);
+
+	/* a team is one wrapping unit: the eight never break up mid-team */
+	& .weapon-row {
+		display: flex;
+		align-items: center;
+		gap: var(--s-0-5);
+	}
+
+	& .vs {
+		font-size: var(--font-2xs);
+		font-weight: var(--weight-semi);
+		color: var(--color-text-high);
+		margin: 0 5px;
+	}
+
+	& img.weapon-icon {
+		flex-shrink: 0;
+		width: 32px;
+		height: 32px;
+		border-radius: var(--radius-full);
+		padding: var(--s-0-5);
+
+		&.pov {
+			outline: var(--border-style-high);
+			background-color: var(--color-bg-high);
+			outline-offset: 1px;
+		}
+	}
+}
+
+.scanner-app .match-side {
+	display: flex;
+	flex-direction: column;
+	align-items: flex-end;
+	gap: var(--s-1-5);
+	margin-inline-start: auto;
+	align-self: stretch;
+	flex-shrink: 0;
+}
+
+.scanner-app .match-score {
+	font-weight: var(--weight-extra);
+	font-variant-numeric: tabular-nums;
+	line-height: 1;
+	padding: 5px var(--s-3);
+	border-radius: var(--radius-full);
+	background: color-mix(in oklab, var(--color-bg) 72%, transparent);
+	backdrop-filter: blur(8px);
+
+	& .win {
+		color: var(--color-error-high);
+	}
+
+	& .lose {
+		color: var(--color-info-high);
+	}
+}
+
+.scanner-app .match-chip {
+	display: inline-flex;
+	align-items: center;
+	gap: var(--s-1-5);
+	padding: var(--s-0-5) var(--s-2-5);
+	border-radius: var(--radius-full);
+	font-size: var(--font-2xs);
+	font-weight: var(--weight-bold);
+	border: var(--border-style);
+	background-color: var(--color-bg);
+	color: var(--color-text-high);
+	white-space: nowrap;
+
+	& .dot {
+		width: 7px;
+		height: 7px;
+		border-radius: var(--radius-full);
+		background: currentColor;
+	}
+
+	&.live {
+		color: var(--color-error);
+		border-color: var(--color-error-low);
+		text-transform: uppercase;
+		letter-spacing: 0.08em;
+
+		& .dot {
+			animation: scanner-pulse 1.4s ease-in-out infinite;
+		}
+	}
+
+	&.in-progress .dot {
+		animation: scanner-pulse 1.4s ease-in-out infinite;
+	}
+
+	&.queued,
+	&.sending {
+		color: var(--color-info-high);
+		border-color: var(--color-info-low);
+		background-color: var(--color-info-low);
+
+		& .dot {
+			animation: scanner-pulse 1.4s ease-in-out infinite;
+		}
+	}
+
+	&.sent {
+		color: var(--color-success-high);
+		border-color: var(--color-success-low);
+		background-color: var(--color-success-low);
+
+		& a {
+			color: inherit;
+			text-decoration: underline;
+			text-underline-offset: 2px;
+
+			&:hover {
+				color: var(--color-text-high);
+			}
+		}
+	}
+
+	&.unlinked {
+		color: var(--color-warning-high);
+		border-color: var(--color-warning-low);
+		background-color: var(--color-warning-low);
+	}
+
+	&.failed {
+		color: var(--color-error-high);
+		border-color: var(--color-error-low);
+		background-color: var(--color-error-low);
+	}
+}
+
+@keyframes scanner-pulse {
+	50% {
+		opacity: 0.25;
+		transform: scale(0.8);
+	}
+}
+
+/* undo the scanner-wide solid button look for the banner icon button */
+.scanner-app button.match-expand {
+	flex-shrink: 0;
+	margin-block-start: auto;
+	width: 28px;
+	height: 28px;
+	padding: 0;
+	border: none;
+	border-radius: var(--radius-full);
+	background: color-mix(in oklab, var(--color-bg) 55%, transparent);
+	backdrop-filter: blur(8px);
+	color: var(--color-text-high);
+	transition: transform 0.25s cubic-bezier(0.16, 1, 0.3, 1);
+
+	& svg {
+		width: var(--field-size-icon);
+		height: var(--field-size-icon);
+	}
+
+	&:hover {
+		color: var(--color-text);
+		background: color-mix(in oklab, var(--color-bg) 78%, transparent);
+	}
+
+	&.expanded {
+		transform: rotate(180deg);
+	}
+}
+
+/* the frame preview: an unstyled button so the image itself is the target */
+.scanner-app .card .meta button.thumb-button {
+	height: auto;
+	padding: 0;
+	border: none;
+	background: none;
+	margin-inline-start: auto;
+	border-radius: var(--radius-field);
+
+	&:hover {
+		filter: brightness(1.2);
+	}
+}
+
+.scanner-app .match-error {
+	padding: 0 var(--s-4) var(--s-2-5);
+	font-size: var(--font-2xs);
+	color: var(--color-error);
+}
+
+.scanner-app .match-card-group {
+	display: flex;
+	flex-direction: column;
+	gap: var(--s-2);
+}
+
+/* source event cards, nested under their match card via an indent rail */
+.scanner-app .match-events {
+	display: flex;
+	flex-direction: column;
+	gap: var(--s-2);
+	margin-inline-start: var(--s-2-5);
+	padding-inline-start: var(--s-3);
+	border-inline-start: var(--border-width) solid var(--color-border);
+	animation: scanner-detail-in 0.25s ease both;
+
+	& .card {
+		padding: var(--s-2-5) 14px;
+		min-width: 0;
+	}
+}
+
+@keyframes scanner-detail-in {
+	from {
+		opacity: 0;
+		transform: translateY(-4px);
+	}
+}
+
+.scanner-app .events-summary {
+	display: flex;
+	align-items: center;
+	gap: var(--s-2-5);
+	flex-wrap: wrap;
+	padding: var(--s-0-5) var(--s-1);
+	font-size: var(--font-2xs);
+	font-weight: var(--weight-semi);
+	color: var(--color-text-high);
+}
+
+.scanner-app .events-summary-type {
+	display: inline-flex;
+	align-items: center;
+	gap: 5px;
+	font-variant-numeric: tabular-nums;
+}
+
+.scanner-app .events-summary-icon {
+	display: inline-flex;
+	align-items: center;
+	justify-content: center;
+	width: 22px;
+	height: 22px;
+	border-radius: var(--radius-full);
+	background: var(--color-bg-higher);
+	color: var(--color-text-high);
+}
+
+.scanner-app button.events-toggle {
+	border: none;
+	background: transparent;
+	color: var(--color-text-accent);
+	height: auto;
+	padding: 0;
+	font-size: var(--font-2xs);
+}
+
+.scanner-app .status.watching::before {
+	content: "";
+	display: inline-block;
+	width: 7px;
+	height: 7px;
+	border-radius: var(--radius-full);
+	background: currentColor;
+	margin-inline-end: var(--s-1-5);
+	animation: scanner-pulse 1.6s ease-in-out infinite;
+}
+
+/* the frame dialog portals outside .scanner-app, so these stay unscoped */
+.scanner-frame-dialog {
+	width: max-content;
+	max-width: min(96vw, 1400px);
+}
+
+.scanner-frame-dialog img.frame-full {
+	display: block;
+	max-width: 100%;
+	max-height: calc(80dvh - 9rem);
+	border-radius: var(--radius-field);
+}
+
+.scanner-frame-dialog .frame-actions {
+	display: flex;
+	justify-content: center;
+	gap: var(--s-3);
+	margin-block-start: var(--s-3);
+}
+
+.scanner-app .telemetry {
+	margin: var(--s-2) 0;
+	font-size: var(--font-2xs);
+	color: var(--color-text-high);
+}
+
+.scanner-app .telemetry summary {
+	cursor: pointer;
+}
+
+.scanner-app .telemetry table {
+	margin-top: var(--s-1-5);
+	border-collapse: collapse;
+}
+
+.scanner-app .telemetry table th,
+.scanner-app .telemetry table td {
+	padding: var(--s-0-5) var(--s-2-5) var(--s-0-5) 0;
+	text-align: right;
+	font-variant-numeric: tabular-nums;
+}
+
+.scanner-app .telemetry table th:first-child,
+.scanner-app .telemetry table td:first-child {
+	text-align: left;
+}
+
+/* ── narrow viewports ──────────────────────────────────────────────── */
+
+/* a 640px wide preview would starve the feed next to it: split evenly instead */
+@container scanner (width < 1000px) {
+	.scanner-app .live-layout {
+		grid-template-columns: minmax(0, 1fr) minmax(0, 1fr);
+	}
+
+	/* the controls wrap here, where a trigger pushed to the end reads as stray */
+	.scanner-app button.icon-menu {
+		margin-inline-start: 0;
+	}
+}
+
+/* the two teams' weapons no longer fit beside each other: one row each */
+@container match-card (width < 460px) {
+	.scanner-app .match-weapons {
+		flex-direction: column;
+		align-items: flex-start;
+		row-gap: var(--s-1);
+
+		& .vs {
+			display: none;
+		}
+	}
+}
+
+@container scanner (width < 700px) {
+	.scanner-app .live-layout {
+		grid-template-columns: minmax(0, 1fr);
+	}
+
+	/* stacked, the preview would otherwise push the feed off the screen */
+	.scanner-app video.preview,
+	.scanner-app canvas.preview {
+		max-height: 45vh;
+		object-fit: contain;
+	}
+
+	.scanner-app .vod-item {
+		flex-wrap: wrap;
+	}
+
+	/* the ROI crops set the width; scroll them instead of the whole page */
+	.scanner-app table.inspector {
+		display: block;
+		overflow-x: auto;
+	}
+}
+
+@media (prefers-reduced-motion: reduce) {
+	.scanner-app .match-card,
+	.scanner-app .match-card.sending::after,
+	.scanner-app .match-card.flash-sent::after,
+	.scanner-app .match-card.flash-failed .match-card-main,
+	.scanner-app .match-events,
+	.scanner-app .match-chip.live .dot,
+	.scanner-app .match-chip.in-progress .dot,
+	.scanner-app .match-chip.queued .dot,
+	.scanner-app .match-chip.sending .dot,
+	.scanner-app .status.watching::before {
+		animation: none;
+	}
+}
diff --git a/app/features/scanner/components/thumbnail.ts b/app/features/scanner/components/thumbnail.ts
new file mode 100644
index 000000000..57d2986e2
--- /dev/null
+++ b/app/features/scanner/components/thumbnail.ts
@@ -0,0 +1,10 @@
+/** Small JPEG data-URL thumbnail of an analyzed frame, for feed cards. */
+export async function thumbnailFromBlob(frame: Blob): Promise<string> {
+	const bitmap = await createImageBitmap(frame);
+	const canvas = document.createElement("canvas");
+	canvas.width = 320;
+	canvas.height = 180;
+	canvas.getContext("2d")!.drawImage(bitmap, 0, 0, 320, 180);
+	bitmap.close();
+	return canvas.toDataURL("image/jpeg", 0.7);
+}
diff --git a/app/features/scanner/core/ability-harvest.ts b/app/features/scanner/core/ability-harvest.ts
new file mode 100644
index 000000000..8c8ef049d
--- /dev/null
+++ b/app/features/scanner/core/ability-harvest.ts
@@ -0,0 +1,97 @@
+/**
+ * Connect death events to scoreboard players: a death overlay shows the
+ * killer's splash-tag name, weapon, and full gear-ability grid, so every
+ * death in a match reveals one enemy player's build. Deaths are attributed
+ * to the next scoreboard-type event in the timeline (a match's deaths
+ * always precede its results screen), and matched to a player row by name
+ * and weapon id.
+ */
+
+import type {
+	AbilityWithUnknown,
+	MainWeaponId,
+} from "~/modules/in-game-lists/types";
+import { DEATH_EVENT_TYPE, type DeathData } from "./detectors/death/index";
+import { SCOREBOARD_EVENT_TYPES } from "./detectors/registry";
+import type { ScoreboardData } from "./detectors/scoreboard/index";
+import type { DetectedEvent } from "./detectors/types";
+
+/** player row index (0-7) → [head, clothes, shoes] ability-id rows */
+export type PlayerAbilityMap = Map<number, AbilityWithUnknown[][]>;
+
+/** Any player row a death can be attributed against (scoreboard, minimap). */
+interface HarvestablePlayer {
+	name: string | null;
+	weaponId: MainWeaponId | null;
+}
+
+/**
+ * Match a death's killer to a player row. Both signals are OCR output, so
+ * neither is trusted alone unless it is unambiguous: a combined name+weapon
+ * hit wins, then a unique name hit, then a unique weapon hit (two players on
+ * the same weapon with a misread name stay unattributed).
+ */
+function matchPlayer(
+	players: readonly HarvestablePlayer[],
+	death: DeathData,
+): number | null {
+	const name = death.name?.trim().toLowerCase() || null;
+	const indices = players.map((_, i) => i);
+	const byName = name
+		? indices.filter(
+				(i) => (players[i]!.name ?? "").trim().toLowerCase() === name,
+			)
+		: [];
+	// scoreboard rows carry main-weapon ids; a sub/special credit says
+	// nothing about which main the killer holds
+	const byWeapon =
+		death.weaponId !== null && death.weaponType === "MAIN"
+			? indices.filter((i) => players[i]!.weaponId === death.weaponId)
+			: [];
+	const both = byName.filter((i) => byWeapon.includes(i));
+	if (both.length > 0) return both[0]!;
+	if (byName.length === 1) return byName[0]!;
+	if (byWeapon.length === 1) return byWeapon[0]!;
+	return null;
+}
+
+/**
+ * Harvest the builds one match's death events reveal: each death with a
+ * readable ability grid is attributed to a scoreboard player row.
+ */
+export function harvestAbilities(
+	players: readonly HarvestablePlayer[],
+	deaths: readonly DeathData[],
+): PlayerAbilityMap {
+	const abilities: PlayerAbilityMap = new Map();
+	for (const death of deaths) {
+		if (death.abilities.length === 0) continue;
+		const index = matchPlayer(players, death);
+		if (index !== null) abilities.set(index, death.abilities);
+	}
+	return abilities;
+}
+
+/**
+ * For each scoreboard/replay event, harvest abilities from the death events
+ * since the previous scoreboard. Keyed by event object identity; events
+ * without any attributed death are absent from the result.
+ */
+export function connectAbilities(
+	events: readonly DetectedEvent[],
+): Map<DetectedEvent, PlayerAbilityMap> {
+	const sorted = events.toSorted((a, b) => a.t - b.t);
+	const result = new Map<DetectedEvent, PlayerAbilityMap>();
+	let pendingDeaths: DeathData[] = [];
+	for (const event of sorted) {
+		if (event.type === DEATH_EVENT_TYPE) {
+			pendingDeaths.push(event.data as DeathData);
+		} else if (SCOREBOARD_EVENT_TYPES.includes(event.type)) {
+			const players = (event.data as ScoreboardData).players;
+			const abilities = harvestAbilities(players, pendingDeaths);
+			if (abilities.size > 0) result.set(event, abilities);
+			pendingDeaths = [];
+		}
+	}
+	return result;
+}
diff --git a/app/features/scanner/core/canonical.ts b/app/features/scanner/core/canonical.ts
new file mode 100644
index 000000000..058302dfc
--- /dev/null
+++ b/app/features/scanner/core/canonical.ts
@@ -0,0 +1,14 @@
+/**
+ * Pure constants/types shared by UI and pipeline. No OpenCV dependency —
+ * the main-thread bundle must not pull in the WASM module (that lives in
+ * the worker).
+ */
+export const CANONICAL_WIDTH = 1920;
+export const CANONICAL_HEIGHT = 1080;
+
+export interface Roi {
+	x: number;
+	y: number;
+	w: number;
+	h: number;
+}
diff --git a/app/features/scanner/core/cv.ts b/app/features/scanner/core/cv.ts
new file mode 100644
index 000000000..eece3a248
--- /dev/null
+++ b/app/features/scanner/core/cv.ts
@@ -0,0 +1,90 @@
+/**
+ * OpenCV.js singleton loader. Works in Node, browser main thread, and workers —
+ * the UMD bundle embeds its WASM, so no asset paths are involved.
+ *
+ * Everything in core/ obtains the cv namespace through getCV(); callers must
+ * await loadOpenCV() once at startup (worker bootstrap, test setup, tool entry).
+ *
+ * Gotcha of this build (5.0.0-release.1): `.data` and `.clone()` are broken
+ * on ROI views — `view.copyTo(freshMat)` before pixel access. Views are fine
+ * as inputs to cv calls.
+ */
+import cvModule from "@techstark/opencv-js";
+
+export type CV = typeof cvModule;
+export type Mat = InstanceType<CV["Mat"]>;
+
+let cvInstance: CV | null = null;
+let loading: Promise<CV> | null = null;
+
+export function loadOpenCV(): Promise<CV> {
+	if (cvInstance) return Promise.resolve(cvInstance);
+	if (loading) return loading;
+	const attempt = (async () => {
+		// The package is patched (patches/@techstark__opencv-js…) to export
+		// { cvReadyPromise } instead of the bare ready-promise: a thenable (or
+		// default-wrapped thenable) module.exports leaks `then` through
+		// vite-node's CJS namespace proxy and crashes every Node-side import.
+		// Depending on bundler interop we see the wrapper (possibly nested
+		// under `default`) or, in bundles that took the UMD's non-CJS branch,
+		// the promise itself.
+		const raw = cvModule as {
+			cvReadyPromise?: unknown;
+			default?: { cvReadyPromise?: unknown };
+		} | null;
+		const mod: unknown =
+			raw?.cvReadyPromise ??
+			raw?.default?.cvReadyPromise ??
+			raw?.default ??
+			raw;
+		let cv: CV;
+		if (mod instanceof Promise) {
+			cv = await mod;
+		} else if ((mod as CV).Mat) {
+			cv = mod as CV;
+		} else {
+			await new Promise<void>((resolve) => {
+				(mod as { onRuntimeInitialized?: () => void }).onRuntimeInitialized =
+					resolve;
+			});
+			cv = mod as CV;
+		}
+		cvInstance = cv;
+		return cv;
+	})();
+	// a failed load must not poison the singleton — clear it so callers can retry
+	loading = attempt.catch((error) => {
+		loading = null;
+		throw error;
+	});
+	return loading;
+}
+
+export function getCV(): CV {
+	if (!cvInstance) {
+		throw new Error(
+			"OpenCV not loaded — await loadOpenCV() before using core/",
+		);
+	}
+	return cvInstance;
+}
+
+// The bundled type definitions mark the optional mask argument of these as
+// required; thin wrappers restore the real (mask-less) signatures.
+
+export interface MinMaxResult {
+	minVal: number;
+	maxVal: number;
+	minLoc: { x: number; y: number };
+	maxLoc: { x: number; y: number };
+}
+
+export function minMaxLoc(mat: Mat): MinMaxResult {
+	return (getCV() as unknown as { minMaxLoc(m: Mat): MinMaxResult }).minMaxLoc(
+		mat,
+	);
+}
+
+export function meanOf(mat: Mat): number[] {
+	return (getCV() as unknown as { mean(m: Mat): number[] }).mean(mat);
+}
diff --git a/app/features/scanner/core/detectors/death/abilities.ts b/app/features/scanner/core/detectors/death/abilities.ts
new file mode 100644
index 000000000..8b5815b61
--- /dev/null
+++ b/app/features/scanner/core/detectors/death/abilities.ts
@@ -0,0 +1,80 @@
+/**
+ * Ability badge templates for the death-screen gear panel.
+ *
+ * Committed icon assets (assets/cv/abilities/) are bare icon art with
+ * alpha; on screen each sits centered on a near-black circular badge
+ * filling a known fraction of the slot. Templates composite the art onto a
+ * black square at that fraction, then resize to the candidate badge sizes —
+ * shaped like weapon templates so matchWeapon's NCC + ink-coverage scoring
+ * (see weapons.ts) applies directly. Mains (⌀~68) and subs (⌀~48) use
+ * different art fractions, so each role gets its own template set.
+ */
+import { getCV } from "../../cv";
+import type { FrameData } from "../../image";
+import { buildTemplateSizes, type WeaponTemplate } from "../scoreboard/weapons";
+import {
+	ABILITY_INK_THRESHOLD,
+	ABILITY_MAIN_ART_RATIO,
+	ABILITY_MAIN_SIZES,
+	ABILITY_SUB_ART_RATIO,
+	ABILITY_SUB_SIZES,
+} from "./rois";
+
+/** Badge interior brightness (near-black circle on the dark panel). */
+const BADGE_BACKGROUND = 10;
+
+export interface AbilityTemplates {
+	mains: WeaponTemplate[];
+	subs: WeaponTemplate[];
+}
+
+/**
+ * Exported for the calibration tooling's art-ratio sweeps and for other
+ * screens' badge sets (scoreboard-own builds its sizes/threshold here).
+ * inkThreshold must match the one passed to matchWeapon, or the coverage
+ * ratio compares mismatched ink counts.
+ */
+export function buildAbilityRole(
+	icons: { id: string; image: FrameData }[],
+	sizes: readonly number[],
+	artRatio: number,
+	inkThreshold: number = ABILITY_INK_THRESHOLD,
+): WeaponTemplate[] {
+	const cv = getCV();
+	return icons.map(({ id, image }) => {
+		// composite the icon art over the badge black, padded so the art
+		// occupies artRatio of the square (as it does of the badge on screen)
+		const side = Math.round(image.width / artRatio);
+		const offset = Math.floor((side - image.width) / 2);
+		const padded = new cv.Mat(
+			side,
+			side,
+			cv.CV_8UC3,
+			new cv.Scalar(BADGE_BACKGROUND, BADGE_BACKGROUND, BADGE_BACKGROUND),
+		);
+		const dst = padded.data;
+		const src = image.data;
+		for (let y = 0; y < image.height; y++) {
+			for (let x = 0; x < image.width; x++) {
+				const si = (y * image.width + x) * 4;
+				const a = src[si + 3]! / 255;
+				const di = ((y + offset) * side + x + offset) * 3;
+				dst[di] = Math.round(src[si]! * a + BADGE_BACKGROUND * (1 - a));
+				dst[di + 1] = Math.round(src[si + 1]! * a + BADGE_BACKGROUND * (1 - a));
+				dst[di + 2] = Math.round(src[si + 2]! * a + BADGE_BACKGROUND * (1 - a));
+			}
+		}
+		const templateSizes = buildTemplateSizes(padded, sizes, inkThreshold);
+		padded.delete();
+		return { id, sizes: templateSizes };
+	});
+}
+
+export function prepareAbilityTemplates(
+	icons: { id: string; image: FrameData }[],
+): AbilityTemplates {
+	return {
+		mains: buildAbilityRole(icons, ABILITY_MAIN_SIZES, ABILITY_MAIN_ART_RATIO),
+		subs: buildAbilityRole(icons, ABILITY_SUB_SIZES, ABILITY_SUB_ART_RATIO),
+	};
+}
diff --git a/app/features/scanner/core/detectors/death/index.ts b/app/features/scanner/core/detectors/death/index.ts
new file mode 100644
index 000000000..0136d934f
--- /dev/null
+++ b/app/features/scanner/core/detectors/death/index.ts
@@ -0,0 +1,832 @@
+/**
+ * DeathDetector: parses the death cam overlay — "Splatted by <weapon>!"
+ * text, the killer's gear abilities (3 rows x [main, sub, sub, sub]), and
+ * the killer's name from the tilted splash tag.
+ *
+ * Weapon reads primarily as OCR text matched against per-language message
+ * templates (localized-messages.ts); the constant line doubles as a
+ * parse-time confirmation (else a lookalike gate hit emits nothing). Falls
+ * back to template-matching the burst weapon icon when the WIPEOUT banner
+ * covers the text, then to a candidate-lattice re-rank for low-fidelity
+ * captures, then to icon/text corroboration when neither is decisive alone
+ * (steps 2c/2d).
+ */
+import type {
+	AbilityWithUnknown,
+	MainWeaponId,
+	SpecialWeaponId,
+	SubWeaponId,
+} from "~/modules/in-game-lists/types";
+import { toAbilityWithUnknown } from "../../../scanner-types";
+import { getCV, type Mat, minMaxLoc } from "../../cv";
+import {
+	type GlyphSet,
+	type RecognizedText,
+	recognizeText,
+	scaleGlyphSet,
+} from "../../glyphs";
+import { copyRoi, cropRoi, meanBrightness, type Roi } from "../../image";
+import { closestEntry, matchKey, rankBy, rankByRead } from "../../text";
+import type { ScoreboardResources } from "../scoreboard/index";
+import { parseName } from "../scoreboard/names";
+import { matchWeapon, type WeaponMatch } from "../scoreboard/weapons";
+import type { DetectedEvent, Detector, GateResult } from "../types";
+import {
+	DEATH_MESSAGE_TEMPLATES,
+	type DeathMessageTemplate,
+	LOCALIZED_WEAPON_NAMES,
+} from "./localized-messages";
+import {
+	ABILITY_INK_THRESHOLD,
+	ABILITY_ROWS,
+	ABILITY_SLOT_MIN_INK,
+	ABILITY_SUB_XS,
+	abilityMainRoi,
+	abilitySubRoi,
+	BURST_ICON_ROI,
+	GATE_BURST_PROBES,
+	GATE_DARK_MAX_MEAN,
+	GATE_ICON_MIN_MAX,
+	GATE_PANEL_PROBES,
+	GATE_TEXT_MAX_FRACTION,
+	GATE_TEXT_MIN_MAX,
+	gateAbilityProbe,
+	JA_CONST_LINE_ROI,
+	JA_WEAPON_LINE_ROI,
+	SPLAT_LINE1_ROI,
+	SPLAT_TEXT_BIN_THRESHOLD,
+	TAG_NAME_INNER,
+	TAG_NAME_OUTER,
+	TAG_NAME_TEXT_HEIGHT,
+	TAG_TILT_DEG,
+	WEAPON_LINE_ROI,
+	WEAPON_TEXT_HEIGHT,
+} from "./rois";
+import {
+	ALL_WEAPON_ENTRIES,
+	type WeaponEntry,
+	type WeaponType,
+} from "./weapon-names";
+
+export interface DeathData {
+	/**
+	 * the killer's weapon id — a sendou main/sub/special weapon id, unique
+	 * only within its kind (`weaponType` disambiguates); null if unreadable
+	 */
+	weaponId: MainWeaponId | SubWeaponId | SpecialWeaponId | null;
+	/** which kind of weapon got the splat; null when the weapon is unreadable */
+	weaponType: WeaponType | null;
+	/**
+	 * killer's gear abilities, [head, clothes, shoes] rows of [main, sub...]
+	 * ability ids; rows carry as many sub entries as the gear has slots (1-3)
+	 */
+	abilities: AbilityWithUnknown[][];
+	/** killer's splash-tag name; null if unreadable */
+	name: string | null;
+}
+
+export const DEATH_EVENT_TYPE = "Death";
+
+/** The constant message line must read back at least this well to emit. */
+const LINE1_MIN_SCORE = 0.5;
+/**
+ * A Latin template's constant line reading at least this well settles the
+ * language and the (expensive) JA line reads are skipped. Fixture-measured:
+ * Latin-language frames read their template at 0.889+, while JA frames'
+ * best Latin-template score is 0.222.
+ */
+const LATIN_DECISIVE_SCORE = 0.85;
+/** Snapped weapon reading below this is reported as null (kept in debug). */
+const WEAPON_MIN_SCORE = 0.55;
+/** Burst-icon fallback match below this is ignored (kept in debug). */
+const BURST_ICON_MIN_SCORE = 0.52;
+/**
+ * Candidate-lattice re-rank acceptance (rankByRead — its scores sit well
+ * below the plain-snap scale; see text.ts). On the 720p-upscaled JP
+ * frames that motivated it, correct picks score 0.25-0.47 with a margin
+ * of 0.056+ over the nearest other weapon, while wrong picks margin
+ * <= 0.03 — the margin, not the score, is the discriminator.
+ */
+const LATTICE_MIN_SCORE = 0.22;
+const LATTICE_MIN_MARGIN = 0.05;
+/**
+ * Burst-icon corroboration: below the decisive threshold the icon alone
+ * can't be trusted, but when the garbled text *independently* ranks the
+ * icon's weapon at (or within EPS of) its own top, the two weak signals
+ * agree out of ~350 candidates and the weapon is accepted. Floor sits at
+ * the weakest corroborated fixture positive (Splat Dualies at 0.33).
+ */
+const BURST_ICON_CORROBORATE_MIN_SCORE = 0.3;
+const CORROBORATE_EPS = 0.02;
+const TAG_NAME_BIN_THRESHOLD = 160;
+/**
+ * The text-color refinement band is absolute closeness (255 - distance) to
+ * the estimated text color, so its threshold is tight by construction:
+ * 215 keeps pixels within 40 of the text color — glyph cores — while art
+ * highlights that leak past the banner-median band sit further away.
+ */
+const TAG_NAME_REFINE_BIN_THRESHOLD = 215;
+/** Don't trust a text-color estimate taken from fewer ink pixels. */
+const TAG_NAME_REFINE_MIN_INK = 200;
+/**
+ * Split-banner detection: some banners paint the name band in two flat
+ * hues (diagonal splits). Any single background estimate turns the other
+ * half into one huge "ink" blob that border-clearing deletes together
+ * with the glyphs standing on it, so when a second quantized color bin
+ * both covers a real share of the band and sits far from the first, a
+ * third read candidate measures distance from the *nearest* of the two.
+ * The share floor keeps the text color itself (or sparse art) from being
+ * mistaken for a second background, which would erase the glyphs.
+ */
+const TAG_SPLIT_MIN_FRACTION = 0.15;
+const TAG_SPLIT_MIN_CHANNEL_DISTANCE = 40;
+
+interface WeaponCandidate {
+	/** the full weapon line as this template renders it, e.g. "Durch Klecksroller" */
+	text: string;
+	entry: WeaponEntry;
+}
+
+/** JA templates read through the JA atlas and the swapped-width line ROIs. */
+function isJaTemplate(t: DeathMessageTemplate): boolean {
+	return t.langs.some((lang) => lang.endsWith("ja"));
+}
+
+/**
+ * The weapon-line strings a template can show: that language's localized
+ * names plus every canonical English name (localized-messages omits names
+ * identical to English), wrapped in the template's constant pre/post text.
+ */
+const templateCandidates = new Map<DeathMessageTemplate, WeaponCandidate[]>();
+function candidatesFor(template: DeathMessageTemplate): WeaponCandidate[] {
+	let candidates = templateCandidates.get(template);
+	if (candidates) return candidates;
+	const byName = new Map(ALL_WEAPON_ENTRIES.map((e) => [e.name, e]));
+	const seen = new Set<string>();
+	candidates = [];
+	const push = (text: string, entry: WeaponEntry | undefined) => {
+		const k = matchKey(text);
+		if (!entry || seen.has(k)) return;
+		seen.add(k);
+		candidates!.push({
+			text: template.weaponPre + text + template.weaponPost,
+			entry,
+		});
+	};
+	for (const lang of template.langs) {
+		for (const { text, name } of LOCALIZED_WEAPON_NAMES[lang] ?? [])
+			push(text, byName.get(name));
+	}
+	for (const entry of ALL_WEAPON_ENTRIES) push(entry.name, entry);
+	templateCandidates.set(template, candidates);
+	return candidates;
+}
+
+export function createDeathDetector(
+	resources: ScoreboardResources,
+): Detector<DeathData> {
+	const cv = getCV();
+
+	const scaled = (
+		set: GlyphSet | null | undefined,
+		height: number,
+	): GlyphSet | null => (set ? scaleGlyphSet(set, height / set.height) : null);
+
+	const weaponGlyphs = scaled(resources.deathWeaponGlyphs, WEAPON_TEXT_HEIGHT);
+	// JA glyphs match at native scale: the atlas mixes fixture crops with
+	// per-face renders already sized to the on-screen condensed text
+	const jaGlyphs = resources.deathWeaponJaGlyphs ?? null;
+	const tagNameGlyphs = scaled(
+		resources.deathTagNameGlyphs,
+		TAG_NAME_TEXT_HEIGHT,
+	);
+	const abilities = resources.abilities ?? null;
+	const burstWeapons = resources.deathBurstWeapons ?? null;
+	const mainById = new Map(
+		ALL_WEAPON_ENTRIES.filter((e) => e.type === "MAIN").map((e) => [e.id, e]),
+	);
+
+	function gate(frame: Mat): GateResult {
+		let darkOk = 0;
+		const darkProbes = [...GATE_BURST_PROBES, ...GATE_PANEL_PROBES];
+		for (const roi of darkProbes) {
+			if (meanBrightness(frame, roi) < GATE_DARK_MAX_MEAN) darkOk++;
+		}
+
+		const gray = new cv.Mat();
+		cv.cvtColor(frame, gray, cv.COLOR_RGBA2GRAY);
+		const line1 = copyRoi(gray, SPLAT_LINE1_ROI);
+		const { maxVal } = minMaxLoc(line1);
+		const bin = new cv.Mat();
+		cv.threshold(line1, bin, GATE_TEXT_MIN_MAX, 255, cv.THRESH_BINARY);
+		line1.delete();
+		const whiteFraction = cv.countNonZero(bin) / (bin.rows * bin.cols);
+		bin.delete();
+		const textOk =
+			maxVal > GATE_TEXT_MIN_MAX &&
+			whiteFraction > 0.01 &&
+			whiteFraction < GATE_TEXT_MAX_FRACTION;
+
+		// max RGB channel, not gray: saturated icon art can be gray-dark (rois.ts)
+		let iconOk = 0;
+		for (const row of [0, 1, 2]) {
+			const probe = copyRoi(frame, gateAbilityProbe(row));
+			const d = probe.data;
+			const ch = probe.channels();
+			const n = probe.rows * probe.cols;
+			let maxCh = 0;
+			for (let i = 0; i < n; i++) {
+				const v = Math.max(d[i * ch]!, d[i * ch + 1]!, d[i * ch + 2]!);
+				if (v > maxCh) maxCh = v;
+			}
+			probe.delete();
+			if (maxCh > GATE_ICON_MIN_MAX) iconOk++;
+		}
+		gray.delete();
+
+		const score =
+			(darkOk / darkProbes.length + (textOk ? 1 : 0) + iconOk / 3) / 3;
+		return {
+			pass: darkOk === darkProbes.length && textOk && iconOk === 3,
+			score,
+		};
+	}
+
+	/** Crop the tilted tag, rotate it level, and return the name band crop. */
+	function levelTagInner(rgb: Mat): Mat {
+		const outer = copyRoi(rgb, TAG_NAME_OUTER);
+		const center = new cv.Point(outer.cols / 2, outer.rows / 2);
+		const m = cv.getRotationMatrix2D(center, -TAG_TILT_DEG, 1);
+		const rotated = new cv.Mat();
+		cv.warpAffine(
+			outer,
+			rotated,
+			m,
+			new cv.Size(outer.cols, outer.rows),
+			cv.INTER_LINEAR,
+			cv.BORDER_REPLICATE,
+			new cv.Scalar(),
+		);
+		m.delete();
+		outer.delete();
+		const inner = copyRoi(rotated, TAG_NAME_INNER);
+		rotated.delete();
+		return inner;
+	}
+
+	/** Per-channel median color of `inner`, over pixels where mask(i) holds. */
+	function medianColor(
+		inner: Mat,
+		mask?: (i: number) => boolean,
+	): [number, number, number] {
+		const n = inner.rows * inner.cols;
+		const px = inner.data;
+		const color: [number, number, number] = [0, 0, 0];
+		for (let c = 0; c < 3; c++) {
+			const hist = new Array<number>(256).fill(0);
+			let total = 0;
+			for (let i = 0; i < n; i++) {
+				if (mask && !mask(i)) continue;
+				hist[px[i * 3 + c]!]!++;
+				total++;
+			}
+			let acc = 0;
+			let v = 0;
+			for (; v < 255; v++) {
+				acc += hist[v]!;
+				if (acc >= total / 2) break;
+			}
+			color[c] = v;
+		}
+		return color;
+	}
+
+	/**
+	 * Dominant colors of `inner`: most frequent quantized colors (5 bits/
+	 * channel), clustered by proximity (else a hue straddling a quantization
+	 * boundary under-reports, split across neighbor bins), each refined to
+	 * its per-channel median with its share of the band. A second background
+	 * estimator besides medianColor — neither wins everywhere (whole-image
+	 * medians blend distinct populations into a color nobody has; the bin
+	 * vote loses to a flat art blob out-voting a textured banner's true
+	 * color) — so both are tried and the better read kept. The runner-up
+	 * cluster feeds the split-banner candidate (see TAG_SPLIT_MIN_FRACTION).
+	 */
+	function dominantColors(
+		inner: Mat,
+		count: number,
+	): { color: [number, number, number]; fraction: number }[] {
+		const n = inner.rows * inner.cols;
+		const px = inner.data;
+		const bins = new Map<number, number>();
+		for (let i = 0; i < n; i++) {
+			const key =
+				((px[i * 3]! >> 3) << 10) |
+				((px[i * 3 + 1]! >> 3) << 5) |
+				(px[i * 3 + 2]! >> 3);
+			bins.set(key, (bins.get(key) ?? 0) + 1);
+		}
+		// greedy cluster of the top bins by quantized-center proximity
+		const CLUSTER_MAX_CHANNEL_DISTANCE = 24;
+		const top = [...bins.entries()].sort((a, b) => b[1] - a[1]).slice(0, 8);
+		const centerOf = (key: number): [number, number, number] => [
+			((key >> 10) << 3) + 4,
+			(((key >> 5) & 31) << 3) + 4,
+			((key & 31) << 3) + 4,
+		];
+		const clusters: {
+			seed: [number, number, number];
+			keys: Set<number>;
+			count: number;
+		}[] = [];
+		for (const [key, binCount] of top) {
+			const c = centerOf(key);
+			const home = clusters.find((cl) =>
+				cl.seed.every(
+					(s, i) => Math.abs(s - c[i]!) <= CLUSTER_MAX_CHANNEL_DISTANCE,
+				),
+			);
+			if (home) {
+				home.keys.add(key);
+				home.count += binCount;
+			} else {
+				clusters.push({ seed: c, keys: new Set([key]), count: binCount });
+			}
+		}
+		return clusters
+			.sort((a, b) => b.count - a.count)
+			.slice(0, count)
+			.map(({ keys, count: clusterCount }) => {
+				const inCluster = (i: number) =>
+					keys.has(
+						((px[i * 3]! >> 3) << 10) |
+							((px[i * 3 + 1]! >> 3) << 5) |
+							(px[i * 3 + 2]! >> 3),
+					);
+				return {
+					color: medianColor(inner, inCluster),
+					fraction: clusterCount / n,
+				};
+			});
+	}
+
+	/**
+	 * Text-ness map: per-pixel max-channel distance from the nearest of
+	 * `colors` (one for solid banners, two hues for a split banner). Uses
+	 * distance from banner color rather than a fixed brightness/polarity
+	 * since text/banner colors vary per player (e.g. pink text on a
+	 * light-blue banner has near-zero luminance contrast). `invert` flips to
+	 * *closeness* for the text-color refinement pass.
+	 */
+	function distanceBand(
+		inner: Mat,
+		colors: readonly [number, number, number][],
+		invert: boolean,
+	): Mat {
+		const n = inner.rows * inner.cols;
+		const px = inner.data;
+		const band = new cv.Mat(inner.rows, inner.cols, cv.CV_8UC1);
+		const out = band.data;
+		for (let i = 0; i < n; i++) {
+			let d = 255;
+			for (const color of colors) {
+				const dc = Math.max(
+					Math.abs(px[i * 3]! - color[0]),
+					Math.abs(px[i * 3 + 1]! - color[1]),
+					Math.abs(px[i * 3 + 2]! - color[2]),
+				);
+				if (dc < d) d = dc;
+			}
+			out[i] = invert ? 255 - d : d;
+		}
+		return band;
+	}
+
+	/**
+	 * Zero ink components touching the band border. Busy banner art also
+	 * differs from the median banner color but continues past the name
+	 * band's edges, while the name sits inside it (fixture extremes: dakuten
+	 * at y=3, descender 2px above bottom) — left in place an edge blob
+	 * merges into a glyph and corrupts the read.
+	 */
+	function clearBorderBlobs(band: Mat, threshold: number): void {
+		const bin = new cv.Mat();
+		cv.threshold(band, bin, threshold, 255, cv.THRESH_BINARY);
+		const labels = new cv.Mat();
+		const stats = new cv.Mat();
+		const centroids = new cv.Mat();
+		const count = cv.connectedComponentsWithStats(
+			bin,
+			labels,
+			stats,
+			centroids,
+			8,
+		);
+		bin.delete();
+		centroids.delete();
+		const s = stats.data32S;
+		const touchesBorder = new Uint8Array(count);
+		for (let i = 1; i < count; i++) {
+			const left = s[i * 5 + cv.CC_STAT_LEFT]!;
+			const top = s[i * 5 + cv.CC_STAT_TOP]!;
+			const right = left + s[i * 5 + cv.CC_STAT_WIDTH]!;
+			const bottom = top + s[i * 5 + cv.CC_STAT_HEIGHT]!;
+			touchesBorder[i] =
+				left === 0 || top === 0 || right === band.cols || bottom === band.rows
+					? 1
+					: 0;
+		}
+		stats.delete();
+		const lab = labels.data32S;
+		const out = band.data;
+		for (let i = 0; i < out.length; i++) {
+			if (touchesBorder[lab[i]!]!) out[i] = 0;
+		}
+		labels.delete();
+	}
+
+	function parse(frame: Mat, t: number): DetectedEvent<DeathData>[] {
+		const gray = new cv.Mat();
+		cv.cvtColor(frame, gray, cv.COLOR_RGBA2GRAY);
+		const rgb = new cv.Mat();
+		cv.cvtColor(frame, rgb, cv.COLOR_RGBA2RGB);
+
+		const confidences: number[] = [];
+
+		// 1. read both burst lines and find the language template whose constant
+		// line reads back best — a gate hit matching none is a lookalike.
+		// Latin templates read the standard line boxes with the Latin atlas;
+		// JA templates read the swapped-width JA boxes (weapon line 1 wide,
+		// constant line 2 narrow — see rois.ts) with the JA atlas, so the two
+		// scripts never compete inside one glyph set.
+		let line1: RecognizedText | null = null;
+		let line2: RecognizedText | null = null;
+		let jaWeaponLine: RecognizedText | null = null;
+		let jaConstLine: RecognizedText | null = null;
+		let template: DeathMessageTemplate | null = null;
+		let line1Score = 0;
+		if (weaponGlyphs) {
+			const readLine = (roi: Roi, glyphs: GlyphSet) => {
+				const crop = cropRoi(gray, roi);
+				const read = recognizeText(crop, glyphs, {
+					binThreshold: SPLAT_TEXT_BIN_THRESHOLD,
+					minCharScore: 0.3,
+				});
+				crop.delete();
+				return read;
+			};
+			line1 = readLine(SPLAT_LINE1_ROI, weaponGlyphs);
+			line2 = readLine(WEAPON_LINE_ROI, weaponGlyphs);
+			for (const t of DEATH_MESSAGE_TEMPLATES) {
+				if (isJaTemplate(t)) continue;
+				const constReading = t.weaponLine === 1 ? line2.text : line1.text;
+				const score = closestEntry(constReading, [t.constText])?.score ?? 0;
+				if (score > line1Score) {
+					line1Score = score;
+					template = t;
+				}
+			}
+			// the JA line reads cost ~2x the Latin ones (condensed-kana atlas),
+			// so they only run when no Latin template already owns the frame:
+			// measured constant-line scores separate cleanly (Latin frames read
+			// their template at 0.889+, JA frames' best Latin score is <= 0.222)
+			if (jaGlyphs && line1Score < LATIN_DECISIVE_SCORE) {
+				jaWeaponLine = readLine(JA_WEAPON_LINE_ROI, jaGlyphs);
+				jaConstLine = readLine(JA_CONST_LINE_ROI, jaGlyphs);
+				for (const t of DEATH_MESSAGE_TEMPLATES) {
+					if (!isJaTemplate(t)) continue;
+					const score =
+						closestEntry(jaConstLine.text, [t.constText])?.score ?? 0;
+					if (score > line1Score) {
+						line1Score = score;
+						template = t;
+					}
+				}
+			}
+			if (!template || line1Score < LINE1_MIN_SCORE) {
+				gray.delete();
+				rgb.delete();
+				return [];
+			}
+		}
+
+		// 2. the other line carries the weapon name; snap it to the template
+		// language's names (localized + canonical English)
+		let weapon: string | null = null;
+		let weaponId: DeathData["weaponId"] = null;
+		let weaponType: WeaponType | null = null;
+		let weaponScore = 0;
+		let weaponRaw: RecognizedText | null = null;
+		let plainRanked: { entry: WeaponCandidate; score: number }[] = [];
+		const accept = (entry: WeaponEntry, score: number) => {
+			weapon = entry.name;
+			weaponId = Number(entry.id) as NonNullable<DeathData["weaponId"]>;
+			weaponType = entry.type;
+			weaponScore = score;
+		};
+		if (weaponGlyphs && template) {
+			weaponRaw = isJaTemplate(template)
+				? jaWeaponLine
+				: template.weaponLine === 1
+					? line1
+					: line2;
+			const reading = weaponRaw!.text;
+			if (reading)
+				plainRanked = rankBy(reading, candidatesFor(template), (c) => c.text);
+			const match = plainRanked[0];
+			if (match) {
+				weaponScore = match.score;
+				if (match.score >= WEAPON_MIN_SCORE)
+					accept(match.entry.entry, match.score);
+			}
+		}
+
+		// 2b. text can be unreadable while the burst's weapon icon is intact
+		// (the WIPEOUT banner covers the weapon name line), so fall back to
+		// matching the icon against the main-weapon set at burst size. Only a
+		// decisive match is trusted: fixture positives score 0.55+ while the
+		// best off-target frame (icon displaced by a rainmaker line) hits 0.48.
+		let burstIcon: WeaponMatch | null = null;
+		if (weapon === null && burstWeapons) {
+			const crop = cropRoi(rgb, BURST_ICON_ROI);
+			burstIcon = matchWeapon(crop, burstWeapons);
+			crop.delete();
+			const entry =
+				burstIcon.score >= BURST_ICON_MIN_SCORE
+					? mainById.get(burstIcon.id)
+					: undefined;
+			if (entry) accept(entry, burstIcon.score);
+		}
+
+		// 2c. low-fidelity captures (720p upscaled to canonical) garble the
+		// per-segment top-1 read enough that the plain snap stays under
+		// WEAPON_MIN_SCORE, while the correct glyphs sit at rank 2-3 of the
+		// segments' candidate lists. Re-rank through those lists (rankByRead)
+		// and accept the top weapon when it clears the field decisively.
+		let latticeTop: {
+			entry: WeaponEntry;
+			score: number;
+			margin: number;
+		} | null = null;
+		let latticeRanked: { entry: WeaponCandidate; score: number }[] = [];
+		if (
+			weapon === null &&
+			weaponGlyphs &&
+			template &&
+			weaponRaw!.chars.length > 0
+		) {
+			latticeRanked = rankByRead(
+				weaponRaw!.chars,
+				candidatesFor(template),
+				(c) => c.text,
+			);
+			const top = latticeRanked[0]!;
+			// margin vs the nearest *other* weapon: the same weapon rides both
+			// its localized and English candidate lines
+			const runner = latticeRanked.find(
+				(r) => r.entry.entry !== top.entry.entry,
+			);
+			latticeTop = {
+				entry: top.entry.entry,
+				score: top.score,
+				margin: top.score - (runner?.score ?? 0),
+			};
+			if (
+				latticeTop.score >= LATTICE_MIN_SCORE &&
+				latticeTop.margin >= LATTICE_MIN_MARGIN
+			) {
+				accept(latticeTop.entry, latticeTop.score);
+			}
+		}
+
+		// 2d. neither signal is decisive alone, but if the burst icon's main
+		// weapon is also the text's best guess (plain or lattice ranking,
+		// within EPS of that ranking's top), the independent agreement is
+		// decisive together.
+		if (
+			weapon === null &&
+			burstIcon &&
+			burstIcon.score >= BURST_ICON_CORROBORATE_MIN_SCORE
+		) {
+			const entry = mainById.get(burstIcon.id);
+			if (entry) {
+				const bestFor = (ranked: { entry: WeaponCandidate; score: number }[]) =>
+					ranked.reduce(
+						(s, r) => (r.entry.entry === entry ? Math.max(s, r.score) : s),
+						0,
+					);
+				const supported =
+					(plainRanked.length > 0 &&
+						bestFor(plainRanked) >= plainRanked[0]!.score - CORROBORATE_EPS) ||
+					(latticeRanked.length > 0 &&
+						bestFor(latticeRanked) >=
+							latticeRanked[0]!.score - CORROBORATE_EPS);
+				if (supported) accept(entry, burstIcon.score);
+			}
+		}
+		if (weaponGlyphs && template) confidences.push(weaponScore);
+
+		// 3. ability grid; rows carry 1-3 sub circles (left-aligned, as many
+		// as the gear has slots), so a sub box without badge ink ends the row
+		const abilityRows: AbilityWithUnknown[][] = [];
+		const abilityDebug: (WeaponMatch | null)[][] = [];
+		if (abilities) {
+			for (let row = 0; row < ABILITY_ROWS; row++) {
+				const ids: AbilityWithUnknown[] = [];
+				const debug: (WeaponMatch | null)[] = [];
+				const mainCrop = cropRoi(rgb, abilityMainRoi(row));
+				const main = matchWeapon(mainCrop, abilities.mains, {
+					inkThreshold: ABILITY_INK_THRESHOLD,
+				});
+				mainCrop.delete();
+				ids.push(toAbilityWithUnknown(main.id) ?? "UNKNOWN");
+				debug.push(main);
+				confidences.push(Math.max(0, main.score));
+				for (let slot = 0; slot < ABILITY_SUB_XS.length; slot++) {
+					const crop = copyRoi(rgb, abilitySubRoi(row, slot));
+					const d = crop.data;
+					const n = crop.rows * crop.cols;
+					let ink = 0;
+					for (let i = 0; i < n; i++) {
+						const v = Math.max(d[i * 3]!, d[i * 3 + 1]!, d[i * 3 + 2]!);
+						if (v > ABILITY_INK_THRESHOLD) ink++;
+					}
+					if (ink < ABILITY_SLOT_MIN_INK) {
+						crop.delete();
+						break;
+					}
+					const sub = matchWeapon(crop, abilities.subs, {
+						inkThreshold: ABILITY_INK_THRESHOLD,
+					});
+					crop.delete();
+					ids.push(toAbilityWithUnknown(sub.id) ?? "UNKNOWN");
+					debug.push(sub);
+					confidences.push(Math.max(0, sub.score));
+				}
+				abilityRows.push(ids);
+				abilityDebug.push(debug);
+			}
+		}
+
+		// 4. splash-tag name: read against the estimated banner color, then
+		// (since busy banner art also differs from that estimate and can
+		// survive as fake glyphs) against closeness to the text color
+		// estimated from pass 1's ink; whichever reads back more confidently
+		// wins. Both background estimators (dominantColors) run the same way.
+		let name: string | null = null;
+		let nameConfidence = 0;
+		let nameRaw = "";
+		let tagBackground: [number, number, number] | null = null;
+		let tagTextColor: [number, number, number] | null = null;
+		if (tagNameGlyphs) {
+			const spaceGap = Math.max(
+				7,
+				Math.round(tagNameGlyphs.medianWidth * 0.55),
+			);
+			const inner = levelTagInner(rgb);
+			const readWithBackground = (
+				backgrounds: readonly [number, number, number][],
+			) => {
+				const band = distanceBand(inner, backgrounds, false);
+				cv.normalize(band, band, 0, 255, cv.NORM_MINMAX);
+				clearBorderBlobs(band, TAG_NAME_BIN_THRESHOLD);
+				let parsed = parseName(band, tagNameGlyphs, {
+					spaceGap,
+					binThreshold: TAG_NAME_BIN_THRESHOLD,
+				});
+
+				let textColor: [number, number, number] | null = null;
+				const ink = band.data;
+				let inkCount = 0;
+				for (let i = 0; i < ink.length; i++)
+					if (ink[i]! > TAG_NAME_BIN_THRESHOLD) inkCount++;
+				if (inkCount >= TAG_NAME_REFINE_MIN_INK) {
+					textColor = medianColor(
+						inner,
+						(i) => ink[i]! > TAG_NAME_BIN_THRESHOLD,
+					);
+					const refined = distanceBand(inner, [textColor], true);
+					clearBorderBlobs(refined, TAG_NAME_REFINE_BIN_THRESHOLD);
+					const reparsed = parseName(refined, tagNameGlyphs, {
+						spaceGap,
+						binThreshold: TAG_NAME_REFINE_BIN_THRESHOLD,
+					});
+					refined.delete();
+					if (reparsed.confidence > parsed.confidence) parsed = reparsed;
+				}
+				band.delete();
+				return { parsed, background: backgrounds[0]!, textColor };
+			};
+
+			const median = medianColor(inner);
+			const dominants = dominantColors(inner, 2);
+			const dominant = dominants[0]!.color;
+			const candidates: [number, number, number][][] = [[median]];
+			if (dominant.some((c, i) => Math.abs(c - median[i]!) > 8))
+				candidates.push([dominant]);
+			const second = dominants[1];
+			if (
+				second &&
+				second.fraction >= TAG_SPLIT_MIN_FRACTION &&
+				second.color.some(
+					(c, i) => Math.abs(c - dominant[i]!) > TAG_SPLIT_MIN_CHANNEL_DISTANCE,
+				)
+			) {
+				candidates.push([dominant, second.color]);
+			}
+			// an empty read never beats one with glyphs (an estimate landing on
+			// the text color blanks the band, and recognizeText scores a
+			// segment-less band confidence 1); near-tied confidences resolve to
+			// the longer read, since confidence is the *min* char score and
+			// erasing most of the name can still read the survivors immaculately
+			const NEAR_TIE = 0.03;
+			const beats = (
+				a: { parsed: { name: string; confidence: number } },
+				b: typeof a,
+			) => {
+				const aRead = a.parsed.name.length > 0 ? 1 : 0;
+				const bRead = b.parsed.name.length > 0 ? 1 : 0;
+				if (aRead !== bRead) return aRead - bRead;
+				if (Math.abs(a.parsed.confidence - b.parsed.confidence) <= NEAR_TIE) {
+					return a.parsed.name.length - b.parsed.name.length;
+				}
+				return a.parsed.confidence - b.parsed.confidence;
+			};
+			let best = readWithBackground(candidates[0]!);
+			for (const backgrounds of candidates.slice(1)) {
+				const alt = readWithBackground(backgrounds);
+				if (beats(alt, best) > 0) best = alt;
+			}
+			inner.delete();
+
+			tagBackground = best.background;
+			tagTextColor = best.textColor;
+			nameRaw = best.parsed.raw.text;
+			if (best.parsed.name.length > 0) name = best.parsed.name;
+			nameConfidence = best.parsed.confidence;
+			confidences.push(nameConfidence);
+		}
+
+		gray.delete();
+		rgb.delete();
+
+		const confidence =
+			confidences.length > 0
+				? confidences.reduce((a, b) => a + b, 0) / confidences.length
+				: 0;
+
+		return [
+			{
+				type: DEATH_EVENT_TYPE,
+				t,
+				confidence,
+				data: { weaponId, weaponType, abilities: abilityRows, name },
+				debug: {
+					weaponName: weapon,
+					line1: line1?.text,
+					line2: line2?.text,
+					jaWeaponLine: jaWeaponLine?.text,
+					jaConstLine: jaConstLine?.text,
+					line1Score,
+					messageLangs: template?.langs,
+					weaponRaw: weaponRaw?.text,
+					weaponScore,
+					weaponLattice: latticeTop && {
+						name: latticeTop.entry.name,
+						score: latticeTop.score,
+						margin: latticeTop.margin,
+					},
+					burstIcon: burstIcon && {
+						id: burstIcon.id,
+						score: burstIcon.score,
+						top: burstIcon.top,
+					},
+					abilityRows: abilityDebug.map((row) =>
+						row.map((m) => m && { top: m.top, score: m.score }),
+					),
+					nameRaw,
+					nameScore: nameConfidence,
+					tagBackground,
+					tagTextColor,
+				},
+			},
+		];
+	}
+
+	// the death cam's animated background flickers the gate; after a
+	// sufficient read the 4s rearm hold stays inside the timeline's 8s
+	// Death merge window, so every parse it skips would merge anyway.
+	// sufficientConfidence sits just under the measured clean-read floor
+	// (fixtures 0.750-0.825, confirmed scan events 0.751+); the refine and
+	// stagnation overrides cap what a ~1.4s parse can cost when a dirty
+	// read never reaches it
+	return {
+		id: "death",
+		refineIntervalS: 0.5,
+		sufficientConfidence: 0.74,
+		rearmCooldownS: 4,
+		maxStagnantParses: 3,
+		gate,
+		parse,
+	};
+}
diff --git a/app/features/scanner/core/detectors/death/localized-messages.ts b/app/features/scanner/core/detectors/death/localized-messages.ts
new file mode 100644
index 000000000..5129b9c46
--- /dev/null
+++ b/app/features/scanner/core/detectors/death/localized-messages.ts
@@ -0,0 +1,9916 @@
+/**
+ * GENERATED by scripts/scanner/build-localized-entries.ts from the splat3 repo's
+ * language dumps — do not edit by hand; regenerate when the game adds
+ * content. Per-language death-burst message templates and localized
+ * weapon names: the "Splatted by\n<weapon>!" burst puts the weapon on line
+ * 1 or 2 depending on language, with language-specific text around it.
+ */
+
+export interface DeathMessageTemplate {
+	/** languages sharing this exact template */
+	langs: readonly string[];
+	/** which burst line carries the weapon name */
+	weaponLine: 1 | 2;
+	/** the constant text on the other line (parse-time confirmation) */
+	constText: string;
+	/** constant text around the weapon name on its own line */
+	weaponPre: string;
+	weaponPost: string;
+}
+
+export const DEATH_MESSAGE_TEMPLATES: readonly DeathMessageTemplate[] = [
+	{
+		langs: ["CNzh"],
+		weaponLine: 1,
+		constText: "而阵亡！",
+		weaponPre: "因",
+		weaponPost: "",
+	},
+	{
+		langs: ["EUde"],
+		weaponLine: 1,
+		constText: "erledigt!",
+		weaponPre: "Durch ",
+		weaponPost: "",
+	},
+	{
+		langs: ["EUen", "USen"],
+		weaponLine: 2,
+		constText: "Splatted by",
+		weaponPre: "",
+		weaponPost: "!",
+	},
+	{
+		langs: ["EUes"],
+		weaponLine: 2,
+		constText: "Te han liquidado con:",
+		weaponPre: "",
+		weaponPost: "",
+	},
+	{
+		langs: ["EUfr"],
+		weaponLine: 2,
+		constText: "Élimination par",
+		weaponPre: "",
+		weaponPost: " !",
+	},
+	{
+		langs: ["EUit"],
+		weaponLine: 2,
+		constText: "Arma dello splat:",
+		weaponPre: "",
+		weaponPost: "!",
+	},
+	{
+		langs: ["EUnl"],
+		weaponLine: 2,
+		constText: "Uitgeschakeld door:",
+		weaponPre: "",
+		weaponPost: "!",
+	},
+	{
+		langs: ["EUru"],
+		weaponLine: 2,
+		constText: "Тебя плюхнули оружием",
+		weaponPre: '"',
+		weaponPost: '"!',
+	},
+	{
+		langs: ["JPja"],
+		weaponLine: 1,
+		constText: "やられた！",
+		weaponPre: "",
+		weaponPost: " で",
+	},
+	{
+		langs: ["KRko"],
+		weaponLine: 1,
+		constText: "당했다!",
+		weaponPre: "",
+		weaponPost: "에",
+	},
+	{
+		langs: ["TWzh"],
+		weaponLine: 1,
+		constText: "陣亡！",
+		weaponPre: "遭",
+		weaponPost: "擊倒",
+	},
+	{
+		langs: ["USes"],
+		weaponLine: 2,
+		constText: "Te reventaron con:",
+		weaponPre: "",
+		weaponPost: "",
+	},
+	{
+		langs: ["USfr"],
+		weaponLine: 2,
+		constText: "Élimination par",
+		weaponPre: "",
+		weaponPost: "!",
+	},
+];
+
+export interface LocalizedWeaponName {
+	text: string;
+	/** canonical English entry name (weapon-names.ts) */
+	name: string;
+}
+
+/**
+ * Per-language weapon names that differ from the canonical English name
+ * (identical ones are omitted; match against the canonical set too).
+ */
+export const LOCALIZED_WEAPON_NAMES: Readonly<
+	Record<string, readonly LocalizedWeaponName[]>
+> = {
+	CNzh: [
+		{
+			text: "快速爆破枪 精英",
+			name: "Rapid Blaster Pro",
+		},
+		{
+			text: "快速爆破枪 精英装饰",
+			name: "Rapid Blaster Pro Deco",
+		},
+		{
+			text: "快速爆破枪 精英WNTR",
+			name: "Rapid Blaster Pro WNT-R",
+		},
+		{
+			text: "冲涂爆破枪",
+			name: "Clash Blaster",
+		},
+		{
+			text: "冲涂爆破枪 新型",
+			name: "Clash Blaster Neo",
+		},
+		{
+			text: "快速爆破枪",
+			name: "Rapid Blaster",
+		},
+		{
+			text: "快速爆破枪 装饰",
+			name: "Rapid Blaster Deco",
+		},
+		{
+			text: "远距爆破枪",
+			name: "Range Blaster",
+		},
+		{
+			text: "远距爆破枪 改装",
+			name: "Custom Range Blaster",
+		},
+		{
+			text: "火热爆破枪",
+			name: "Blaster",
+		},
+		{
+			text: "火热爆破枪 改装",
+			name: "Custom Blaster",
+		},
+		{
+			text: "火热爆破枪 艳",
+			name: "Gleamz Blaster",
+		},
+		{
+			text: "S-BLAST92",
+			name: "S-BLAST '92",
+		},
+		{
+			text: "S-BLAST91",
+			name: "S-BLAST '91",
+		},
+		{
+			text: "新星爆破枪",
+			name: "Luna Blaster",
+		},
+		{
+			text: "新星爆破枪 新型",
+			name: "Luna Blaster Neo",
+		},
+		{
+			text: "秩序爆破枪 复制",
+			name: "Order Blaster Replica",
+		},
+		{
+			text: "文森",
+			name: "Painbrush",
+		},
+		{
+			text: "文森·新艺术",
+			name: "Painbrush Nouveau",
+		},
+		{
+			text: "文森BRNZ",
+			name: "Painbrush BRN-Z",
+		},
+		{
+			text: "巴勃罗",
+			name: "Inkbrush",
+		},
+		{
+			text: "巴勃罗·新艺术",
+			name: "Inkbrush Nouveau",
+		},
+		{
+			text: "北斋",
+			name: "Octobrush",
+		},
+		{
+			text: "北斋·新艺术",
+			name: "Octobrush Nouveau",
+		},
+		{
+			text: "北斋 彗",
+			name: "Cometz Octobrush",
+		},
+		{
+			text: "秩序排刷 复制",
+			name: "Orderbrush Replica",
+		},
+		{
+			text: "高压油管枪",
+			name: "Goo Tuber",
+		},
+		{
+			text: "高压油管枪 改装",
+			name: "Custom Goo Tuber",
+		},
+		{
+			text: "14式竹筒枪·甲",
+			name: "Bamboozler 14 Mk I",
+		},
+		{
+			text: "14式竹筒枪·乙",
+			name: "Bamboozler 14 Mk II",
+		},
+		{
+			text: "4K准星枪",
+			name: "E-liter 4K Scope",
+		},
+		{
+			text: "4K准星枪 改装",
+			name: "Custom E-liter 4K Scope",
+		},
+		{
+			text: "公升4K",
+			name: "E-liter 4K",
+		},
+		{
+			text: "公升4K 改装",
+			name: "Custom E-liter 4K",
+		},
+		{
+			text: "斯普拉准星枪",
+			name: "Splatterscope",
+		},
+		{
+			text: "斯普拉准星枪 联名",
+			name: "Z+F Splatterscope",
+		},
+		{
+			text: "斯普拉准星枪FRST",
+			name: "Splatterscope CAM-O",
+		},
+		{
+			text: "斯普拉蓄力狙击枪",
+			name: "Splat Charger",
+		},
+		{
+			text: "斯普拉蓄力狙击枪 联名",
+			name: "Z+F Splat Charger",
+		},
+		{
+			text: "斯普拉蓄力狙击枪FRST",
+			name: "Splat Charger CAM-O",
+		},
+		{
+			text: "秩序蓄力狙击枪 复制",
+			name: "Order Charger Replica",
+		},
+		{
+			text: "R-PEN/5H",
+			name: "Snipewriter 5H",
+		},
+		{
+			text: "R-PEN/5B",
+			name: "Snipewriter 5B",
+		},
+		{
+			text: "鱿快洁α",
+			name: "Classic Squiffer",
+		},
+		{
+			text: "鱿快洁β",
+			name: "New Squiffer",
+		},
+		{
+			text: "双重清洁枪",
+			name: "Dualie Squelchers",
+		},
+		{
+			text: "双重清洁枪 改装",
+			name: "Custom Dualie Squelchers",
+		},
+		{
+			text: "双重清洁枪 蹄",
+			name: "Hoofz Dualie Squelchers",
+		},
+		{
+			text: "开尔文525",
+			name: "Glooga Dualies",
+		},
+		{
+			text: "开尔文525 装饰",
+			name: "Glooga Dualies Deco",
+		},
+		{
+			text: "灭熄FF",
+			name: "Douser Dualies FF",
+		},
+		{
+			text: "灭熄FF 改装",
+			name: "Custom Douser Dualies FF",
+		},
+		{
+			text: "斯普拉机动枪",
+			name: "Splat Dualies",
+		},
+		{
+			text: "斯普拉机动枪 联名",
+			name: "Enperry Splat Dualies",
+		},
+		{
+			text: "斯普拉机动枪 耀",
+			name: "Twinklez Splat Dualies",
+		},
+		{
+			text: "秩序机动枪 复制",
+			name: "Order Dualie Replicas",
+		},
+		{
+			text: "溅镀枪",
+			name: "Dapple Dualies",
+		},
+		{
+			text: "溅镀枪·新艺术",
+			name: "Dapple Dualies Nouveau",
+		},
+		{
+			text: "溅镀枪OWL",
+			name: "Dapple Dualies NOC-T",
+		},
+		{
+			text: "四重弹跳手枪 黑",
+			name: "Dark Tetra Dualies",
+		},
+		{
+			text: "四重弹跳手枪 白",
+			name: "Light Tetra Dualies",
+		},
+		{
+			text: "碳纤维滚筒",
+			name: "Carbon Roller",
+		},
+		{
+			text: "碳纤维滚筒 装饰",
+			name: "Carbon Roller Deco",
+		},
+		{
+			text: "碳纤维滚筒ANGL",
+			name: "Carbon Roller ANG-L",
+		},
+		{
+			text: "电动马达滚筒",
+			name: "Dynamo Roller",
+		},
+		{
+			text: "电动马达滚筒 高磁波",
+			name: "Gold Dynamo Roller",
+		},
+		{
+			text: "电动马达滚筒 冥",
+			name: "Starz Dynamo Roller",
+		},
+		{
+			text: "可变式滚筒",
+			name: "Flingza Roller",
+		},
+		{
+			text: "可变式滚筒 金属箔",
+			name: "Foil Flingza Roller",
+		},
+		{
+			text: "斯普拉滚筒",
+			name: "Splat Roller",
+		},
+		{
+			text: "斯普拉滚筒 联名",
+			name: "Krak-On Splat Roller",
+		},
+		{
+			text: "秩序滚筒 复制",
+			name: "Order Roller Replica",
+		},
+		{
+			text: "宽滚筒",
+			name: "Big Swig Roller",
+		},
+		{
+			text: "宽滚筒 联名",
+			name: "Big Swig Roller Express",
+		},
+		{
+			text: "宽滚筒 惑",
+			name: "Planetz Big Swig Roller",
+		},
+		{
+			text: "巨齿刮水刀 薄荷",
+			name: "Mint Decavitator",
+		},
+		{
+			text: "巨齿刮水刀 墨黑",
+			name: "Charcoal Decavitator",
+		},
+		{
+			text: "雨刷刮水刀",
+			name: "Splatana Wiper",
+		},
+		{
+			text: "雨刷刮水刀 装饰",
+			name: "Splatana Wiper Deco",
+		},
+		{
+			text: "雨刷刮水刀RUST",
+			name: "Splatana Wiper RUS-T",
+		},
+		{
+			text: "工作刮水刀",
+			name: "Splatana Stamper",
+		},
+		{
+			text: "工作刮水刀·新艺术",
+			name: "Splatana Stamper Nouveau",
+		},
+		{
+			text: "工作刮水刀 封",
+			name: "Stickerz Splatana Stamper",
+		},
+		{
+			text: "秩序刮水刀 复制",
+			name: "Order Splatana Replica",
+		},
+		{
+			text: "特工配件",
+			name: "Undercover Brella",
+		},
+		{
+			text: "特工配件 姐妹",
+			name: "Undercover Sorella Brella",
+		},
+		{
+			text: "特工配件 缭",
+			name: "Patternz Undercover Brella",
+		},
+		{
+			text: "24式可替换伞·甲",
+			name: "Recycled Brella 24 Mk I",
+		},
+		{
+			text: "24式可替换伞·乙",
+			name: "Recycled Brella 24 Mk II",
+		},
+		{
+			text: "遮阳防空伞",
+			name: "Splat Brella",
+		},
+		{
+			text: "遮阳防空伞 姐妹",
+			name: "Sorella Brella",
+		},
+		{
+			text: "秩序防空伞 复制",
+			name: "Order Brella Replica",
+		},
+		{
+			text: "露营防空伞",
+			name: "Tenta Brella",
+		},
+		{
+			text: "露营防空伞 姐妹",
+			name: "Tenta Sorella Brella",
+		},
+		{
+			text: "露营防空伞CREM",
+			name: "Tenta Brella CRE-M",
+		},
+		{
+			text: "专业模型枪MG",
+			name: "Aerospray MG",
+		},
+		{
+			text: "专业模型枪RG",
+			name: "Aerospray RG",
+		},
+		{
+			text: "专业模型枪 彩",
+			name: "Colorz Aerospray",
+		},
+		{
+			text: "顶尖射击枪",
+			name: "Splattershot Pro",
+		},
+		{
+			text: "顶尖射击枪 联名",
+			name: "Forge Splattershot Pro",
+		},
+		{
+			text: "顶尖射击枪FRZN",
+			name: "Splattershot Pro FRZ-N",
+		},
+		{
+			text: "新叶射击枪",
+			name: "Splattershot Jr.",
+		},
+		{
+			text: "枫叶射击枪",
+			name: "Custom Splattershot Jr.",
+		},
+		{
+			text: "开瓶喷泉枪",
+			name: "Squeezer",
+		},
+		{
+			text: "开瓶喷泉枪 金属箔",
+			name: "Foil Squeezer",
+		},
+		{
+			text: ".52加仑",
+			name: ".52 Gal",
+		},
+		{
+			text: ".52加仑 装饰",
+			name: ".52 Gal Deco",
+		},
+		{
+			text: ".96加仑",
+			name: ".96 Gal",
+		},
+		{
+			text: ".96加仑 装饰",
+			name: ".96 Gal Deco",
+		},
+		{
+			text: ".96加仑 爪",
+			name: "Clawz .96 Gal",
+		},
+		{
+			text: "喷射清洁枪",
+			name: "Jet Squelcher",
+		},
+		{
+			text: "喷射清洁枪 改装",
+			name: "Custom Jet Squelcher",
+		},
+		{
+			text: "喷射清洁枪COBR",
+			name: "Jet Squelcher COB-R",
+		},
+		{
+			text: "斯普拉射击枪",
+			name: "Splattershot",
+		},
+		{
+			text: "斯普拉射击枪 联名",
+			name: "Tentatek Splattershot",
+		},
+		{
+			text: "斯普拉射击枪 煌",
+			name: "Glamorz Splattershot",
+		},
+		{
+			text: "英雄射击枪 复制",
+			name: "Hero Shot Replica",
+		},
+		{
+			text: "秩序射击枪 复制",
+			name: "Order Shot Replica",
+		},
+		{
+			text: "章鱼射击枪 复制",
+			name: "Octo Shot Replica",
+		},
+		{
+			text: "窄域标记枪",
+			name: "Splash-o-matic",
+		},
+		{
+			text: "窄域标记枪 新型",
+			name: "Neo Splash-o-matic",
+		},
+		{
+			text: "窄域标记枪GECK",
+			name: "Splash-o-matic GCK-O",
+		},
+		{
+			text: "太空射击枪",
+			name: "Splattershot Nova",
+		},
+		{
+			text: "太空射击枪 联名",
+			name: "Annaki Splattershot Nova",
+		},
+		{
+			text: "N-ZAP85",
+			name: "N-ZAP '85",
+		},
+		{
+			text: "N-ZAP89",
+			name: "N-ZAP '89",
+		},
+		{
+			text: "广域标记枪",
+			name: "Sploosh-o-matic",
+		},
+		{
+			text: "广域标记枪 新型",
+			name: "Neo Sploosh-o-matic",
+		},
+		{
+			text: "H3卷管枪",
+			name: "H-3 Nozzlenose",
+		},
+		{
+			text: "H3卷管枪D",
+			name: "H-3 Nozzlenose D",
+		},
+		{
+			text: "H3卷管枪SNAK",
+			name: "H-3 Nozzlenose VIP-R",
+		},
+		{
+			text: "L3卷管枪",
+			name: "L-3 Nozzlenose",
+		},
+		{
+			text: "L3卷管枪D",
+			name: "L-3 Nozzlenose D",
+		},
+		{
+			text: "L3卷管枪 箔",
+			name: "Glitterz L-3 Nozzlenose",
+		},
+		{
+			text: "满溢泡澡泼桶",
+			name: "Bloblobber",
+		},
+		{
+			text: "满溢泡澡泼桶 装饰",
+			name: "Bloblobber Deco",
+		},
+		{
+			text: "洗笔桶",
+			name: "Tri-Slosher",
+		},
+		{
+			text: "洗笔桶·新艺术",
+			name: "Tri-Slosher Nouveau",
+		},
+		{
+			text: "洗笔桶ASH",
+			name: "Tri-Slosher ASH-N",
+		},
+		{
+			text: "墨瀑淋",
+			name: "Dread Wringer",
+		},
+		{
+			text: "墨瀑淋D",
+			name: "Dread Wringer D",
+		},
+		{
+			text: "墨瀑淋 角",
+			name: "Hornz Dread Wringer",
+		},
+		{
+			text: "回旋泼桶",
+			name: "Sloshing Machine",
+		},
+		{
+			text: "回旋泼桶 新型",
+			name: "Sloshing Machine Neo",
+		},
+		{
+			text: "飞溅泼桶",
+			name: "Slosher",
+		},
+		{
+			text: "飞溅泼桶 装饰",
+			name: "Slosher Deco",
+		},
+		{
+			text: "秩序泼桶 复制",
+			name: "Order Slosher Replica",
+		},
+		{
+			text: "爆炸泼桶",
+			name: "Explosher",
+		},
+		{
+			text: "爆炸泼桶 改装",
+			name: "Custom Explosher",
+		},
+		{
+			text: "圆珠笔",
+			name: "Ballpoint Splatling",
+		},
+		{
+			text: "圆珠笔·新艺术",
+			name: "Ballpoint Splatling Nouveau",
+		},
+		{
+			text: "审查者",
+			name: "Heavy Edit Splatling",
+		},
+		{
+			text: "审查者·新艺术",
+			name: "Heavy Edit Splatling Nouveau",
+		},
+		{
+			text: "消防栓旋转枪",
+			name: "Hydra Splatling",
+		},
+		{
+			text: "消防栓旋转枪 改装",
+			name: "Custom Hydra Splatling",
+		},
+		{
+			text: "消防栓旋转枪 压",
+			name: "Torrentz Hydra Splatling",
+		},
+		{
+			text: "斯普拉旋转枪",
+			name: "Mini Splatling",
+		},
+		{
+			text: "斯普拉旋转枪 联名",
+			name: "Zink Mini Splatling",
+		},
+		{
+			text: "斯普拉旋转枪PYTN",
+			name: "Mini Splatling RTL-R",
+		},
+		{
+			text: "鹦鹉螺号47",
+			name: "Nautilus 47",
+		},
+		{
+			text: "鹦鹉螺号79",
+			name: "Nautilus 79",
+		},
+		{
+			text: "桶装旋转枪",
+			name: "Heavy Splatling",
+		},
+		{
+			text: "桶装旋转枪 装饰",
+			name: "Heavy Splatling Deco",
+		},
+		{
+			text: "秩序旋转枪 复制",
+			name: "Order Splatling Replica",
+		},
+		{
+			text: "邦普V",
+			name: "Wellstring V",
+		},
+		{
+			text: "邦普V 改装",
+			name: "Custom Wellstring V",
+		},
+		{
+			text: "三发猎鱼弓",
+			name: "Tri-Stringer",
+		},
+		{
+			text: "三发猎鱼弓 联名",
+			name: "Inkline Tri-Stringer",
+		},
+		{
+			text: "三发猎鱼弓 灯",
+			name: "Bulbz Tri-Stringer",
+		},
+		{
+			text: "秩序猎鱼弓 复制",
+			name: "Order Stringer Replica",
+		},
+		{
+			text: "LACT-450",
+			name: "REEF-LUX 450",
+		},
+		{
+			text: "LACT-450 装饰",
+			name: "REEF-LUX 450 Deco",
+		},
+		{
+			text: "LACT-450MILK",
+			name: "REEF-LUX 450 MIL-K",
+		},
+		{
+			text: "跳跃信标",
+			name: "Squid Beakon",
+		},
+		{
+			text: "冰壶炸弹",
+			name: "Curling Bomb",
+		},
+		{
+			text: "碳酸炸弹",
+			name: "Fizzy Bomb",
+		},
+		{
+			text: "快速炸弹",
+			name: "Burst Bomb",
+		},
+		{
+			text: "机器人炸弹",
+			name: "Autobomb",
+		},
+		{
+			text: "斯普拉炸弹",
+			name: "Splat Bomb",
+		},
+		{
+			text: "吸盘炸弹",
+			name: "Suction Bomb",
+		},
+		{
+			text: "鱼雷",
+			name: "Torpedo",
+		},
+		{
+			text: "标线器",
+			name: "Angle Shooter",
+		},
+		{
+			text: "定点侦测器",
+			name: "Point Sensor",
+		},
+		{
+			text: "毒雾",
+			name: "Toxic Mist",
+		},
+		{
+			text: "斯普拉防护墙",
+			name: "Splash Wall",
+		},
+		{
+			text: "洒墨器",
+			name: "Sprinkler",
+		},
+		{
+			text: "墨汁陷阱",
+			name: "Ink Mine",
+		},
+		{
+			text: "吸墨机",
+			name: "Ink Vac",
+		},
+		{
+			text: "帝王鱿鱼",
+			name: "Kraken Royale",
+		},
+		{
+			text: "螃蟹坦克",
+			name: "Crab Tank",
+		},
+		{
+			text: "浮墨幕墙",
+			name: "Splattercolor Screen",
+		},
+		{
+			text: "能量站",
+			name: "Tacticooler",
+		},
+		{
+			text: "诱饵烟花",
+			name: "Super Chump",
+		},
+		{
+			text: "巨大防护罩",
+			name: "Big Bubbler",
+		},
+		{
+			text: "墨雨云",
+			name: "Ink Storm",
+		},
+		{
+			text: "喷射背包",
+			name: "Inkjet",
+		},
+		{
+			text: "喇叭镭射5.1ch",
+			name: "Killer Wail 5.1",
+		},
+		{
+			text: "多重导弹",
+			name: "Tenta Missiles",
+		},
+		{
+			text: "赞气弹",
+			name: "Booyah Bomb",
+		},
+		{
+			text: "终极着陆",
+			name: "Triple Splashdown",
+		},
+		{
+			text: "弹跳声呐",
+			name: "Wave Breaker",
+		},
+		{
+			text: "鲨鱼坐骑",
+			name: "Reefslider",
+		},
+		{
+			text: "触手喷射",
+			name: "Zipcaster",
+		},
+		{
+			text: "三重龙卷风",
+			name: "Triple Inkstrike",
+		},
+		{
+			text: "终极发射",
+			name: "Trizooka",
+		},
+		{
+			text: "终极印章",
+			name: "Ultra Stamp",
+		},
+	],
+	EUde: [
+		{
+			text: "Turbo-Blaster Plus",
+			name: "Rapid Blaster Pro",
+		},
+		{
+			text: "Turbo-Blaster Plus Deko",
+			name: "Rapid Blaster Pro Deco",
+		},
+		{
+			text: "Turbo-Blaster Plus WNT-R",
+			name: "Rapid Blaster Pro WNT-R",
+		},
+		{
+			text: "Kontra-Blaster",
+			name: "Clash Blaster",
+		},
+		{
+			text: "Kontra-Blaster Neo",
+			name: "Clash Blaster Neo",
+		},
+		{
+			text: "Turbo-Blaster",
+			name: "Rapid Blaster",
+		},
+		{
+			text: "Turbo-Blaster Deko",
+			name: "Rapid Blaster Deco",
+		},
+		{
+			text: "Fern-Blaster",
+			name: "Range Blaster",
+		},
+		{
+			text: "Fern-Blaster SE",
+			name: "Custom Range Blaster",
+		},
+		{
+			text: "Blaster SE",
+			name: "Custom Blaster",
+		},
+		{
+			text: "Blaster GLAM",
+			name: "Gleamz Blaster",
+		},
+		{
+			text: "S-BLAST92",
+			name: "S-BLAST '92",
+		},
+		{
+			text: "S-BLAST91",
+			name: "S-BLAST '91",
+		},
+		{
+			text: "Luna-Blaster",
+			name: "Luna Blaster",
+		},
+		{
+			text: "Luna-Blaster Neo",
+			name: "Luna Blaster Neo",
+		},
+		{
+			text: "Ordnung-Blaster Replik",
+			name: "Order Blaster Replica",
+		},
+		{
+			text: "Fächerfärber",
+			name: "Painbrush",
+		},
+		{
+			text: "Fächerfärber Fresco",
+			name: "Painbrush Nouveau",
+		},
+		{
+			text: "Fächerfärber BRN-Z",
+			name: "Painbrush BRN-Z",
+		},
+		{
+			text: "Quasto",
+			name: "Inkbrush",
+		},
+		{
+			text: "Quasto Fresco",
+			name: "Inkbrush Nouveau",
+		},
+		{
+			text: "Kalligraf",
+			name: "Octobrush",
+		},
+		{
+			text: "Kalligraf Fresco",
+			name: "Octobrush Nouveau",
+		},
+		{
+			text: "Kalligraf Astro",
+			name: "Cometz Octobrush",
+		},
+		{
+			text: "Ordnung-Kalligraf Replik",
+			name: "Orderbrush Replica",
+		},
+		{
+			text: "T-Tuber",
+			name: "Goo Tuber",
+		},
+		{
+			text: "T-Tuber SE",
+			name: "Custom Goo Tuber",
+		},
+		{
+			text: "Klotzer 14-A",
+			name: "Bamboozler 14 Mk I",
+		},
+		{
+			text: "Klotzer 14-B",
+			name: "Bamboozler 14 Mk II",
+		},
+		{
+			text: "Ziel-E-liter 4K",
+			name: "E-liter 4K Scope",
+		},
+		{
+			text: "Ziel-E-liter 4K SE",
+			name: "Custom E-liter 4K Scope",
+		},
+		{
+			text: "E-liter 4K SE",
+			name: "Custom E-liter 4K",
+		},
+		{
+			text: "Ziel-Konzentrator",
+			name: "Splatterscope",
+		},
+		{
+			text: "Zekkori-Ziel-Konzentrator",
+			name: "Z+F Splatterscope",
+		},
+		{
+			text: "Ziel-Konzentrator TAR-N",
+			name: "Splatterscope CAM-O",
+		},
+		{
+			text: "Klecks-Konzentrator",
+			name: "Splat Charger",
+		},
+		{
+			text: "Zekkori-Klecks-Konzentrator",
+			name: "Z+F Splat Charger",
+		},
+		{
+			text: "Klecks-Konzentrator TAR-N",
+			name: "Splat Charger CAM-O",
+		},
+		{
+			text: "Ordnung-Konzentrator Replik",
+			name: "Order Charger Replica",
+		},
+		{
+			text: "R-BLR/5H",
+			name: "Snipewriter 5H",
+		},
+		{
+			text: "R-BLR/5B",
+			name: "Snipewriter 5B",
+		},
+		{
+			text: "Sepiator α",
+			name: "Classic Squiffer",
+		},
+		{
+			text: "Sepiator β",
+			name: "New Squiffer",
+		},
+		{
+			text: "Dual-Platscher",
+			name: "Dualie Squelchers",
+		},
+		{
+			text: "Dual-Platscher SE",
+			name: "Custom Dualie Squelchers",
+		},
+		{
+			text: "Dual-Platscher ZBR",
+			name: "Hoofz Dualie Squelchers",
+		},
+		{
+			text: "Kelvin 525",
+			name: "Glooga Dualies",
+		},
+		{
+			text: "Kelvin 525 Deko",
+			name: "Glooga Dualies Deco",
+		},
+		{
+			text: "Lösch-Doppler FW",
+			name: "Douser Dualies FF",
+		},
+		{
+			text: "Lösch-Doppler FW SE",
+			name: "Custom Douser Dualies FF",
+		},
+		{
+			text: "Klecks-Doppler",
+			name: "Splat Dualies",
+		},
+		{
+			text: "Enperry-Klecks-Doppler",
+			name: "Enperry Splat Dualies",
+		},
+		{
+			text: "Glitz-Klecks-Doppler",
+			name: "Twinklez Splat Dualies",
+		},
+		{
+			text: "Ordnung-Doppler Replik",
+			name: "Order Dualie Replicas",
+		},
+		{
+			text: "Sprenkler",
+			name: "Dapple Dualies",
+		},
+		{
+			text: "Sprenkler Fresco",
+			name: "Dapple Dualies Nouveau",
+		},
+		{
+			text: "Sprenkler U-HU",
+			name: "Dapple Dualies NOC-T",
+		},
+		{
+			text: "Quadhopper Noir",
+			name: "Dark Tetra Dualies",
+		},
+		{
+			text: "Quadhopper Blanc",
+			name: "Light Tetra Dualies",
+		},
+		{
+			text: "Karbonroller",
+			name: "Carbon Roller",
+		},
+		{
+			text: "Karbonroller Deko",
+			name: "Carbon Roller Deco",
+		},
+		{
+			text: "Karbonroller ANG-LR",
+			name: "Carbon Roller ANG-L",
+		},
+		{
+			text: "Dynaroller",
+			name: "Dynamo Roller",
+		},
+		{
+			text: "Dynaroller Tesla",
+			name: "Gold Dynamo Roller",
+		},
+		{
+			text: "Dynaroller Galaxa",
+			name: "Starz Dynamo Roller",
+		},
+		{
+			text: "Flex-Roller",
+			name: "Flingza Roller",
+		},
+		{
+			text: "Flex-Roller Fol",
+			name: "Foil Flingza Roller",
+		},
+		{
+			text: "Klecksroller",
+			name: "Splat Roller",
+		},
+		{
+			text: "Medusa-Klecksroller",
+			name: "Krak-On Splat Roller",
+		},
+		{
+			text: "Ordnung-Roller Replik",
+			name: "Order Roller Replica",
+		},
+		{
+			text: "Breitroller",
+			name: "Big Swig Roller",
+		},
+		{
+			text: "Breitroller Express",
+			name: "Big Swig Roller Express",
+		},
+		{
+			text: "Breitroller Exzell",
+			name: "Planetz Big Swig Roller",
+		},
+		{
+			text: "Minz-Prophylator",
+			name: "Mint Decavitator",
+		},
+		{
+			text: "Carbo-Prophylator",
+			name: "Charcoal Decavitator",
+		},
+		{
+			text: "Wischer-Splatana",
+			name: "Splatana Wiper",
+		},
+		{
+			text: "Wischer-Splatana Deko",
+			name: "Splatana Wiper Deco",
+		},
+		{
+			text: "Wischer-Splatana RST-G",
+			name: "Splatana Wiper RUS-T",
+		},
+		{
+			text: "Stempel-Splatana",
+			name: "Splatana Stamper",
+		},
+		{
+			text: "Stempel-Splatana Fresco",
+			name: "Splatana Stamper Nouveau",
+		},
+		{
+			text: "Stempel-Splatana Sticker",
+			name: "Stickerz Splatana Stamper",
+		},
+		{
+			text: "Ordnung-Splatana Replik",
+			name: "Order Splatana Replica",
+		},
+		{
+			text: "UnderCover",
+			name: "Undercover Brella",
+		},
+		{
+			text: "Sorella-UnderCover",
+			name: "Undercover Sorella Brella",
+		},
+		{
+			text: "Flair-UnderCover",
+			name: "Patternz Undercover Brella",
+		},
+		{
+			text: "Bast-Pluviator 24-A",
+			name: "Recycled Brella 24 Mk I",
+		},
+		{
+			text: "Bast-Pluviator 24-B",
+			name: "Recycled Brella 24 Mk II",
+		},
+		{
+			text: "Parapluviator",
+			name: "Splat Brella",
+		},
+		{
+			text: "Sorella-Parapluviator",
+			name: "Sorella Brella",
+		},
+		{
+			text: "Ordnung-Pluviator Replik",
+			name: "Order Brella Replica",
+		},
+		{
+			text: "Camp-Pluviator",
+			name: "Tenta Brella",
+		},
+		{
+			text: "Sorella-Camp-Pluviator",
+			name: "Tenta Sorella Brella",
+		},
+		{
+			text: "Camp-Pluviator CR-MA",
+			name: "Tenta Brella CRE-M",
+		},
+		{
+			text: "Airbrush MG",
+			name: "Aerospray MG",
+		},
+		{
+			text: "Airbrush RG",
+			name: "Aerospray RG",
+		},
+		{
+			text: "Airbrush RGB",
+			name: "Colorz Aerospray",
+		},
+		{
+			text: "Profi-Kleckser",
+			name: "Splattershot Pro",
+		},
+		{
+			text: "Focus-Profi-Kleckser",
+			name: "Forge Splattershot Pro",
+		},
+		{
+			text: "Profi-Kleckser CH-LL",
+			name: "Splattershot Pro FRZ-N",
+		},
+		{
+			text: "Junior-Kleckser",
+			name: "Splattershot Jr.",
+		},
+		{
+			text: "Junior-Kleckser Plus",
+			name: "Custom Splattershot Jr.",
+		},
+		{
+			text: "Quetscher",
+			name: "Squeezer",
+		},
+		{
+			text: "Quetscher Fol",
+			name: "Foil Squeezer",
+		},
+		{
+			text: ".52 Gallon",
+			name: ".52 Gal",
+		},
+		{
+			text: ".52 Gallon Deko",
+			name: ".52 Gal Deco",
+		},
+		{
+			text: ".96 Gallon",
+			name: ".96 Gal",
+		},
+		{
+			text: ".96 Gallon Deko",
+			name: ".96 Gal Deco",
+		},
+		{
+			text: ".96 Gallon Leo",
+			name: "Clawz .96 Gal",
+		},
+		{
+			text: "Platscher",
+			name: "Jet Squelcher",
+		},
+		{
+			text: "Platscher SE",
+			name: "Custom Jet Squelcher",
+		},
+		{
+			text: "Platscher KB-RA",
+			name: "Jet Squelcher COB-R",
+		},
+		{
+			text: "Kleckser",
+			name: "Splattershot",
+		},
+		{
+			text: "Tentatek-Kleckser",
+			name: "Tentatek Splattershot",
+		},
+		{
+			text: "Chroma-Kleckser",
+			name: "Glamorz Splattershot",
+		},
+		{
+			text: "Heldenwaffe Replik",
+			name: "Hero Shot Replica",
+		},
+		{
+			text: "Ordnung-Kleckser Replik",
+			name: "Order Shot Replica",
+		},
+		{
+			text: "Okto-Kleckser Replik",
+			name: "Octo Shot Replica",
+		},
+		{
+			text: "Fein-Disperser",
+			name: "Splash-o-matic",
+		},
+		{
+			text: "Fein-Disperser Neo",
+			name: "Neo Splash-o-matic",
+		},
+		{
+			text: "Fein-Disperser GK-KO",
+			name: "Splash-o-matic GCK-O",
+		},
+		{
+			text: "Kosmo-Kleckser",
+			name: "Splattershot Nova",
+		},
+		{
+			text: "Annaki-Kosmo-Kleckser",
+			name: "Annaki Splattershot Nova",
+		},
+		{
+			text: "N-ZAP85",
+			name: "N-ZAP '85",
+		},
+		{
+			text: "N-ZAP89",
+			name: "N-ZAP '89",
+		},
+		{
+			text: "Disperser",
+			name: "Sploosh-o-matic",
+		},
+		{
+			text: "Disperser Neo",
+			name: "Neo Sploosh-o-matic",
+		},
+		{
+			text: "S3 Tintenwerfer",
+			name: "H-3 Nozzlenose",
+		},
+		{
+			text: "S3 Tintenwerfer D",
+			name: "H-3 Nozzlenose D",
+		},
+		{
+			text: "S3 Tintenwerfer VIP-R",
+			name: "H-3 Nozzlenose VIP-R",
+		},
+		{
+			text: "L3 Tintenwerfer",
+			name: "L-3 Nozzlenose",
+		},
+		{
+			text: "L3 Tintenwerfer D",
+			name: "L-3 Nozzlenose D",
+		},
+		{
+			text: "L3 Tintenwerfer Oro",
+			name: "Glitterz L-3 Nozzlenose",
+		},
+		{
+			text: "Wannen-Schwapper",
+			name: "Bloblobber",
+		},
+		{
+			text: "Wannen-Schwapper Deko",
+			name: "Bloblobber Deco",
+		},
+		{
+			text: "3R-Schwapper",
+			name: "Tri-Slosher",
+		},
+		{
+			text: "3R-Schwapper Fresco",
+			name: "Tri-Slosher Nouveau",
+		},
+		{
+			text: "3R-Schwapper OX-D",
+			name: "Tri-Slosher ASH-N",
+		},
+		{
+			text: "Schwappwascher",
+			name: "Dread Wringer",
+		},
+		{
+			text: "Schwappwascher D",
+			name: "Dread Wringer D",
+		},
+		{
+			text: "Schwappwascher Horn",
+			name: "Hornz Dread Wringer",
+		},
+		{
+			text: "Trommel-Schwapper",
+			name: "Sloshing Machine",
+		},
+		{
+			text: "Trommel-Schwapper Neo",
+			name: "Sloshing Machine Neo",
+		},
+		{
+			text: "Schwapper",
+			name: "Slosher",
+		},
+		{
+			text: "Schwapper Deko",
+			name: "Slosher Deco",
+		},
+		{
+			text: "Ordnung-Schwapper Replik",
+			name: "Order Slosher Replica",
+		},
+		{
+			text: "Knall-Schwapper",
+			name: "Explosher",
+		},
+		{
+			text: "Knall-Schwapper SE",
+			name: "Custom Explosher",
+		},
+		{
+			text: "Kuli-Splatling",
+			name: "Ballpoint Splatling",
+		},
+		{
+			text: "Kuli-Splatling Fresco",
+			name: "Ballpoint Splatling Nouveau",
+		},
+		{
+			text: "Kartuschierer",
+			name: "Heavy Edit Splatling",
+		},
+		{
+			text: "Kartuschierer Fresco",
+			name: "Heavy Edit Splatling Nouveau",
+		},
+		{
+			text: "Hydrant",
+			name: "Hydra Splatling",
+		},
+		{
+			text: "Hydrant SE",
+			name: "Custom Hydra Splatling",
+		},
+		{
+			text: "Hydrant ATÜ",
+			name: "Torrentz Hydra Splatling",
+		},
+		{
+			text: "Klecks-Splatling",
+			name: "Mini Splatling",
+		},
+		{
+			text: "Sagitron-Klecks-Splatling",
+			name: "Zink Mini Splatling",
+		},
+		{
+			text: "Klecks-Splatling KLP-R",
+			name: "Mini Splatling RTL-R",
+		},
+		{
+			text: "Splatling",
+			name: "Heavy Splatling",
+		},
+		{
+			text: "Splatling Deko",
+			name: "Heavy Splatling Deco",
+		},
+		{
+			text: "Ordnung-Splatling Replik",
+			name: "Order Splatling Replica",
+		},
+		{
+			text: "Penta-Pumper",
+			name: "Wellstring V",
+		},
+		{
+			text: "Penta-Pumper SE",
+			name: "Custom Wellstring V",
+		},
+		{
+			text: "Alpomar-Tri-Stringer",
+			name: "Inkline Tri-Stringer",
+		},
+		{
+			text: "Prisma-Tri-Stringer",
+			name: "Bulbz Tri-Stringer",
+		},
+		{
+			text: "Ordnung-Stringer Replik",
+			name: "Order Stringer Replica",
+		},
+		{
+			text: "LACT-450",
+			name: "REEF-LUX 450",
+		},
+		{
+			text: "LACT-450 Deko",
+			name: "REEF-LUX 450 Deco",
+		},
+		{
+			text: "LACT-450 Q-MLCH",
+			name: "REEF-LUX 450 MIL-K",
+		},
+		{
+			text: "Sprungboje",
+			name: "Squid Beakon",
+		},
+		{
+			text: "Curling-Bombe",
+			name: "Curling Bomb",
+		},
+		{
+			text: "Sprudel-Bombe",
+			name: "Fizzy Bomb",
+		},
+		{
+			text: "Insta-Bombe",
+			name: "Burst Bomb",
+		},
+		{
+			text: "Robo-Bombe",
+			name: "Autobomb",
+		},
+		{
+			text: "Klecks-Bombe",
+			name: "Splat Bomb",
+		},
+		{
+			text: "Haftbombe",
+			name: "Suction Bomb",
+		},
+		{
+			text: "Winkelmarker",
+			name: "Angle Shooter",
+		},
+		{
+			text: "Detektor",
+			name: "Point Sensor",
+		},
+		{
+			text: "Sepitox-Nebel",
+			name: "Toxic Mist",
+		},
+		{
+			text: "Tintenwall",
+			name: "Splash Wall",
+		},
+		{
+			text: "Tintenmine",
+			name: "Ink Mine",
+		},
+		{
+			text: "Tintegrator",
+			name: "Ink Vac",
+		},
+		{
+			text: "Tintentyrann",
+			name: "Kraken Royale",
+		},
+		{
+			text: "Krabbenpanzer",
+			name: "Crab Tank",
+		},
+		{
+			text: "Unsichtbarriere",
+			name: "Splattercolor Screen",
+		},
+		{
+			text: "Tranktank",
+			name: "Tacticooler",
+		},
+		{
+			text: "Bluffbomber",
+			name: "Super Chump",
+		},
+		{
+			text: "Kugelschild Pro",
+			name: "Big Bubbler",
+		},
+		{
+			text: "Tintenschauer",
+			name: "Ink Storm",
+		},
+		{
+			text: "Tintendüser",
+			name: "Inkjet",
+		},
+		{
+			text: "Heulboje 5.1",
+			name: "Killer Wail 5.1",
+		},
+		{
+			text: "Schwarmraketen",
+			name: "Tenta Missiles",
+		},
+		{
+			text: "Cool-Kugel",
+			name: "Booyah Bomb",
+		},
+		{
+			text: "Tri-Tintenschock",
+			name: "Triple Splashdown",
+		},
+		{
+			text: "Schauerwelle",
+			name: "Wave Breaker",
+		},
+		{
+			text: "Haihammer",
+			name: "Reefslider",
+		},
+		{
+			text: "Haftsprung",
+			name: "Zipcaster",
+		},
+		{
+			text: "Tri-Tintferno",
+			name: "Triple Inkstrike",
+		},
+		{
+			text: "Ultra-Stempel",
+			name: "Ultra Stamp",
+		},
+	],
+	EUes: [
+		{
+			text: "Superdevastador",
+			name: "Rapid Blaster Pro",
+		},
+		{
+			text: "Superdevastador DX",
+			name: "Rapid Blaster Pro Deco",
+		},
+		{
+			text: "Superdevastador INV",
+			name: "Rapid Blaster Pro WNT-R",
+		},
+		{
+			text: "Turbodevastador",
+			name: "Clash Blaster",
+		},
+		{
+			text: "Turbodevastador neo",
+			name: "Clash Blaster Neo",
+		},
+		{
+			text: "Devastador exprés",
+			name: "Rapid Blaster",
+		},
+		{
+			text: "Devastador exprés DX",
+			name: "Rapid Blaster Deco",
+		},
+		{
+			text: "Teledevastador",
+			name: "Range Blaster",
+		},
+		{
+			text: "Teledevastador SP",
+			name: "Custom Range Blaster",
+		},
+		{
+			text: "Devastador",
+			name: "Blaster",
+		},
+		{
+			text: "Devastador SP",
+			name: "Custom Blaster",
+		},
+		{
+			text: "Devastador LUX",
+			name: "Gleamz Blaster",
+		},
+		{
+			text: "D-VAST 92",
+			name: "S-BLAST '92",
+		},
+		{
+			text: "D-VAST 91",
+			name: "S-BLAST '91",
+		},
+		{
+			text: "Ultradevastador",
+			name: "Luna Blaster",
+		},
+		{
+			text: "Ultradevastador neo",
+			name: "Luna Blaster Neo",
+		},
+		{
+			text: "Devastador orden (réplica)",
+			name: "Order Blaster Replica",
+		},
+		{
+			text: "Brocha abanico",
+			name: "Painbrush",
+		},
+		{
+			text: "Brocha abanico maestra",
+			name: "Painbrush Nouveau",
+		},
+		{
+			text: "Brocha abanico BNC",
+			name: "Painbrush BRN-Z",
+		},
+		{
+			text: "Pincel",
+			name: "Inkbrush",
+		},
+		{
+			text: "Pincel maestro",
+			name: "Inkbrush Nouveau",
+		},
+		{
+			text: "Brocha",
+			name: "Octobrush",
+		},
+		{
+			text: "Brocha maestra",
+			name: "Octobrush Nouveau",
+		},
+		{
+			text: "Brocha cometa",
+			name: "Cometz Octobrush",
+		},
+		{
+			text: "Brocha orden (réplica)",
+			name: "Orderbrush Replica",
+		},
+		{
+			text: "Tubofusil",
+			name: "Goo Tuber",
+		},
+		{
+			text: "Tubofusil SP",
+			name: "Custom Goo Tuber",
+		},
+		{
+			text: "Bambufusil 14-I",
+			name: "Bamboozler 14 Mk I",
+		},
+		{
+			text: "Bambufusil 14-II",
+			name: "Bamboozler 14 Mk II",
+		},
+		{
+			text: "Telentintador 4K",
+			name: "E-liter 4K Scope",
+		},
+		{
+			text: "Telentintador 4K SP",
+			name: "Custom E-liter 4K Scope",
+		},
+		{
+			text: "Entintador 4K",
+			name: "E-liter 4K",
+		},
+		{
+			text: "Entintador 4K SP",
+			name: "Custom E-liter 4K",
+		},
+		{
+			text: "Cargatintas con mira",
+			name: "Splatterscope",
+		},
+		{
+			text: "Cargatintas con mira Ezkkor",
+			name: "Z+F Splatterscope",
+		},
+		{
+			text: "Cargatintas con mira BSQ",
+			name: "Splatterscope CAM-O",
+		},
+		{
+			text: "Cargatintas",
+			name: "Splat Charger",
+		},
+		{
+			text: "Cargatintas Ezkkor",
+			name: "Z+F Splat Charger",
+		},
+		{
+			text: "Cargatintas BSQ",
+			name: "Splat Charger CAM-O",
+		},
+		{
+			text: "Cargatintas orden (réplica)",
+			name: "Order Charger Replica",
+		},
+		{
+			text: "Cargaminas 5H",
+			name: "Snipewriter 5H",
+		},
+		{
+			text: "Cargaminas 5B",
+			name: "Snipewriter 5B",
+		},
+		{
+			text: "Kalarrapid α",
+			name: "Classic Squiffer",
+		},
+		{
+			text: "Kalarrapid β",
+			name: "New Squiffer",
+		},
+		{
+			text: "Barredora dual",
+			name: "Dualie Squelchers",
+		},
+		{
+			text: "Barredora dual SP",
+			name: "Custom Dualie Squelchers",
+		},
+		{
+			text: "Barredora dual rayas",
+			name: "Hoofz Dualie Squelchers",
+		},
+		{
+			text: "Fundidora 525 dual",
+			name: "Glooga Dualies",
+		},
+		{
+			text: "Fundidora 525 dual DX",
+			name: "Glooga Dualies Deco",
+		},
+		{
+			text: "Extintor Dual FF",
+			name: "Douser Dualies FF",
+		},
+		{
+			text: "Extintor Dual FF SP",
+			name: "Custom Douser Dualies FF",
+		},
+		{
+			text: "Difusor dual",
+			name: "Splat Dualies",
+		},
+		{
+			text: "Difusor dual B",
+			name: "Enperry Splat Dualies",
+		},
+		{
+			text: "Difusor dual chispa",
+			name: "Twinklez Splat Dualies",
+		},
+		{
+			text: "Difusor dual orden (réplica)",
+			name: "Order Dualie Replicas",
+		},
+		{
+			text: "Atomizador dual",
+			name: "Dapple Dualies",
+		},
+		{
+			text: "Atomizador dual maestro",
+			name: "Dapple Dualies Nouveau",
+		},
+		{
+			text: "Atomizador dual búho",
+			name: "Dapple Dualies NOC-T",
+		},
+		{
+			text: "Motatrónic dual negro",
+			name: "Dark Tetra Dualies",
+		},
+		{
+			text: "Motatrónic dual blanco",
+			name: "Light Tetra Dualies",
+		},
+		{
+			text: "Rodillo de carbono",
+			name: "Carbon Roller",
+		},
+		{
+			text: "Rodillo de carbono DX",
+			name: "Carbon Roller Deco",
+		},
+		{
+			text: "Rodillo de carbono ABSL",
+			name: "Carbon Roller ANG-L",
+		},
+		{
+			text: "Dinamorrodillo",
+			name: "Dynamo Roller",
+		},
+		{
+			text: "Dinamorrodillo T",
+			name: "Gold Dynamo Roller",
+		},
+		{
+			text: "Dinamorrodillo cosmos",
+			name: "Starz Dynamo Roller",
+		},
+		{
+			text: "Rodillo versátil",
+			name: "Flingza Roller",
+		},
+		{
+			text: "Rodillo versátil B",
+			name: "Foil Flingza Roller",
+		},
+		{
+			text: "Rodillo básico",
+			name: "Splat Roller",
+		},
+		{
+			text: "Rodillo básico B",
+			name: "Krak-On Splat Roller",
+		},
+		{
+			text: "Rodillo orden (réplica)",
+			name: "Order Roller Replica",
+		},
+		{
+			text: "Rodillo mágnum",
+			name: "Big Swig Roller",
+		},
+		{
+			text: "Rodillo mágnum B",
+			name: "Big Swig Roller Express",
+		},
+		{
+			text: "Rodillo mágnum SAT",
+			name: "Planetz Big Swig Roller",
+		},
+		{
+			text: "Odontintador menta",
+			name: "Mint Decavitator",
+		},
+		{
+			text: "Odontintador carbón",
+			name: "Charcoal Decavitator",
+		},
+		{
+			text: "Azotintador brisa",
+			name: "Splatana Wiper",
+		},
+		{
+			text: "Azotintador brisa DX",
+			name: "Splatana Wiper Deco",
+		},
+		{
+			text: "Azotintador brisa óxido",
+			name: "Splatana Wiper RUS-T",
+		},
+		{
+			text: "Azotintador pro",
+			name: "Splatana Stamper",
+		},
+		{
+			text: "Azotintador pro maestro",
+			name: "Splatana Stamper Nouveau",
+		},
+		{
+			text: "Azotintador pro pegatas",
+			name: "Stickerz Splatana Stamper",
+		},
+		{
+			text: "Azotintador orden (réplica)",
+			name: "Order Splatana Replica",
+		},
+		{
+			text: "Paratintas clásico",
+			name: "Undercover Brella",
+		},
+		{
+			text: "Paratintas clásico B",
+			name: "Undercover Sorella Brella",
+		},
+		{
+			text: "Paratintas clásico MIX",
+			name: "Patternz Undercover Brella",
+		},
+		{
+			text: "Prototintas 24-I",
+			name: "Recycled Brella 24 Mk I",
+		},
+		{
+			text: "Prototintas 24-II",
+			name: "Recycled Brella 24 Mk II",
+		},
+		{
+			text: "Paratintas",
+			name: "Splat Brella",
+		},
+		{
+			text: "Paratintas B",
+			name: "Sorella Brella",
+		},
+		{
+			text: "Paratintas orden (réplica)",
+			name: "Order Brella Replica",
+		},
+		{
+			text: "Paratintas maxi",
+			name: "Tenta Brella",
+		},
+		{
+			text: "Paratintas maxi B",
+			name: "Tenta Sorella Brella",
+		},
+		{
+			text: "Paratintas maxi crema",
+			name: "Tenta Brella CRE-M",
+		},
+		{
+			text: "Aerógrafo pro",
+			name: "Aerospray MG",
+		},
+		{
+			text: "Aerógrafo plus",
+			name: "Aerospray RG",
+		},
+		{
+			text: "Aerógrafo arcoíris",
+			name: "Colorz Aerospray",
+		},
+		{
+			text: "Lanzatintas plus",
+			name: "Splattershot Pro",
+		},
+		{
+			text: "Lanzatintas plus B",
+			name: "Forge Splattershot Pro",
+		},
+		{
+			text: "Lanzatintas plus gélido",
+			name: "Splattershot Pro FRZ-N",
+		},
+		{
+			text: "Lanzatintas novato",
+			name: "Splattershot Jr.",
+		},
+		{
+			text: "Lanzatintas novato B",
+			name: "Custom Splattershot Jr.",
+		},
+		{
+			text: "Tintopresor",
+			name: "Squeezer",
+		},
+		{
+			text: "Tintopresor B",
+			name: "Foil Squeezer",
+		},
+		{
+			text: "Salpicadora 2000",
+			name: ".52 Gal",
+		},
+		{
+			text: "Salpicadora 2000 DX",
+			name: ".52 Gal Deco",
+		},
+		{
+			text: "Salpicadora 3000",
+			name: ".96 Gal",
+		},
+		{
+			text: "Salpicadora 3000 DX",
+			name: ".96 Gal Deco",
+		},
+		{
+			text: "Salpicadora 3000 garra",
+			name: "Clawz .96 Gal",
+		},
+		{
+			text: "Megabarredora",
+			name: "Jet Squelcher",
+		},
+		{
+			text: "Megabarredora SP",
+			name: "Custom Jet Squelcher",
+		},
+		{
+			text: "Megabarredora cobra",
+			name: "Jet Squelcher COB-R",
+		},
+		{
+			text: "Lanzatintas",
+			name: "Splattershot",
+		},
+		{
+			text: "Lanzatintas B",
+			name: "Tentatek Splattershot",
+		},
+		{
+			text: "Lanzatintas ZAS",
+			name: "Glamorz Splattershot",
+		},
+		{
+			text: "Pistola de élite (réplica)",
+			name: "Hero Shot Replica",
+		},
+		{
+			text: "Lanzatintas orden (réplica)",
+			name: "Order Shot Replica",
+		},
+		{
+			text: "Pistola octariana (réplica)",
+			name: "Octo Shot Replica",
+		},
+		{
+			text: "Marcador fino",
+			name: "Splash-o-matic",
+		},
+		{
+			text: "Marcador fino neo",
+			name: "Neo Splash-o-matic",
+		},
+		{
+			text: "Marcador fino geco",
+			name: "Splash-o-matic GCK-O",
+		},
+		{
+			text: "Lanzatintas espacial",
+			name: "Splattershot Nova",
+		},
+		{
+			text: "Lanzatintas espacial B",
+			name: "Annaki Splattershot Nova",
+		},
+		{
+			text: "N-ZAP 85",
+			name: "N-ZAP '85",
+		},
+		{
+			text: "N-ZAP 89",
+			name: "N-ZAP '89",
+		},
+		{
+			text: "Marcador",
+			name: "Sploosh-o-matic",
+		},
+		{
+			text: "Marcador neo",
+			name: "Neo Sploosh-o-matic",
+		},
+		{
+			text: "Tintambor pesado",
+			name: "H-3 Nozzlenose",
+		},
+		{
+			text: "Tintambor pesado D",
+			name: "H-3 Nozzlenose D",
+		},
+		{
+			text: "Tintambor pesado áspid",
+			name: "H-3 Nozzlenose VIP-R",
+		},
+		{
+			text: "Tintambor ligero",
+			name: "L-3 Nozzlenose",
+		},
+		{
+			text: "Tintambor ligero D",
+			name: "L-3 Nozzlenose D",
+		},
+		{
+			text: "Tintambor ligero chapa",
+			name: "Glitterz L-3 Nozzlenose",
+		},
+		{
+			text: "Derramatic baño",
+			name: "Bloblobber",
+		},
+		{
+			text: "Derramatic baño DX",
+			name: "Bloblobber Deco",
+		},
+		{
+			text: "Derramatic triple",
+			name: "Tri-Slosher",
+		},
+		{
+			text: "Derramatic triple maestro",
+			name: "Tri-Slosher Nouveau",
+		},
+		{
+			text: "Derramatic triple ceniza",
+			name: "Tri-Slosher ASH-N",
+		},
+		{
+			text: "Friegamatic",
+			name: "Dread Wringer",
+		},
+		{
+			text: "Friegamatic D",
+			name: "Dread Wringer D",
+		},
+		{
+			text: "Friegamatic asta",
+			name: "Hornz Dread Wringer",
+		},
+		{
+			text: "Derramatic centrífugo",
+			name: "Sloshing Machine",
+		},
+		{
+			text: "Derramatic centrífugo neo",
+			name: "Sloshing Machine Neo",
+		},
+		{
+			text: "Derramatic",
+			name: "Slosher",
+		},
+		{
+			text: "Derramatic DX",
+			name: "Slosher Deco",
+		},
+		{
+			text: "Derramatic orden (réplica)",
+			name: "Order Slosher Replica",
+		},
+		{
+			text: "Derramatic turbo",
+			name: "Explosher",
+		},
+		{
+			text: "Derramatic turbo SP",
+			name: "Custom Explosher",
+		},
+		{
+			text: "Ametrallógrafo",
+			name: "Ballpoint Splatling",
+		},
+		{
+			text: "Ametrallógrafo maestro",
+			name: "Ballpoint Splatling Nouveau",
+		},
+		{
+			text: "Corrigetintas",
+			name: "Heavy Edit Splatling",
+		},
+		{
+			text: "Corrigetintas maestro",
+			name: "Heavy Edit Splatling Nouveau",
+		},
+		{
+			text: "Extintador",
+			name: "Hydra Splatling",
+		},
+		{
+			text: "Extintador SP",
+			name: "Custom Hydra Splatling",
+		},
+		{
+			text: "Extintador presión",
+			name: "Torrentz Hydra Splatling",
+		},
+		{
+			text: "Tintralladora ligera",
+			name: "Mini Splatling",
+		},
+		{
+			text: "Tintralladora ligera B",
+			name: "Zink Mini Splatling",
+		},
+		{
+			text: "Tintralladora ligera pitón",
+			name: "Mini Splatling RTL-R",
+		},
+		{
+			text: "Subtralladora 47",
+			name: "Nautilus 47",
+		},
+		{
+			text: "Subtralladora 79",
+			name: "Nautilus 79",
+		},
+		{
+			text: "Tintralladora",
+			name: "Heavy Splatling",
+		},
+		{
+			text: "Tintralladora DX",
+			name: "Heavy Splatling Deco",
+		},
+		{
+			text: "Tintralladora orden (réplica)",
+			name: "Order Splatling Replica",
+		},
+		{
+			text: "Arcrotensor V",
+			name: "Wellstring V",
+		},
+		{
+			text: "Arcrotensor V SP",
+			name: "Custom Wellstring V",
+		},
+		{
+			text: "Arcromatizador triple",
+			name: "Tri-Stringer",
+		},
+		{
+			text: "Arcromatizador triple B",
+			name: "Inkline Tri-Stringer",
+		},
+		{
+			text: "Arcromatizador triple LUZ",
+			name: "Bulbz Tri-Stringer",
+		},
+		{
+			text: "Arcromatizador orden (réplica)",
+			name: "Order Stringer Replica",
+		},
+		{
+			text: "AR-CR0 450",
+			name: "REEF-LUX 450",
+		},
+		{
+			text: "AR-CR0 450 DX",
+			name: "REEF-LUX 450 Deco",
+		},
+		{
+			text: "AR-CR0 450 lácteo",
+			name: "REEF-LUX 450 MIL-K",
+		},
+		{
+			text: "Baliza transportadora",
+			name: "Squid Beakon",
+		},
+		{
+			text: "Bomba deslizante",
+			name: "Curling Bomb",
+		},
+		{
+			text: "Bomba carbónica",
+			name: "Fizzy Bomb",
+		},
+		{
+			text: "Bomba rápida",
+			name: "Burst Bomb",
+		},
+		{
+			text: "Robobomba",
+			name: "Autobomb",
+		},
+		{
+			text: "Bomba básica",
+			name: "Splat Bomb",
+		},
+		{
+			text: "Bomba ventosa",
+			name: "Suction Bomb",
+		},
+		{
+			text: "Tiralíneas",
+			name: "Angle Shooter",
+		},
+		{
+			text: "Rastreador",
+			name: "Point Sensor",
+		},
+		{
+			text: "Nebulizador",
+			name: "Toxic Mist",
+		},
+		{
+			text: "Telón de tinta",
+			name: "Splash Wall",
+		},
+		{
+			text: "Aspersor",
+			name: "Sprinkler",
+		},
+		{
+			text: "Bomba trampa",
+			name: "Ink Mine",
+		},
+		{
+			text: "Aspiratinta",
+			name: "Ink Vac",
+		},
+		{
+			text: "Calamar imperial",
+			name: "Kraken Royale",
+		},
+		{
+			text: "Cangrejobot",
+			name: "Crab Tank",
+		},
+		{
+			text: "Pantintalla",
+			name: "Splattercolor Screen",
+		},
+		{
+			text: "Dispensabebidas",
+			name: "Tacticooler",
+		},
+		{
+			text: "Multiseñuelos",
+			name: "Super Chump",
+		},
+		{
+			text: "Megaburbuja",
+			name: "Big Bubbler",
+		},
+		{
+			text: "Atormentador",
+			name: "Ink Storm",
+		},
+		{
+			text: "Propulsor",
+			name: "Inkjet",
+		},
+		{
+			text: "Tintófono 5.1",
+			name: "Killer Wail 5.1",
+		},
+		{
+			text: "Lanzamisiles",
+			name: "Tenta Missiles",
+		},
+		{
+			text: "Bola genializante",
+			name: "Booyah Bomb",
+		},
+		{
+			text: "Puñetazos explosivos",
+			name: "Triple Splashdown",
+		},
+		{
+			text: "Emiteondas",
+			name: "Wave Breaker",
+		},
+		{
+			text: "Flotiburón",
+			name: "Reefslider",
+		},
+		{
+			text: "Gancho tentacular",
+			name: "Zipcaster",
+		},
+		{
+			text: "Tornado triple",
+			name: "Triple Inkstrike",
+		},
+		{
+			text: "Tintazuca triple",
+			name: "Trizooka",
+		},
+		{
+			text: "Ultraselladora",
+			name: "Ultra Stamp",
+		},
+	],
+	EUfr: [
+		{
+			text: "Turboblaster pro",
+			name: "Rapid Blaster Pro",
+		},
+		{
+			text: "Turboblaster pro chic",
+			name: "Rapid Blaster Pro Deco",
+		},
+		{
+			text: "Turboblaster pro POL-R",
+			name: "Rapid Blaster Pro WNT-R",
+		},
+		{
+			text: "Rafablaster",
+			name: "Clash Blaster",
+		},
+		{
+			text: "Rafablaster Néo",
+			name: "Clash Blaster Neo",
+		},
+		{
+			text: "Turboblaster",
+			name: "Rapid Blaster",
+		},
+		{
+			text: "Turboblaster chic",
+			name: "Rapid Blaster Deco",
+		},
+		{
+			text: "Éclablaster XL",
+			name: "Range Blaster",
+		},
+		{
+			text: "Éclablaster XL griffé",
+			name: "Custom Range Blaster",
+		},
+		{
+			text: "Éclablaster",
+			name: "Blaster",
+		},
+		{
+			text: "Éclablaster modifié",
+			name: "Custom Blaster",
+		},
+		{
+			text: "Éclablaster mirapex",
+			name: "Gleamz Blaster",
+		},
+		{
+			text: "S-Blaster '92",
+			name: "S-BLAST '92",
+		},
+		{
+			text: "S-Blaster '91",
+			name: "S-BLAST '91",
+		},
+		{
+			text: "Proxiblaster",
+			name: "Luna Blaster",
+		},
+		{
+			text: "Proxiblaster Néo",
+			name: "Luna Blaster Neo",
+		},
+		{
+			text: "Blaster d'Ordre (réplique)",
+			name: "Order Blaster Replica",
+		},
+		{
+			text: "Épinceau écaïe",
+			name: "Painbrush",
+		},
+		{
+			text: "Épinceau écaïe nuancé",
+			name: "Painbrush Nouveau",
+		},
+		{
+			text: "Épinceau écaïe BRN-Z",
+			name: "Painbrush BRN-Z",
+		},
+		{
+			text: "Épinceau",
+			name: "Inkbrush",
+		},
+		{
+			text: "Épinceau nuancé",
+			name: "Inkbrush Nouveau",
+		},
+		{
+			text: "Épinceau brosse",
+			name: "Octobrush",
+		},
+		{
+			text: "Épinceau brosse nuancé",
+			name: "Octobrush Nouveau",
+		},
+		{
+			text: "Épinceau brosse stellapex",
+			name: "Cometz Octobrush",
+		},
+		{
+			text: "Pinceau d'Ordre (réplique)",
+			name: "Orderbrush Replica",
+		},
+		{
+			text: "Détubeur",
+			name: "Goo Tuber",
+		},
+		{
+			text: "Détubeur modifié",
+			name: "Custom Goo Tuber",
+		},
+		{
+			text: "Bimbamboum Mk I",
+			name: "Bamboozler 14 Mk I",
+		},
+		{
+			text: "Bimbamboum Mk II",
+			name: "Bamboozler 14 Mk II",
+		},
+		{
+			text: "Extraceur + zoom",
+			name: "E-liter 4K Scope",
+		},
+		{
+			text: "Extraceur + zoom modifié",
+			name: "Custom E-liter 4K Scope",
+		},
+		{
+			text: "Extraceur +",
+			name: "E-liter 4K",
+		},
+		{
+			text: "Extraceur + modifié",
+			name: "Custom E-liter 4K",
+		},
+		{
+			text: "Concentraceur zoom",
+			name: "Splatterscope",
+		},
+		{
+			text: "Concentraceur zoom E+F",
+			name: "Z+F Splatterscope",
+		},
+		{
+			text: "Concentraceur zoom CAM-O",
+			name: "Splatterscope CAM-O",
+		},
+		{
+			text: "Concentraceur",
+			name: "Splat Charger",
+		},
+		{
+			text: "Concentraceur E+F",
+			name: "Z+F Splat Charger",
+		},
+		{
+			text: "Concentraceur CAM-O",
+			name: "Splat Charger CAM-O",
+		},
+		{
+			text: "Fusil d'Ordre (réplique)",
+			name: "Order Charger Replica",
+		},
+		{
+			text: "Crayon X - 5H",
+			name: "Snipewriter 5H",
+		},
+		{
+			text: "Crayon X - 5B",
+			name: "Snipewriter 5B",
+		},
+		{
+			text: "Décap'express Alpha",
+			name: "Classic Squiffer",
+		},
+		{
+			text: "Décap'express Bêta",
+			name: "New Squiffer",
+		},
+		{
+			text: "Double nettoyeur",
+			name: "Dualie Squelchers",
+		},
+		{
+			text: "Double nettoyeur modifié",
+			name: "Custom Dualie Squelchers",
+		},
+		{
+			text: "Double nettoyeur zébrapex",
+			name: "Hoofz Dualie Squelchers",
+		},
+		{
+			text: "Double Kelvin 525",
+			name: "Glooga Dualies",
+		},
+		{
+			text: "Double Kelvin 525 chic",
+			name: "Glooga Dualies Deco",
+		},
+		{
+			text: "Double ignifugeur",
+			name: "Douser Dualies FF",
+		},
+		{
+			text: "Double ignifugeur modifié",
+			name: "Custom Douser Dualies FF",
+		},
+		{
+			text: "Double encreur",
+			name: "Splat Dualies",
+		},
+		{
+			text: "Double encreur griffé",
+			name: "Enperry Splat Dualies",
+		},
+		{
+			text: "Double encreur flambapex",
+			name: "Twinklez Splat Dualies",
+		},
+		{
+			text: "Arme double d'Ordre (réplique)",
+			name: "Order Dualie Replicas",
+		},
+		{
+			text: "Double moucheteur",
+			name: "Dapple Dualies",
+		},
+		{
+			text: "Double moucheteur nuancé",
+			name: "Dapple Dualies Nouveau",
+		},
+		{
+			text: "Double moucheteur NOC-T",
+			name: "Dapple Dualies NOC-T",
+		},
+		{
+			text: "Double voltigeur noir",
+			name: "Dark Tetra Dualies",
+		},
+		{
+			text: "Double voltigeur blanc",
+			name: "Light Tetra Dualies",
+		},
+		{
+			text: "Rouleau carbone",
+			name: "Carbon Roller",
+		},
+		{
+			text: "Rouleau carbone chic",
+			name: "Carbon Roller Deco",
+		},
+		{
+			text: "Rouleau carbone BOD-RWA",
+			name: "Carbon Roller ANG-L",
+		},
+		{
+			text: "Dynamo-rouleau",
+			name: "Dynamo Roller",
+		},
+		{
+			text: "Dynamo-rouleau tesla",
+			name: "Gold Dynamo Roller",
+		},
+		{
+			text: "Dynamo-rouleau galapex",
+			name: "Starz Dynamo Roller",
+		},
+		{
+			text: "Flexi-rouleau",
+			name: "Flingza Roller",
+		},
+		{
+			text: "Flexi-rouleau alu",
+			name: "Foil Flingza Roller",
+		},
+		{
+			text: "Rouleau",
+			name: "Splat Roller",
+		},
+		{
+			text: "Rouleau griffé",
+			name: "Krak-On Splat Roller",
+		},
+		{
+			text: "Rouleau d'Ordre (réplique)",
+			name: "Order Roller Replica",
+		},
+		{
+			text: "Rouleau large",
+			name: "Big Swig Roller",
+		},
+		{
+			text: "Rouleau large Xpress",
+			name: "Big Swig Roller Express",
+		},
+		{
+			text: "Rouleau large astrapex",
+			name: "Planetz Big Swig Roller",
+		},
+		{
+			text: "Sabrifrice menthe",
+			name: "Mint Decavitator",
+		},
+		{
+			text: "Sabrifrice charbon",
+			name: "Charcoal Decavitator",
+		},
+		{
+			text: "Éclatana Doto",
+			name: "Splatana Wiper",
+		},
+		{
+			text: "Éclatana Doto chic",
+			name: "Splatana Wiper Deco",
+		},
+		{
+			text: "Éclatana Doto OXY-D",
+			name: "Splatana Wiper RUS-T",
+		},
+		{
+			text: "Éclatana d'estampe",
+			name: "Splatana Stamper",
+		},
+		{
+			text: "Éclatana d'estampe nuancé",
+			name: "Splatana Stamper Nouveau",
+		},
+		{
+			text: "Éclatana d'estampe décapex",
+			name: "Stickerz Splatana Stamper",
+		},
+		{
+			text: "Éclatana d'Ordre (réplique)",
+			name: "Order Splatana Replica",
+		},
+		{
+			text: "Para-encre espion",
+			name: "Undercover Brella",
+		},
+		{
+			text: "Para-encre espion Sorella",
+			name: "Undercover Sorella Brella",
+		},
+		{
+			text: "Para-encre espion amalgapex",
+			name: "Patternz Undercover Brella",
+		},
+		{
+			text: "Para-encre Ré-gen 24 Mk I",
+			name: "Recycled Brella 24 Mk I",
+		},
+		{
+			text: "Para-encre Ré-gen 24 Mk II",
+			name: "Recycled Brella 24 Mk II",
+		},
+		{
+			text: "Para-encre",
+			name: "Splat Brella",
+		},
+		{
+			text: "Para-encre Sorella",
+			name: "Sorella Brella",
+		},
+		{
+			text: "Para-encre d'Ordre (réplique)",
+			name: "Order Brella Replica",
+		},
+		{
+			text: "Para-encre XL",
+			name: "Tenta Brella",
+		},
+		{
+			text: "Para-encre XL Sorella",
+			name: "Tenta Sorella Brella",
+		},
+		{
+			text: "Para-encre XL CRM-A",
+			name: "Tenta Brella CRE-M",
+		},
+		{
+			text: "Aérogun",
+			name: "Aerospray MG",
+		},
+		{
+			text: "Aérogun premium",
+			name: "Aerospray RG",
+		},
+		{
+			text: "Aérogun chromapex",
+			name: "Colorz Aerospray",
+		},
+		{
+			text: "Liquidateur pro",
+			name: "Splattershot Pro",
+		},
+		{
+			text: "Liquidateur pro griffé",
+			name: "Forge Splattershot Pro",
+		},
+		{
+			text: "Liquidateur pro GLA-C",
+			name: "Splattershot Pro FRZ-N",
+		},
+		{
+			text: "Liquidateur Jr.",
+			name: "Splattershot Jr.",
+		},
+		{
+			text: "Liquidateur Sr.",
+			name: "Custom Splattershot Jr.",
+		},
+		{
+			text: "Compresseur",
+			name: "Squeezer",
+		},
+		{
+			text: "Compresseur alu",
+			name: "Foil Squeezer",
+		},
+		{
+			text: "Calibre 2000",
+			name: ".52 Gal",
+		},
+		{
+			text: "Calibre 2000 chic",
+			name: ".52 Gal Deco",
+		},
+		{
+			text: "Calibre 3000",
+			name: ".96 Gal",
+		},
+		{
+			text: "Calibre 3000 chic",
+			name: ".96 Gal Deco",
+		},
+		{
+			text: "Calibre 3000 guépapex",
+			name: "Clawz .96 Gal",
+		},
+		{
+			text: "Nettoyeur XL",
+			name: "Jet Squelcher",
+		},
+		{
+			text: "Nettoyeur XL modifié",
+			name: "Custom Jet Squelcher",
+		},
+		{
+			text: "Nettoyeur XL COB-R",
+			name: "Jet Squelcher COB-R",
+		},
+		{
+			text: "Liquidateur",
+			name: "Splattershot",
+		},
+		{
+			text: "Liquidateur griffé",
+			name: "Tentatek Splattershot",
+		},
+		{
+			text: "Liquidateur glamapex",
+			name: "Glamorz Splattershot",
+		},
+		{
+			text: "Lanceur héroïque (réplique)",
+			name: "Hero Shot Replica",
+		},
+		{
+			text: "Lanceur d'Ordre (réplique)",
+			name: "Order Shot Replica",
+		},
+		{
+			text: "Lanceur Octaling (réplique)",
+			name: "Octo Shot Replica",
+		},
+		{
+			text: "Marqueur léger",
+			name: "Splash-o-matic",
+		},
+		{
+			text: "Marqueur léger Néo",
+			name: "Neo Splash-o-matic",
+		},
+		{
+			text: "Marqueur léger G-KO",
+			name: "Splash-o-matic GCK-O",
+		},
+		{
+			text: "Lanceur spatial",
+			name: "Splattershot Nova",
+		},
+		{
+			text: "Lanceur spatial Aroz",
+			name: "Annaki Splattershot Nova",
+		},
+		{
+			text: "N-ZAP 85",
+			name: "N-ZAP '85",
+		},
+		{
+			text: "N-ZAP 89",
+			name: "N-ZAP '89",
+		},
+		{
+			text: "Marqueur lourd",
+			name: "Sploosh-o-matic",
+		},
+		{
+			text: "Marqueur lourd Néo",
+			name: "Neo Sploosh-o-matic",
+		},
+		{
+			text: "Arroseur lourd",
+			name: "H-3 Nozzlenose",
+		},
+		{
+			text: "Arroseur lourd Cétacé",
+			name: "H-3 Nozzlenose D",
+		},
+		{
+			text: "Arroseur lourd VIP-R",
+			name: "H-3 Nozzlenose VIP-R",
+		},
+		{
+			text: "Arroseur léger",
+			name: "L-3 Nozzlenose",
+		},
+		{
+			text: "Arroseur léger Cétacé",
+			name: "L-3 Nozzlenose D",
+		},
+		{
+			text: "Arroseur léger éclapex",
+			name: "Glitterz L-3 Nozzlenose",
+		},
+		{
+			text: "Bassineur",
+			name: "Bloblobber",
+		},
+		{
+			text: "Bassineur chic",
+			name: "Bloblobber Deco",
+		},
+		{
+			text: "Dépoteur",
+			name: "Tri-Slosher",
+		},
+		{
+			text: "Dépoteur nuancé",
+			name: "Tri-Slosher Nouveau",
+		},
+		{
+			text: "Dépoteur 100-DRÉ",
+			name: "Tri-Slosher ASH-N",
+		},
+		{
+			text: "Seau S-Horreur",
+			name: "Dread Wringer",
+		},
+		{
+			text: "Seau S-Horreur Cétacé",
+			name: "Dread Wringer D",
+		},
+		{
+			text: "Seau S-Horreur kérapex",
+			name: "Hornz Dread Wringer",
+		},
+		{
+			text: "Encrifugeur",
+			name: "Sloshing Machine",
+		},
+		{
+			text: "Encrifugeur Néo",
+			name: "Sloshing Machine Neo",
+		},
+		{
+			text: "Seauceur",
+			name: "Slosher",
+		},
+		{
+			text: "Seauceur chic",
+			name: "Slosher Deco",
+		},
+		{
+			text: "Seau d'Ordre (réplique)",
+			name: "Order Slosher Replica",
+		},
+		{
+			text: "Détoneur",
+			name: "Explosher",
+		},
+		{
+			text: "Détoneur modifié",
+			name: "Custom Explosher",
+		},
+		{
+			text: "Badigeonneur stylo",
+			name: "Ballpoint Splatling",
+		},
+		{
+			text: "Badigeonneur stylo nuancé",
+			name: "Ballpoint Splatling Nouveau",
+		},
+		{
+			text: "Correcteur",
+			name: "Heavy Edit Splatling",
+		},
+		{
+			text: "Correcteur nuancé",
+			name: "Heavy Edit Splatling Nouveau",
+		},
+		{
+			text: "Exteinteur",
+			name: "Hydra Splatling",
+		},
+		{
+			text: "Exteinteur modifié",
+			name: "Custom Hydra Splatling",
+		},
+		{
+			text: "Exteinteur cascapex",
+			name: "Torrentz Hydra Splatling",
+		},
+		{
+			text: "Badigeonneur XS",
+			name: "Mini Splatling",
+		},
+		{
+			text: "Badigeonneur XS griffé",
+			name: "Zink Mini Splatling",
+		},
+		{
+			text: "Badigeonneur XS VN-1",
+			name: "Mini Splatling RTL-R",
+		},
+		{
+			text: "Badigeonneur",
+			name: "Heavy Splatling",
+		},
+		{
+			text: "Badigeonneur chic",
+			name: "Heavy Splatling Deco",
+		},
+		{
+			text: "Badigeonneur d'Ordre (réplique)",
+			name: "Order Splatling Replica",
+		},
+		{
+			text: "Multisperceur V",
+			name: "Wellstring V",
+		},
+		{
+			text: "Multisperceur V modifié",
+			name: "Custom Wellstring V",
+		},
+		{
+			text: "Trisperceur",
+			name: "Tri-Stringer",
+		},
+		{
+			text: "Trisperceur Abysma",
+			name: "Inkline Tri-Stringer",
+		},
+		{
+			text: "Trisperceur prismapex",
+			name: "Bulbz Tri-Stringer",
+		},
+		{
+			text: "Transperceur d'Ordre (réplique)",
+			name: "Order Stringer Replica",
+		},
+		{
+			text: "Coralux 450",
+			name: "REEF-LUX 450",
+		},
+		{
+			text: "Coralux 450 chic",
+			name: "REEF-LUX 450 Deco",
+		},
+		{
+			text: "Coralux 450 LACTO",
+			name: "REEF-LUX 450 MIL-K",
+		},
+		{
+			text: "Balise de saut",
+			name: "Squid Beakon",
+		},
+		{
+			text: "Bombe curling",
+			name: "Curling Bomb",
+		},
+		{
+			text: "Bombe soda",
+			name: "Fizzy Bomb",
+		},
+		{
+			text: "Bombe ballon",
+			name: "Burst Bomb",
+		},
+		{
+			text: "Bombe robot",
+			name: "Autobomb",
+		},
+		{
+			text: "Bombe splash",
+			name: "Splat Bomb",
+		},
+		{
+			text: "Bombe gluante",
+			name: "Suction Bomb",
+		},
+		{
+			text: "Bentorpille",
+			name: "Torpedo",
+		},
+		{
+			text: "Ricocheur",
+			name: "Angle Shooter",
+		},
+		{
+			text: "Détecteur",
+			name: "Point Sensor",
+		},
+		{
+			text: "Brume toxique",
+			name: "Toxic Mist",
+		},
+		{
+			text: "Mur d'encre",
+			name: "Splash Wall",
+		},
+		{
+			text: "Fontaine",
+			name: "Sprinkler",
+		},
+		{
+			text: "Mine",
+			name: "Ink Mine",
+		},
+		{
+			text: "Aspirencre",
+			name: "Ink Vac",
+		},
+		{
+			text: "Kraken royal",
+			name: "Kraken Royale",
+		},
+		{
+			text: "Crabe d'assaut",
+			name: "Crab Tank",
+		},
+		{
+			text: "Barrière barbouillée",
+			name: "Splattercolor Screen",
+		},
+		{
+			text: "Districool",
+			name: "Tacticooler",
+		},
+		{
+			text: "Multi-leurres",
+			name: "Super Chump",
+		},
+		{
+			text: "Super bouclier",
+			name: "Big Bubbler",
+		},
+		{
+			text: "Pluie d'encre",
+			name: "Ink Storm",
+		},
+		{
+			text: "Chromo-jet",
+			name: "Inkjet",
+		},
+		{
+			text: "Haut-perceur 5.1",
+			name: "Killer Wail 5.1",
+		},
+		{
+			text: "Multi-missile",
+			name: "Tenta Missiles",
+		},
+		{
+			text: "Jolizator",
+			name: "Booyah Bomb",
+		},
+		{
+			text: "Triple choc chromatique",
+			name: "Triple Splashdown",
+		},
+		{
+			text: "Sonar paf",
+			name: "Wave Breaker",
+		},
+		{
+			text: "Cavalsquale",
+			name: "Reefslider",
+		},
+		{
+			text: "Super Mollusque",
+			name: "Zipcaster",
+		},
+		{
+			text: "Trimissile tornade",
+			name: "Triple Inkstrike",
+		},
+		{
+			text: "Lance-rafales",
+			name: "Trizooka",
+		},
+		{
+			text: "Ultra-tamponneur",
+			name: "Ultra Stamp",
+		},
+	],
+	EUit: [
+		{
+			text: "Blaster élite",
+			name: "Rapid Blaster Pro",
+		},
+		{
+			text: "Blaster élite DX",
+			name: "Rapid Blaster Pro Deco",
+		},
+		{
+			text: "Blaster élite INV-N",
+			name: "Rapid Blaster Pro WNT-R",
+		},
+		{
+			text: "Blaster da mischia",
+			name: "Clash Blaster",
+		},
+		{
+			text: "Blaster da mischia Neo",
+			name: "Clash Blaster Neo",
+		},
+		{
+			text: "Blaster rapido",
+			name: "Rapid Blaster",
+		},
+		{
+			text: "Blaster rapido DX",
+			name: "Rapid Blaster Deco",
+		},
+		{
+			text: "Blaster a distanza",
+			name: "Range Blaster",
+		},
+		{
+			text: "Blaster a distanza CM",
+			name: "Custom Range Blaster",
+		},
+		{
+			text: "Blaster CM",
+			name: "Custom Blaster",
+		},
+		{
+			text: "Blaster glam-bon",
+			name: "Gleamz Blaster",
+		},
+		{
+			text: "S-BLAST92",
+			name: "S-BLAST '92",
+		},
+		{
+			text: "S-BLAST91",
+			name: "S-BLAST '91",
+		},
+		{
+			text: "Blaster lunar",
+			name: "Luna Blaster",
+		},
+		{
+			text: "Blaster lunar Neo",
+			name: "Luna Blaster Neo",
+		},
+		{
+			text: "Blaster Ordine replica",
+			name: "Order Blaster Replica",
+		},
+		{
+			text: "Tonnoretto",
+			name: "Painbrush",
+		},
+		{
+			text: "Tonnoretto master",
+			name: "Painbrush Nouveau",
+		},
+		{
+			text: "Tonnoretto BRN-Z",
+			name: "Painbrush BRN-Z",
+		},
+		{
+			text: "Calamaravaggio",
+			name: "Inkbrush",
+		},
+		{
+			text: "Calamaravaggio master",
+			name: "Inkbrush Nouveau",
+		},
+		{
+			text: "Tinturicchio",
+			name: "Octobrush",
+		},
+		{
+			text: "Tinturicchio master",
+			name: "Octobrush Nouveau",
+		},
+		{
+			text: "Tinturicchio comet-bon",
+			name: "Cometz Octobrush",
+		},
+		{
+			text: "Pennello Ordine replica",
+			name: "Orderbrush Replica",
+		},
+		{
+			text: "Tintubator",
+			name: "Goo Tuber",
+		},
+		{
+			text: "Tintubator CM",
+			name: "Custom Goo Tuber",
+		},
+		{
+			text: "Bimbamboom 14-I",
+			name: "Bamboozler 14 Mk I",
+		},
+		{
+			text: "Bimbamboom 14-II",
+			name: "Bamboozler 14 Mk II",
+		},
+		{
+			text: "Tinter con mirino 4K",
+			name: "E-liter 4K Scope",
+		},
+		{
+			text: "Tinter con mirino 4K CM",
+			name: "Custom E-liter 4K Scope",
+		},
+		{
+			text: "Tinter a carica 4K",
+			name: "E-liter 4K",
+		},
+		{
+			text: "Tinter a carica 4K CM",
+			name: "Custom E-liter 4K",
+		},
+		{
+			text: "Splatter con mirino",
+			name: "Splatterscope",
+		},
+		{
+			text: "Splatter con mirino logo",
+			name: "Z+F Splatterscope",
+		},
+		{
+			text: "Splatter con mirino FRS-T",
+			name: "Splatterscope CAM-O",
+		},
+		{
+			text: "Splatter a carica",
+			name: "Splat Charger",
+		},
+		{
+			text: "Splatter a carica logo",
+			name: "Z+F Splat Charger",
+		},
+		{
+			text: "Splatter a carica FRS-T",
+			name: "Splat Charger CAM-O",
+		},
+		{
+			text: "Splatter Ordine replica",
+			name: "Order Charger Replica",
+		},
+		{
+			text: "Lapis cecchino 5H",
+			name: "Snipewriter 5H",
+		},
+		{
+			text: "Lapis cecchino 5B",
+			name: "Snipewriter 5B",
+		},
+		{
+			text: "Kalamarapid α",
+			name: "Classic Squiffer",
+		},
+		{
+			text: "Kalamarapid β",
+			name: "New Squiffer",
+		},
+		{
+			text: "Sweeper duplo",
+			name: "Dualie Squelchers",
+		},
+		{
+			text: "Sweeper duplo CM",
+			name: "Custom Dualie Squelchers",
+		},
+		{
+			text: "Sweeper duplo zebra-bon",
+			name: "Hoofz Dualie Squelchers",
+		},
+		{
+			text: "Kelvin duplo 525",
+			name: "Glooga Dualies",
+		},
+		{
+			text: "Kelvin duplo 525 DX",
+			name: "Glooga Dualies Deco",
+		},
+		{
+			text: "Repolper estintori FF",
+			name: "Douser Dualies FF",
+		},
+		{
+			text: "Repolper estintori FF CM",
+			name: "Custom Douser Dualies FF",
+		},
+		{
+			text: "Repolper duplo",
+			name: "Splat Dualies",
+		},
+		{
+			text: "Repolper duplo logo",
+			name: "Enperry Splat Dualies",
+		},
+		{
+			text: "Repolper duplo metal-bon",
+			name: "Twinklez Splat Dualies",
+		},
+		{
+			text: "Repolper Ordine replica",
+			name: "Order Dualie Replicas",
+		},
+		{
+			text: "Ripolpella duplo",
+			name: "Dapple Dualies",
+		},
+		{
+			text: "Ripolpella duplo master",
+			name: "Dapple Dualies Nouveau",
+		},
+		{
+			text: "Ripolpella duplo NOT-T",
+			name: "Dapple Dualies NOC-T",
+		},
+		{
+			text: "Moscarpino duplo nero",
+			name: "Dark Tetra Dualies",
+		},
+		{
+			text: "Moscarpino duplo bianco",
+			name: "Light Tetra Dualies",
+		},
+		{
+			text: "Rullo di carbonio",
+			name: "Carbon Roller",
+		},
+		{
+			text: "Rullo di carbonio DX",
+			name: "Carbon Roller Deco",
+		},
+		{
+			text: "Rullo di carbonio PSC-AB",
+			name: "Carbon Roller ANG-L",
+		},
+		{
+			text: "Rullo dinamo",
+			name: "Dynamo Roller",
+		},
+		{
+			text: "Rullo dinamo dorato",
+			name: "Gold Dynamo Roller",
+		},
+		{
+			text: "Rullo dinamo galax-bon",
+			name: "Starz Dynamo Roller",
+		},
+		{
+			text: "Flexi-rullo",
+			name: "Flingza Roller",
+		},
+		{
+			text: "Flexi-rullo B",
+			name: "Foil Flingza Roller",
+		},
+		{
+			text: "Rullo splat",
+			name: "Splat Roller",
+		},
+		{
+			text: "Rullo splat logo",
+			name: "Krak-On Splat Roller",
+		},
+		{
+			text: "Rullo Ordine replica",
+			name: "Order Roller Replica",
+		},
+		{
+			text: "Ampiorullo",
+			name: "Big Swig Roller",
+		},
+		{
+			text: "Ampiorullo Express",
+			name: "Big Swig Roller Express",
+		},
+		{
+			text: "Ampiorullo astra-bon",
+			name: "Planetz Big Swig Roller",
+		},
+		{
+			text: "Spazzolama menta",
+			name: "Mint Decavitator",
+		},
+		{
+			text: "Spazzolama carbone",
+			name: "Charcoal Decavitator",
+		},
+		{
+			text: "Tergilama",
+			name: "Splatana Wiper",
+		},
+		{
+			text: "Tergilama DX",
+			name: "Splatana Wiper Deco",
+		},
+		{
+			text: "Tergilama RUG-N",
+			name: "Splatana Wiper RUS-T",
+		},
+		{
+			text: "Splattalama",
+			name: "Splatana Stamper",
+		},
+		{
+			text: "Splattalama master",
+			name: "Splatana Stamper Nouveau",
+		},
+		{
+			text: "Splattalama adesi-bon",
+			name: "Stickerz Splatana Stamper",
+		},
+		{
+			text: "Lama Ordine replica",
+			name: "Order Splatana Replica",
+		},
+		{
+			text: "Bombrello",
+			name: "Undercover Brella",
+		},
+		{
+			text: "Bombrello Solerra",
+			name: "Undercover Sorella Brella",
+		},
+		{
+			text: "Bombrello sgargia-bon",
+			name: "Patternz Undercover Brella",
+		},
+		{
+			text: "Sparasole riciclo 24-I",
+			name: "Recycled Brella 24 Mk I",
+		},
+		{
+			text: "Sparasole riciclo 24-II",
+			name: "Recycled Brella 24 Mk II",
+		},
+		{
+			text: "Sparasole",
+			name: "Splat Brella",
+		},
+		{
+			text: "Sparasole Solerra",
+			name: "Sorella Brella",
+		},
+		{
+			text: "Sparasole Ordine replica",
+			name: "Order Brella Replica",
+		},
+		{
+			text: "Sparatenda",
+			name: "Tenta Brella",
+		},
+		{
+			text: "Sparatenda Solerra",
+			name: "Tenta Sorella Brella",
+		},
+		{
+			text: "Sparatenda CRM-A",
+			name: "Tenta Brella CRE-M",
+		},
+		{
+			text: "Aerografo",
+			name: "Aerospray MG",
+		},
+		{
+			text: "Aerografo élite",
+			name: "Aerospray RG",
+		},
+		{
+			text: "Aerografo color-bon",
+			name: "Colorz Aerospray",
+		},
+		{
+			text: "Splasher élite",
+			name: "Splattershot Pro",
+		},
+		{
+			text: "Splasher élite logo",
+			name: "Forge Splattershot Pro",
+		},
+		{
+			text: "Splasher élite GLA-C",
+			name: "Splattershot Pro FRZ-N",
+		},
+		{
+			text: "Sparacolore recluta",
+			name: "Splattershot Jr.",
+		},
+		{
+			text: "Sparacolore logo",
+			name: "Custom Splattershot Jr.",
+		},
+		{
+			text: "Strizzer",
+			name: "Squeezer",
+		},
+		{
+			text: "Strizzer B",
+			name: "Foil Squeezer",
+		},
+		{
+			text: "Calibro 2000",
+			name: ".52 Gal",
+		},
+		{
+			text: "Calibro 2000 DX",
+			name: ".52 Gal Deco",
+		},
+		{
+			text: "Calibro 3000",
+			name: ".96 Gal",
+		},
+		{
+			text: "Calibro 3000 DX",
+			name: ".96 Gal Deco",
+		},
+		{
+			text: "Calibro 3000 leo-bon",
+			name: "Clawz .96 Gal",
+		},
+		{
+			text: "Sweeper",
+			name: "Jet Squelcher",
+		},
+		{
+			text: "Sweeper CM",
+			name: "Custom Jet Squelcher",
+		},
+		{
+			text: "Sweeper COB-R",
+			name: "Jet Squelcher COB-R",
+		},
+		{
+			text: "Splasher",
+			name: "Splattershot",
+		},
+		{
+			text: "Splasher logo",
+			name: "Tentatek Splattershot",
+		},
+		{
+			text: "Splasher iride-bon",
+			name: "Glamorz Splattershot",
+		},
+		{
+			text: "Pistola élite replica",
+			name: "Hero Shot Replica",
+		},
+		{
+			text: "Pistola Ordine replica",
+			name: "Order Shot Replica",
+		},
+		{
+			text: "Octosplasher replica",
+			name: "Octo Shot Replica",
+		},
+		{
+			text: "Marker d'assalto",
+			name: "Splash-o-matic",
+		},
+		{
+			text: "Marker d'assalto Neo",
+			name: "Neo Splash-o-matic",
+		},
+		{
+			text: "Marker d'assalto GEC-O",
+			name: "Splash-o-matic GCK-O",
+		},
+		{
+			text: "Splasher Nova",
+			name: "Splattershot Nova",
+		},
+		{
+			text: "Splasher Nova Annak",
+			name: "Annaki Splattershot Nova",
+		},
+		{
+			text: "N-ZAP85",
+			name: "N-ZAP '85",
+		},
+		{
+			text: "N-ZAP89",
+			name: "N-ZAP '89",
+		},
+		{
+			text: "Marker",
+			name: "Sploosh-o-matic",
+		},
+		{
+			text: "Marker Neo",
+			name: "Neo Sploosh-o-matic",
+		},
+		{
+			text: "Triplete",
+			name: "H-3 Nozzlenose",
+		},
+		{
+			text: "Triplete D",
+			name: "H-3 Nozzlenose D",
+		},
+		{
+			text: "Triplete VIP-R",
+			name: "H-3 Nozzlenose VIP-R",
+		},
+		{
+			text: "Triplete compatto",
+			name: "L-3 Nozzlenose",
+		},
+		{
+			text: "Triplete compatto D",
+			name: "L-3 Nozzlenose D",
+		},
+		{
+			text: "Triplete compatto lucci-bon",
+			name: "Glitterz L-3 Nozzlenose",
+		},
+		{
+			text: "Secchiostro vasca",
+			name: "Bloblobber",
+		},
+		{
+			text: "Secchiostro vasca DX",
+			name: "Bloblobber Deco",
+		},
+		{
+			text: "Secchiostro triplo",
+			name: "Tri-Slosher",
+		},
+		{
+			text: "Secchiostro triplo master",
+			name: "Tri-Slosher Nouveau",
+		},
+		{
+			text: "Secchiostro triplo POL-V",
+			name: "Tri-Slosher ASH-N",
+		},
+		{
+			text: "Secchiapavimenti",
+			name: "Dread Wringer",
+		},
+		{
+			text: "Secchiapavimenti D",
+			name: "Dread Wringer D",
+		},
+		{
+			text: "Secchiapavimenti acu-bon",
+			name: "Hornz Dread Wringer",
+		},
+		{
+			text: "Secchiostro centrifuga",
+			name: "Sloshing Machine",
+		},
+		{
+			text: "Secchiostro centrifuga Neo",
+			name: "Sloshing Machine Neo",
+		},
+		{
+			text: "Secchiostro",
+			name: "Slosher",
+		},
+		{
+			text: "Secchiostro DX",
+			name: "Slosher Deco",
+		},
+		{
+			text: "Secchiostro Ordine replica",
+			name: "Order Slosher Replica",
+		},
+		{
+			text: "Termosecchiostro",
+			name: "Explosher",
+		},
+		{
+			text: "Termosecchiostro master",
+			name: "Custom Explosher",
+		},
+		{
+			text: "Tetrapenna",
+			name: "Ballpoint Splatling",
+		},
+		{
+			text: "Tetrapenna master",
+			name: "Ballpoint Splatling Nouveau",
+		},
+		{
+			text: "Splatling a pennarelli",
+			name: "Heavy Edit Splatling",
+		},
+		{
+			text: "Splatling a pennarelli master",
+			name: "Heavy Edit Splatling Nouveau",
+		},
+		{
+			text: "Idrante",
+			name: "Hydra Splatling",
+		},
+		{
+			text: "Idrante CM",
+			name: "Custom Hydra Splatling",
+		},
+		{
+			text: "Idrante spray-bon",
+			name: "Torrentz Hydra Splatling",
+		},
+		{
+			text: "Mini splatling logo",
+			name: "Zink Mini Splatling",
+		},
+		{
+			text: "Mini splatling PIT-N",
+			name: "Mini Splatling RTL-R",
+		},
+		{
+			text: "Splatling a tanica",
+			name: "Heavy Splatling",
+		},
+		{
+			text: "Splatling a tanica DX",
+			name: "Heavy Splatling Deco",
+		},
+		{
+			text: "Splatling Ordine replica",
+			name: "Order Splatling Replica",
+		},
+		{
+			text: "Fontanarco V",
+			name: "Wellstring V",
+		},
+		{
+			text: "Fontanarco V CM",
+			name: "Custom Wellstring V",
+		},
+		{
+			text: "Tri-calamarco",
+			name: "Tri-Stringer",
+		},
+		{
+			text: "Tri-calamarco Maremont",
+			name: "Inkline Tri-Stringer",
+		},
+		{
+			text: "Tri-calamarco LED-bon",
+			name: "Bulbz Tri-Stringer",
+		},
+		{
+			text: "Calamarco Ordine replica",
+			name: "Order Stringer Replica",
+		},
+		{
+			text: "ARCO-RAL 450",
+			name: "REEF-LUX 450",
+		},
+		{
+			text: "ARCO-RAL 450 DX",
+			name: "REEF-LUX 450 Deco",
+		},
+		{
+			text: "ARCO-RAL 450 LAT-T",
+			name: "REEF-LUX 450 MIL-K",
+		},
+		{
+			text: "Trasferitore",
+			name: "Squid Beakon",
+		},
+		{
+			text: "Bomba curling",
+			name: "Curling Bomb",
+		},
+		{
+			text: "Bomba a gassosa",
+			name: "Fizzy Bomb",
+		},
+		{
+			text: "Granata",
+			name: "Burst Bomb",
+		},
+		{
+			text: "Robo-bomba",
+			name: "Autobomb",
+		},
+		{
+			text: "Bomba splash",
+			name: "Splat Bomb",
+		},
+		{
+			text: "Appiccibomba",
+			name: "Suction Bomb",
+		},
+		{
+			text: "Torpedinatore",
+			name: "Torpedo",
+		},
+		{
+			text: "Sparalinee",
+			name: "Angle Shooter",
+		},
+		{
+			text: "Cimice",
+			name: "Point Sensor",
+		},
+		{
+			text: "Nebbia tossica",
+			name: "Toxic Mist",
+		},
+		{
+			text: "Muro di colore",
+			name: "Splash Wall",
+		},
+		{
+			text: "Spruzzatore",
+			name: "Sprinkler",
+		},
+		{
+			text: "Mina",
+			name: "Ink Mine",
+		},
+		{
+			text: "Vampinchiostro",
+			name: "Ink Vac",
+		},
+		{
+			text: "Kraken reale",
+			name: "Kraken Royale",
+		},
+		{
+			text: "Granchio armato",
+			name: "Crab Tank",
+		},
+		{
+			text: "Cortina ingannevole",
+			name: "Splattercolor Screen",
+		},
+		{
+			text: "Rinfrigorente",
+			name: "Tacticooler",
+		},
+		{
+			text: "Diversivo esplosivo",
+			name: "Super Chump",
+		},
+		{
+			text: "Gran bolla scudo",
+			name: "Big Bubbler",
+		},
+		{
+			text: "Pioggia di colore",
+			name: "Ink Storm",
+		},
+		{
+			text: "Jet splat",
+			name: "Inkjet",
+		},
+		{
+			text: "Tintofono 5.1",
+			name: "Killer Wail 5.1",
+		},
+		{
+			text: "Lanciarazzi",
+			name: "Tenta Missiles",
+		},
+		{
+			text: "Granbotto",
+			name: "Booyah Bomb",
+		},
+		{
+			text: "Triplo vernischianto",
+			name: "Triple Splashdown",
+		},
+		{
+			text: "Sonar esplosivo",
+			name: "Wave Breaker",
+		},
+		{
+			text: "Motosqualo",
+			name: "Reefslider",
+		},
+		{
+			text: "Molluscatto",
+			name: "Zipcaster",
+		},
+		{
+			text: "Triplo tornado",
+			name: "Triple Inkstrike",
+		},
+		{
+			text: "Ultraturbinator",
+			name: "Trizooka",
+		},
+		{
+			text: "Mega timbro",
+			name: "Ultra Stamp",
+		},
+	],
+	EUnl: [
+		{
+			text: "Flitsblaster Pro",
+			name: "Rapid Blaster Pro",
+		},
+		{
+			text: "Flitsblaster Pro Deco",
+			name: "Rapid Blaster Pro Deco",
+		},
+		{
+			text: "Flitsblaster Pro WNT-R",
+			name: "Rapid Blaster Pro WNT-R",
+		},
+		{
+			text: "Knalblaster",
+			name: "Clash Blaster",
+		},
+		{
+			text: "Knalblaster Neo",
+			name: "Clash Blaster Neo",
+		},
+		{
+			text: "Flitsblaster",
+			name: "Rapid Blaster",
+		},
+		{
+			text: "Flitsblaster Deco",
+			name: "Rapid Blaster Deco",
+		},
+		{
+			text: "Teleblaster",
+			name: "Range Blaster",
+		},
+		{
+			text: "Gemodde Teleblaster",
+			name: "Custom Range Blaster",
+		},
+		{
+			text: "Klodderblaster",
+			name: "Blaster",
+		},
+		{
+			text: "Gemodde Klodderblaster",
+			name: "Custom Blaster",
+		},
+		{
+			text: "Klodderblaster Schÿn",
+			name: "Gleamz Blaster",
+		},
+		{
+			text: "Ordeblaster (replica)",
+			name: "Order Blaster Replica",
+		},
+		{
+			text: "Kwistkwast",
+			name: "Painbrush",
+		},
+		{
+			text: "Kwistkwast Nouveau",
+			name: "Painbrush Nouveau",
+		},
+		{
+			text: "Kwistkwast BRN-S",
+			name: "Painbrush BRN-Z",
+		},
+		{
+			text: "Inktkwast",
+			name: "Inkbrush",
+		},
+		{
+			text: "Inktkwast Nouveau",
+			name: "Inkbrush Nouveau",
+		},
+		{
+			text: "Octokwast",
+			name: "Octobrush",
+		},
+		{
+			text: "Octokwast Nouveau",
+			name: "Octobrush Nouveau",
+		},
+		{
+			text: "Octokwast Kösmös",
+			name: "Cometz Octobrush",
+		},
+		{
+			text: "Ordekwast (replica)",
+			name: "Orderbrush Replica",
+		},
+		{
+			text: "Spetbuizer",
+			name: "Goo Tuber",
+		},
+		{
+			text: "Gemodde Spetbuizer",
+			name: "Custom Goo Tuber",
+		},
+		{
+			text: "Bamboem 14-A",
+			name: "Bamboozler 14 Mk I",
+		},
+		{
+			text: "Bamboem 14-B",
+			name: "Bamboozler 14 Mk II",
+		},
+		{
+			text: "E-liter 4K met vizier",
+			name: "E-liter 4K Scope",
+		},
+		{
+			text: "Gemodde E-liter 4K met vizier",
+			name: "Custom E-liter 4K Scope",
+		},
+		{
+			text: "Gemodde E-liter 4K",
+			name: "Custom E-liter 4K",
+		},
+		{
+			text: "Schelpschutter",
+			name: "Splatterscope",
+		},
+		{
+			text: "Zekkofin Schelpschutter",
+			name: "Z+F Splatterscope",
+		},
+		{
+			text: "Schelpschutter CAM-O",
+			name: "Splatterscope CAM-O",
+		},
+		{
+			text: "Bloplader",
+			name: "Splat Charger",
+		},
+		{
+			text: "Zekkofin Bloplader",
+			name: "Z+F Splat Charger",
+		},
+		{
+			text: "Bloplader CAM-O",
+			name: "Splat Charger CAM-O",
+		},
+		{
+			text: "Ordelader (replica)",
+			name: "Order Charger Replica",
+		},
+		{
+			text: "Schotlood 5H",
+			name: "Snipewriter 5H",
+		},
+		{
+			text: "Schotlood 5B",
+			name: "Snipewriter 5B",
+		},
+		{
+			text: "Octopoets",
+			name: "Classic Squiffer",
+		},
+		{
+			text: "Octopoets Ultra",
+			name: "New Squiffer",
+		},
+		{
+			text: "Dubbelplonzers",
+			name: "Dualie Squelchers",
+		},
+		{
+			text: "Gemodde Dubbelplonzers",
+			name: "Custom Dualie Squelchers",
+		},
+		{
+			text: "Dubbelplonzers Zëbra",
+			name: "Hoofz Dualie Squelchers",
+		},
+		{
+			text: "Kelvin 525",
+			name: "Glooga Dualies",
+		},
+		{
+			text: "Kelvin 525 Deco",
+			name: "Glooga Dualies Deco",
+		},
+		{
+			text: "Blusknallers BW",
+			name: "Douser Dualies FF",
+		},
+		{
+			text: "Gemodde Blusknallers BW",
+			name: "Custom Douser Dualies FF",
+		},
+		{
+			text: "Dubbelknallers",
+			name: "Splat Dualies",
+		},
+		{
+			text: "Enperry Dubbelknallers",
+			name: "Enperry Splat Dualies",
+		},
+		{
+			text: "Dubbelknallers Fönkel",
+			name: "Twinklez Splat Dualies",
+		},
+		{
+			text: "Ordeknallers (replica)",
+			name: "Order Dualie Replicas",
+		},
+		{
+			text: "Dubbelspatters",
+			name: "Dapple Dualies",
+		},
+		{
+			text: "Dubbelspatters Nouveau",
+			name: "Dapple Dualies Nouveau",
+		},
+		{
+			text: "Dubbelspatters VLR-M",
+			name: "Dapple Dualies NOC-T",
+		},
+		{
+			text: "Quadhoppers Zwart",
+			name: "Dark Tetra Dualies",
+		},
+		{
+			text: "Quadhoppers Wit",
+			name: "Light Tetra Dualies",
+		},
+		{
+			text: "Carbonroller HNG-L",
+			name: "Carbon Roller ANG-L",
+		},
+		{
+			text: "Gouden Dynamoroller",
+			name: "Gold Dynamo Roller",
+		},
+		{
+			text: "Dynamoroller Aströ",
+			name: "Starz Dynamo Roller",
+		},
+		{
+			text: "Flexroller",
+			name: "Flingza Roller",
+		},
+		{
+			text: "Foil Flexroller",
+			name: "Foil Flingza Roller",
+		},
+		{
+			text: "Klodderroller",
+			name: "Splat Roller",
+		},
+		{
+			text: "Krak-On Klodderroller",
+			name: "Krak-On Splat Roller",
+		},
+		{
+			text: "Orderoller (replica)",
+			name: "Order Roller Replica",
+		},
+		{
+			text: "Breedroller",
+			name: "Big Swig Roller",
+		},
+		{
+			text: "Breedroller Impuls",
+			name: "Big Swig Roller Express",
+		},
+		{
+			text: "Breedroller Fütür",
+			name: "Planetz Big Swig Roller",
+		},
+		{
+			text: "Schrobbehak PM",
+			name: "Mint Decavitator",
+		},
+		{
+			text: "Schrobbehak HK",
+			name: "Charcoal Decavitator",
+		},
+		{
+			text: "Wisserbladzwieper",
+			name: "Splatana Wiper",
+		},
+		{
+			text: "Wisserbladzwieper Deco",
+			name: "Splatana Wiper Deco",
+		},
+		{
+			text: "Wisserbladzwieper O-XID",
+			name: "Splatana Wiper RUS-T",
+		},
+		{
+			text: "Stempelzwieper",
+			name: "Splatana Stamper",
+		},
+		{
+			text: "Stempelzwieper Nouveau",
+			name: "Splatana Stamper Nouveau",
+		},
+		{
+			text: "Stempelzwieper Pläkkerz",
+			name: "Stickerz Splatana Stamper",
+		},
+		{
+			text: "Ordezwieper (replica)",
+			name: "Order Splatana Replica",
+		},
+		{
+			text: "Paraplenzer",
+			name: "Undercover Brella",
+		},
+		{
+			text: "Sorella Paraplenzer",
+			name: "Undercover Sorella Brella",
+		},
+		{
+			text: "Paraplenzer Fräppant",
+			name: "Patternz Undercover Brella",
+		},
+		{
+			text: "Protoplenzer 24-I",
+			name: "Recycled Brella 24 Mk I",
+		},
+		{
+			text: "Protoplenzer 24-II",
+			name: "Recycled Brella 24 Mk II",
+		},
+		{
+			text: "Plenzer",
+			name: "Splat Brella",
+		},
+		{
+			text: "Sorella Plenzer",
+			name: "Sorella Brella",
+		},
+		{
+			text: "Ordeplenzer (replica)",
+			name: "Order Brella Replica",
+		},
+		{
+			text: "Kampeerplenzer",
+			name: "Tenta Brella",
+		},
+		{
+			text: "Sorella Kampeerplenzer",
+			name: "Tenta Sorella Brella",
+		},
+		{
+			text: "Kampeerplenzer CRE-M",
+			name: "Tenta Brella CRE-M",
+		},
+		{
+			text: "Kladderwerper",
+			name: "Aerospray MG",
+		},
+		{
+			text: "Kladderwerper Pro",
+			name: "Aerospray RG",
+		},
+		{
+			text: "Kladderwerper Bönt",
+			name: "Colorz Aerospray",
+		},
+		{
+			text: "Superspetter Pro",
+			name: "Splattershot Pro",
+		},
+		{
+			text: "Forge Superspetter Pro",
+			name: "Forge Splattershot Pro",
+		},
+		{
+			text: "Superspetter Pro BIB-R",
+			name: "Splattershot Pro FRZ-N",
+		},
+		{
+			text: "Superspetter jr.",
+			name: "Splattershot Jr.",
+		},
+		{
+			text: "Gemodde Superspetter jr.",
+			name: "Custom Splattershot Jr.",
+		},
+		{
+			text: "Floeper",
+			name: "Squeezer",
+		},
+		{
+			text: "Foil Floeper",
+			name: "Foil Squeezer",
+		},
+		{
+			text: ".52 Kaliter",
+			name: ".52 Gal",
+		},
+		{
+			text: ".52 Kaliter Deco",
+			name: ".52 Gal Deco",
+		},
+		{
+			text: ".96 Kaliter",
+			name: ".96 Gal",
+		},
+		{
+			text: ".96 Kaliter Deco",
+			name: ".96 Gal Deco",
+		},
+		{
+			text: ".96 Kaliter Pänter",
+			name: "Clawz .96 Gal",
+		},
+		{
+			text: "Straalplonzer",
+			name: "Jet Squelcher",
+		},
+		{
+			text: "Gemodde Straalplonzer",
+			name: "Custom Jet Squelcher",
+		},
+		{
+			text: "Straalplonzer COB-R",
+			name: "Jet Squelcher COB-R",
+		},
+		{
+			text: "Superspetter",
+			name: "Splattershot",
+		},
+		{
+			text: "Tentatek Superspetter",
+			name: "Tentatek Splattershot",
+		},
+		{
+			text: "Superspetter Glänz",
+			name: "Glamorz Splattershot",
+		},
+		{
+			text: "Heldenspetter (replica)",
+			name: "Hero Shot Replica",
+		},
+		{
+			text: "Ordespetter (replica)",
+			name: "Order Shot Replica",
+		},
+		{
+			text: "Octospetter (replica)",
+			name: "Octo Shot Replica",
+		},
+		{
+			text: "Spetterspuit",
+			name: "Splash-o-matic",
+		},
+		{
+			text: "Spetterspuit Neo",
+			name: "Neo Splash-o-matic",
+		},
+		{
+			text: "Spetterspuit GKK-O",
+			name: "Splash-o-matic GCK-O",
+		},
+		{
+			text: "Superspetter Nova",
+			name: "Splattershot Nova",
+		},
+		{
+			text: "Annaki Superspetter Nova",
+			name: "Annaki Splattershot Nova",
+		},
+		{
+			text: "Spettertuit",
+			name: "Sploosh-o-matic",
+		},
+		{
+			text: "Spettertuit Neo",
+			name: "Neo Sploosh-o-matic",
+		},
+		{
+			text: "H-3 Langsnuit",
+			name: "H-3 Nozzlenose",
+		},
+		{
+			text: "H-3 Langsnuit D",
+			name: "H-3 Nozzlenose D",
+		},
+		{
+			text: "H-3 Langsnuit ANC-D",
+			name: "H-3 Nozzlenose VIP-R",
+		},
+		{
+			text: "L-3 Stompsnuit",
+			name: "L-3 Nozzlenose",
+		},
+		{
+			text: "L-3 Stompsnuit D",
+			name: "L-3 Nozzlenose D",
+		},
+		{
+			text: "L-3 Stompsnuit Spränkel",
+			name: "Glitterz L-3 Nozzlenose",
+		},
+		{
+			text: "Spatkuip",
+			name: "Bloblobber",
+		},
+		{
+			text: "Spatkuip Deco",
+			name: "Bloblobber Deco",
+		},
+		{
+			text: "Triomorser",
+			name: "Tri-Slosher",
+		},
+		{
+			text: "Triomorser Nouveau",
+			name: "Tri-Slosher Nouveau",
+		},
+		{
+			text: "Triomorser GRW-G",
+			name: "Tri-Slosher ASH-N",
+		},
+		{
+			text: "Wringmorser",
+			name: "Dread Wringer",
+		},
+		{
+			text: "Wringmorser D",
+			name: "Dread Wringer D",
+		},
+		{
+			text: "Wringmorser Hörnz",
+			name: "Hornz Dread Wringer",
+		},
+		{
+			text: "Klotstrommel",
+			name: "Sloshing Machine",
+		},
+		{
+			text: "Klotstrommel Neo",
+			name: "Sloshing Machine Neo",
+		},
+		{
+			text: "Morser",
+			name: "Slosher",
+		},
+		{
+			text: "Morser Deco",
+			name: "Slosher Deco",
+		},
+		{
+			text: "Ordemorser (replica)",
+			name: "Order Slosher Replica",
+		},
+		{
+			text: "Kliederkachel",
+			name: "Explosher",
+		},
+		{
+			text: "Gemodde Kliederkachel",
+			name: "Custom Explosher",
+		},
+		{
+			text: "Stylospetling",
+			name: "Ballpoint Splatling",
+		},
+		{
+			text: "Stylospetling Nouveau",
+			name: "Ballpoint Splatling Nouveau",
+		},
+		{
+			text: "Examinator",
+			name: "Heavy Edit Splatling",
+		},
+		{
+			text: "Examinator Nouveau",
+			name: "Heavy Edit Splatling Nouveau",
+		},
+		{
+			text: "Blusling",
+			name: "Hydra Splatling",
+		},
+		{
+			text: "Gemodde Blusling",
+			name: "Custom Hydra Splatling",
+		},
+		{
+			text: "Blusling Störtvlud",
+			name: "Torrentz Hydra Splatling",
+		},
+		{
+			text: "Mini-Spetling",
+			name: "Mini Splatling",
+		},
+		{
+			text: "Zink Mini-Spetling",
+			name: "Zink Mini Splatling",
+		},
+		{
+			text: "Mini-Spetling PYT-N",
+			name: "Mini Splatling RTL-R",
+		},
+		{
+			text: "Spetling",
+			name: "Heavy Splatling",
+		},
+		{
+			text: "Spetling Deco",
+			name: "Heavy Splatling Deco",
+		},
+		{
+			text: "Ordespetling (replica)",
+			name: "Order Splatling Replica",
+		},
+		{
+			text: "Pentapomper",
+			name: "Wellstring V",
+		},
+		{
+			text: "Gemodde Pentapomper",
+			name: "Custom Wellstring V",
+		},
+		{
+			text: "Triospanner",
+			name: "Tri-Stringer",
+		},
+		{
+			text: "Inkline Triospanner",
+			name: "Inkline Tri-Stringer",
+		},
+		{
+			text: "Triospanner Lüminus",
+			name: "Bulbz Tri-Stringer",
+		},
+		{
+			text: "Ordespanner (replica)",
+			name: "Order Stringer Replica",
+		},
+		{
+			text: "RIF-LEX 450",
+			name: "REEF-LUX 450",
+		},
+		{
+			text: "RIF-LEX 450 Deco",
+			name: "REEF-LUX 450 Deco",
+		},
+		{
+			text: "RIF-LEX 450 MEL-K",
+			name: "REEF-LUX 450 MIL-K",
+		},
+		{
+			text: "Springschotel",
+			name: "Squid Beakon",
+		},
+		{
+			text: "Curlingbom",
+			name: "Curling Bomb",
+		},
+		{
+			text: "Bomblikje",
+			name: "Fizzy Bomb",
+		},
+		{
+			text: "Ballonbom",
+			name: "Burst Bomb",
+		},
+		{
+			text: "Robobom",
+			name: "Autobomb",
+		},
+		{
+			text: "Klodderbom",
+			name: "Splat Bomb",
+		},
+		{
+			text: "Kleefbom",
+			name: "Suction Bomb",
+		},
+		{
+			text: "Torpedobom",
+			name: "Torpedo",
+		},
+		{
+			text: "Ketskogel",
+			name: "Angle Shooter",
+		},
+		{
+			text: "Detector",
+			name: "Point Sensor",
+		},
+		{
+			text: "Gifmist",
+			name: "Toxic Mist",
+		},
+		{
+			text: "Inktgordijn",
+			name: "Splash Wall",
+		},
+		{
+			text: "Inktsprinkler",
+			name: "Sprinkler",
+		},
+		{
+			text: "Inktmijn",
+			name: "Ink Mine",
+		},
+		{
+			text: "Inktdief",
+			name: "Ink Vac",
+		},
+		{
+			text: "Monstermorfose",
+			name: "Kraken Royale",
+		},
+		{
+			text: "Krabbentank",
+			name: "Crab Tank",
+		},
+		{
+			text: "PLED-scherm",
+			name: "Splattercolor Screen",
+		},
+		{
+			text: "Reddingsbar",
+			name: "Tacticooler",
+		},
+		{
+			text: "Voorschutter",
+			name: "Super Chump",
+		},
+		{
+			text: "Joekelschild",
+			name: "Big Bubbler",
+		},
+		{
+			text: "Spetterbui",
+			name: "Ink Storm",
+		},
+		{
+			text: "Inktjet",
+			name: "Inkjet",
+		},
+		{
+			text: "Megalofoon 5.1",
+			name: "Killer Wail 5.1",
+		},
+		{
+			text: "Spetterraketten",
+			name: "Tenta Missiles",
+		},
+		{
+			text: "Coole bom",
+			name: "Booyah Bomb",
+		},
+		{
+			text: "Ultralanding",
+			name: "Triple Splashdown",
+		},
+		{
+			text: "Golfbeker",
+			name: "Wave Breaker",
+		},
+		{
+			text: "Opblaashaai",
+			name: "Reefslider",
+		},
+		{
+			text: "Tentakabel",
+			name: "Zipcaster",
+		},
+		{
+			text: "Tri-tornado",
+			name: "Triple Inkstrike",
+		},
+		{
+			text: "Ultrastempel",
+			name: "Ultra Stamp",
+		},
+	],
+	EUru: [
+		{
+			text: "Бластермат ПРО",
+			name: "Rapid Blaster Pro",
+		},
+		{
+			text: "Бластермат ПРО «Деко»",
+			name: "Rapid Blaster Pro Deco",
+		},
+		{
+			text: "Бластермат ПРО «К-ЛОТУН»",
+			name: "Rapid Blaster Pro WNT-R",
+		},
+		{
+			text: "Контрабластер",
+			name: "Clash Blaster",
+		},
+		{
+			text: "Контрабластер «Нео»",
+			name: "Clash Blaster Neo",
+		},
+		{
+			text: "Бластермат",
+			name: "Rapid Blaster",
+		},
+		{
+			text: "Бластермат «Деко»",
+			name: "Rapid Blaster Deco",
+		},
+		{
+			text: "Дальнобластер",
+			name: "Range Blaster",
+		},
+		{
+			text: "Дальнобластер «Понт»",
+			name: "Custom Range Blaster",
+		},
+		{
+			text: "Бластер",
+			name: "Blaster",
+		},
+		{
+			text: "Бластер «Понт»",
+			name: "Custom Blaster",
+		},
+		{
+			text: "Бластер «Лоск»",
+			name: "Gleamz Blaster",
+		},
+		{
+			text: "S-BLAST 92",
+			name: "S-BLAST '92",
+		},
+		{
+			text: "S-BLAST 91",
+			name: "S-BLAST '91",
+		},
+		{
+			text: "Лунобластер",
+			name: "Luna Blaster",
+		},
+		{
+			text: "Лунобластер «Нео»",
+			name: "Luna Blaster Neo",
+		},
+		{
+			text: "Бластер Порядка (клон)",
+			name: "Order Blaster Replica",
+		},
+		{
+			text: "Веерокисть «Плюхассо»",
+			name: "Painbrush",
+		},
+		{
+			text: "Веерокисть «НуВо»",
+			name: "Painbrush Nouveau",
+		},
+		{
+			text: "Веерокисть «БРОН-З»",
+			name: "Painbrush BRN-Z",
+		},
+		{
+			text: "Кисть",
+			name: "Inkbrush",
+		},
+		{
+			text: "Кисть «НуВо»",
+			name: "Inkbrush Nouveau",
+		},
+		{
+			text: "Арт-кисть",
+			name: "Octobrush",
+		},
+		{
+			text: "Арт-кисть «НуВо»",
+			name: "Octobrush Nouveau",
+		},
+		{
+			text: "Арт-кисть «Комета»",
+			name: "Cometz Octobrush",
+		},
+		{
+			text: "Кисть Порядка (клон)",
+			name: "Orderbrush Replica",
+		},
+		{
+			text: "Трубастер",
+			name: "Goo Tuber",
+		},
+		{
+			text: "Трубастер «Понт»",
+			name: "Custom Goo Tuber",
+		},
+		{
+			text: "Бамбух 14-I",
+			name: "Bamboozler 14 Mk I",
+		},
+		{
+			text: "Бамбух 14-II",
+			name: "Bamboozler 14 Mk II",
+		},
+		{
+			text: "Снайп-э-литр 95",
+			name: "E-liter 4K Scope",
+		},
+		{
+			text: "Снайп-э-литр 95 «Понт»",
+			name: "Custom E-liter 4K Scope",
+		},
+		{
+			text: "Э-литр 95",
+			name: "E-liter 4K",
+		},
+		{
+			text: "Э-литр 95 «Понт»",
+			name: "Custom E-liter 4K",
+		},
+		{
+			text: "Снайпокрас",
+			name: "Splatterscope",
+		},
+		{
+			text: "Снайпокрас «ЙожкоТюр»",
+			name: "Z+F Splatterscope",
+		},
+		{
+			text: "Снайпокрас «К-ФЛЯЖ»",
+			name: "Splatterscope CAM-O",
+		},
+		{
+			text: "Сплатган",
+			name: "Splat Charger",
+		},
+		{
+			text: "Сплатган «ЙожкоТюр»",
+			name: "Z+F Splat Charger",
+		},
+		{
+			text: "Сплатган «К-ФЛЯЖ»",
+			name: "Splat Charger CAM-O",
+		},
+		{
+			text: "Сплатган Порядка (клон)",
+			name: "Order Charger Replica",
+		},
+		{
+			text: "Патрондаш 5Т",
+			name: "Snipewriter 5H",
+		},
+		{
+			text: "Патрондаш 5М",
+			name: "Snipewriter 5B",
+		},
+		{
+			text: "Стиратель",
+			name: "Classic Squiffer",
+		},
+		{
+			text: "Стиратель-II",
+			name: "New Squiffer",
+		},
+		{
+			text: "Спурт-плескари",
+			name: "Dualie Squelchers",
+		},
+		{
+			text: "Спурт-плескари «Понт»",
+			name: "Custom Dualie Squelchers",
+		},
+		{
+			text: "Спурт-плескари «Копыта»",
+			name: "Hoofz Dualie Squelchers",
+		},
+		{
+			text: "Термоплюхи 525",
+			name: "Glooga Dualies",
+		},
+		{
+			text: "Термоплюхи 525 «Деко»",
+			name: "Glooga Dualies Deco",
+		},
+		{
+			text: "Краскотушители 255",
+			name: "Douser Dualies FF",
+		},
+		{
+			text: "Краскотушители «Понт»",
+			name: "Custom Douser Dualies FF",
+		},
+		{
+			text: "Спуртометы",
+			name: "Splat Dualies",
+		},
+		{
+			text: "Спуртометы «К.К.»",
+			name: "Enperry Splat Dualies",
+		},
+		{
+			text: "Спуртометы «Искра»",
+			name: "Twinklez Splat Dualies",
+		},
+		{
+			text: "Спуртометы Порядка (кл.)",
+			name: "Order Dualie Replicas",
+		},
+		{
+			text: "Импрессиометы",
+			name: "Dapple Dualies",
+		},
+		{
+			text: "Импрессиометы «НуВо»",
+			name: "Dapple Dualies Nouveau",
+		},
+		{
+			text: "Импрессиометы «Ф-ЛИН»",
+			name: "Dapple Dualies NOC-T",
+		},
+		{
+			text: "Черные спуртокроссы",
+			name: "Dark Tetra Dualies",
+		},
+		{
+			text: "Белые спуртокроссы",
+			name: "Light Tetra Dualies",
+		},
+		{
+			text: "Валик ЛАЙТ",
+			name: "Carbon Roller",
+		},
+		{
+			text: "Валик ЛАЙТ «Деко»",
+			name: "Carbon Roller Deco",
+		},
+		{
+			text: "Валик ЛАЙТ «У-ДИЛЬ»",
+			name: "Carbon Roller ANG-L",
+		},
+		{
+			text: "Мотовалик",
+			name: "Dynamo Roller",
+		},
+		{
+			text: "Мотовалик VIP",
+			name: "Gold Dynamo Roller",
+		},
+		{
+			text: "Мотовалик «Пульсар»",
+			name: "Starz Dynamo Roller",
+		},
+		{
+			text: "Омнивалик",
+			name: "Flingza Roller",
+		},
+		{
+			text: "Омнивалик «Блеск»",
+			name: "Foil Flingza Roller",
+		},
+		{
+			text: "Сплат-валик",
+			name: "Splat Roller",
+		},
+		{
+			text: "Сплат-валик «Кра-Кен»",
+			name: "Krak-On Splat Roller",
+		},
+		{
+			text: "Валик Порядка (клон)",
+			name: "Order Roller Replica",
+		},
+		{
+			text: "Макси-валик",
+			name: "Big Swig Roller",
+		},
+		{
+			text: "Макси-валик «Экспресс»",
+			name: "Big Swig Roller Express",
+		},
+		{
+			text: "Макси-валик «Планета»",
+			name: "Planetz Big Swig Roller",
+		},
+		{
+			text: "Мятная дентана",
+			name: "Mint Decavitator",
+		},
+		{
+			text: "Угольная дентана",
+			name: "Charcoal Decavitator",
+		},
+		{
+			text: "Cплат-дворник",
+			name: "Splatana Wiper",
+		},
+		{
+			text: "Cплат-дворник «Деко»",
+			name: "Splatana Wiper Deco",
+		},
+		{
+			text: "Сплат-дворник «РЖАВ-Ч»",
+			name: "Splatana Wiper RUS-T",
+		},
+		{
+			text: "Сплат-печатель",
+			name: "Splatana Stamper",
+		},
+		{
+			text: "Сплат-печатель «НуВо»",
+			name: "Splatana Stamper Nouveau",
+		},
+		{
+			text: "Сплат-печатель «Уклейка»",
+			name: "Stickerz Splatana Stamper",
+		},
+		{
+			text: "Сплат-катана Порядка (кл.)",
+			name: "Order Splatana Replica",
+		},
+		{
+			text: "Шпионский зонт",
+			name: "Undercover Brella",
+		},
+		{
+			text: "Шпионский зонт «Родиччи»",
+			name: "Undercover Sorella Brella",
+		},
+		{
+			text: "Шпионский зонт «Коллаж»",
+			name: "Patternz Undercover Brella",
+		},
+		{
+			text: "Ребут-зонтган М-1",
+			name: "Recycled Brella 24 Mk I",
+		},
+		{
+			text: "Ребут-зонтган М-2",
+			name: "Recycled Brella 24 Mk II",
+		},
+		{
+			text: "Сплат-зонт",
+			name: "Splat Brella",
+		},
+		{
+			text: "Зонтган «Родиччи»",
+			name: "Sorella Brella",
+		},
+		{
+			text: "Зонтган Порядка (клон)",
+			name: "Order Brella Replica",
+		},
+		{
+			text: "Зонтент",
+			name: "Tenta Brella",
+		},
+		{
+			text: "Зонтент «Родиччи»",
+			name: "Tenta Sorella Brella",
+		},
+		{
+			text: "Зонтент «СЛИВ-К»",
+			name: "Tenta Brella CRE-M",
+		},
+		{
+			text: "Аэроспрей",
+			name: "Aerospray MG",
+		},
+		{
+			text: "Аэроспрей ДЕЛЮКС",
+			name: "Aerospray RG",
+		},
+		{
+			text: "Аэроспрей «Перелив»",
+			name: "Colorz Aerospray",
+		},
+		{
+			text: "Каплестрел ПРО",
+			name: "Splattershot Pro",
+		},
+		{
+			text: "Каплестрел ПРО «Блиц»",
+			name: "Forge Splattershot Pro",
+		},
+		{
+			text: "Каплестрел ПРО «СТУ-Ж»",
+			name: "Splattershot Pro FRZ-N",
+		},
+		{
+			text: "Каплестрел-У",
+			name: "Splattershot Jr.",
+		},
+		{
+			text: "Каплестрел-У 2.0",
+			name: "Custom Splattershot Jr.",
+		},
+		{
+			text: "Бутылятор",
+			name: "Squeezer",
+		},
+		{
+			text: "Бутылятор «Блеск»",
+			name: "Foil Squeezer",
+		},
+		{
+			text: "Струевик .52",
+			name: ".52 Gal",
+		},
+		{
+			text: "Струевик .52 «Деко»",
+			name: ".52 Gal Deco",
+		},
+		{
+			text: "Струевик .96",
+			name: ".96 Gal",
+		},
+		{
+			text: "Струевик .96 «Деко»",
+			name: ".96 Gal Deco",
+		},
+		{
+			text: "Струевик .96 «Царап»",
+			name: "Clawz .96 Gal",
+		},
+		{
+			text: "Плескарь",
+			name: "Jet Squelcher",
+		},
+		{
+			text: "Плескарь «Понт»",
+			name: "Custom Jet Squelcher",
+		},
+		{
+			text: "Плескарь «КОБ-Р»",
+			name: "Jet Squelcher COB-R",
+		},
+		{
+			text: "Каплестрел",
+			name: "Splattershot",
+		},
+		{
+			text: "Каплестрел «Щуччи»",
+			name: "Tentatek Splattershot",
+		},
+		{
+			text: "Каплестрел «Блесна»",
+			name: "Glamorz Splattershot",
+		},
+		{
+			text: "Каплестрел героя (клон)",
+			name: "Hero Shot Replica",
+		},
+		{
+			text: "Каплестрел Порядка (клон)",
+			name: "Order Shot Replica",
+		},
+		{
+			text: "Осьмострел (клон)",
+			name: "Octo Shot Replica",
+		},
+		{
+			text: "Плюхомет",
+			name: "Splash-o-matic",
+		},
+		{
+			text: "Плюхомет «Нео»",
+			name: "Neo Splash-o-matic",
+		},
+		{
+			text: "Плюхомет «Г-КОН»",
+			name: "Splash-o-matic GCK-O",
+		},
+		{
+			text: "Каплестрел НОВА",
+			name: "Splattershot Nova",
+		},
+		{
+			text: "Каплестрел НОВА-ПАНК",
+			name: "Annaki Splattershot Nova",
+		},
+		{
+			text: "N-ZAP 85",
+			name: "N-ZAP '85",
+		},
+		{
+			text: "N-ZAP 89",
+			name: "N-ZAP '89",
+		},
+		{
+			text: "Плюхотрон",
+			name: "Sploosh-o-matic",
+		},
+		{
+			text: "Плюхотрон «Нео»",
+			name: "Neo Sploosh-o-matic",
+		},
+		{
+			text: "Тяжелый каплетрон",
+			name: "H-3 Nozzlenose",
+		},
+		{
+			text: "Тяжелый каплетрон 2.0",
+			name: "H-3 Nozzlenose D",
+		},
+		{
+			text: "Т-каплетрон «МАМ-Б»",
+			name: "H-3 Nozzlenose VIP-R",
+		},
+		{
+			text: "Каплетрон-компакт",
+			name: "L-3 Nozzlenose",
+		},
+		{
+			text: "Каплетрон-компакт 2.0",
+			name: "L-3 Nozzlenose D",
+		},
+		{
+			text: "Каплетрон «Страз»",
+			name: "Glitterz L-3 Nozzlenose",
+		},
+		{
+			text: "Ваннаган",
+			name: "Bloblobber",
+		},
+		{
+			text: "Ваннаган «Деко»",
+			name: "Bloblobber Deco",
+		},
+		{
+			text: "Ведроган 3 в 1",
+			name: "Tri-Slosher",
+		},
+		{
+			text: "Ведроган 3 в 1 «НуВо»",
+			name: "Tri-Slosher Nouveau",
+		},
+		{
+			text: "Ведроган 3 в 1 «ГАЛЬ-Н»",
+			name: "Tri-Slosher ASH-N",
+		},
+		{
+			text: "Отжиматель",
+			name: "Dread Wringer",
+		},
+		{
+			text: "Отжиматель 2.0",
+			name: "Dread Wringer D",
+		},
+		{
+			text: "Отжиматель «Рога»",
+			name: "Hornz Dread Wringer",
+		},
+		{
+			text: "Центрифугер",
+			name: "Sloshing Machine",
+		},
+		{
+			text: "Центрифугер «Нео»",
+			name: "Sloshing Machine Neo",
+		},
+		{
+			text: "Ведроган",
+			name: "Slosher",
+		},
+		{
+			text: "Ведроган «Деко»",
+			name: "Slosher Deco",
+		},
+		{
+			text: "Ведроган Порядка (клон)",
+			name: "Order Slosher Replica",
+		},
+		{
+			text: "Шпарган",
+			name: "Explosher",
+		},
+		{
+			text: "Шпарган «Понт»",
+			name: "Custom Explosher",
+		},
+		{
+			text: "Кугельшрайбер",
+			name: "Ballpoint Splatling",
+		},
+		{
+			text: "Кугельшрайбер «НуВо»",
+			name: "Ballpoint Splatling Nouveau",
+		},
+		{
+			text: "Брызгомет XL «Корректор»",
+			name: "Heavy Edit Splatling",
+		},
+		{
+			text: "Корректор «НуВо»",
+			name: "Heavy Edit Splatling Nouveau",
+		},
+		{
+			text: "Брызгомет «Горыныч»",
+			name: "Hydra Splatling",
+		},
+		{
+			text: "«Понт-Горыныч»",
+			name: "Custom Hydra Splatling",
+		},
+		{
+			text: "«Баллон-Горыныч»",
+			name: "Torrentz Hydra Splatling",
+		},
+		{
+			text: "Брызгомет-М",
+			name: "Mini Splatling",
+		},
+		{
+			text: "Брызгомет-М «Шпротус»",
+			name: "Zink Mini Splatling",
+		},
+		{
+			text: "Брызгомет-М «Г-ДЮК»",
+			name: "Mini Splatling RTL-R",
+		},
+		{
+			text: "Наутилус-47",
+			name: "Nautilus 47",
+		},
+		{
+			text: "Наутилус-79",
+			name: "Nautilus 79",
+		},
+		{
+			text: "Брызгомет XL",
+			name: "Heavy Splatling",
+		},
+		{
+			text: "Брызгомет XL «Деко»",
+			name: "Heavy Splatling Deco",
+		},
+		{
+			text: "Брызгомет Порядка (клон)",
+			name: "Order Splatling Replica",
+		},
+		{
+			text: "Квинтиватор «Колодезь»",
+			name: "Wellstring V",
+		},
+		{
+			text: "Квинтиватор «Понт»",
+			name: "Custom Wellstring V",
+		},
+		{
+			text: "Тритиватор",
+			name: "Tri-Stringer",
+		},
+		{
+			text: "Тритиватор «Коллаб»",
+			name: "Inkline Tri-Stringer",
+		},
+		{
+			text: "Тритиватор «Диод»",
+			name: "Bulbz Tri-Stringer",
+		},
+		{
+			text: "Тетиватор Порядка (клон)",
+			name: "Order Stringer Replica",
+		},
+		{
+			text: "КО-РАЛЛ 450",
+			name: "REEF-LUX 450",
+		},
+		{
+			text: "КО-РАЛЛ 450 «Деко»",
+			name: "REEF-LUX 450 Deco",
+		},
+		{
+			text: "КО-РАЛЛ 450 «М-ЛОКО»",
+			name: "REEF-LUX 450 MIL-K",
+		},
+		{
+			text: "Прыжковый маячок",
+			name: "Squid Beakon",
+		},
+		{
+			text: "Керлинг-бомба",
+			name: "Curling Bomb",
+		},
+		{
+			text: "Содовая бомба",
+			name: "Fizzy Bomb",
+		},
+		{
+			text: "Разрывная бомба",
+			name: "Burst Bomb",
+		},
+		{
+			text: "Робобомба",
+			name: "Autobomb",
+		},
+		{
+			text: "Брызгающая бомба",
+			name: "Splat Bomb",
+		},
+		{
+			text: "Бомба на присоске",
+			name: "Suction Bomb",
+		},
+		{
+			text: "Торпедная бомба",
+			name: "Torpedo",
+		},
+		{
+			text: "Углострел",
+			name: "Angle Shooter",
+		},
+		{
+			text: "Маркер движения",
+			name: "Point Sensor",
+		},
+		{
+			text: "Едкий туман",
+			name: "Toxic Mist",
+		},
+		{
+			text: "Чернильный занавес",
+			name: "Splash Wall",
+		},
+		{
+			text: "Распылятор",
+			name: "Sprinkler",
+		},
+		{
+			text: "Мина",
+			name: "Ink Mine",
+		},
+		{
+			text: "Краскосос",
+			name: "Ink Vac",
+		},
+		{
+			text: "Тираннокракен",
+			name: "Kraken Royale",
+		},
+		{
+			text: "Кработанк",
+			name: "Crab Tank",
+		},
+		{
+			text: "Заливной барьер",
+			name: "Splattercolor Screen",
+		},
+		{
+			text: "Тоникулер",
+			name: "Tacticooler",
+		},
+		{
+			text: "Суперпрыжатор",
+			name: "Super Chump",
+		},
+		{
+			text: "Шарощит",
+			name: "Big Bubbler",
+		},
+		{
+			text: "Туча краски",
+			name: "Ink Storm",
+		},
+		{
+			text: "Красколет",
+			name: "Inkjet",
+		},
+		{
+			text: "Мегалофон 5.1",
+			name: "Killer Wail 5.1",
+		},
+		{
+			text: "Каракатница",
+			name: "Tenta Missiles",
+		},
+		{
+			text: "Йо-хо-плюхер",
+			name: "Booyah Bomb",
+		},
+		{
+			text: "Тройной мегаплюх",
+			name: "Triple Splashdown",
+		},
+		{
+			text: "Волноплюхер",
+			name: "Wave Breaker",
+		},
+		{
+			text: "Мотокула",
+			name: "Reefslider",
+		},
+		{
+			text: "Краскотрос",
+			name: "Zipcaster",
+		},
+		{
+			text: "Тройной торнадо",
+			name: "Triple Inkstrike",
+		},
+		{
+			text: "Гранатомет «Трезубец»",
+			name: "Trizooka",
+		},
+		{
+			text: "Припечать",
+			name: "Ultra Stamp",
+		},
+	],
+	JPja: [
+		{
+			text: "Rブラスターエリート",
+			name: "Rapid Blaster Pro",
+		},
+		{
+			text: "Rブラスターエリートデコ",
+			name: "Rapid Blaster Pro Deco",
+		},
+		{
+			text: "RブラスターエリートWNTR",
+			name: "Rapid Blaster Pro WNT-R",
+		},
+		{
+			text: "クラッシュブラスター",
+			name: "Clash Blaster",
+		},
+		{
+			text: "クラッシュブラスターネオ",
+			name: "Clash Blaster Neo",
+		},
+		{
+			text: "ラピッドブラスター",
+			name: "Rapid Blaster",
+		},
+		{
+			text: "ラピッドブラスターデコ",
+			name: "Rapid Blaster Deco",
+		},
+		{
+			text: "ロングブラスター",
+			name: "Range Blaster",
+		},
+		{
+			text: "ロングブラスターカスタム",
+			name: "Custom Range Blaster",
+		},
+		{
+			text: "ホットブラスター",
+			name: "Blaster",
+		},
+		{
+			text: "ホットブラスターカスタム",
+			name: "Custom Blaster",
+		},
+		{
+			text: "ホットブラスター艶",
+			name: "Gleamz Blaster",
+		},
+		{
+			text: "S-BLAST92",
+			name: "S-BLAST '92",
+		},
+		{
+			text: "S-BLAST91",
+			name: "S-BLAST '91",
+		},
+		{
+			text: "ノヴァブラスター",
+			name: "Luna Blaster",
+		},
+		{
+			text: "ノヴァブラスターネオ",
+			name: "Luna Blaster Neo",
+		},
+		{
+			text: "オーダーブラスター レプリカ",
+			name: "Order Blaster Replica",
+		},
+		{
+			text: "フィンセント",
+			name: "Painbrush",
+		},
+		{
+			text: "フィンセント・ヒュー",
+			name: "Painbrush Nouveau",
+		},
+		{
+			text: "フィンセントBRNZ",
+			name: "Painbrush BRN-Z",
+		},
+		{
+			text: "パブロ",
+			name: "Inkbrush",
+		},
+		{
+			text: "パブロ・ヒュー",
+			name: "Inkbrush Nouveau",
+		},
+		{
+			text: "ホクサイ",
+			name: "Octobrush",
+		},
+		{
+			text: "ホクサイ・ヒュー",
+			name: "Octobrush Nouveau",
+		},
+		{
+			text: "ホクサイ彗",
+			name: "Cometz Octobrush",
+		},
+		{
+			text: "オーダーブラシ レプリカ",
+			name: "Orderbrush Replica",
+		},
+		{
+			text: "ソイチューバー",
+			name: "Goo Tuber",
+		},
+		{
+			text: "ソイチューバーカスタム",
+			name: "Custom Goo Tuber",
+		},
+		{
+			text: "14式竹筒銃・甲",
+			name: "Bamboozler 14 Mk I",
+		},
+		{
+			text: "14式竹筒銃・乙",
+			name: "Bamboozler 14 Mk II",
+		},
+		{
+			text: "4Kスコープ",
+			name: "E-liter 4K Scope",
+		},
+		{
+			text: "4Kスコープカスタム",
+			name: "Custom E-liter 4K Scope",
+		},
+		{
+			text: "リッター4K",
+			name: "E-liter 4K",
+		},
+		{
+			text: "リッター4Kカスタム",
+			name: "Custom E-liter 4K",
+		},
+		{
+			text: "スプラスコープ",
+			name: "Splatterscope",
+		},
+		{
+			text: "スプラスコープコラボ",
+			name: "Z+F Splatterscope",
+		},
+		{
+			text: "スプラスコープFRST",
+			name: "Splatterscope CAM-O",
+		},
+		{
+			text: "スプラチャージャー",
+			name: "Splat Charger",
+		},
+		{
+			text: "スプラチャージャーコラボ",
+			name: "Z+F Splat Charger",
+		},
+		{
+			text: "スプラチャージャーFRST",
+			name: "Splat Charger CAM-O",
+		},
+		{
+			text: "オーダーチャージャー レプリカ",
+			name: "Order Charger Replica",
+		},
+		{
+			text: "R-PEN/5H",
+			name: "Snipewriter 5H",
+		},
+		{
+			text: "R-PEN/5B",
+			name: "Snipewriter 5B",
+		},
+		{
+			text: "スクイックリンα",
+			name: "Classic Squiffer",
+		},
+		{
+			text: "スクイックリンβ",
+			name: "New Squiffer",
+		},
+		{
+			text: "デュアルスイーパー",
+			name: "Dualie Squelchers",
+		},
+		{
+			text: "デュアルスイーパーカスタム",
+			name: "Custom Dualie Squelchers",
+		},
+		{
+			text: "デュアルスイーパー蹄",
+			name: "Hoofz Dualie Squelchers",
+		},
+		{
+			text: "ケルビン525",
+			name: "Glooga Dualies",
+		},
+		{
+			text: "ケルビン525デコ",
+			name: "Glooga Dualies Deco",
+		},
+		{
+			text: "ガエンFF",
+			name: "Douser Dualies FF",
+		},
+		{
+			text: "ガエンFFカスタム",
+			name: "Custom Douser Dualies FF",
+		},
+		{
+			text: "スプラマニューバー",
+			name: "Splat Dualies",
+		},
+		{
+			text: "スプラマニューバーコラボ",
+			name: "Enperry Splat Dualies",
+		},
+		{
+			text: "スプラマニューバー耀",
+			name: "Twinklez Splat Dualies",
+		},
+		{
+			text: "オーダーマニューバー レプリカ",
+			name: "Order Dualie Replicas",
+		},
+		{
+			text: "スパッタリー",
+			name: "Dapple Dualies",
+		},
+		{
+			text: "スパッタリー・ヒュー",
+			name: "Dapple Dualies Nouveau",
+		},
+		{
+			text: "スパッタリーOWL",
+			name: "Dapple Dualies NOC-T",
+		},
+		{
+			text: "クアッドホッパーブラック",
+			name: "Dark Tetra Dualies",
+		},
+		{
+			text: "クアッドホッパーホワイト",
+			name: "Light Tetra Dualies",
+		},
+		{
+			text: "カーボンローラー",
+			name: "Carbon Roller",
+		},
+		{
+			text: "カーボンローラーデコ",
+			name: "Carbon Roller Deco",
+		},
+		{
+			text: "カーボンローラーANGL",
+			name: "Carbon Roller ANG-L",
+		},
+		{
+			text: "ダイナモローラー",
+			name: "Dynamo Roller",
+		},
+		{
+			text: "ダイナモローラーテスラ",
+			name: "Gold Dynamo Roller",
+		},
+		{
+			text: "ダイナモローラー冥",
+			name: "Starz Dynamo Roller",
+		},
+		{
+			text: "ヴァリアブルローラー",
+			name: "Flingza Roller",
+		},
+		{
+			text: "ヴァリアブルローラーフォイル",
+			name: "Foil Flingza Roller",
+		},
+		{
+			text: "スプラローラー",
+			name: "Splat Roller",
+		},
+		{
+			text: "スプラローラーコラボ",
+			name: "Krak-On Splat Roller",
+		},
+		{
+			text: "オーダーローラー レプリカ",
+			name: "Order Roller Replica",
+		},
+		{
+			text: "ワイドローラー",
+			name: "Big Swig Roller",
+		},
+		{
+			text: "ワイドローラーコラボ",
+			name: "Big Swig Roller Express",
+		},
+		{
+			text: "ワイドローラー惑",
+			name: "Planetz Big Swig Roller",
+		},
+		{
+			text: "デンタルワイパーミント",
+			name: "Mint Decavitator",
+		},
+		{
+			text: "デンタルワイパースミ",
+			name: "Charcoal Decavitator",
+		},
+		{
+			text: "ドライブワイパー",
+			name: "Splatana Wiper",
+		},
+		{
+			text: "ドライブワイパーデコ",
+			name: "Splatana Wiper Deco",
+		},
+		{
+			text: "ドライブワイパーRUST",
+			name: "Splatana Wiper RUS-T",
+		},
+		{
+			text: "ジムワイパー",
+			name: "Splatana Stamper",
+		},
+		{
+			text: "ジムワイパー・ヒュー",
+			name: "Splatana Stamper Nouveau",
+		},
+		{
+			text: "ジムワイパー封",
+			name: "Stickerz Splatana Stamper",
+		},
+		{
+			text: "オーダーワイパー レプリカ",
+			name: "Order Splatana Replica",
+		},
+		{
+			text: "スパイガジェット",
+			name: "Undercover Brella",
+		},
+		{
+			text: "スパイガジェットソレーラ",
+			name: "Undercover Sorella Brella",
+		},
+		{
+			text: "スパイガジェット繚",
+			name: "Patternz Undercover Brella",
+		},
+		{
+			text: "24式張替傘・甲",
+			name: "Recycled Brella 24 Mk I",
+		},
+		{
+			text: "24式張替傘・乙",
+			name: "Recycled Brella 24 Mk II",
+		},
+		{
+			text: "パラシェルター",
+			name: "Splat Brella",
+		},
+		{
+			text: "パラシェルターソレーラ",
+			name: "Sorella Brella",
+		},
+		{
+			text: "オーダーシェルター レプリカ",
+			name: "Order Brella Replica",
+		},
+		{
+			text: "キャンピングシェルター",
+			name: "Tenta Brella",
+		},
+		{
+			text: "キャンピングシェルターソレーラ",
+			name: "Tenta Sorella Brella",
+		},
+		{
+			text: "キャンピングシェルターCREM",
+			name: "Tenta Brella CRE-M",
+		},
+		{
+			text: "プロモデラーMG",
+			name: "Aerospray MG",
+		},
+		{
+			text: "プロモデラーRG",
+			name: "Aerospray RG",
+		},
+		{
+			text: "プロモデラー彩",
+			name: "Colorz Aerospray",
+		},
+		{
+			text: "プライムシューター",
+			name: "Splattershot Pro",
+		},
+		{
+			text: "プライムシューターコラボ",
+			name: "Forge Splattershot Pro",
+		},
+		{
+			text: "プライムシューターFRZN",
+			name: "Splattershot Pro FRZ-N",
+		},
+		{
+			text: "わかばシューター",
+			name: "Splattershot Jr.",
+		},
+		{
+			text: "もみじシューター",
+			name: "Custom Splattershot Jr.",
+		},
+		{
+			text: "ボトルガイザー",
+			name: "Squeezer",
+		},
+		{
+			text: "ボトルガイザーフォイル",
+			name: "Foil Squeezer",
+		},
+		{
+			text: ".52ガロン",
+			name: ".52 Gal",
+		},
+		{
+			text: ".52ガロンデコ",
+			name: ".52 Gal Deco",
+		},
+		{
+			text: ".96ガロン",
+			name: ".96 Gal",
+		},
+		{
+			text: ".96ガロンデコ",
+			name: ".96 Gal Deco",
+		},
+		{
+			text: ".96ガロン爪",
+			name: "Clawz .96 Gal",
+		},
+		{
+			text: "ジェットスイーパー",
+			name: "Jet Squelcher",
+		},
+		{
+			text: "ジェットスイーパーカスタム",
+			name: "Custom Jet Squelcher",
+		},
+		{
+			text: "ジェットスイーパーCOBR",
+			name: "Jet Squelcher COB-R",
+		},
+		{
+			text: "スプラシューター",
+			name: "Splattershot",
+		},
+		{
+			text: "スプラシューターコラボ",
+			name: "Tentatek Splattershot",
+		},
+		{
+			text: "スプラシューター煌",
+			name: "Glamorz Splattershot",
+		},
+		{
+			text: "ヒーローシューター レプリカ",
+			name: "Hero Shot Replica",
+		},
+		{
+			text: "オーダーシューター レプリカ",
+			name: "Order Shot Replica",
+		},
+		{
+			text: "オクタシューター レプリカ",
+			name: "Octo Shot Replica",
+		},
+		{
+			text: "シャープマーカー",
+			name: "Splash-o-matic",
+		},
+		{
+			text: "シャープマーカーネオ",
+			name: "Neo Splash-o-matic",
+		},
+		{
+			text: "シャープマーカーGECK",
+			name: "Splash-o-matic GCK-O",
+		},
+		{
+			text: "スペースシューター",
+			name: "Splattershot Nova",
+		},
+		{
+			text: "スペースシューターコラボ",
+			name: "Annaki Splattershot Nova",
+		},
+		{
+			text: "N-ZAP85",
+			name: "N-ZAP '85",
+		},
+		{
+			text: "N-ZAP89",
+			name: "N-ZAP '89",
+		},
+		{
+			text: "ボールドマーカー",
+			name: "Sploosh-o-matic",
+		},
+		{
+			text: "ボールドマーカーネオ",
+			name: "Neo Sploosh-o-matic",
+		},
+		{
+			text: "H3リールガン",
+			name: "H-3 Nozzlenose",
+		},
+		{
+			text: "H3リールガンD",
+			name: "H-3 Nozzlenose D",
+		},
+		{
+			text: "H3リールガンSNAK",
+			name: "H-3 Nozzlenose VIP-R",
+		},
+		{
+			text: "L3リールガン",
+			name: "L-3 Nozzlenose",
+		},
+		{
+			text: "L3リールガンD",
+			name: "L-3 Nozzlenose D",
+		},
+		{
+			text: "L3リールガン箔",
+			name: "Glitterz L-3 Nozzlenose",
+		},
+		{
+			text: "オーバーフロッシャー",
+			name: "Bloblobber",
+		},
+		{
+			text: "オーバーフロッシャーデコ",
+			name: "Bloblobber Deco",
+		},
+		{
+			text: "ヒッセン",
+			name: "Tri-Slosher",
+		},
+		{
+			text: "ヒッセン・ヒュー",
+			name: "Tri-Slosher Nouveau",
+		},
+		{
+			text: "ヒッセンASH",
+			name: "Tri-Slosher ASH-N",
+		},
+		{
+			text: "モップリン",
+			name: "Dread Wringer",
+		},
+		{
+			text: "モップリンD",
+			name: "Dread Wringer D",
+		},
+		{
+			text: "モップリン角",
+			name: "Hornz Dread Wringer",
+		},
+		{
+			text: "スクリュースロッシャー",
+			name: "Sloshing Machine",
+		},
+		{
+			text: "スクリュースロッシャーネオ",
+			name: "Sloshing Machine Neo",
+		},
+		{
+			text: "バケットスロッシャー",
+			name: "Slosher",
+		},
+		{
+			text: "バケットスロッシャーデコ",
+			name: "Slosher Deco",
+		},
+		{
+			text: "オーダースロッシャー レプリカ",
+			name: "Order Slosher Replica",
+		},
+		{
+			text: "エクスプロッシャー",
+			name: "Explosher",
+		},
+		{
+			text: "エクスプロッシャーカスタム",
+			name: "Custom Explosher",
+		},
+		{
+			text: "クーゲルシュライバー",
+			name: "Ballpoint Splatling",
+		},
+		{
+			text: "クーゲルシュライバー・ヒュー",
+			name: "Ballpoint Splatling Nouveau",
+		},
+		{
+			text: "イグザミナー",
+			name: "Heavy Edit Splatling",
+		},
+		{
+			text: "イグザミナー・ヒュー",
+			name: "Heavy Edit Splatling Nouveau",
+		},
+		{
+			text: "ハイドラント",
+			name: "Hydra Splatling",
+		},
+		{
+			text: "ハイドラントカスタム",
+			name: "Custom Hydra Splatling",
+		},
+		{
+			text: "ハイドラント圧",
+			name: "Torrentz Hydra Splatling",
+		},
+		{
+			text: "スプラスピナー",
+			name: "Mini Splatling",
+		},
+		{
+			text: "スプラスピナーコラボ",
+			name: "Zink Mini Splatling",
+		},
+		{
+			text: "スプラスピナーPYTN",
+			name: "Mini Splatling RTL-R",
+		},
+		{
+			text: "ノーチラス47",
+			name: "Nautilus 47",
+		},
+		{
+			text: "ノーチラス79",
+			name: "Nautilus 79",
+		},
+		{
+			text: "バレルスピナー",
+			name: "Heavy Splatling",
+		},
+		{
+			text: "バレルスピナーデコ",
+			name: "Heavy Splatling Deco",
+		},
+		{
+			text: "オーダースピナー レプリカ",
+			name: "Order Splatling Replica",
+		},
+		{
+			text: "フルイドV",
+			name: "Wellstring V",
+		},
+		{
+			text: "フルイドVカスタム",
+			name: "Custom Wellstring V",
+		},
+		{
+			text: "トライストリンガー",
+			name: "Tri-Stringer",
+		},
+		{
+			text: "トライストリンガーコラボ",
+			name: "Inkline Tri-Stringer",
+		},
+		{
+			text: "トライストリンガー燈",
+			name: "Bulbz Tri-Stringer",
+		},
+		{
+			text: "オーダーストリンガー レプリカ",
+			name: "Order Stringer Replica",
+		},
+		{
+			text: "LACT-450",
+			name: "REEF-LUX 450",
+		},
+		{
+			text: "LACT-450デコ",
+			name: "REEF-LUX 450 Deco",
+		},
+		{
+			text: "LACT-450MILK",
+			name: "REEF-LUX 450 MIL-K",
+		},
+		{
+			text: "ジャンプビーコン",
+			name: "Squid Beakon",
+		},
+		{
+			text: "カーリングボム",
+			name: "Curling Bomb",
+		},
+		{
+			text: "タンサンボム",
+			name: "Fizzy Bomb",
+		},
+		{
+			text: "クイックボム",
+			name: "Burst Bomb",
+		},
+		{
+			text: "ロボットボム",
+			name: "Autobomb",
+		},
+		{
+			text: "スプラッシュボム",
+			name: "Splat Bomb",
+		},
+		{
+			text: "キューバンボム",
+			name: "Suction Bomb",
+		},
+		{
+			text: "トーピード",
+			name: "Torpedo",
+		},
+		{
+			text: "ラインマーカー",
+			name: "Angle Shooter",
+		},
+		{
+			text: "ポイントセンサー",
+			name: "Point Sensor",
+		},
+		{
+			text: "ポイズンミスト",
+			name: "Toxic Mist",
+		},
+		{
+			text: "スプラッシュシールド",
+			name: "Splash Wall",
+		},
+		{
+			text: "スプリンクラー",
+			name: "Sprinkler",
+		},
+		{
+			text: "トラップ",
+			name: "Ink Mine",
+		},
+		{
+			text: "キューインキ",
+			name: "Ink Vac",
+		},
+		{
+			text: "テイオウイカ",
+			name: "Kraken Royale",
+		},
+		{
+			text: "カニタンク",
+			name: "Crab Tank",
+		},
+		{
+			text: "スミナガシート",
+			name: "Splattercolor Screen",
+		},
+		{
+			text: "エナジースタンド",
+			name: "Tacticooler",
+		},
+		{
+			text: "デコイチラシ",
+			name: "Super Chump",
+		},
+		{
+			text: "グレートバリア",
+			name: "Big Bubbler",
+		},
+		{
+			text: "アメフラシ",
+			name: "Ink Storm",
+		},
+		{
+			text: "ジェットパック",
+			name: "Inkjet",
+		},
+		{
+			text: "メガホンレーザー5.1ch",
+			name: "Killer Wail 5.1",
+		},
+		{
+			text: "マルチミサイル",
+			name: "Tenta Missiles",
+		},
+		{
+			text: "ナイスダマ",
+			name: "Booyah Bomb",
+		},
+		{
+			text: "ウルトラチャクチ",
+			name: "Triple Splashdown",
+		},
+		{
+			text: "ホップソナー",
+			name: "Wave Breaker",
+		},
+		{
+			text: "サメライド",
+			name: "Reefslider",
+		},
+		{
+			text: "ショクワンダー",
+			name: "Zipcaster",
+		},
+		{
+			text: "トリプルトルネード",
+			name: "Triple Inkstrike",
+		},
+		{
+			text: "ウルトラショット",
+			name: "Trizooka",
+		},
+		{
+			text: "ウルトラハンコ",
+			name: "Ultra Stamp",
+		},
+	],
+	KRko: [
+		{
+			text: "R 블래스터 엘리트",
+			name: "Rapid Blaster Pro",
+		},
+		{
+			text: "R 블래스터 엘리트 데코",
+			name: "Rapid Blaster Pro Deco",
+		},
+		{
+			text: "R 블래스터 엘리트 WNTR",
+			name: "Rapid Blaster Pro WNT-R",
+		},
+		{
+			text: "크래시 블래스터",
+			name: "Clash Blaster",
+		},
+		{
+			text: "네오 크래시 블래스터",
+			name: "Clash Blaster Neo",
+		},
+		{
+			text: "래피드 블래스터",
+			name: "Rapid Blaster",
+		},
+		{
+			text: "래피드 블래스터 데코",
+			name: "Rapid Blaster Deco",
+		},
+		{
+			text: "롱 블래스터",
+			name: "Range Blaster",
+		},
+		{
+			text: "커스텀 롱 블래스터",
+			name: "Custom Range Blaster",
+		},
+		{
+			text: "핫 블래스터",
+			name: "Blaster",
+		},
+		{
+			text: "커스텀 핫 블래스터",
+			name: "Custom Blaster",
+		},
+		{
+			text: "글림 핫 블래스터",
+			name: "Gleamz Blaster",
+		},
+		{
+			text: "S-BLAST92",
+			name: "S-BLAST '92",
+		},
+		{
+			text: "S-BLAST91",
+			name: "S-BLAST '91",
+		},
+		{
+			text: "노바 블래스터",
+			name: "Luna Blaster",
+		},
+		{
+			text: "네오 노바 블래스터",
+			name: "Luna Blaster Neo",
+		},
+		{
+			text: "오더 블래스터 레플리카",
+			name: "Order Blaster Replica",
+		},
+		{
+			text: "빈센트",
+			name: "Painbrush",
+		},
+		{
+			text: "빈센트 휴",
+			name: "Painbrush Nouveau",
+		},
+		{
+			text: "빈센트 BRNZ",
+			name: "Painbrush BRN-Z",
+		},
+		{
+			text: "파블로",
+			name: "Inkbrush",
+		},
+		{
+			text: "파블로 휴",
+			name: "Inkbrush Nouveau",
+		},
+		{
+			text: "호쿠사이",
+			name: "Octobrush",
+		},
+		{
+			text: "호쿠사이 휴",
+			name: "Octobrush Nouveau",
+		},
+		{
+			text: "코메트 호쿠사이",
+			name: "Cometz Octobrush",
+		},
+		{
+			text: "오더 브러시 레플리카",
+			name: "Orderbrush Replica",
+		},
+		{
+			text: "소이 튜버",
+			name: "Goo Tuber",
+		},
+		{
+			text: "커스텀 소이 튜버",
+			name: "Custom Goo Tuber",
+		},
+		{
+			text: "14식 대나무 총 갑",
+			name: "Bamboozler 14 Mk I",
+		},
+		{
+			text: "14식 대나무 총 을",
+			name: "Bamboozler 14 Mk II",
+		},
+		{
+			text: "4K 스코프",
+			name: "E-liter 4K Scope",
+		},
+		{
+			text: "커스텀 4K 스코프",
+			name: "Custom E-liter 4K Scope",
+		},
+		{
+			text: "리터 4K",
+			name: "E-liter 4K",
+		},
+		{
+			text: "커스텀 리터 4K",
+			name: "Custom E-liter 4K",
+		},
+		{
+			text: "스플랫 스코프",
+			name: "Splatterscope",
+		},
+		{
+			text: "스플랫 스코프 컬래버",
+			name: "Z+F Splatterscope",
+		},
+		{
+			text: "스플랫 스코프 FRST",
+			name: "Splatterscope CAM-O",
+		},
+		{
+			text: "스플랫 차저",
+			name: "Splat Charger",
+		},
+		{
+			text: "스플랫 차저 컬래버",
+			name: "Z+F Splat Charger",
+		},
+		{
+			text: "스플랫 차저 FRST",
+			name: "Splat Charger CAM-O",
+		},
+		{
+			text: "오더 차저 레플리카",
+			name: "Order Charger Replica",
+		},
+		{
+			text: "R-PEN/5H",
+			name: "Snipewriter 5H",
+		},
+		{
+			text: "R-PEN/5B",
+			name: "Snipewriter 5B",
+		},
+		{
+			text: "스퀵 클린 α",
+			name: "Classic Squiffer",
+		},
+		{
+			text: "스퀵 클린 β",
+			name: "New Squiffer",
+		},
+		{
+			text: "듀얼 스위퍼",
+			name: "Dualie Squelchers",
+		},
+		{
+			text: "커스텀 듀얼 스위퍼",
+			name: "Custom Dualie Squelchers",
+		},
+		{
+			text: "후프 듀얼 스위퍼",
+			name: "Hoofz Dualie Squelchers",
+		},
+		{
+			text: "켈빈 525",
+			name: "Glooga Dualies",
+		},
+		{
+			text: "켈빈 525 데코",
+			name: "Glooga Dualies Deco",
+		},
+		{
+			text: "소방 FF",
+			name: "Douser Dualies FF",
+		},
+		{
+			text: "커스텀 소방 FF",
+			name: "Custom Douser Dualies FF",
+		},
+		{
+			text: "스플랫 머누버",
+			name: "Splat Dualies",
+		},
+		{
+			text: "스플랫 머누버 컬래버",
+			name: "Enperry Splat Dualies",
+		},
+		{
+			text: "트윙클 스플랫 머누버",
+			name: "Twinklez Splat Dualies",
+		},
+		{
+			text: "오더 머누버 레플리카",
+			name: "Order Dualie Replicas",
+		},
+		{
+			text: "스퍼터리",
+			name: "Dapple Dualies",
+		},
+		{
+			text: "스퍼터리 휴",
+			name: "Dapple Dualies Nouveau",
+		},
+		{
+			text: "스퍼터리 OWL",
+			name: "Dapple Dualies NOC-T",
+		},
+		{
+			text: "블랙 쿼드 호퍼",
+			name: "Dark Tetra Dualies",
+		},
+		{
+			text: "화이트 쿼드 호퍼",
+			name: "Light Tetra Dualies",
+		},
+		{
+			text: "카본 롤러",
+			name: "Carbon Roller",
+		},
+		{
+			text: "카본 롤러 데코",
+			name: "Carbon Roller Deco",
+		},
+		{
+			text: "카본 롤러 ANGL",
+			name: "Carbon Roller ANG-L",
+		},
+		{
+			text: "다이너모 롤러",
+			name: "Dynamo Roller",
+		},
+		{
+			text: "골드 다이너모 롤러",
+			name: "Gold Dynamo Roller",
+		},
+		{
+			text: "스타 다이너모 롤러",
+			name: "Starz Dynamo Roller",
+		},
+		{
+			text: "베리어블 롤러",
+			name: "Flingza Roller",
+		},
+		{
+			text: "포일 베리어블 롤러",
+			name: "Foil Flingza Roller",
+		},
+		{
+			text: "스플랫 롤러",
+			name: "Splat Roller",
+		},
+		{
+			text: "스플랫 롤러 컬래버",
+			name: "Krak-On Splat Roller",
+		},
+		{
+			text: "오더 롤러 레플리카",
+			name: "Order Roller Replica",
+		},
+		{
+			text: "와이드 롤러",
+			name: "Big Swig Roller",
+		},
+		{
+			text: "와이드 롤러 컬래버",
+			name: "Big Swig Roller Express",
+		},
+		{
+			text: "플래닛 와이드 롤러",
+			name: "Planetz Big Swig Roller",
+		},
+		{
+			text: "민트 덴탈 와이퍼",
+			name: "Mint Decavitator",
+		},
+		{
+			text: "잉크 덴탈 와이퍼",
+			name: "Charcoal Decavitator",
+		},
+		{
+			text: "드라이브 와이퍼",
+			name: "Splatana Wiper",
+		},
+		{
+			text: "드라이브 와이퍼 데코",
+			name: "Splatana Wiper Deco",
+		},
+		{
+			text: "드라이브 와이퍼 RUST",
+			name: "Splatana Wiper RUS-T",
+		},
+		{
+			text: "사무 와이퍼",
+			name: "Splatana Stamper",
+		},
+		{
+			text: "사무 와이퍼 휴",
+			name: "Splatana Stamper Nouveau",
+		},
+		{
+			text: "스티커 사무 와이퍼",
+			name: "Stickerz Splatana Stamper",
+		},
+		{
+			text: "오더 와이퍼 레플리카",
+			name: "Order Splatana Replica",
+		},
+		{
+			text: "스파이 가젯",
+			name: "Undercover Brella",
+		},
+		{
+			text: "스파이 가젯 소렐라",
+			name: "Undercover Sorella Brella",
+		},
+		{
+			text: "패턴 스파이 가젯",
+			name: "Patternz Undercover Brella",
+		},
+		{
+			text: "24식 도돌이 우산 갑",
+			name: "Recycled Brella 24 Mk I",
+		},
+		{
+			text: "24식 도돌이 우산 을",
+			name: "Recycled Brella 24 Mk II",
+		},
+		{
+			text: "파라 셸터",
+			name: "Splat Brella",
+		},
+		{
+			text: "파라 셸터 소렐라",
+			name: "Sorella Brella",
+		},
+		{
+			text: "오더 셸터 레플리카",
+			name: "Order Brella Replica",
+		},
+		{
+			text: "캠핑 셸터",
+			name: "Tenta Brella",
+		},
+		{
+			text: "캠핑 셸터 소렐라",
+			name: "Tenta Sorella Brella",
+		},
+		{
+			text: "캠핑 셸터 CREM",
+			name: "Tenta Brella CRE-M",
+		},
+		{
+			text: "프로모델러 MG",
+			name: "Aerospray MG",
+		},
+		{
+			text: "프로모델러 RG",
+			name: "Aerospray RG",
+		},
+		{
+			text: "컬러 프로모델러",
+			name: "Colorz Aerospray",
+		},
+		{
+			text: "프라임 슈터",
+			name: "Splattershot Pro",
+		},
+		{
+			text: "프라임 슈터 컬래버",
+			name: "Forge Splattershot Pro",
+		},
+		{
+			text: "프라임 슈터 FRZN",
+			name: "Splattershot Pro FRZ-N",
+		},
+		{
+			text: "새싹 슈터",
+			name: "Splattershot Jr.",
+		},
+		{
+			text: "단풍 슈터",
+			name: "Custom Splattershot Jr.",
+		},
+		{
+			text: "보틀 가이저",
+			name: "Squeezer",
+		},
+		{
+			text: "포일 보틀 가이저",
+			name: "Foil Squeezer",
+		},
+		{
+			text: ".52 갤런",
+			name: ".52 Gal",
+		},
+		{
+			text: ".52 갤런 데코",
+			name: ".52 Gal Deco",
+		},
+		{
+			text: ".96 갤런",
+			name: ".96 Gal",
+		},
+		{
+			text: ".96 갤런 데코",
+			name: ".96 Gal Deco",
+		},
+		{
+			text: "클로 .96 갤런",
+			name: "Clawz .96 Gal",
+		},
+		{
+			text: "제트 스위퍼",
+			name: "Jet Squelcher",
+		},
+		{
+			text: "커스텀 제트 스위퍼",
+			name: "Custom Jet Squelcher",
+		},
+		{
+			text: "제트 스위퍼 COBR",
+			name: "Jet Squelcher COB-R",
+		},
+		{
+			text: "스플랫 슈터",
+			name: "Splattershot",
+		},
+		{
+			text: "스플랫 슈터 컬래버",
+			name: "Tentatek Splattershot",
+		},
+		{
+			text: "글램 스플랫 슈터",
+			name: "Glamorz Splattershot",
+		},
+		{
+			text: "히어로 슈터 레플리카",
+			name: "Hero Shot Replica",
+		},
+		{
+			text: "오더 슈터 레플리카",
+			name: "Order Shot Replica",
+		},
+		{
+			text: "옥타 슈터 레플리카",
+			name: "Octo Shot Replica",
+		},
+		{
+			text: "샤프 마커",
+			name: "Splash-o-matic",
+		},
+		{
+			text: "네오 샤프 마커",
+			name: "Neo Splash-o-matic",
+		},
+		{
+			text: "샤프 마커 GECK",
+			name: "Splash-o-matic GCK-O",
+		},
+		{
+			text: "스페이스 슈터",
+			name: "Splattershot Nova",
+		},
+		{
+			text: "스페이스 슈터 컬래버",
+			name: "Annaki Splattershot Nova",
+		},
+		{
+			text: "N-ZAP85",
+			name: "N-ZAP '85",
+		},
+		{
+			text: "N-ZAP89",
+			name: "N-ZAP '89",
+		},
+		{
+			text: "볼드 마커",
+			name: "Sploosh-o-matic",
+		},
+		{
+			text: "네오 볼드 마커",
+			name: "Neo Sploosh-o-matic",
+		},
+		{
+			text: "H3 릴 건",
+			name: "H-3 Nozzlenose",
+		},
+		{
+			text: "H3 릴 건 D",
+			name: "H-3 Nozzlenose D",
+		},
+		{
+			text: "H3 릴 건 SNAK",
+			name: "H-3 Nozzlenose VIP-R",
+		},
+		{
+			text: "L3 릴 건",
+			name: "L-3 Nozzlenose",
+		},
+		{
+			text: "L3 릴 건 D",
+			name: "L-3 Nozzlenose D",
+		},
+		{
+			text: "글리터 L3 릴 건",
+			name: "Glitterz L-3 Nozzlenose",
+		},
+		{
+			text: "오버플로셔",
+			name: "Bloblobber",
+		},
+		{
+			text: "오버플로셔 데코",
+			name: "Bloblobber Deco",
+		},
+		{
+			text: "물통",
+			name: "Tri-Slosher",
+		},
+		{
+			text: "물통 휴",
+			name: "Tri-Slosher Nouveau",
+		},
+		{
+			text: "물통 ASH",
+			name: "Tri-Slosher ASH-N",
+		},
+		{
+			text: "몹 링",
+			name: "Dread Wringer",
+		},
+		{
+			text: "몹 링 D",
+			name: "Dread Wringer D",
+		},
+		{
+			text: "혼 몹 링",
+			name: "Hornz Dread Wringer",
+		},
+		{
+			text: "스크루 슬로셔",
+			name: "Sloshing Machine",
+		},
+		{
+			text: "네오 스크루 슬로셔",
+			name: "Sloshing Machine Neo",
+		},
+		{
+			text: "버킷 슬로셔",
+			name: "Slosher",
+		},
+		{
+			text: "버킷 슬로셔 데코",
+			name: "Slosher Deco",
+		},
+		{
+			text: "오더 슬로셔 레플리카",
+			name: "Order Slosher Replica",
+		},
+		{
+			text: "익스플로셔",
+			name: "Explosher",
+		},
+		{
+			text: "커스텀 익스플로셔",
+			name: "Custom Explosher",
+		},
+		{
+			text: "쿠겔 슈라이버",
+			name: "Ballpoint Splatling",
+		},
+		{
+			text: "쿠겔 슈라이버 휴",
+			name: "Ballpoint Splatling Nouveau",
+		},
+		{
+			text: "이그재미너",
+			name: "Heavy Edit Splatling",
+		},
+		{
+			text: "이그재미너 휴",
+			name: "Heavy Edit Splatling Nouveau",
+		},
+		{
+			text: "하이드런트",
+			name: "Hydra Splatling",
+		},
+		{
+			text: "커스텀 하이드런트",
+			name: "Custom Hydra Splatling",
+		},
+		{
+			text: "토렌트 하이드런트",
+			name: "Torrentz Hydra Splatling",
+		},
+		{
+			text: "스플랫 스피너",
+			name: "Mini Splatling",
+		},
+		{
+			text: "스플랫 스피너 컬래버",
+			name: "Zink Mini Splatling",
+		},
+		{
+			text: "스플랫 스피너 PYTN",
+			name: "Mini Splatling RTL-R",
+		},
+		{
+			text: "노틸러스 47",
+			name: "Nautilus 47",
+		},
+		{
+			text: "노틸러스 79",
+			name: "Nautilus 79",
+		},
+		{
+			text: "배럴 스피너",
+			name: "Heavy Splatling",
+		},
+		{
+			text: "배럴 스피너 데코",
+			name: "Heavy Splatling Deco",
+		},
+		{
+			text: "오더 스피너 레플리카",
+			name: "Order Splatling Replica",
+		},
+		{
+			text: "플루이드 V",
+			name: "Wellstring V",
+		},
+		{
+			text: "커스텀 플루이드 V",
+			name: "Custom Wellstring V",
+		},
+		{
+			text: "트라이 스트링거",
+			name: "Tri-Stringer",
+		},
+		{
+			text: "트라이 스트링거 컬래버",
+			name: "Inkline Tri-Stringer",
+		},
+		{
+			text: "벌브 트라이 스트링거",
+			name: "Bulbz Tri-Stringer",
+		},
+		{
+			text: "오더 스트링거 레플리카",
+			name: "Order Stringer Replica",
+		},
+		{
+			text: "LACT-450",
+			name: "REEF-LUX 450",
+		},
+		{
+			text: "LACT-450 데코",
+			name: "REEF-LUX 450 Deco",
+		},
+		{
+			text: "LACT-450 MILK",
+			name: "REEF-LUX 450 MIL-K",
+		},
+		{
+			text: "점프 비컨",
+			name: "Squid Beakon",
+		},
+		{
+			text: "컬링 밤",
+			name: "Curling Bomb",
+		},
+		{
+			text: "탄산 밤",
+			name: "Fizzy Bomb",
+		},
+		{
+			text: "퀵 밤",
+			name: "Burst Bomb",
+		},
+		{
+			text: "로봇 밤",
+			name: "Autobomb",
+		},
+		{
+			text: "스플래시 밤",
+			name: "Splat Bomb",
+		},
+		{
+			text: "빨판 밤",
+			name: "Suction Bomb",
+		},
+		{
+			text: "토피도",
+			name: "Torpedo",
+		},
+		{
+			text: "라인 마커",
+			name: "Angle Shooter",
+		},
+		{
+			text: "포인트 센서",
+			name: "Point Sensor",
+		},
+		{
+			text: "포이즌 미스트",
+			name: "Toxic Mist",
+		},
+		{
+			text: "스플래시 실드",
+			name: "Splash Wall",
+		},
+		{
+			text: "스프링클러",
+			name: "Sprinkler",
+		},
+		{
+			text: "트랩",
+			name: "Ink Mine",
+		},
+		{
+			text: "흡입기",
+			name: "Ink Vac",
+		},
+		{
+			text: "로열 크라켄",
+			name: "Kraken Royale",
+		},
+		{
+			text: "크랩 탱크",
+			name: "Crab Tank",
+		},
+		{
+			text: "스플래터컬러 스크린",
+			name: "Splattercolor Screen",
+		},
+		{
+			text: "에너지 스탠드",
+			name: "Tacticooler",
+		},
+		{
+			text: "디코이 캐넌",
+			name: "Super Chump",
+		},
+		{
+			text: "그레이트 배리어",
+			name: "Big Bubbler",
+		},
+		{
+			text: "먹구름",
+			name: "Ink Storm",
+		},
+		{
+			text: "제트 팩",
+			name: "Inkjet",
+		},
+		{
+			text: "메가폰 레이저 5.1ch",
+			name: "Killer Wail 5.1",
+		},
+		{
+			text: "멀티 미사일",
+			name: "Tenta Missiles",
+		},
+		{
+			text: "나이스옥",
+			name: "Booyah Bomb",
+		},
+		{
+			text: "울트라 착지",
+			name: "Triple Splashdown",
+		},
+		{
+			text: "홉 소나",
+			name: "Wave Breaker",
+		},
+		{
+			text: "샤크 라이드",
+			name: "Reefslider",
+		},
+		{
+			text: "쇼크 원더",
+			name: "Zipcaster",
+		},
+		{
+			text: "트리플 토네이도",
+			name: "Triple Inkstrike",
+		},
+		{
+			text: "울트라 샷",
+			name: "Trizooka",
+		},
+		{
+			text: "울트라 스탬프",
+			name: "Ultra Stamp",
+		},
+	],
+	TWzh: [
+		{
+			text: "快速爆破槍 精英",
+			name: "Rapid Blaster Pro",
+		},
+		{
+			text: "快速爆破槍 精英裝飾",
+			name: "Rapid Blaster Pro Deco",
+		},
+		{
+			text: "快速爆破槍 精英WNTR",
+			name: "Rapid Blaster Pro WNT-R",
+		},
+		{
+			text: "衝塗爆破槍",
+			name: "Clash Blaster",
+		},
+		{
+			text: "衝塗爆破槍 新型",
+			name: "Clash Blaster Neo",
+		},
+		{
+			text: "快速爆破槍",
+			name: "Rapid Blaster",
+		},
+		{
+			text: "快速爆破槍 裝飾",
+			name: "Rapid Blaster Deco",
+		},
+		{
+			text: "遠距爆破槍",
+			name: "Range Blaster",
+		},
+		{
+			text: "遠距爆破槍 改裝",
+			name: "Custom Range Blaster",
+		},
+		{
+			text: "火熱爆破槍",
+			name: "Blaster",
+		},
+		{
+			text: "火熱爆破槍 改裝",
+			name: "Custom Blaster",
+		},
+		{
+			text: "火熱爆破槍 艷",
+			name: "Gleamz Blaster",
+		},
+		{
+			text: "S-BLAST92",
+			name: "S-BLAST '92",
+		},
+		{
+			text: "S-BLAST91",
+			name: "S-BLAST '91",
+		},
+		{
+			text: "新星爆破槍",
+			name: "Luna Blaster",
+		},
+		{
+			text: "新星爆破槍 新型",
+			name: "Luna Blaster Neo",
+		},
+		{
+			text: "秩序爆破槍 複製",
+			name: "Order Blaster Replica",
+		},
+		{
+			text: "文森",
+			name: "Painbrush",
+		},
+		{
+			text: "文森‧新藝術",
+			name: "Painbrush Nouveau",
+		},
+		{
+			text: "文森BRNZ",
+			name: "Painbrush BRN-Z",
+		},
+		{
+			text: "巴勃羅",
+			name: "Inkbrush",
+		},
+		{
+			text: "巴勃羅‧新藝術",
+			name: "Inkbrush Nouveau",
+		},
+		{
+			text: "北齋",
+			name: "Octobrush",
+		},
+		{
+			text: "北齋‧新藝術",
+			name: "Octobrush Nouveau",
+		},
+		{
+			text: "北齋 彗",
+			name: "Cometz Octobrush",
+		},
+		{
+			text: "秩序排刷 複製",
+			name: "Orderbrush Replica",
+		},
+		{
+			text: "高壓油管槍",
+			name: "Goo Tuber",
+		},
+		{
+			text: "高壓油管槍 改裝",
+			name: "Custom Goo Tuber",
+		},
+		{
+			text: "14式竹筒槍‧甲",
+			name: "Bamboozler 14 Mk I",
+		},
+		{
+			text: "14式竹筒槍‧乙",
+			name: "Bamboozler 14 Mk II",
+		},
+		{
+			text: "4K準星槍",
+			name: "E-liter 4K Scope",
+		},
+		{
+			text: "4K準星槍 改裝",
+			name: "Custom E-liter 4K Scope",
+		},
+		{
+			text: "公升4K",
+			name: "E-liter 4K",
+		},
+		{
+			text: "公升4K 改裝",
+			name: "Custom E-liter 4K",
+		},
+		{
+			text: "斯普拉準星槍",
+			name: "Splatterscope",
+		},
+		{
+			text: "斯普拉準星槍 聯名",
+			name: "Z+F Splatterscope",
+		},
+		{
+			text: "斯普拉準星槍FRST",
+			name: "Splatterscope CAM-O",
+		},
+		{
+			text: "斯普拉蓄力狙擊槍",
+			name: "Splat Charger",
+		},
+		{
+			text: "斯普拉蓄力狙擊槍 聯名",
+			name: "Z+F Splat Charger",
+		},
+		{
+			text: "斯普拉蓄力狙擊槍FRST",
+			name: "Splat Charger CAM-O",
+		},
+		{
+			text: "秩序蓄力狙擊槍 複製",
+			name: "Order Charger Replica",
+		},
+		{
+			text: "R-PEN/5H",
+			name: "Snipewriter 5H",
+		},
+		{
+			text: "R-PEN/5B",
+			name: "Snipewriter 5B",
+		},
+		{
+			text: "魷快潔α",
+			name: "Classic Squiffer",
+		},
+		{
+			text: "魷快潔β",
+			name: "New Squiffer",
+		},
+		{
+			text: "雙重清潔槍",
+			name: "Dualie Squelchers",
+		},
+		{
+			text: "雙重清潔槍 改裝",
+			name: "Custom Dualie Squelchers",
+		},
+		{
+			text: "雙重清潔槍 蹄",
+			name: "Hoofz Dualie Squelchers",
+		},
+		{
+			text: "開爾文525",
+			name: "Glooga Dualies",
+		},
+		{
+			text: "開爾文525 裝飾",
+			name: "Glooga Dualies Deco",
+		},
+		{
+			text: "滅熄FF",
+			name: "Douser Dualies FF",
+		},
+		{
+			text: "滅熄FF 改裝",
+			name: "Custom Douser Dualies FF",
+		},
+		{
+			text: "斯普拉機動槍",
+			name: "Splat Dualies",
+		},
+		{
+			text: "斯普拉機動槍 聯名",
+			name: "Enperry Splat Dualies",
+		},
+		{
+			text: "斯普拉機動槍 耀",
+			name: "Twinklez Splat Dualies",
+		},
+		{
+			text: "秩序機動槍 複製",
+			name: "Order Dualie Replicas",
+		},
+		{
+			text: "濺鍍槍",
+			name: "Dapple Dualies",
+		},
+		{
+			text: "濺鍍槍‧新藝術",
+			name: "Dapple Dualies Nouveau",
+		},
+		{
+			text: "濺鍍槍OWL",
+			name: "Dapple Dualies NOC-T",
+		},
+		{
+			text: "四重彈跳手槍 黑",
+			name: "Dark Tetra Dualies",
+		},
+		{
+			text: "四重彈跳手槍 白",
+			name: "Light Tetra Dualies",
+		},
+		{
+			text: "碳纖維滾筒",
+			name: "Carbon Roller",
+		},
+		{
+			text: "碳纖維滾筒 裝飾",
+			name: "Carbon Roller Deco",
+		},
+		{
+			text: "碳纖維滾筒ANGL",
+			name: "Carbon Roller ANG-L",
+		},
+		{
+			text: "電動馬達滾筒",
+			name: "Dynamo Roller",
+		},
+		{
+			text: "電動馬達滾筒 高磁波",
+			name: "Gold Dynamo Roller",
+		},
+		{
+			text: "電動馬達滾筒 冥",
+			name: "Starz Dynamo Roller",
+		},
+		{
+			text: "可變式滾筒",
+			name: "Flingza Roller",
+		},
+		{
+			text: "可變式滾筒 金屬箔",
+			name: "Foil Flingza Roller",
+		},
+		{
+			text: "斯普拉滾筒",
+			name: "Splat Roller",
+		},
+		{
+			text: "斯普拉滾筒 聯名",
+			name: "Krak-On Splat Roller",
+		},
+		{
+			text: "秩序滾筒 複製",
+			name: "Order Roller Replica",
+		},
+		{
+			text: "寬滾筒",
+			name: "Big Swig Roller",
+		},
+		{
+			text: "寬滾筒 聯名",
+			name: "Big Swig Roller Express",
+		},
+		{
+			text: "寬滾筒 惑",
+			name: "Planetz Big Swig Roller",
+		},
+		{
+			text: "巨齒刮水刀 薄荷",
+			name: "Mint Decavitator",
+		},
+		{
+			text: "巨齒刮水刀 墨黑",
+			name: "Charcoal Decavitator",
+		},
+		{
+			text: "雨刷刮水刀",
+			name: "Splatana Wiper",
+		},
+		{
+			text: "雨刷刮水刀 裝飾",
+			name: "Splatana Wiper Deco",
+		},
+		{
+			text: "雨刷刮水刀RUST",
+			name: "Splatana Wiper RUS-T",
+		},
+		{
+			text: "工作刮水刀",
+			name: "Splatana Stamper",
+		},
+		{
+			text: "工作刮水刀‧新藝術",
+			name: "Splatana Stamper Nouveau",
+		},
+		{
+			text: "工作刮水刀 封",
+			name: "Stickerz Splatana Stamper",
+		},
+		{
+			text: "秩序刮水刀 複製",
+			name: "Order Splatana Replica",
+		},
+		{
+			text: "特務配件",
+			name: "Undercover Brella",
+		},
+		{
+			text: "特務配件 姐妹",
+			name: "Undercover Sorella Brella",
+		},
+		{
+			text: "特務配件 繚",
+			name: "Patternz Undercover Brella",
+		},
+		{
+			text: "24式可替換傘‧甲",
+			name: "Recycled Brella 24 Mk I",
+		},
+		{
+			text: "24式可替換傘‧乙",
+			name: "Recycled Brella 24 Mk II",
+		},
+		{
+			text: "遮陽防空傘",
+			name: "Splat Brella",
+		},
+		{
+			text: "遮陽防空傘 姐妹",
+			name: "Sorella Brella",
+		},
+		{
+			text: "秩序防空傘 複製",
+			name: "Order Brella Replica",
+		},
+		{
+			text: "露營防空傘",
+			name: "Tenta Brella",
+		},
+		{
+			text: "露營防空傘 姐妹",
+			name: "Tenta Sorella Brella",
+		},
+		{
+			text: "露營防空傘CREM",
+			name: "Tenta Brella CRE-M",
+		},
+		{
+			text: "專業模型槍MG",
+			name: "Aerospray MG",
+		},
+		{
+			text: "專業模型槍RG",
+			name: "Aerospray RG",
+		},
+		{
+			text: "專業模型槍 彩",
+			name: "Colorz Aerospray",
+		},
+		{
+			text: "頂尖射擊槍",
+			name: "Splattershot Pro",
+		},
+		{
+			text: "頂尖射擊槍 聯名",
+			name: "Forge Splattershot Pro",
+		},
+		{
+			text: "頂尖射擊槍FRZN",
+			name: "Splattershot Pro FRZ-N",
+		},
+		{
+			text: "新葉射擊槍",
+			name: "Splattershot Jr.",
+		},
+		{
+			text: "楓葉射擊槍",
+			name: "Custom Splattershot Jr.",
+		},
+		{
+			text: "開瓶噴泉槍",
+			name: "Squeezer",
+		},
+		{
+			text: "開瓶噴泉槍 金屬箔",
+			name: "Foil Squeezer",
+		},
+		{
+			text: ".52加侖",
+			name: ".52 Gal",
+		},
+		{
+			text: ".52加侖 裝飾",
+			name: ".52 Gal Deco",
+		},
+		{
+			text: ".96加侖",
+			name: ".96 Gal",
+		},
+		{
+			text: ".96加侖 裝飾",
+			name: ".96 Gal Deco",
+		},
+		{
+			text: ".96加侖 爪",
+			name: "Clawz .96 Gal",
+		},
+		{
+			text: "噴射清潔槍",
+			name: "Jet Squelcher",
+		},
+		{
+			text: "噴射清潔槍 改裝",
+			name: "Custom Jet Squelcher",
+		},
+		{
+			text: "噴射清潔槍COBR",
+			name: "Jet Squelcher COB-R",
+		},
+		{
+			text: "斯普拉射擊槍",
+			name: "Splattershot",
+		},
+		{
+			text: "斯普拉射擊槍 聯名",
+			name: "Tentatek Splattershot",
+		},
+		{
+			text: "斯普拉射擊槍 煌",
+			name: "Glamorz Splattershot",
+		},
+		{
+			text: "英雄射擊槍 複製",
+			name: "Hero Shot Replica",
+		},
+		{
+			text: "秩序射擊槍 複製",
+			name: "Order Shot Replica",
+		},
+		{
+			text: "章魚射擊槍 複製",
+			name: "Octo Shot Replica",
+		},
+		{
+			text: "窄域標記槍",
+			name: "Splash-o-matic",
+		},
+		{
+			text: "窄域標記槍 新型",
+			name: "Neo Splash-o-matic",
+		},
+		{
+			text: "窄域標記槍GECK",
+			name: "Splash-o-matic GCK-O",
+		},
+		{
+			text: "太空射擊槍",
+			name: "Splattershot Nova",
+		},
+		{
+			text: "太空射擊槍 聯名",
+			name: "Annaki Splattershot Nova",
+		},
+		{
+			text: "N-ZAP85",
+			name: "N-ZAP '85",
+		},
+		{
+			text: "N-ZAP89",
+			name: "N-ZAP '89",
+		},
+		{
+			text: "廣域標記槍",
+			name: "Sploosh-o-matic",
+		},
+		{
+			text: "廣域標記槍 新型",
+			name: "Neo Sploosh-o-matic",
+		},
+		{
+			text: "H3捲管槍",
+			name: "H-3 Nozzlenose",
+		},
+		{
+			text: "H3捲管槍D",
+			name: "H-3 Nozzlenose D",
+		},
+		{
+			text: "H3捲管槍SNAK",
+			name: "H-3 Nozzlenose VIP-R",
+		},
+		{
+			text: "L3捲管槍",
+			name: "L-3 Nozzlenose",
+		},
+		{
+			text: "L3捲管槍D",
+			name: "L-3 Nozzlenose D",
+		},
+		{
+			text: "L3捲管槍 箔",
+			name: "Glitterz L-3 Nozzlenose",
+		},
+		{
+			text: "滿溢泡澡潑桶",
+			name: "Bloblobber",
+		},
+		{
+			text: "滿溢泡澡潑桶 裝飾",
+			name: "Bloblobber Deco",
+		},
+		{
+			text: "洗筆桶",
+			name: "Tri-Slosher",
+		},
+		{
+			text: "洗筆桶‧新藝術",
+			name: "Tri-Slosher Nouveau",
+		},
+		{
+			text: "洗筆桶ASH",
+			name: "Tri-Slosher ASH-N",
+		},
+		{
+			text: "墨瀑淋",
+			name: "Dread Wringer",
+		},
+		{
+			text: "墨瀑淋D",
+			name: "Dread Wringer D",
+		},
+		{
+			text: "墨瀑淋 角",
+			name: "Hornz Dread Wringer",
+		},
+		{
+			text: "迴旋潑桶",
+			name: "Sloshing Machine",
+		},
+		{
+			text: "迴旋潑桶 新型",
+			name: "Sloshing Machine Neo",
+		},
+		{
+			text: "飛濺潑桶",
+			name: "Slosher",
+		},
+		{
+			text: "飛濺潑桶 裝飾",
+			name: "Slosher Deco",
+		},
+		{
+			text: "秩序潑桶 複製",
+			name: "Order Slosher Replica",
+		},
+		{
+			text: "爆炸潑桶",
+			name: "Explosher",
+		},
+		{
+			text: "爆炸潑桶 改裝",
+			name: "Custom Explosher",
+		},
+		{
+			text: "圓珠筆",
+			name: "Ballpoint Splatling",
+		},
+		{
+			text: "圓珠筆‧新藝術",
+			name: "Ballpoint Splatling Nouveau",
+		},
+		{
+			text: "審查者",
+			name: "Heavy Edit Splatling",
+		},
+		{
+			text: "審查者‧新藝術",
+			name: "Heavy Edit Splatling Nouveau",
+		},
+		{
+			text: "消防栓旋轉槍",
+			name: "Hydra Splatling",
+		},
+		{
+			text: "消防栓旋轉槍 改裝",
+			name: "Custom Hydra Splatling",
+		},
+		{
+			text: "消防栓旋轉槍 壓",
+			name: "Torrentz Hydra Splatling",
+		},
+		{
+			text: "斯普拉旋轉槍",
+			name: "Mini Splatling",
+		},
+		{
+			text: "斯普拉旋轉槍 聯名",
+			name: "Zink Mini Splatling",
+		},
+		{
+			text: "斯普拉旋轉槍PYTN",
+			name: "Mini Splatling RTL-R",
+		},
+		{
+			text: "鸚鵡螺號47",
+			name: "Nautilus 47",
+		},
+		{
+			text: "鸚鵡螺號79",
+			name: "Nautilus 79",
+		},
+		{
+			text: "桶裝旋轉槍",
+			name: "Heavy Splatling",
+		},
+		{
+			text: "桶裝旋轉槍 裝飾",
+			name: "Heavy Splatling Deco",
+		},
+		{
+			text: "秩序旋轉槍 複製",
+			name: "Order Splatling Replica",
+		},
+		{
+			text: "邦普V",
+			name: "Wellstring V",
+		},
+		{
+			text: "邦普V 改裝",
+			name: "Custom Wellstring V",
+		},
+		{
+			text: "三發獵魚弓",
+			name: "Tri-Stringer",
+		},
+		{
+			text: "三發獵魚弓 聯名",
+			name: "Inkline Tri-Stringer",
+		},
+		{
+			text: "三發獵魚弓 燈",
+			name: "Bulbz Tri-Stringer",
+		},
+		{
+			text: "秩序獵魚弓 複製",
+			name: "Order Stringer Replica",
+		},
+		{
+			text: "LACT-450",
+			name: "REEF-LUX 450",
+		},
+		{
+			text: "LACT-450 裝飾",
+			name: "REEF-LUX 450 Deco",
+		},
+		{
+			text: "LACT-450MILK",
+			name: "REEF-LUX 450 MIL-K",
+		},
+		{
+			text: "跳躍信標",
+			name: "Squid Beakon",
+		},
+		{
+			text: "冰壺炸彈",
+			name: "Curling Bomb",
+		},
+		{
+			text: "碳酸炸彈",
+			name: "Fizzy Bomb",
+		},
+		{
+			text: "快速炸彈",
+			name: "Burst Bomb",
+		},
+		{
+			text: "機器人炸彈",
+			name: "Autobomb",
+		},
+		{
+			text: "斯普拉炸彈",
+			name: "Splat Bomb",
+		},
+		{
+			text: "吸盤炸彈",
+			name: "Suction Bomb",
+		},
+		{
+			text: "魚雷",
+			name: "Torpedo",
+		},
+		{
+			text: "標線器",
+			name: "Angle Shooter",
+		},
+		{
+			text: "定點偵測器",
+			name: "Point Sensor",
+		},
+		{
+			text: "毒霧",
+			name: "Toxic Mist",
+		},
+		{
+			text: "斯普拉防護牆",
+			name: "Splash Wall",
+		},
+		{
+			text: "灑墨器",
+			name: "Sprinkler",
+		},
+		{
+			text: "墨汁陷阱",
+			name: "Ink Mine",
+		},
+		{
+			text: "吸墨機",
+			name: "Ink Vac",
+		},
+		{
+			text: "帝王魷魚",
+			name: "Kraken Royale",
+		},
+		{
+			text: "螃蟹坦克",
+			name: "Crab Tank",
+		},
+		{
+			text: "浮墨幕牆",
+			name: "Splattercolor Screen",
+		},
+		{
+			text: "能量站",
+			name: "Tacticooler",
+		},
+		{
+			text: "誘餌煙火",
+			name: "Super Chump",
+		},
+		{
+			text: "巨大防護罩",
+			name: "Big Bubbler",
+		},
+		{
+			text: "墨雨雲",
+			name: "Ink Storm",
+		},
+		{
+			text: "噴射背包",
+			name: "Inkjet",
+		},
+		{
+			text: "喇叭雷射5.1ch",
+			name: "Killer Wail 5.1",
+		},
+		{
+			text: "多重導彈",
+			name: "Tenta Missiles",
+		},
+		{
+			text: "讚氣彈",
+			name: "Booyah Bomb",
+		},
+		{
+			text: "終極著陸",
+			name: "Triple Splashdown",
+		},
+		{
+			text: "彈跳聲納",
+			name: "Wave Breaker",
+		},
+		{
+			text: "鯊魚坐騎",
+			name: "Reefslider",
+		},
+		{
+			text: "觸手噴射",
+			name: "Zipcaster",
+		},
+		{
+			text: "三重龍捲風",
+			name: "Triple Inkstrike",
+		},
+		{
+			text: "終極發射",
+			name: "Trizooka",
+		},
+		{
+			text: "終極印章",
+			name: "Ultra Stamp",
+		},
+	],
+	USes: [
+		{
+			text: "Turbolanzamotas Pro",
+			name: "Rapid Blaster Pro",
+		},
+		{
+			text: "Turbolanzamotas Pro chic",
+			name: "Rapid Blaster Pro Deco",
+		},
+		{
+			text: "Turbolanzamotas INV",
+			name: "Rapid Blaster Pro WNT-R",
+		},
+		{
+			text: "Hiperlanzamotas",
+			name: "Clash Blaster",
+		},
+		{
+			text: "Hiperlanzamotas neo",
+			name: "Clash Blaster Neo",
+		},
+		{
+			text: "Turbolanzamotas",
+			name: "Rapid Blaster",
+		},
+		{
+			text: "Turbolanzamotas chic",
+			name: "Rapid Blaster Deco",
+		},
+		{
+			text: "Telelanzamotas",
+			name: "Range Blaster",
+		},
+		{
+			text: "Telelanzamotas adaptado",
+			name: "Custom Range Blaster",
+		},
+		{
+			text: "Lanzamotas",
+			name: "Blaster",
+		},
+		{
+			text: "Lanzamotas adaptado",
+			name: "Custom Blaster",
+		},
+		{
+			text: "Lanzamotas DSX",
+			name: "Gleamz Blaster",
+		},
+		{
+			text: "L-MOT 92",
+			name: "S-BLAST '92",
+		},
+		{
+			text: "L-MOT 91",
+			name: "S-BLAST '91",
+		},
+		{
+			text: "Lanzamotas Nova",
+			name: "Luna Blaster",
+		},
+		{
+			text: "Lanzamotas Nova neo",
+			name: "Luna Blaster Neo",
+		},
+		{
+			text: "Lanzamotas orden réplica",
+			name: "Order Blaster Replica",
+		},
+		{
+			text: "Pincel abanico",
+			name: "Painbrush",
+		},
+		{
+			text: "Pincel abanico maestro",
+			name: "Painbrush Nouveau",
+		},
+		{
+			text: "Pincel abanico BNC",
+			name: "Painbrush BRN-Z",
+		},
+		{
+			text: "Pincel",
+			name: "Inkbrush",
+		},
+		{
+			text: "Pincel maestro",
+			name: "Inkbrush Nouveau",
+		},
+		{
+			text: "Pincel caligrafía",
+			name: "Octobrush",
+		},
+		{
+			text: "Pincel caligrafía maestro",
+			name: "Octobrush Nouveau",
+		},
+		{
+			text: "Pincel caligrafía CMX",
+			name: "Cometz Octobrush",
+		},
+		{
+			text: "Pincel caligrafía orden réplica",
+			name: "Orderbrush Replica",
+		},
+		{
+			text: "Entintubo",
+			name: "Goo Tuber",
+		},
+		{
+			text: "Entintubo adaptado",
+			name: "Custom Goo Tuber",
+		},
+		{
+			text: "Bamzuka 14-I",
+			name: "Bamboozler 14 Mk I",
+		},
+		{
+			text: "Bamzuka 14-II",
+			name: "Bamboozler 14 Mk II",
+		},
+		{
+			text: "Telentintador 4K",
+			name: "E-liter 4K Scope",
+		},
+		{
+			text: "Telentintador 4K adaptado",
+			name: "Custom E-liter 4K Scope",
+		},
+		{
+			text: "Entintador 4K",
+			name: "E-liter 4K",
+		},
+		{
+			text: "Entintador 4K adaptado",
+			name: "Custom E-liter 4K",
+		},
+		{
+			text: "Telecargatintas",
+			name: "Splatterscope",
+		},
+		{
+			text: "Telecargatintas ZyS",
+			name: "Z+F Splatterscope",
+		},
+		{
+			text: "Telecargatintas BSQ",
+			name: "Splatterscope CAM-O",
+		},
+		{
+			text: "Cargatintas",
+			name: "Splat Charger",
+		},
+		{
+			text: "Cargatintas ZyS",
+			name: "Z+F Splat Charger",
+		},
+		{
+			text: "Cargatintas BSQ",
+			name: "Splat Charger CAM-O",
+		},
+		{
+			text: "Cargatintas orden réplica",
+			name: "Order Charger Replica",
+		},
+		{
+			text: "Cargaminas 5H",
+			name: "Snipewriter 5H",
+		},
+		{
+			text: "Cargaminas 5B",
+			name: "Snipewriter 5B",
+		},
+		{
+			text: "Delineador X",
+			name: "Classic Squiffer",
+		},
+		{
+			text: "Delineador Y",
+			name: "New Squiffer",
+		},
+		{
+			text: "Soplador dual",
+			name: "Dualie Squelchers",
+		},
+		{
+			text: "Soplador dual adaptado",
+			name: "Custom Dualie Squelchers",
+		},
+		{
+			text: "Soplador dual RYX",
+			name: "Hoofz Dualie Squelchers",
+		},
+		{
+			text: "Fundidora 525 dual",
+			name: "Glooga Dualies",
+		},
+		{
+			text: "Fundidora 525 dual chic",
+			name: "Glooga Dualies Deco",
+		},
+		{
+			text: "Extintor dual FF",
+			name: "Douser Dualies FF",
+		},
+		{
+			text: "Extintor dual FF adaptado",
+			name: "Custom Douser Dualies FF",
+		},
+		{
+			text: "Difusor dual",
+			name: "Splat Dualies",
+		},
+		{
+			text: "Difusor dual Emperi",
+			name: "Enperry Splat Dualies",
+		},
+		{
+			text: "Difusor dual CHX",
+			name: "Twinklez Splat Dualies",
+		},
+		{
+			text: "Difusor dual orden réplica",
+			name: "Order Dualie Replicas",
+		},
+		{
+			text: "Atomizador dual",
+			name: "Dapple Dualies",
+		},
+		{
+			text: "Atomizador dual maestro",
+			name: "Dapple Dualies Nouveau",
+		},
+		{
+			text: "Atomizador dual NCT",
+			name: "Dapple Dualies NOC-T",
+		},
+		{
+			text: "Tetra dual negro",
+			name: "Dark Tetra Dualies",
+		},
+		{
+			text: "Tetra dual blanco",
+			name: "Light Tetra Dualies",
+		},
+		{
+			text: "Rodillo de carbono",
+			name: "Carbon Roller",
+		},
+		{
+			text: "Rodillo de carbono chic",
+			name: "Carbon Roller Deco",
+		},
+		{
+			text: "Rodillo de carbono ABL",
+			name: "Carbon Roller ANG-L",
+		},
+		{
+			text: "Rodillo Pro",
+			name: "Dynamo Roller",
+		},
+		{
+			text: "Rodillo Pro dorado",
+			name: "Gold Dynamo Roller",
+		},
+		{
+			text: "Rodillo Pro CSX",
+			name: "Starz Dynamo Roller",
+		},
+		{
+			text: "Rodillo versátil",
+			name: "Flingza Roller",
+		},
+		{
+			text: "Rodillo versátil Foil",
+			name: "Foil Flingza Roller",
+		},
+		{
+			text: "Rodillo básico",
+			name: "Splat Roller",
+		},
+		{
+			text: "Rodillo básico Meddux",
+			name: "Krak-On Splat Roller",
+		},
+		{
+			text: "Rodillo orden réplica",
+			name: "Order Roller Replica",
+		},
+		{
+			text: "Rodillo mágnum",
+			name: "Big Swig Roller",
+		},
+		{
+			text: "Rodillo mágnum exprés",
+			name: "Big Swig Roller Express",
+		},
+		{
+			text: "Rodillo mágnum PLX",
+			name: "Planetz Big Swig Roller",
+		},
+		{
+			text: "Odontintador menta",
+			name: "Mint Decavitator",
+		},
+		{
+			text: "Odontintador carbón",
+			name: "Charcoal Decavitator",
+		},
+		{
+			text: "Azotintador brisa",
+			name: "Splatana Wiper",
+		},
+		{
+			text: "Azotintador brisa chic",
+			name: "Splatana Wiper Deco",
+		},
+		{
+			text: "Azotintador brisa OXD",
+			name: "Splatana Wiper RUS-T",
+		},
+		{
+			text: "Azotintador Pro",
+			name: "Splatana Stamper",
+		},
+		{
+			text: "Azotintador Pro maestro",
+			name: "Splatana Stamper Nouveau",
+		},
+		{
+			text: "Azotintador Pro CLX",
+			name: "Stickerz Splatana Stamper",
+		},
+		{
+			text: "Azotintador orden réplica",
+			name: "Order Splatana Replica",
+		},
+		{
+			text: "Paratintas discreto",
+			name: "Undercover Brella",
+		},
+		{
+			text: "Paratintas discreto Sorella",
+			name: "Undercover Sorella Brella",
+		},
+		{
+			text: "Paratintas discreto PTX",
+			name: "Patternz Undercover Brella",
+		},
+		{
+			text: "Prototintas 24-I",
+			name: "Recycled Brella 24 Mk I",
+		},
+		{
+			text: "Prototintas 24-II",
+			name: "Recycled Brella 24 Mk II",
+		},
+		{
+			text: "Paratintas",
+			name: "Splat Brella",
+		},
+		{
+			text: "Paratintas Sorella",
+			name: "Sorella Brella",
+		},
+		{
+			text: "Paratintas orden réplica",
+			name: "Order Brella Replica",
+		},
+		{
+			text: "Paratintas forestal",
+			name: "Tenta Brella",
+		},
+		{
+			text: "Paratintas forestal Sorella",
+			name: "Tenta Sorella Brella",
+		},
+		{
+			text: "Paratintas forestal CRM",
+			name: "Tenta Brella CRE-M",
+		},
+		{
+			text: "Aerógrafo GP",
+			name: "Aerospray MG",
+		},
+		{
+			text: "Aerógrafo GN",
+			name: "Aerospray RG",
+		},
+		{
+			text: "Aerógrafo ARX",
+			name: "Colorz Aerospray",
+		},
+		{
+			text: "Rociador Pro",
+			name: "Splattershot Pro",
+		},
+		{
+			text: "Rociador Forima",
+			name: "Forge Splattershot Pro",
+		},
+		{
+			text: "Rociador Pro GLD",
+			name: "Splattershot Pro FRZ-N",
+		},
+		{
+			text: "Rociador básico",
+			name: "Splattershot Jr.",
+		},
+		{
+			text: "Rociador básico adaptado",
+			name: "Custom Splattershot Jr.",
+		},
+		{
+			text: "Tintopresor",
+			name: "Squeezer",
+		},
+		{
+			text: "Tintopresor Foil",
+			name: "Foil Squeezer",
+		},
+		{
+			text: "Salpicadora 2000",
+			name: ".52 Gal",
+		},
+		{
+			text: "Salpicadora 2000 chic",
+			name: ".52 Gal Deco",
+		},
+		{
+			text: "Salpicadora 3000",
+			name: ".96 Gal",
+		},
+		{
+			text: "Salpicadora 3000 chic",
+			name: ".96 Gal Deco",
+		},
+		{
+			text: "Salpicadora 3000 GRX",
+			name: "Clawz .96 Gal",
+		},
+		{
+			text: "Megasoplador",
+			name: "Jet Squelcher",
+		},
+		{
+			text: "Megasoplador adaptado",
+			name: "Custom Jet Squelcher",
+		},
+		{
+			text: "Megasoplador CBR",
+			name: "Jet Squelcher COB-R",
+		},
+		{
+			text: "Rociador",
+			name: "Splattershot",
+		},
+		{
+			text: "Rociador Tentáctica",
+			name: "Tentatek Splattershot",
+		},
+		{
+			text: "Rociador GLX",
+			name: "Glamorz Splattershot",
+		},
+		{
+			text: "Rociador de élite réplica",
+			name: "Hero Shot Replica",
+		},
+		{
+			text: "Rociador orden réplica",
+			name: "Order Shot Replica",
+		},
+		{
+			text: "Rociador octariano réplica",
+			name: "Octo Shot Replica",
+		},
+		{
+			text: "Plumón",
+			name: "Splash-o-matic",
+		},
+		{
+			text: "Plumón neo",
+			name: "Neo Splash-o-matic",
+		},
+		{
+			text: "Plumón GCO",
+			name: "Splash-o-matic GCK-O",
+		},
+		{
+			text: "Rociador espacial",
+			name: "Splattershot Nova",
+		},
+		{
+			text: "Rociador espacial Annak",
+			name: "Annaki Splattershot Nova",
+		},
+		{
+			text: "N-ZAP 85",
+			name: "N-ZAP '85",
+		},
+		{
+			text: "N-ZAP 89",
+			name: "N-ZAP '89",
+		},
+		{
+			text: "Marcador grueso",
+			name: "Sploosh-o-matic",
+		},
+		{
+			text: "Marcador grueso neo",
+			name: "Neo Sploosh-o-matic",
+		},
+		{
+			text: "Manguera pesada",
+			name: "H-3 Nozzlenose",
+		},
+		{
+			text: "Manguera pesada D",
+			name: "H-3 Nozzlenose D",
+		},
+		{
+			text: "Manguera pesada PTN",
+			name: "H-3 Nozzlenose VIP-R",
+		},
+		{
+			text: "Manguera ligera",
+			name: "L-3 Nozzlenose",
+		},
+		{
+			text: "Manguera ligera D",
+			name: "L-3 Nozzlenose D",
+		},
+		{
+			text: "Manguera ligera BRX",
+			name: "Glitterz L-3 Nozzlenose",
+		},
+		{
+			text: "Derramatic baño",
+			name: "Bloblobber",
+		},
+		{
+			text: "Derramatic baño chic",
+			name: "Bloblobber Deco",
+		},
+		{
+			text: "Derramatic triple",
+			name: "Tri-Slosher",
+		},
+		{
+			text: "Derramatic triple maestro",
+			name: "Tri-Slosher Nouveau",
+		},
+		{
+			text: "Derramatic triple CNZ",
+			name: "Tri-Slosher ASH-N",
+		},
+		{
+			text: "Friegamatic",
+			name: "Dread Wringer",
+		},
+		{
+			text: "Friegamatic D",
+			name: "Dread Wringer D",
+		},
+		{
+			text: "Friegamatic ATX",
+			name: "Hornz Dread Wringer",
+		},
+		{
+			text: "Derramatic centrífugo",
+			name: "Sloshing Machine",
+		},
+		{
+			text: "Derramatic centrífugo neo",
+			name: "Sloshing Machine Neo",
+		},
+		{
+			text: "Derramatic",
+			name: "Slosher",
+		},
+		{
+			text: "Derramatic chic",
+			name: "Slosher Deco",
+		},
+		{
+			text: "Derramatic orden réplica",
+			name: "Order Slosher Replica",
+		},
+		{
+			text: "Derramatic XP",
+			name: "Explosher",
+		},
+		{
+			text: "Derramatic XP adaptado",
+			name: "Custom Explosher",
+		},
+		{
+			text: "Garabateador PLM",
+			name: "Ballpoint Splatling",
+		},
+		{
+			text: "Garabateador PLM maestro",
+			name: "Ballpoint Splatling Nouveau",
+		},
+		{
+			text: "Corrigetintas",
+			name: "Heavy Edit Splatling",
+		},
+		{
+			text: "Corrigetintas maestro",
+			name: "Heavy Edit Splatling Nouveau",
+		},
+		{
+			text: "Garabateador HD",
+			name: "Hydra Splatling",
+		},
+		{
+			text: "Garabateador HD adaptado",
+			name: "Custom Hydra Splatling",
+		},
+		{
+			text: "Garabateador HD TRX",
+			name: "Torrentz Hydra Splatling",
+		},
+		{
+			text: "Garabateador",
+			name: "Mini Splatling",
+		},
+		{
+			text: "Garabateador Tintaz",
+			name: "Zink Mini Splatling",
+		},
+		{
+			text: "Garabateador CSB",
+			name: "Mini Splatling RTL-R",
+		},
+		{
+			text: "Nautilo 47",
+			name: "Nautilus 47",
+		},
+		{
+			text: "Nautilo 79",
+			name: "Nautilus 79",
+		},
+		{
+			text: "Garabateador Pro",
+			name: "Heavy Splatling",
+		},
+		{
+			text: "Garabateador Pro chic",
+			name: "Heavy Splatling Deco",
+		},
+		{
+			text: "Garabateador orden réplica",
+			name: "Order Splatling Replica",
+		},
+		{
+			text: "Arcrotensor V",
+			name: "Wellstring V",
+		},
+		{
+			text: "Arcrotensor V adaptado",
+			name: "Custom Wellstring V",
+		},
+		{
+			text: "Arcromatizador triple",
+			name: "Tri-Stringer",
+		},
+		{
+			text: "Arcromatizador triple Moluskia",
+			name: "Inkline Tri-Stringer",
+		},
+		{
+			text: "Arcromatizador triple FCX",
+			name: "Bulbz Tri-Stringer",
+		},
+		{
+			text: "Arcromatizador orden réplica",
+			name: "Order Stringer Replica",
+		},
+		{
+			text: "AR-CR0 450",
+			name: "REEF-LUX 450",
+		},
+		{
+			text: "AR-CR0 450 chic",
+			name: "REEF-LUX 450 Deco",
+		},
+		{
+			text: "AR-CR0 450 LCT",
+			name: "REEF-LUX 450 MIL-K",
+		},
+		{
+			text: "Baliza",
+			name: "Squid Beakon",
+		},
+		{
+			text: "Bomba deslizante",
+			name: "Curling Bomb",
+		},
+		{
+			text: "Bomba carbónica",
+			name: "Fizzy Bomb",
+		},
+		{
+			text: "Globo entintado",
+			name: "Burst Bomb",
+		},
+		{
+			text: "Robobomba",
+			name: "Autobomb",
+		},
+		{
+			text: "Plasbomba",
+			name: "Splat Bomb",
+		},
+		{
+			text: "Bomba pegajosa",
+			name: "Suction Bomb",
+		},
+		{
+			text: "Dardo resaltador",
+			name: "Angle Shooter",
+		},
+		{
+			text: "Rastreador",
+			name: "Point Sensor",
+		},
+		{
+			text: "Nebulizador",
+			name: "Toxic Mist",
+		},
+		{
+			text: "Barricada",
+			name: "Splash Wall",
+		},
+		{
+			text: "Aspersor",
+			name: "Sprinkler",
+		},
+		{
+			text: "Mina de tinta",
+			name: "Ink Mine",
+		},
+		{
+			text: "Aspiratinta",
+			name: "Ink Vac",
+		},
+		{
+			text: "Calamar imperial",
+			name: "Kraken Royale",
+		},
+		{
+			text: "Cangrejobot",
+			name: "Crab Tank",
+		},
+		{
+			text: "Muro marmoleado",
+			name: "Splattercolor Screen",
+		},
+		{
+			text: "Dispensabebidas",
+			name: "Tacticooler",
+		},
+		{
+			text: "Multiseñuelos",
+			name: "Super Chump",
+		},
+		{
+			text: "Megaburbuja",
+			name: "Big Bubbler",
+		},
+		{
+			text: "Atormentador",
+			name: "Ink Storm",
+		},
+		{
+			text: "Propulsor",
+			name: "Inkjet",
+		},
+		{
+			text: "Berreón 5.1",
+			name: "Killer Wail 5.1",
+		},
+		{
+			text: "Lanzamisiles",
+			name: "Tenta Missiles",
+		},
+		{
+			text: "Bola genializante",
+			name: "Booyah Bomb",
+		},
+		{
+			text: "Clavado triple",
+			name: "Triple Splashdown",
+		},
+		{
+			text: "Emiteondas",
+			name: "Wave Breaker",
+		},
+		{
+			text: "Flotiburón",
+			name: "Reefslider",
+		},
+		{
+			text: "Gancho tentacular",
+			name: "Zipcaster",
+		},
+		{
+			text: "Tornado triple",
+			name: "Triple Inkstrike",
+		},
+		{
+			text: "Cañón triple",
+			name: "Trizooka",
+		},
+		{
+			text: "Ultraselladora",
+			name: "Ultra Stamp",
+		},
+	],
+	USfr: [
+		{
+			text: "Turboblasteur pro",
+			name: "Rapid Blaster Pro",
+		},
+		{
+			text: "Turboblasteur pro chic",
+			name: "Rapid Blaster Pro Deco",
+		},
+		{
+			text: "Turboblasteur pro POL-R",
+			name: "Rapid Blaster Pro WNT-R",
+		},
+		{
+			text: "Rafalblasteur",
+			name: "Clash Blaster",
+		},
+		{
+			text: "Rafalblasteur néo",
+			name: "Clash Blaster Neo",
+		},
+		{
+			text: "Turboblasteur",
+			name: "Rapid Blaster",
+		},
+		{
+			text: "Turboblasteur chic",
+			name: "Rapid Blaster Deco",
+		},
+		{
+			text: "Éclablasteur LP",
+			name: "Range Blaster",
+		},
+		{
+			text: "Éclablasteur LP modifié",
+			name: "Custom Range Blaster",
+		},
+		{
+			text: "Éclablasteur",
+			name: "Blaster",
+		},
+		{
+			text: "Éclablasteur modifié",
+			name: "Custom Blaster",
+		},
+		{
+			text: "Éclablasteur miragius",
+			name: "Gleamz Blaster",
+		},
+		{
+			text: "S-Blasteur '92",
+			name: "S-BLAST '92",
+		},
+		{
+			text: "S-Blasteur '91",
+			name: "S-BLAST '91",
+		},
+		{
+			text: "Proxiblasteur",
+			name: "Luna Blaster",
+		},
+		{
+			text: "Proxiblasteur néo",
+			name: "Luna Blaster Neo",
+		},
+		{
+			text: "Blasteur d'Ordre (réplique)",
+			name: "Order Blaster Replica",
+		},
+		{
+			text: "Épinceau écaïe",
+			name: "Painbrush",
+		},
+		{
+			text: "Épinceau écaïe nuancé",
+			name: "Painbrush Nouveau",
+		},
+		{
+			text: "Épinceau écaïe BRN-Z",
+			name: "Painbrush BRN-Z",
+		},
+		{
+			text: "Épinceau",
+			name: "Inkbrush",
+		},
+		{
+			text: "Épinceau nuancé",
+			name: "Inkbrush Nouveau",
+		},
+		{
+			text: "Épinceau brosse",
+			name: "Octobrush",
+		},
+		{
+			text: "Épinceau brosse nuancé",
+			name: "Octobrush Nouveau",
+		},
+		{
+			text: "Épinceau brosse stellius",
+			name: "Cometz Octobrush",
+		},
+		{
+			text: "Pinceau d'Ordre (réplique)",
+			name: "Orderbrush Replica",
+		},
+		{
+			text: "Détubeur",
+			name: "Goo Tuber",
+		},
+		{
+			text: "Détubeur modifié",
+			name: "Custom Goo Tuber",
+		},
+		{
+			text: "Bimbamboum Mk I",
+			name: "Bamboozler 14 Mk I",
+		},
+		{
+			text: "Bimbamboum Mk II",
+			name: "Bamboozler 14 Mk II",
+		},
+		{
+			text: "X-traceur + zoom",
+			name: "E-liter 4K Scope",
+		},
+		{
+			text: "X-traceur + zoom modifié",
+			name: "Custom E-liter 4K Scope",
+		},
+		{
+			text: "X-traceur +",
+			name: "E-liter 4K",
+		},
+		{
+			text: "X-traceur + modifié",
+			name: "Custom E-liter 4K",
+		},
+		{
+			text: "Concentraceur zoom",
+			name: "Splatterscope",
+		},
+		{
+			text: "Concentraceur zoom E+A",
+			name: "Z+F Splatterscope",
+		},
+		{
+			text: "Concentraceur zoom CAM-O",
+			name: "Splatterscope CAM-O",
+		},
+		{
+			text: "Concentraceur",
+			name: "Splat Charger",
+		},
+		{
+			text: "Concentraceur E+A",
+			name: "Z+F Splat Charger",
+		},
+		{
+			text: "Concentraceur CAM-O",
+			name: "Splat Charger CAM-O",
+		},
+		{
+			text: "Fusil d'Ordre (réplique)",
+			name: "Order Charger Replica",
+		},
+		{
+			text: "Crayon X - 5H",
+			name: "Snipewriter 5H",
+		},
+		{
+			text: "Crayon X - 5B",
+			name: "Snipewriter 5B",
+		},
+		{
+			text: "Lignizateur alpha",
+			name: "Classic Squiffer",
+		},
+		{
+			text: "Lignizateur bêta",
+			name: "New Squiffer",
+		},
+		{
+			text: "Double nettoyeur",
+			name: "Dualie Squelchers",
+		},
+		{
+			text: "Double nettoyeur modifié",
+			name: "Custom Dualie Squelchers",
+		},
+		{
+			text: "Double nettoyeur zébranius",
+			name: "Hoofz Dualie Squelchers",
+		},
+		{
+			text: "Double Kelvin 525",
+			name: "Glooga Dualies",
+		},
+		{
+			text: "Double Kelvin 525 chic",
+			name: "Glooga Dualies Deco",
+		},
+		{
+			text: "Double ignifugeur",
+			name: "Douser Dualies FF",
+		},
+		{
+			text: "Double ignifugeur modifié",
+			name: "Custom Douser Dualies FF",
+		},
+		{
+			text: "Double encreur",
+			name: "Splat Dualies",
+		},
+		{
+			text: "Double encreur DUX",
+			name: "Enperry Splat Dualies",
+		},
+		{
+			text: "Double encreur flambius",
+			name: "Twinklez Splat Dualies",
+		},
+		{
+			text: "Arme double d'Ordre (réplique)",
+			name: "Order Dualie Replicas",
+		},
+		{
+			text: "Double moucheteur",
+			name: "Dapple Dualies",
+		},
+		{
+			text: "Double moucheteur nuancé",
+			name: "Dapple Dualies Nouveau",
+		},
+		{
+			text: "Double moucheteur NOC-T",
+			name: "Dapple Dualies NOC-T",
+		},
+		{
+			text: "Double voltigeur noir",
+			name: "Dark Tetra Dualies",
+		},
+		{
+			text: "Double voltigeur blanc",
+			name: "Light Tetra Dualies",
+		},
+		{
+			text: "Rouleau carbone",
+			name: "Carbon Roller",
+		},
+		{
+			text: "Rouleau carbone chic",
+			name: "Carbon Roller Deco",
+		},
+		{
+			text: "Rouleau carbone BOD-RWA",
+			name: "Carbon Roller ANG-L",
+		},
+		{
+			text: "Dynamo-rouleau",
+			name: "Dynamo Roller",
+		},
+		{
+			text: "Dynamo-rouleau pro",
+			name: "Gold Dynamo Roller",
+		},
+		{
+			text: "Dynamo-rouleau galaxius",
+			name: "Starz Dynamo Roller",
+		},
+		{
+			text: "Flexi-rouleau",
+			name: "Flingza Roller",
+		},
+		{
+			text: "Flexi-rouleau aluminium",
+			name: "Foil Flingza Roller",
+		},
+		{
+			text: "Rouleau",
+			name: "Splat Roller",
+		},
+		{
+			text: "Rouleau Krakeurs",
+			name: "Krak-On Splat Roller",
+		},
+		{
+			text: "Rouleau d'Ordre (réplique)",
+			name: "Order Roller Replica",
+		},
+		{
+			text: "Rouleau large",
+			name: "Big Swig Roller",
+		},
+		{
+			text: "Rouleau large Xpress",
+			name: "Big Swig Roller Express",
+		},
+		{
+			text: "Rouleau large astralius",
+			name: "Planetz Big Swig Roller",
+		},
+		{
+			text: "Sabrifrice menthe",
+			name: "Mint Decavitator",
+		},
+		{
+			text: "Sabrifrice charbon",
+			name: "Charcoal Decavitator",
+		},
+		{
+			text: "Éclatana Doto",
+			name: "Splatana Wiper",
+		},
+		{
+			text: "Éclatana Doto chic",
+			name: "Splatana Wiper Deco",
+		},
+		{
+			text: "Éclatana Doto OXY-D",
+			name: "Splatana Wiper RUS-T",
+		},
+		{
+			text: "Éclatana d'estampe",
+			name: "Splatana Stamper",
+		},
+		{
+			text: "Éclatana d'estampe nuancé",
+			name: "Splatana Stamper Nouveau",
+		},
+		{
+			text: "Éclatana d'estampe décolius",
+			name: "Stickerz Splatana Stamper",
+		},
+		{
+			text: "Éclatana d'Ordre (réplique)",
+			name: "Order Splatana Replica",
+		},
+		{
+			text: "Para-encre espion",
+			name: "Undercover Brella",
+		},
+		{
+			text: "Para-encre espion Sorella",
+			name: "Undercover Sorella Brella",
+		},
+		{
+			text: "Para-encre espion mélangius",
+			name: "Patternz Undercover Brella",
+		},
+		{
+			text: "Para-encre Ré-gen 24 Mk I",
+			name: "Recycled Brella 24 Mk I",
+		},
+		{
+			text: "Para-encre Ré-gen 24 Mk II",
+			name: "Recycled Brella 24 Mk II",
+		},
+		{
+			text: "Para-encre",
+			name: "Splat Brella",
+		},
+		{
+			text: "Para-encre Sorella",
+			name: "Sorella Brella",
+		},
+		{
+			text: "Para-encre d'Ordre (réplique)",
+			name: "Order Brella Replica",
+		},
+		{
+			text: "Méga para-encre",
+			name: "Tenta Brella",
+		},
+		{
+			text: "Méga para-encre Sorella",
+			name: "Tenta Sorella Brella",
+		},
+		{
+			text: "Méga para-encre CRM-A",
+			name: "Tenta Brella CRE-M",
+		},
+		{
+			text: "Pouche-pouche",
+			name: "Aerospray MG",
+		},
+		{
+			text: "Pouche-pouche premium",
+			name: "Aerospray RG",
+		},
+		{
+			text: "Pouche-pouche chromius",
+			name: "Colorz Aerospray",
+		},
+		{
+			text: "Liquéficateur pro",
+			name: "Splattershot Pro",
+		},
+		{
+			text: "Liquéficateur pro Fosia",
+			name: "Forge Splattershot Pro",
+		},
+		{
+			text: "Liquéficateur pro GLA-C",
+			name: "Splattershot Pro FRZ-N",
+		},
+		{
+			text: "Liquéficateur ultra",
+			name: "Splattershot Jr.",
+		},
+		{
+			text: "Liquéficateur ultra modifié",
+			name: "Custom Splattershot Jr.",
+		},
+		{
+			text: "Compresseur",
+			name: "Squeezer",
+		},
+		{
+			text: "Compresseur aluminium",
+			name: "Foil Squeezer",
+		},
+		{
+			text: "Calibre 2000",
+			name: ".52 Gal",
+		},
+		{
+			text: "Calibre 2000 chic",
+			name: ".52 Gal Deco",
+		},
+		{
+			text: "Calibre 3000",
+			name: ".96 Gal",
+		},
+		{
+			text: "Calibre 3000 chic",
+			name: ".96 Gal Deco",
+		},
+		{
+			text: "Calibre 3000 guépius",
+			name: "Clawz .96 Gal",
+		},
+		{
+			text: "Méganettoyeur",
+			name: "Jet Squelcher",
+		},
+		{
+			text: "Méganettoyeur modifié",
+			name: "Custom Jet Squelcher",
+		},
+		{
+			text: "Méganettoyeur COB-R",
+			name: "Jet Squelcher COB-R",
+		},
+		{
+			text: "Liquéficateur",
+			name: "Splattershot",
+		},
+		{
+			text: "Liquéficateur Tentatek",
+			name: "Tentatek Splattershot",
+		},
+		{
+			text: "Liquéficateur glamius",
+			name: "Glamorz Splattershot",
+		},
+		{
+			text: "Liquéfi. héroïque (rép.)",
+			name: "Hero Shot Replica",
+		},
+		{
+			text: "Lanceur d'Ordre (réplique)",
+			name: "Order Shot Replica",
+		},
+		{
+			text: "Lanceur octaling (réplique)",
+			name: "Octo Shot Replica",
+		},
+		{
+			text: "Marqueur léger",
+			name: "Splash-o-matic",
+		},
+		{
+			text: "Marqueur léger néo",
+			name: "Neo Splash-o-matic",
+		},
+		{
+			text: "Marqueur léger G-KO",
+			name: "Splash-o-matic GCK-O",
+		},
+		{
+			text: "Lanceur spatial",
+			name: "Splattershot Nova",
+		},
+		{
+			text: "Lanceur spatial Aroz",
+			name: "Annaki Splattershot Nova",
+		},
+		{
+			text: "N-ZAP 85",
+			name: "N-ZAP '85",
+		},
+		{
+			text: "N-ZAP 89",
+			name: "N-ZAP '89",
+		},
+		{
+			text: "Marqueur lourd",
+			name: "Sploosh-o-matic",
+		},
+		{
+			text: "Marqueur lourd néo",
+			name: "Neo Sploosh-o-matic",
+		},
+		{
+			text: "Arroseur lourd",
+			name: "H-3 Nozzlenose",
+		},
+		{
+			text: "Arroseur lourd requin",
+			name: "H-3 Nozzlenose D",
+		},
+		{
+			text: "Arroseur lourd VIP-R",
+			name: "H-3 Nozzlenose VIP-R",
+		},
+		{
+			text: "Arroseur léger",
+			name: "L-3 Nozzlenose",
+		},
+		{
+			text: "Arroseur léger requin",
+			name: "L-3 Nozzlenose D",
+		},
+		{
+			text: "Arroseur léger éclatius",
+			name: "Glitterz L-3 Nozzlenose",
+		},
+		{
+			text: "Bassineur",
+			name: "Bloblobber",
+		},
+		{
+			text: "Bassineur chic",
+			name: "Bloblobber Deco",
+		},
+		{
+			text: "Seauceur trio",
+			name: "Tri-Slosher",
+		},
+		{
+			text: "Seauceur nuancé",
+			name: "Tri-Slosher Nouveau",
+		},
+		{
+			text: "Seauceur trio 100-DRÉ",
+			name: "Tri-Slosher ASH-N",
+		},
+		{
+			text: "Seau S-Horreur",
+			name: "Dread Wringer",
+		},
+		{
+			text: "Seau S-Horreur requin",
+			name: "Dread Wringer D",
+		},
+		{
+			text: "Seau S-Horreur kératius",
+			name: "Hornz Dread Wringer",
+		},
+		{
+			text: "Encrifugeur",
+			name: "Sloshing Machine",
+		},
+		{
+			text: "Encrifugeur néo",
+			name: "Sloshing Machine Neo",
+		},
+		{
+			text: "Seauceur",
+			name: "Slosher",
+		},
+		{
+			text: "Seauceur chic",
+			name: "Slosher Deco",
+		},
+		{
+			text: "Seau d'Ordre (réplique)",
+			name: "Order Slosher Replica",
+		},
+		{
+			text: "Détoneur",
+			name: "Explosher",
+		},
+		{
+			text: "Détoneur modifié",
+			name: "Custom Explosher",
+		},
+		{
+			text: "Badigeonneur stylo",
+			name: "Ballpoint Splatling",
+		},
+		{
+			text: "Badigeonneur stylo nuancé",
+			name: "Ballpoint Splatling Nouveau",
+		},
+		{
+			text: "Correcteur",
+			name: "Heavy Edit Splatling",
+		},
+		{
+			text: "Correcteur nuancé",
+			name: "Heavy Edit Splatling Nouveau",
+		},
+		{
+			text: "Exteinteur",
+			name: "Hydra Splatling",
+		},
+		{
+			text: "Exteinteur modifié",
+			name: "Custom Hydra Splatling",
+		},
+		{
+			text: "Exteinteur cascadius",
+			name: "Torrentz Hydra Splatling",
+		},
+		{
+			text: "Badigeonneur XP",
+			name: "Mini Splatling",
+		},
+		{
+			text: "Badigeonneur XP Leviathus",
+			name: "Zink Mini Splatling",
+		},
+		{
+			text: "Badigeonneur XP VN-1",
+			name: "Mini Splatling RTL-R",
+		},
+		{
+			text: "Badigeonneur",
+			name: "Heavy Splatling",
+		},
+		{
+			text: "Badigeonneur chic",
+			name: "Heavy Splatling Deco",
+		},
+		{
+			text: "Badigeonneur d'Ordre (réplique)",
+			name: "Order Splatling Replica",
+		},
+		{
+			text: "Multisperceur V",
+			name: "Wellstring V",
+		},
+		{
+			text: "Multisperceur V modifié",
+			name: "Custom Wellstring V",
+		},
+		{
+			text: "Trisperceur",
+			name: "Tri-Stringer",
+		},
+		{
+			text: "Trisperceur Abysma",
+			name: "Inkline Tri-Stringer",
+		},
+		{
+			text: "Trisperceur prismalius",
+			name: "Bulbz Tri-Stringer",
+		},
+		{
+			text: "Transperceur d'Ordre (réplique)",
+			name: "Order Stringer Replica",
+		},
+		{
+			text: "Coralux 450",
+			name: "REEF-LUX 450",
+		},
+		{
+			text: "Coralux 450 chic",
+			name: "REEF-LUX 450 Deco",
+		},
+		{
+			text: "Coralux 450 LACTO",
+			name: "REEF-LUX 450 MIL-K",
+		},
+		{
+			text: "Balise de saut",
+			name: "Squid Beakon",
+		},
+		{
+			text: "Bombe curling",
+			name: "Curling Bomb",
+		},
+		{
+			text: "Bombe soda",
+			name: "Fizzy Bomb",
+		},
+		{
+			text: "Bombe ballon",
+			name: "Burst Bomb",
+		},
+		{
+			text: "Bombe robot",
+			name: "Autobomb",
+		},
+		{
+			text: "Bombe splash",
+			name: "Splat Bomb",
+		},
+		{
+			text: "Bombe gluante",
+			name: "Suction Bomb",
+		},
+		{
+			text: "Bentorpille",
+			name: "Torpedo",
+		},
+		{
+			text: "Ricocheur",
+			name: "Angle Shooter",
+		},
+		{
+			text: "Détecteur",
+			name: "Point Sensor",
+		},
+		{
+			text: "Brume toxique",
+			name: "Toxic Mist",
+		},
+		{
+			text: "Mur d'encre",
+			name: "Splash Wall",
+		},
+		{
+			text: "Gicleur",
+			name: "Sprinkler",
+		},
+		{
+			text: "Mine d'encre",
+			name: "Ink Mine",
+		},
+		{
+			text: "Aspirencre",
+			name: "Ink Vac",
+		},
+		{
+			text: "Kraken royal",
+			name: "Kraken Royale",
+		},
+		{
+			text: "Crabe d'assaut",
+			name: "Crab Tank",
+		},
+		{
+			text: "Barrière barbouillée",
+			name: "Splattercolor Screen",
+		},
+		{
+			text: "Districool",
+			name: "Tacticooler",
+		},
+		{
+			text: "Multi-leurres",
+			name: "Super Chump",
+		},
+		{
+			text: "Super bouclier",
+			name: "Big Bubbler",
+		},
+		{
+			text: "Pluie d'encre",
+			name: "Ink Storm",
+		},
+		{
+			text: "Chromo-jet",
+			name: "Inkjet",
+		},
+		{
+			text: "Laser perçant 5.1",
+			name: "Killer Wail 5.1",
+		},
+		{
+			text: "Multi-missile",
+			name: "Tenta Missiles",
+		},
+		{
+			text: "Excellinator",
+			name: "Booyah Bomb",
+		},
+		{
+			text: "Triple choc chromatique",
+			name: "Triple Splashdown",
+		},
+		{
+			text: "Sonar paf",
+			name: "Wave Breaker",
+		},
+		{
+			text: "Cavalsquale",
+			name: "Reefslider",
+		},
+		{
+			text: "Super Mollusque",
+			name: "Zipcaster",
+		},
+		{
+			text: "Trimissile tornade",
+			name: "Triple Inkstrike",
+		},
+		{
+			text: "Lance-tornades",
+			name: "Trizooka",
+		},
+		{
+			text: "Ultra-étampeur",
+			name: "Ultra Stamp",
+		},
+	],
+};
diff --git a/app/features/scanner/core/detectors/death/rois.ts b/app/features/scanner/core/detectors/death/rois.ts
new file mode 100644
index 000000000..5f8e0a61f
--- /dev/null
+++ b/app/features/scanner/core/detectors/death/rois.ts
@@ -0,0 +1,146 @@
+/**
+ * ALL death-screen ROI coordinates, in canonical 1920x1080 space.
+ * Calibrated against the death/ fixtures via tools/dump-crops.ts,
+ * HoughCircles measurement, and bright-row profiling.
+ *
+ * The death cam overlays three fixed elements on live gameplay: a dark
+ * camo "splat burst" top-center (two-line "Splatted by" / "<weapon>!"
+ * message); the killer's gear panel bottom-left (three gear rows, each
+ * with one main-ability circle ⌀~68 plus three sub circles ⌀~48,
+ * divided by dashed lines); and the killer's splash tag bottom-right,
+ * tilted, name in large type. Probes sit in the overlays' opaque-dark
+ * parts (everything but the tag banner sits over the live scene).
+ */
+import type { Roi } from "../../canonical";
+
+/** The constant "Splatted by" line (white text centered at x=960). */
+export const SPLAT_LINE1_ROI: Roi = { x: 790, y: 362, w: 340, h: 52 };
+
+/** The weapon name line ("Rapid Blaster Deco!"), centered, length varies. */
+export const WEAPON_LINE_ROI: Roi = { x: 640, y: 414, w: 640, h: 48 };
+
+/** White message text on the dark burst binarizes cleanly and high. */
+export const SPLAT_TEXT_BIN_THRESHOLD = 190;
+
+/** Tight cap height of the message text (atlas nominal height). */
+export const WEAPON_TEXT_HEIGHT = 34;
+
+/**
+ * Non-Latin weaponLine=1 langs (JA: "<weapon> で" / "やられた！") swap line
+ * widths: variable name gets the full-width box, the short constant line
+ * gets a narrow one. Both boxes run taller than Latin: kana overshoot the
+ * cap band both sides (JP line spans y=359..401 vs Latin's y=362 start).
+ */
+export const JA_WEAPON_LINE_ROI: Roi = { x: 640, y: 354, w: 640, h: 62 };
+export const JA_CONST_LINE_ROI: Roi = { x: 790, y: 412, w: 340, h: 54 };
+
+/**
+ * Killer's weapon icon, upright above the message text (~110px art;
+ * specials render team-tinted, unmatched). Templates at
+ * BURST_ICON_TEMPLATE_SIZES. A "Lost the Rainmaker!" style line shifts
+ * the icon out of this box; the text read handles those.
+ */
+export const BURST_ICON_ROI: Roi = { x: 785, y: 230, w: 190, h: 140 };
+export const BURST_ICON_TEMPLATE_SIZES = [116, 124, 132] as const;
+
+/** Gear panel rows: [head, clothes, shoes]. */
+export const ABILITY_ROWS = 3;
+/** Main-ability circle centers (⌀~68). */
+const ABILITY_MAIN_X = 515;
+const ABILITY_MAIN_YS = [696, 795, 887] as const;
+/** Sub-ability circle centers (⌀~48), slightly below the main's center. */
+export const ABILITY_SUB_XS = [578, 630, 682] as const;
+const ABILITY_SUB_YS = [702, 797, 888] as const;
+
+/**
+ * Search boxes around each circle; heights double as the size filter
+ * (matchTemplate skips templates taller than the ROI).
+ */
+export function abilityMainRoi(row: number): Roi {
+	const cy = ABILITY_MAIN_YS[row]!;
+	return { x: ABILITY_MAIN_X - 38, y: cy - 38, w: 76, h: 76 };
+}
+
+export function abilitySubRoi(row: number, slot: number): Roi {
+	const cx = ABILITY_SUB_XS[slot]!;
+	const cy = ABILITY_SUB_YS[row]!;
+	return { x: cx - 28, y: cy - 28, w: 56, h: 56 };
+}
+
+/** Template heights (px at 1080p) per circle role. */
+export const ABILITY_MAIN_SIZES = [64, 68, 72] as const;
+export const ABILITY_SUB_SIZES = [44, 48, 52] as const;
+
+/**
+ * Icon art diameter as fraction of circle box: mains peak 1.0, subs 0.92
+ * — badges draw art nearly edge-to-edge, ring contributes ~nothing.
+ */
+export const ABILITY_MAIN_ART_RATIO = 1.0;
+export const ABILITY_SUB_ART_RATIO = 0.92;
+
+/**
+ * Ink threshold: badge near-black, icon art saturated-bright; panel is
+ * slightly translucent so a bright scene can ghost through — kept above that.
+ */
+export const ABILITY_INK_THRESHOLD = 90;
+
+/**
+ * A gear row carries only as many sub circles as gear slots (1-3); an
+ * absent slot shows bare panel. Bright pixels (max channel >
+ * ABILITY_INK_THRESHOLD) separate cases: absent measures 0, every real
+ * badge measures 403+ even at the dimmest 720p capture.
+ */
+export const ABILITY_SLOT_MIN_INK = 200;
+
+/**
+ * Splash tag name band. Tag renders tilted (baseline rises right by
+ * TAG_TILT_DEG); crop TAG_NAME_OUTER, rotate level, read TAG_NAME_INNER
+ * relative to the rotated crop.
+ */
+export const TAG_TILT_DEG = 3.0;
+export const TAG_NAME_OUTER: Roi = { x: 1130, y: 770, w: 650, h: 140 };
+/**
+ * Name band inside the rotated crop. Top edge must clear kana dakuten
+ * (old y=34 clipped them, misreading こ for ご); y=21 splits the title
+ * line above (ends outer y=17) with margin.
+ */
+export const TAG_NAME_INNER: Roi = { x: 20, y: 21, w: 610, h: 87 };
+
+/** Tight cap height of the tag name text (atlas nominal height). */
+export const TAG_NAME_TEXT_HEIGHT = 46;
+
+/**
+ * Gate probes: burst camo is dark left/right of the text line and below
+ * the weapon line; gear panel is dark right of the sub circles.
+ */
+export const GATE_BURST_PROBES: readonly Roi[] = [
+	{ x: 750, y: 376, w: 36, h: 22 },
+	{ x: 1134, y: 376, w: 36, h: 22 },
+	{ x: 930, y: 466, w: 60, h: 18 },
+];
+export const GATE_PANEL_PROBES: readonly Roi[] = [
+	{ x: 720, y: 686, w: 30, h: 20 },
+	{ x: 720, y: 785, w: 30, h: 20 },
+];
+export const GATE_DARK_MAX_MEAN = 95;
+/** SPLAT_LINE1_ROI must contain near-white pixels... */
+export const GATE_TEXT_MIN_MAX = 210;
+/** ...but not too many: it is a short text line, not a white panel. */
+export const GATE_TEXT_MAX_FRACTION = 0.35;
+
+/**
+ * Dark probes + white text also match the scoreboard screens, so the gate
+ * additionally requires bright icon art at all three main-ability centers
+ * (max RGB channel, not grayscale — saturated art can be gray-dark yet
+ * bright in max-channel). Death fixtures measure 244+, closest non-death
+ * row 184.
+ */
+export function gateAbilityProbe(row: number): Roi {
+	return {
+		x: ABILITY_MAIN_X - 14,
+		y: ABILITY_MAIN_YS[row]! - 14,
+		w: 28,
+		h: 28,
+	};
+}
+export const GATE_ICON_MIN_MAX = 200;
diff --git a/app/features/scanner/core/detectors/death/weapon-names.ts b/app/features/scanner/core/detectors/death/weapon-names.ts
new file mode 100644
index 000000000..d94246951
--- /dev/null
+++ b/app/features/scanner/core/detectors/death/weapon-names.ts
@@ -0,0 +1,245 @@
+/**
+ * English weapon names keyed by in-game weapon id, generated from
+ * sendou.ink locales/en/weapons.json (MAIN_/SUB_/SPECIAL_<id> entries;
+ * mains filtered to the assets/cv/main-weapons icon manifest).
+ * The death screen shows the killer's weapon as text ("Splatted by
+ * <name>!") and can credit a main, sub, or special, so the closed set
+ * that OCR output snaps to spans all three kinds. Ids are only unique
+ * within a kind (sub 0 = Splat Bomb, main 0 = Sploosh-o-matic).
+ */
+export type WeaponType = "MAIN" | "SUB" | "SPECIAL";
+
+export interface WeaponEntry {
+	id: string;
+	name: string;
+	type: WeaponType;
+}
+
+const WEAPON_NAMES: ReadonlyMap<string, string> = new Map([
+	["0", "Sploosh-o-matic"],
+	["1", "Neo Sploosh-o-matic"],
+	["10", "Splattershot Jr."],
+	["11", "Custom Splattershot Jr."],
+	["20", "Splash-o-matic"],
+	["21", "Neo Splash-o-matic"],
+	["22", "Splash-o-matic GCK-O"],
+	["30", "Aerospray MG"],
+	["31", "Aerospray RG"],
+	["32", "Colorz Aerospray"],
+	["40", "Splattershot"],
+	["41", "Tentatek Splattershot"],
+	["42", "Glamorz Splattershot"],
+	["45", "Hero Shot Replica"],
+	["46", "Octo Shot Replica"],
+	["47", "Order Shot Replica"],
+	["50", ".52 Gal"],
+	["51", ".52 Gal Deco"],
+	["60", "N-ZAP '85"],
+	["61", "N-ZAP '89"],
+	["70", "Splattershot Pro"],
+	["71", "Forge Splattershot Pro"],
+	["72", "Splattershot Pro FRZ-N"],
+	["80", ".96 Gal"],
+	["81", ".96 Gal Deco"],
+	["82", "Clawz .96 Gal"],
+	["90", "Jet Squelcher"],
+	["91", "Custom Jet Squelcher"],
+	["92", "Jet Squelcher COB-R"],
+	["100", "Splattershot Nova"],
+	["101", "Annaki Splattershot Nova"],
+	["200", "Luna Blaster"],
+	["201", "Luna Blaster Neo"],
+	["205", "Order Blaster Replica"],
+	["210", "Blaster"],
+	["211", "Custom Blaster"],
+	["212", "Gleamz Blaster"],
+	["220", "Range Blaster"],
+	["221", "Custom Range Blaster"],
+	["230", "Clash Blaster"],
+	["231", "Clash Blaster Neo"],
+	["240", "Rapid Blaster"],
+	["241", "Rapid Blaster Deco"],
+	["250", "Rapid Blaster Pro"],
+	["251", "Rapid Blaster Pro Deco"],
+	["252", "Rapid Blaster Pro WNT-R"],
+	["260", "S-BLAST '92"],
+	["261", "S-BLAST '91"],
+	["300", "L-3 Nozzlenose"],
+	["301", "L-3 Nozzlenose D"],
+	["302", "Glitterz L-3 Nozzlenose"],
+	["310", "H-3 Nozzlenose"],
+	["311", "H-3 Nozzlenose D"],
+	["312", "H-3 Nozzlenose VIP-R"],
+	["400", "Squeezer"],
+	["401", "Foil Squeezer"],
+	["1000", "Carbon Roller"],
+	["1001", "Carbon Roller Deco"],
+	["1002", "Carbon Roller ANG-L"],
+	["1010", "Splat Roller"],
+	["1011", "Krak-On Splat Roller"],
+	["1015", "Order Roller Replica"],
+	["1020", "Dynamo Roller"],
+	["1021", "Gold Dynamo Roller"],
+	["1022", "Starz Dynamo Roller"],
+	["1030", "Flingza Roller"],
+	["1031", "Foil Flingza Roller"],
+	["1040", "Big Swig Roller"],
+	["1041", "Big Swig Roller Express"],
+	["1042", "Planetz Big Swig Roller"],
+	["1100", "Inkbrush"],
+	["1101", "Inkbrush Nouveau"],
+	["1110", "Octobrush"],
+	["1111", "Octobrush Nouveau"],
+	["1112", "Cometz Octobrush"],
+	["1115", "Orderbrush Replica"],
+	["1120", "Painbrush"],
+	["1121", "Painbrush Nouveau"],
+	["1122", "Painbrush BRN-Z"],
+	["2000", "Classic Squiffer"],
+	["2001", "New Squiffer"],
+	["2010", "Splat Charger"],
+	["2011", "Z+F Splat Charger"],
+	["2012", "Splat Charger CAM-O"],
+	["2015", "Order Charger Replica"],
+	["2020", "Splatterscope"],
+	["2021", "Z+F Splatterscope"],
+	["2022", "Splatterscope CAM-O"],
+	["2030", "E-liter 4K"],
+	["2031", "Custom E-liter 4K"],
+	["2040", "E-liter 4K Scope"],
+	["2041", "Custom E-liter 4K Scope"],
+	["2050", "Bamboozler 14 Mk I"],
+	["2051", "Bamboozler 14 Mk II"],
+	["2060", "Goo Tuber"],
+	["2061", "Custom Goo Tuber"],
+	["2070", "Snipewriter 5H"],
+	["2071", "Snipewriter 5B"],
+	["3000", "Slosher"],
+	["3001", "Slosher Deco"],
+	["3005", "Order Slosher Replica"],
+	["3010", "Tri-Slosher"],
+	["3011", "Tri-Slosher Nouveau"],
+	["3012", "Tri-Slosher ASH-N"],
+	["3020", "Sloshing Machine"],
+	["3021", "Sloshing Machine Neo"],
+	["3030", "Bloblobber"],
+	["3031", "Bloblobber Deco"],
+	["3040", "Explosher"],
+	["3041", "Custom Explosher"],
+	["3050", "Dread Wringer"],
+	["3051", "Dread Wringer D"],
+	["3052", "Hornz Dread Wringer"],
+	["4000", "Mini Splatling"],
+	["4001", "Zink Mini Splatling"],
+	["4002", "Mini Splatling RTL-R"],
+	["4010", "Heavy Splatling"],
+	["4011", "Heavy Splatling Deco"],
+	["4015", "Order Splatling Replica"],
+	["4020", "Hydra Splatling"],
+	["4021", "Custom Hydra Splatling"],
+	["4022", "Torrentz Hydra Splatling"],
+	["4030", "Ballpoint Splatling"],
+	["4031", "Ballpoint Splatling Nouveau"],
+	["4040", "Nautilus 47"],
+	["4041", "Nautilus 79"],
+	["4050", "Heavy Edit Splatling"],
+	["4051", "Heavy Edit Splatling Nouveau"],
+	["5000", "Dapple Dualies"],
+	["5001", "Dapple Dualies Nouveau"],
+	["5002", "Dapple Dualies NOC-T"],
+	["5010", "Splat Dualies"],
+	["5011", "Enperry Splat Dualies"],
+	["5012", "Twinklez Splat Dualies"],
+	["5015", "Order Dualie Replicas"],
+	["5020", "Glooga Dualies"],
+	["5021", "Glooga Dualies Deco"],
+	["5030", "Dualie Squelchers"],
+	["5031", "Custom Dualie Squelchers"],
+	["5032", "Hoofz Dualie Squelchers"],
+	["5040", "Dark Tetra Dualies"],
+	["5041", "Light Tetra Dualies"],
+	["5050", "Douser Dualies FF"],
+	["5051", "Custom Douser Dualies FF"],
+	["6000", "Splat Brella"],
+	["6001", "Sorella Brella"],
+	["6005", "Order Brella Replica"],
+	["6010", "Tenta Brella"],
+	["6011", "Tenta Sorella Brella"],
+	["6012", "Tenta Brella CRE-M"],
+	["6020", "Undercover Brella"],
+	["6021", "Undercover Sorella Brella"],
+	["6022", "Patternz Undercover Brella"],
+	["6030", "Recycled Brella 24 Mk I"],
+	["6031", "Recycled Brella 24 Mk II"],
+	["7010", "Tri-Stringer"],
+	["7011", "Inkline Tri-Stringer"],
+	["7012", "Bulbz Tri-Stringer"],
+	["7015", "Order Stringer Replica"],
+	["7020", "REEF-LUX 450"],
+	["7021", "REEF-LUX 450 Deco"],
+	["7022", "REEF-LUX 450 MIL-K"],
+	["7030", "Wellstring V"],
+	["7031", "Custom Wellstring V"],
+	["8000", "Splatana Stamper"],
+	["8001", "Splatana Stamper Nouveau"],
+	["8002", "Stickerz Splatana Stamper"],
+	["8005", "Order Splatana Replica"],
+	["8010", "Splatana Wiper"],
+	["8011", "Splatana Wiper Deco"],
+	["8012", "Splatana Wiper RUS-T"],
+	["8020", "Mint Decavitator"],
+	["8021", "Charcoal Decavitator"],
+]);
+
+const SUB_WEAPON_NAMES: ReadonlyMap<string, string> = new Map([
+	["0", "Splat Bomb"],
+	["1", "Suction Bomb"],
+	["2", "Burst Bomb"],
+	["3", "Sprinkler"],
+	["4", "Splash Wall"],
+	["5", "Fizzy Bomb"],
+	["6", "Curling Bomb"],
+	["7", "Autobomb"],
+	["8", "Squid Beakon"],
+	["9", "Point Sensor"],
+	["10", "Ink Mine"],
+	["11", "Toxic Mist"],
+	["12", "Angle Shooter"],
+	["13", "Torpedo"],
+]);
+
+const SPECIAL_WEAPON_NAMES: ReadonlyMap<string, string> = new Map([
+	["1", "Trizooka"],
+	["2", "Big Bubbler"],
+	["3", "Zipcaster"],
+	["4", "Tenta Missiles"],
+	["5", "Ink Storm"],
+	["6", "Booyah Bomb"],
+	["7", "Wave Breaker"],
+	["8", "Ink Vac"],
+	["9", "Killer Wail 5.1"],
+	["10", "Inkjet"],
+	["11", "Ultra Stamp"],
+	["12", "Crab Tank"],
+	["13", "Reefslider"],
+	["14", "Triple Inkstrike"],
+	["15", "Tacticooler"],
+	["16", "Super Chump"],
+	["17", "Kraken Royale"],
+	["18", "Triple Splashdown"],
+	["19", "Splattercolor Screen"],
+]);
+
+function entriesOf(
+	map: ReadonlyMap<string, string>,
+	type: WeaponType,
+): WeaponEntry[] {
+	return [...map.entries()].map(([id, name]) => ({ id, name, type }));
+}
+
+/** Every weapon that can appear in the death message, across all kinds. */
+export const ALL_WEAPON_ENTRIES: readonly WeaponEntry[] = [
+	...entriesOf(WEAPON_NAMES, "MAIN"),
+	...entriesOf(SUB_WEAPON_NAMES, "SUB"),
+	...entriesOf(SPECIAL_WEAPON_NAMES, "SPECIAL"),
+];
diff --git a/app/features/scanner/core/detectors/map-start/index.ts b/app/features/scanner/core/detectors/map-start/index.ts
new file mode 100644
index 000000000..2fbb18912
--- /dev/null
+++ b/app/features/scanner/core/detectors/map-start/index.ts
@@ -0,0 +1,365 @@
+/**
+ * MapStartDetector: parses the match-intro splash — the mode title on the
+ * black center splat and the stage name bottom-right, both snapped to the
+ * localized closed sets (core/localized.ts) and reported under canonical
+ * English names.
+ *
+ * The mode title wraps to two lines for longer names ("Splat" / "Zones"),
+ * so parse finds text lines inside MODE_BLOCK_ROI by row projection, OCRs
+ * each band, and snaps the joined reading. The constant "MODE" label
+ * doubles as a parse-time confirmation (else a lookalike gate hit emits
+ * nothing). The splash sits on live gameplay, so bright stages leak
+ * background past the text edges: the title block is masked to near-dark
+ * for line finding only (raw crop OCRs better); the stage line reads its
+ * min channel (drops blue-tinted water gray keeps) under several
+ * binarizations, keeping the best-snapping one (see rois.ts).
+ */
+import type { ModeShort, StageId } from "~/modules/in-game-lists/types";
+import { getCV, type Mat, minMaxLoc } from "../../cv";
+import {
+	type GlyphSet,
+	type RecognizedText,
+	recognizeText,
+	scaleGlyphSet,
+} from "../../glyphs";
+import { copyRoi, meanBrightness, minChannel } from "../../image";
+import {
+	ALL_MODE_ENTRIES,
+	ALL_MODE_LABELS,
+	ALL_STAGE_ENTRIES,
+} from "../../localized";
+import { closestBy } from "../../text";
+import type { ScoreboardResources } from "../scoreboard/index";
+import type { DetectedEvent, Detector, GateResult } from "../types";
+import {
+	BLOCK_MASK_RADIUS,
+	GATE_DARK_MAX_MEAN,
+	GATE_DARK_PROBES,
+	GATE_INK_BAND,
+	GATE_INK_BAND_MAX_BRIGHT,
+	GATE_INK_BAND_MIN_DARK,
+	GATE_TEXT_MAX_FRACTION,
+	GATE_TEXT_MIN_FRACTION,
+	GATE_TEXT_MIN_MAX,
+	LINE_GAP_TOLERANCE,
+	LINE_MIN_HEIGHT,
+	LINE_MIN_ROW_PIXELS,
+	LINE_ROW_FRACTION,
+	MASK_DARK_MAX,
+	MODE_BLOCK_ROI,
+	MODE_LABEL_ROI,
+	MODE_LABEL_TEXT_HEIGHT,
+	MODE_TEXT_HEIGHT,
+	STAGE_BIN_THRESHOLD,
+	STAGE_MASK_RADIUS,
+	STAGE_RAW_BIN_THRESHOLDS,
+	STAGE_ROI,
+	STAGE_TEXT_HEIGHT,
+	TEXT_BIN_THRESHOLD,
+} from "./rois";
+
+export interface MapStartData {
+	mode: ModeShort | null;
+	stage: StageId | null;
+}
+
+export const MAP_START_EVENT_TYPE = "MapStart";
+
+/** "MODE" must read back at least this well for parse to emit. */
+const LABEL_MIN_SCORE = 0.5;
+/** Accept a closed-set match only above this score (1 = exact). */
+const MIN_MATCH_SCORE = 0.62;
+
+interface LineBand {
+	y0: number;
+	y1: number;
+}
+
+/** Zero every pixel with no near-black pixel within `radius` of it. */
+function maskNearDark(gray: Mat, radius: number): Mat {
+	const cv = getCV();
+	const dark = new cv.Mat();
+	cv.threshold(gray, dark, MASK_DARK_MAX, 255, cv.THRESH_BINARY_INV);
+	const kernel = cv.getStructuringElement(
+		cv.MORPH_ELLIPSE,
+		new cv.Size(2 * radius + 1, 2 * radius + 1),
+	);
+	const near = new cv.Mat();
+	cv.dilate(dark, near, kernel);
+	kernel.delete();
+	dark.delete();
+	const out = new cv.Mat(gray.rows, gray.cols, cv.CV_8UC1, new cv.Scalar(0));
+	gray.copyTo(out, near);
+	near.delete();
+	return out;
+}
+
+/** Find text line bands in a binarized block by row projection. */
+function findLineBands(binary: Mat): LineBand[] {
+	const { rows, cols, data } = binary;
+	const counts = new Array<number>(rows).fill(0);
+	for (let y = 0; y < rows; y++) {
+		for (let x = 0; x < cols; x++) {
+			if (data[y * cols + x]! > 0) counts[y]!++;
+		}
+	}
+	// dual threshold: a band needs rows above a cutoff scaled to the
+	// strongest row (background leaking past the splat's rim puts a
+	// scene-dependent noise floor under every row), then extends over a
+	// fixed floor so antialiased glyph tops/bottoms stay inside the band
+	const core = Math.max(
+		LINE_MIN_ROW_PIXELS,
+		LINE_ROW_FRACTION * Math.max(...counts),
+	);
+	const bands: LineBand[] = [];
+	let start = -1;
+	let gap = 0;
+	for (let y = 0; y < rows; y++) {
+		if (counts[y]! >= core) {
+			if (start < 0) start = y;
+			gap = 0;
+		} else if (start >= 0 && ++gap > LINE_GAP_TOLERANCE) {
+			bands.push({ y0: start, y1: y - gap + 1 });
+			start = -1;
+		}
+	}
+	if (start >= 0) bands.push({ y0: start, y1: rows - gap });
+
+	for (const band of bands) {
+		while (band.y0 > 0 && counts[band.y0 - 1]! >= LINE_MIN_ROW_PIXELS)
+			band.y0--;
+		while (band.y1 < rows && counts[band.y1]! >= LINE_MIN_ROW_PIXELS) band.y1++;
+	}
+	const merged: LineBand[] = [];
+	for (const band of bands) {
+		const last = merged[merged.length - 1];
+		if (last && band.y0 <= last.y1) last.y1 = Math.max(last.y1, band.y1);
+		else merged.push(band);
+	}
+	return merged.filter((b) => b.y1 - b.y0 >= LINE_MIN_HEIGHT);
+}
+
+/**
+ * Trim a line band to its text columns (on the masked binary), so the raw
+ * OCR crop excludes the background the wide block picks up at its edges.
+ */
+function bandExtent(
+	binary: Mat,
+	band: LineBand,
+): { x0: number; x1: number } | null {
+	const { cols, data } = binary;
+	let x0 = -1;
+	let x1 = -1;
+	for (let x = 0; x < cols; x++) {
+		let count = 0;
+		for (let y = band.y0; y < band.y1; y++) {
+			if (data[y * cols + x]! > 0) count++;
+		}
+		if (count >= 2) {
+			if (x0 < 0) x0 = x;
+			x1 = x;
+		}
+	}
+	return x0 < 0 ? null : { x0, x1 };
+}
+
+export function createMapStartDetector(
+	resources: ScoreboardResources,
+): Detector<MapStartData> {
+	const cv = getCV();
+
+	const scaled = (
+		set: GlyphSet | null | undefined,
+		height: number,
+	): GlyphSet | null => (set ? scaleGlyphSet(set, height / set.height) : null);
+
+	const modeGlyphs = scaled(resources.mapStartModeGlyphs, MODE_TEXT_HEIGHT);
+	const stageGlyphs = scaled(resources.mapStartStageGlyphs, STAGE_TEXT_HEIGHT);
+	const labelGlyphs = scaled(
+		resources.mapStartStageGlyphs,
+		MODE_LABEL_TEXT_HEIGHT,
+	);
+
+	function gate(frame: Mat): GateResult {
+		let darkOk = 0;
+		for (const roi of GATE_DARK_PROBES) {
+			if (meanBrightness(frame, roi) < GATE_DARK_MAX_MEAN) darkOk++;
+		}
+
+		const gray = new cv.Mat();
+		cv.cvtColor(frame, gray, cv.COLOR_RGBA2GRAY);
+
+		const label = copyRoi(gray, MODE_LABEL_ROI);
+		const { maxVal } = minMaxLoc(label);
+		const bin = new cv.Mat();
+		cv.threshold(label, bin, TEXT_BIN_THRESHOLD, 255, cv.THRESH_BINARY);
+		label.delete();
+		const whiteFraction = cv.countNonZero(bin) / (bin.rows * bin.cols);
+		bin.delete();
+		const textOk =
+			maxVal > GATE_TEXT_MIN_MAX &&
+			whiteFraction > GATE_TEXT_MIN_FRACTION &&
+			whiteFraction < GATE_TEXT_MAX_FRACTION;
+
+		// the label-to-title gap core is solid ink on this screen: it must be
+		// near-totally dark (the scoreboards' pills aren't) and carry no bright
+		// pixels (the death burst's "Splatted by" line crosses it)
+		const band = copyRoi(gray, GATE_INK_BAND);
+		const bandPixels = band.rows * band.cols;
+		const bandBright = new cv.Mat();
+		cv.threshold(band, bandBright, TEXT_BIN_THRESHOLD, 255, cv.THRESH_BINARY);
+		const brightFraction = cv.countNonZero(bandBright) / bandPixels;
+		bandBright.delete();
+		const bandDark = new cv.Mat();
+		cv.threshold(band, bandDark, MASK_DARK_MAX, 255, cv.THRESH_BINARY_INV);
+		const darkFraction = cv.countNonZero(bandDark) / bandPixels;
+		bandDark.delete();
+		band.delete();
+		const inkOk =
+			brightFraction <= GATE_INK_BAND_MAX_BRIGHT &&
+			darkFraction >= GATE_INK_BAND_MIN_DARK;
+		gray.delete();
+
+		const score =
+			(darkOk / GATE_DARK_PROBES.length + (textOk ? 1 : 0) + (inkOk ? 1 : 0)) /
+			3;
+		return {
+			pass: darkOk === GATE_DARK_PROBES.length && textOk && inkOk,
+			score,
+		};
+	}
+
+	function parse(frame: Mat, t: number): DetectedEvent<MapStartData>[] {
+		const gray = new cv.Mat();
+		cv.cvtColor(frame, gray, cv.COLOR_RGBA2GRAY);
+
+		// 1. confirm the constant label — a gate hit without it is a lookalike
+		let label: RecognizedText | null = null;
+		let labelScore = 0;
+		if (labelGlyphs) {
+			const crop = copyRoi(gray, MODE_LABEL_ROI);
+			label = recognizeText(crop, labelGlyphs, {
+				binThreshold: TEXT_BIN_THRESHOLD,
+				minCharScore: 0.3,
+			});
+			crop.delete();
+			labelScore = closestBy(label.text, ALL_MODE_LABELS, (l) => l)?.score ?? 0;
+			if (labelScore < LABEL_MIN_SCORE) {
+				gray.delete();
+				return [];
+			}
+		}
+
+		// 2. mode title: find the 1-2 text lines, OCR each, snap the joined text
+		let mode: ModeShort | null = null;
+		let modeScore = 0;
+		let modeReading = "";
+		if (modeGlyphs) {
+			const block = copyRoi(gray, MODE_BLOCK_ROI);
+			// find line bands on the masked block (bright background rows would
+			// merge/invent bands) but OCR the raw crop (masking clips strokes and
+			// costs accuracy); each band is trimmed to its text columns (also
+			// from the mask) since the full-width block picks up background junk
+			const masked = maskNearDark(block, BLOCK_MASK_RADIUS);
+			const binary = new cv.Mat();
+			cv.threshold(masked, binary, TEXT_BIN_THRESHOLD, 255, cv.THRESH_BINARY);
+			masked.delete();
+			const bands = findLineBands(binary);
+			const lines: string[] = [];
+			for (const band of bands) {
+				const extent = bandExtent(binary, band);
+				if (!extent) continue;
+				const pad = 3;
+				const y0 = Math.max(0, band.y0 - pad);
+				const x0 = Math.max(0, extent.x0 - pad);
+				const line = copyRoi(block, {
+					x: x0,
+					y: y0,
+					w: Math.min(block.cols, extent.x1 + 1 + pad) - x0,
+					h: Math.min(block.rows, band.y1 + pad) - y0,
+				});
+				const read = recognizeText(line, modeGlyphs, {
+					binThreshold: TEXT_BIN_THRESHOLD,
+					minCharScore: 0.3,
+				});
+				line.delete();
+				if (read.text.trim()) lines.push(read.text.trim());
+			}
+			binary.delete();
+			block.delete();
+			modeReading = lines.join(" ");
+			const match = modeReading
+				? closestBy(modeReading, ALL_MODE_ENTRIES, (e) => e.text)
+				: null;
+			if (match) {
+				modeScore = match.score;
+				if (match.score >= MIN_MATCH_SCORE) mode = match.entry.mode;
+			}
+		}
+
+		// 3. stage name. Backdrop is live gameplay (dark water on one stage,
+		// a bright floor on another), so no single binarization works
+		// everywhere: read the near-dark-masked crop plus the raw crop at a
+		// few rising thresholds, and keep whichever snaps best.
+		let stage: StageId | null = null;
+		let stageScore = 0;
+		let stageReading = "";
+		if (stageGlyphs) {
+			const rgbaCrop = copyRoi(frame, STAGE_ROI);
+			const bright = minChannel(rgbaCrop);
+			rgbaCrop.delete();
+			const masked = maskNearDark(bright, STAGE_MASK_RADIUS);
+			const attempts: [Mat, number][] = [
+				[masked, STAGE_BIN_THRESHOLD],
+				...STAGE_RAW_BIN_THRESHOLDS.map((thr): [Mat, number] => [bright, thr]),
+			];
+			for (const [input, binThreshold] of attempts) {
+				const read = recognizeText(input, stageGlyphs, {
+					binThreshold,
+					minCharScore: 0.3,
+				});
+				const match = read.text
+					? closestBy(read.text, ALL_STAGE_ENTRIES, (e) => e.text)
+					: null;
+				if (match && match.score > stageScore) {
+					stageScore = match.score;
+					stageReading = read.text;
+					if (match.score >= MIN_MATCH_SCORE) stage = match.entry.stageId;
+				}
+			}
+			masked.delete();
+			bright.delete();
+		}
+
+		gray.delete();
+
+		return [
+			{
+				type: MAP_START_EVENT_TYPE,
+				t,
+				// mean like every other detector: a clean mode read must survive an
+				// unreadable stage (map-start is the only mode source for VoD matches),
+				// not be zeroed by it
+				confidence: (modeScore + stageScore) / 2,
+				data: { mode, stage },
+				debug: {
+					label: label?.text,
+					labelScore,
+					modeReading,
+					modeScore,
+					stageReading,
+					stageScore,
+				},
+			},
+		];
+	}
+
+	// just under the measured clean-read floor (fixtures 0.795-0.864,
+	// confirmed scan events 0.854-1.0)
+	return {
+		id: "map-start",
+		sufficientConfidence: 0.79,
+		gate,
+		parse,
+	};
+}
diff --git a/app/features/scanner/core/detectors/map-start/rois.ts b/app/features/scanner/core/detectors/map-start/rois.ts
new file mode 100644
index 000000000..da4ccbba2
--- /dev/null
+++ b/app/features/scanner/core/detectors/map-start/rois.ts
@@ -0,0 +1,97 @@
+/**
+ * ALL map-start ROI coordinates, in canonical 1920x1080 space.
+ * Calibrated against the map-start/ fixtures via row/column profiling.
+ *
+ * The match-intro splash overlays live gameplay: a black ink splat
+ * top-center with the constant "MODE" label (~48px caps), the mode title
+ * (~76px BlitzBold, up to two lines), and an objective subtitle; the
+ * stage name bottom-right (~40px); and eight players' splash tags along
+ * the left/right edges.
+ */
+import type { Roi } from "../../canonical";
+
+/**
+ * The constant "MODE" label (white caps centered x=960), kept tight
+ * inside the label's black pill (x≈825-1110): on bright stages
+ * (Mahi-Mahi) a wider crop picks up background that garbles the read.
+ */
+export const MODE_LABEL_ROI: Roi = { x: 850, y: 268, w: 220, h: 62 };
+export const MODE_LABEL_TEXT_HEIGHT = 48;
+
+/**
+ * Mode title block below the label, one or two lines (parse finds lines
+ * by row projection, not fixed positions). Ends above the objective
+ * subtitle (~y678); wide enough for the longest title ("Herrschaft" /
+ * "Spetterzone" ~660px) — at 520 wide the German H/t clipped ("lerrschaf").
+ */
+export const MODE_BLOCK_ROI: Roi = { x: 620, y: 380, w: 680, h: 285 };
+export const MODE_TEXT_HEIGHT = 76;
+
+/** A block row is text when it has at least this many bright pixels... */
+export const LINE_MIN_ROW_PIXELS = 40;
+/**
+ * ...and at least this fraction of the block's strongest row: background
+ * leak past the splat rim sets a scene-dependent floor (Robo ROM-en's
+ * bright mall merged title + junk into one 227px band without this).
+ */
+export const LINE_ROW_FRACTION = 0.25;
+/** Text rows closer than this merge into one line band. */
+export const LINE_GAP_TOLERANCE = 8;
+/** Discard bands shorter than this (splat-texture speckle, drips). */
+export const LINE_MIN_HEIGHT = 40;
+
+/** Stage name, bottom-right over live gameplay. */
+export const STAGE_ROI: Roi = { x: 1300, y: 984, w: 600, h: 56 };
+export const STAGE_TEXT_HEIGHT = 40;
+
+/** White text on the near-black splat binarizes cleanly and high. */
+export const TEXT_BIN_THRESHOLD = 190;
+
+/**
+ * Bright-background suppression (light stages like Mahi-Mahi: water ~200
+ * gray, docks 230+): text counts only near a near-black pixel (title
+ * borders splat ink, stage name has a drop shadow). Radius must exceed
+ * stroke half-width or it eats glyph cores: ~12 for the title, ~6 for
+ * the stage line.
+ */
+export const MASK_DARK_MAX = 70;
+export const BLOCK_MASK_RADIUS = 12;
+export const STAGE_MASK_RADIUS = 6;
+/**
+ * Stage line also reads the per-pixel min channel at a higher threshold
+ * (blue water drops via its low red channel, white glyphs stay near 255).
+ * When the mask fails on an all-bright backdrop (Robo ROM-en's mall
+ * floor), parse tries the raw crop at these thresholds and keeps the best.
+ */
+export const STAGE_BIN_THRESHOLD = 210;
+export const STAGE_RAW_BIN_THRESHOLDS: readonly number[] = [225, 235, 245];
+
+/**
+ * Gate probes: splat ink flanking the "MODE" label and before the title,
+ * on spots verified solid across fixtures (mean ≤8, well above ink yet
+ * under the dark scoreboard pills ~51+). Flanking pair sits outside x
+ * 838-1082, past the widest label text ("Kampfart", "Vechtstijl").
+ */
+export const GATE_DARK_PROBES: readonly Roi[] = [
+	{ x: 780, y: 280, w: 30, h: 20 },
+	{ x: 1105, y: 280, w: 30, h: 20 },
+	{ x: 850, y: 355, w: 30, h: 20 },
+	{ x: 1030, y: 355, w: 30, h: 20 },
+];
+export const GATE_DARK_MAX_MEAN = 45;
+
+/**
+ * Core of the label-to-title gap is solid splat ink: near-total darkness,
+ * zero bright pixels. Death's "Splatted by" line runs through here
+ * (bright fraction 0.17+); scoreboard pills only reach ~0.83 dark.
+ */
+export const GATE_INK_BAND: Roi = { x: 840, y: 350, w: 230, h: 36 };
+export const GATE_INK_BAND_MAX_BRIGHT = 0.005;
+export const GATE_INK_BAND_MIN_DARK = 0.95;
+
+/** MODE_LABEL_ROI must contain near-white pixels... */
+export const GATE_TEXT_MIN_MAX = 210;
+/** ...at a text fill fraction: "MODE" fills ~0.25 of the tight ROI, while
+ * stray white on the other screens stays under ~0.13. */
+export const GATE_TEXT_MIN_FRACTION = 0.05;
+export const GATE_TEXT_MAX_FRACTION = 0.35;
diff --git a/app/features/scanner/core/detectors/minimap/abilities.ts b/app/features/scanner/core/detectors/minimap/abilities.ts
new file mode 100644
index 000000000..c4b27d5ae
--- /dev/null
+++ b/app/features/scanner/core/detectors/minimap/abilities.ts
@@ -0,0 +1,24 @@
+/**
+ * Ability badge templates at the minimap cards' badge size (⌀~44 on both
+ * the own cards and the enemy panel; one role, mains only — the cards show
+ * no sub-ability slots). Built via the death panel's badge compositor.
+ */
+import type { FrameData } from "../../image";
+import { buildAbilityRole } from "../death/abilities";
+import type { WeaponTemplate } from "../scoreboard/weapons";
+import {
+	BADGE_ART_RATIO,
+	BADGE_TEMPLATE_SIZES,
+	MINIMAP_ABILITY_INK_THRESHOLD,
+} from "./rois";
+
+export function prepareMinimapAbilityTemplates(
+	icons: { id: string; image: FrameData }[],
+): WeaponTemplate[] {
+	return buildAbilityRole(
+		icons,
+		BADGE_TEMPLATE_SIZES,
+		BADGE_ART_RATIO,
+		MINIMAP_ABILITY_INK_THRESHOLD,
+	);
+}
diff --git a/app/features/scanner/core/detectors/minimap/index.ts b/app/features/scanner/core/detectors/minimap/index.ts
new file mode 100644
index 000000000..9b2ab6649
--- /dev/null
+++ b/app/features/scanner/core/detectors/minimap/index.ts
@@ -0,0 +1,657 @@
+/**
+ * MinimapDetector: parses the in-match map overlay (opened with X) — the
+ * own-team callout cards (name, main weapon, the three main-ability
+ * badges), the enemy panel rows (weapon, abilities; the game shows no
+ * enemy names) — plus the stage, matched from the drawn map (stage.ts).
+ * The goal is the most complete read of every card/row; per-match state
+ * (respawn cross-outs, special charge, map control) is deliberately not
+ * reported.
+ *
+ * Two screen states still steer the reads without being emitted:
+ * - a respawning player's card is struck through with a large team-color
+ *   X that covers the name and badges (own cards also lose the weapon;
+ *   enemy rows keep theirs — the X spares the row's weapon icon). Reading
+ *   through the X yields garbage, so an occlusion probe skips the covered
+ *   fields and reports them null;
+ * - a charged special swaps the card/row background for a light camo
+ *   pattern; weapons are full-color icon art matched against art-cropped
+ *   template sets composited for the surface actually behind them — bg-40
+ *   for the translucent dark cards/rows, bg-150 for the camo (dark
+ *   templates anti-correlate there) — so a corner-brightness probe picks
+ *   the template set, ink threshold, and score floor per card.
+ */
+
+import type {
+	AbilityWithUnknown,
+	MainWeaponId,
+	StageId,
+} from "~/modules/in-game-lists/types";
+import { toAbilityWithUnknown, toMainWeaponId } from "../../../scanner-types";
+import { getCV, type Mat } from "../../cv";
+import { type GlyphSet, scaleGlyphSet } from "../../glyphs";
+import {
+	copyRoi,
+	cropRoi,
+	laplacianAbs,
+	maxBrightness,
+	meanBrightness,
+	type Roi,
+} from "../../image";
+import type { ScoreboardResources } from "../scoreboard/index";
+import { type ParsedName, parseName } from "../scoreboard/names";
+import {
+	disambiguateWeaponBySub,
+	matchSpecial,
+	tiedWeaponsWithDistinctSubs,
+} from "../scoreboard/specials";
+import { matchWeapon, type WeaponMatch } from "../scoreboard/weapons";
+import type { DetectedEvent, Detector, GateResult } from "../types";
+import {
+	badgeRoi,
+	CARD_LAYOUTS,
+	type CardSlot,
+	CROSS_MIN_FRACTION,
+	CROSS_SATURATION_MIN,
+	CROSS_VALUE_MIN,
+	ENEMY_BADGE_XS,
+	ENEMY_ROW_CYS,
+	enemyCrossRoi,
+	enemySubTileRoi,
+	enemyWeaponRoi,
+	GATE_BRIGHT_MIN_MAX,
+	GATE_CLOSE_DARK_PROBES,
+	GATE_CLOSE_X_BRIGHT,
+	GATE_CLOSE_X_DARK,
+	GATE_DARK_MAX_MEAN,
+	GATE_SPAWN_BRIGHT,
+	GATE_SPAWN_DARK_PROBES,
+	GATE_SPECTATOR_X_BRIGHT,
+	GATE_SPECTATOR_X_DARK,
+	MINIMAP_ABILITY_INK_THRESHOLD,
+	MINIMAP_WEAPON_INK_THRESHOLD,
+	NAME_BIN_THRESHOLD,
+	NAME_TEXT_HEIGHT,
+	PRESENCE_MIN_LAPLACIAN,
+	SPECIAL_READY_INK_THRESHOLD,
+	SPECIAL_READY_MIN_CORNER_MEAN,
+	SPECIAL_READY_WEAPON_MIN_SCORE,
+	SPECTATOR_ENEMY_DX,
+	SPECTATOR_NAME_TEXT_HEIGHTS,
+	SPECTATOR_SLOTS,
+	spectatorCardLayout,
+	WEAPON_MIN_SCORE,
+} from "./rois";
+import { matchStage, plannerSignature, type StageMatch } from "./stage";
+
+export interface MinimapTeammate {
+	/** which callout card: super-jump slot, or the POV player's own card */
+	slot: CardSlot;
+	/** card name; null when covered by a respawn cross-out or unreadable */
+	name: string | null;
+	/** sendou main-weapon id; null when unreadable/covered */
+	weaponId: MainWeaponId | null;
+	/**
+	 * the card's three main abilities, [head, clothes, shoes] (null per
+	 * unreadable badge); empty when a respawn cross-out sits over the badges
+	 */
+	abilities: (AbilityWithUnknown | null)[];
+}
+
+export interface MinimapEnemy {
+	/**
+	 * the POV overlay shows no enemy names (always null there); the
+	 * spectator screen does, so spectator rows carry them
+	 */
+	name: string | null;
+	/** readable even on struck rows: the cross-out spares the weapon icon */
+	weaponId: MainWeaponId | null;
+	abilities: (AbilityWithUnknown | null)[];
+}
+
+export interface MinimapData {
+	/**
+	 * sendou stage id, matched from the drawn map against the planner
+	 * renders (stage.ts); null when no stage matched confidently or the
+	 * planner signatures were not loaded. The mode is not identifiable this
+	 * way (see stage.ts) and is left to the mode-bearing detectors.
+	 */
+	stage: StageId | null;
+	/**
+	 * true when the frame is a casted stream's 8-player spectator map screen
+	 * rather than the POV overlay: the alpha (left) column is reported as
+	 * teammates (d-pad slots up/right/down/left) and the bravo (right)
+	 * column as enemy rows — with names, which this screen shows
+	 */
+	spectator: boolean;
+	/** own-team callout cards; a slot missing from the frame is omitted */
+	teammates: MinimapTeammate[];
+	/** enemy panel rows, top to bottom */
+	enemies: MinimapEnemy[];
+}
+
+export const MINIMAP_EVENT_TYPE = "Minimap";
+
+/** Badge match below this is reported as null (kept in debug). */
+const ABILITY_MIN_SCORE = 0.45;
+
+/**
+ * Light-camo (special-charged) probe: min of the two 8x8 top-corner means
+ * of the weapon box. Camo backgrounds brighten both corners (140-165); on
+ * a dark card at least one stays dark even when avatar bleed or a
+ * cross-out stroke lights up the other.
+ */
+function minTopCornerMean(gray: Mat, roi: Roi): number {
+	const corners: Roi[] = [
+		{ x: roi.x, y: roi.y, w: 8, h: 8 },
+		{ x: roi.x + roi.w - 8, y: roi.y, w: 8, h: 8 },
+	];
+	return Math.min(...corners.map((c) => meanBrightness(gray, c)));
+}
+
+/** fraction of the probe that is saturated-and-bright (cross-out strokes) */
+function saturatedFraction(hsv: Mat, roi: Roi): number {
+	const m = copyRoi(hsv, roi);
+	const n = m.rows * m.cols;
+	const md = m.data;
+	let hit = 0;
+	for (let i = 0; i < n; i++) {
+		if (
+			md[i * 3 + 1]! >= CROSS_SATURATION_MIN &&
+			md[i * 3 + 2]! >= CROSS_VALUE_MIN
+		) {
+			hit++;
+		}
+	}
+	m.delete();
+	return hit / n;
+}
+
+export function createMinimapDetector(
+	resources: ScoreboardResources,
+): Detector<MinimapData> {
+	const cv = getCV();
+
+	const nameGlyphs: GlyphSet | null = resources.nameGlyphs
+		? scaleGlyphSet(
+				resources.nameGlyphs,
+				NAME_TEXT_HEIGHT / resources.nameGlyphs.height,
+			)
+		: null;
+	const spectatorNameGlyphs: GlyphSet[] = resources.nameGlyphs
+		? SPECTATOR_NAME_TEXT_HEIGHTS.map((h) =>
+				h === NAME_TEXT_HEIGHT
+					? nameGlyphs!
+					: scaleGlyphSet(
+							resources.nameGlyphs!,
+							h / resources.nameGlyphs!.height,
+						),
+			)
+		: [];
+	const cardWeapons = resources.minimapCardWeapons ?? null;
+	const lightWeapons = resources.minimapLightWeapons ?? null;
+	const badges = resources.minimapAbilities ?? null;
+	const subWeapons = resources.minimapSubWeapons ?? null;
+	const plannerStages = resources.plannerStages ?? null;
+
+	/** Identify the stage from the drawn map; contributes to confidence. */
+	function detectStage(frame: Mat, confidences: number[]): StageMatch | null {
+		if (!plannerStages?.length) return null;
+		const sig = plannerSignature(frame);
+		const match = matchStage(sig, plannerStages);
+		if (match) confidences.push(match.score);
+		return match;
+	}
+
+	function probeGate(
+		gray: Mat,
+		darkProbes: readonly Roi[],
+		brightProbes: readonly Roi[],
+	): GateResult {
+		let darkOk = 0;
+		for (const roi of darkProbes) {
+			if (meanBrightness(gray, roi) <= GATE_DARK_MAX_MEAN) darkOk++;
+		}
+		let brightOk = 0;
+		for (const roi of brightProbes) {
+			if (maxBrightness(gray, roi) >= GATE_BRIGHT_MIN_MAX) brightOk++;
+		}
+		return {
+			pass: darkOk === darkProbes.length && brightOk === brightProbes.length,
+			score: (darkOk / darkProbes.length + brightOk / brightProbes.length) / 2,
+		};
+	}
+
+	/** POV overlay chrome: close-button disc + Spawn Point pill. */
+	function overlayGate(gray: Mat): GateResult {
+		return probeGate(
+			gray,
+			[
+				...GATE_CLOSE_DARK_PROBES,
+				...GATE_CLOSE_X_DARK,
+				...GATE_SPAWN_DARK_PROBES,
+			],
+			[...GATE_CLOSE_X_BRIGHT, GATE_SPAWN_BRIGHT],
+		);
+	}
+
+	/** Spectator screen: the X jump-button disc beside the 8th player card. */
+	function spectatorGate(gray: Mat): GateResult {
+		return probeGate(gray, GATE_SPECTATOR_X_DARK, GATE_SPECTATOR_X_BRIGHT);
+	}
+
+	function gate(frame: Mat): GateResult {
+		const gray = new cv.Mat();
+		cv.cvtColor(frame, gray, cv.COLOR_RGBA2GRAY);
+		const overlay = overlayGate(gray);
+		const spectator = spectatorGate(gray);
+		gray.delete();
+		return {
+			pass: overlay.pass || spectator.pass,
+			score: Math.max(overlay.score, spectator.score),
+			variant: spectator.pass ? "spectator" : "overlay",
+		};
+	}
+
+	function matchBadges(
+		rgb: Mat,
+		centers: readonly (readonly [number, number])[],
+		inkThreshold: number,
+		confidences: number[],
+		debugRow: (WeaponMatch | null)[],
+	): (AbilityWithUnknown | null)[] {
+		if (!badges) return [null, null, null];
+		return centers.map(([cx, cy]) => {
+			const crop = cropRoi(rgb, badgeRoi(cx, cy));
+			const match = matchWeapon(crop, badges, { inkThreshold });
+			crop.delete();
+			debugRow.push(match);
+			confidences.push(Math.max(0, match.score));
+			return match.score >= ABILITY_MIN_SCORE
+				? toAbilityWithUnknown(match.id)
+				: null;
+		});
+	}
+
+	/**
+	 * Near-tied weapon icons whose kits differ by sub (plain vs Custom
+	 * Dualie Squelchers): let the card/row's team-tinted sub tile break the
+	 * tie. Shape-only matching survives the tint, the camo surface, and a
+	 * cross-out stroke clipping the tile.
+	 */
+	function resolveTieBySubTile(
+		rgb: Mat,
+		weapon: WeaponMatch,
+		tile: Roi,
+	): WeaponMatch {
+		if (!subWeapons?.length || !tiedWeaponsWithDistinctSubs(weapon))
+			return weapon;
+		const crop = cropRoi(rgb, tile);
+		const sub = matchSpecial(crop, subWeapons);
+		crop.delete();
+		return disambiguateWeaponBySub(weapon, sub);
+	}
+
+	/** Try the name band at each spectator glyph height; best read wins. */
+	function bestNameRead(gray: Mat, roi: Roi): ParsedName | null {
+		let best: ParsedName | null = null;
+		for (const set of spectatorNameGlyphs) {
+			const band = copyRoi(gray, roi);
+			const parsed = parseName(band, set, { binThreshold: NAME_BIN_THRESHOLD });
+			band.delete();
+			if (!best || parsed.confidence > best.confidence) best = parsed;
+		}
+		return best;
+	}
+
+	/**
+	 * The spectator screen's 8-card grid doesn't share the overlay's ROIs
+	 * (running the overlay parse against it reads phantom cards), so it gets
+	 * its own card loop: same fields per card, both columns carry names.
+	 */
+	function parseSpectator(
+		frame: Mat,
+		gray: Mat,
+		t: number,
+	): DetectedEvent<MinimapData>[] {
+		const rgb = new cv.Mat();
+		cv.cvtColor(frame, rgb, cv.COLOR_RGBA2RGB);
+		const hsv = new cv.Mat();
+		cv.cvtColor(rgb, hsv, cv.COLOR_RGB2HSV);
+		const lap = laplacianAbs(gray);
+
+		const confidences: number[] = [];
+		const debug: Record<string, unknown> = { spectator: true };
+
+		const teammates: MinimapTeammate[] = [];
+		const enemies: MinimapEnemy[] = [];
+		const cardDebug: Record<string, unknown>[] = [];
+		for (const dx of [0, SPECTATOR_ENEMY_DX]) {
+			for (let row = 0; row < 4; row++) {
+				const layout = spectatorCardLayout(row, dx);
+				const presence = meanBrightness(lap, layout.name);
+				if (presence < PRESENCE_MIN_LAPLACIAN) {
+					cardDebug.push({ dx, row, presence, skipped: true });
+					continue;
+				}
+				const crossFraction = saturatedFraction(hsv, layout.cross);
+				const occluded = crossFraction >= CROSS_MIN_FRACTION;
+				const cornerMin = minTopCornerMean(gray, layout.weapon);
+				const lightSurface = cornerMin >= SPECIAL_READY_MIN_CORNER_MEAN;
+
+				let name: string | null = null;
+				let nameRaw = "";
+				let weapon: WeaponMatch | null = null;
+				const badgeDebug: (WeaponMatch | null)[] = [];
+				let abilities: (AbilityWithUnknown | null)[] = [];
+				// the spectator cross-out sits clear of the weapon ROI (like
+				// overlay enemy rows), so the weapon stays readable when struck
+				const templates = lightSurface ? lightWeapons : cardWeapons;
+				if (templates) {
+					const crop = cropRoi(rgb, layout.weapon);
+					weapon = matchWeapon(crop, templates, {
+						inkThreshold: lightSurface
+							? SPECIAL_READY_INK_THRESHOLD
+							: Math.max(
+									MINIMAP_WEAPON_INK_THRESHOLD,
+									Math.round(cornerMin) + 50,
+								),
+					});
+					crop.delete();
+					weapon = resolveTieBySubTile(rgb, weapon, layout.subTile);
+					confidences.push(Math.max(0, weapon.score));
+				}
+				if (!occluded) {
+					const parsed = bestNameRead(gray, layout.name);
+					if (parsed) {
+						nameRaw = parsed.raw.text;
+						if (parsed.name.length > 0) name = parsed.name;
+						confidences.push(parsed.confidence);
+					}
+					abilities = matchBadges(
+						rgb,
+						layout.badges,
+						Math.max(MINIMAP_ABILITY_INK_THRESHOLD, Math.round(cornerMin) + 50),
+						confidences,
+						badgeDebug,
+					);
+				}
+				cardDebug.push({
+					dx,
+					row,
+					presence,
+					crossFraction,
+					occluded,
+					cornerMin,
+					lightSurface,
+					nameRaw,
+					weapon,
+					badges: badgeDebug,
+				});
+
+				const floor = lightSurface
+					? SPECIAL_READY_WEAPON_MIN_SCORE
+					: WEAPON_MIN_SCORE;
+				const matched =
+					weapon !== null && weapon.score >= floor ? weapon : null;
+				const fields = {
+					name,
+					weaponId: matched ? toMainWeaponId(matched.id) : null,
+					abilities,
+				};
+				if (dx === 0) {
+					teammates.push({ slot: SPECTATOR_SLOTS[row]!, ...fields });
+				} else {
+					enemies.push(fields);
+				}
+			}
+		}
+		debug.cards = cardDebug;
+
+		const stageMatch = detectStage(frame, confidences);
+		debug.stage = stageMatch;
+
+		rgb.delete();
+		hsv.delete();
+		lap.delete();
+
+		const confidence =
+			confidences.length > 0
+				? confidences.reduce((a, b) => a + b, 0) / confidences.length
+				: 0;
+
+		return [
+			{
+				type: MINIMAP_EVENT_TYPE,
+				t,
+				confidence,
+				data: {
+					stage: stageMatch?.stageId ?? null,
+					spectator: true,
+					teammates,
+					enemies,
+				},
+				debug,
+			},
+		];
+	}
+
+	function parse(
+		frame: Mat,
+		t: number,
+		gateResult?: GateResult,
+	): DetectedEvent<MinimapData>[] {
+		const gray = new cv.Mat();
+		cv.cvtColor(frame, gray, cv.COLOR_RGBA2GRAY);
+
+		const isSpectator = gateResult?.variant
+			? gateResult.variant === "spectator"
+			: spectatorGate(gray).pass;
+		if (isSpectator) {
+			const events = parseSpectator(frame, gray, t);
+			gray.delete();
+			return events;
+		}
+
+		const rgb = new cv.Mat();
+		cv.cvtColor(frame, rgb, cv.COLOR_RGBA2RGB);
+		const hsv = new cv.Mat();
+		cv.cvtColor(rgb, hsv, cv.COLOR_RGB2HSV);
+		const lap = laplacianAbs(gray);
+
+		const confidences: number[] = [];
+		const debug: Record<string, unknown> = {};
+
+		// 1. own-team callout cards
+		const teammates: MinimapTeammate[] = [];
+		const cardDebug: Record<string, unknown>[] = [];
+		for (const layout of CARD_LAYOUTS) {
+			// presence: the card is crisp UI, absent slots show blurred scene
+			const presence = meanBrightness(lap, layout.name);
+			if (presence < PRESENCE_MIN_LAPLACIAN) {
+				cardDebug.push({ slot: layout.slot, presence, skipped: true });
+				continue;
+			}
+			const crossFraction = saturatedFraction(hsv, layout.cross);
+			const occluded = crossFraction >= CROSS_MIN_FRACTION;
+			const cornerMin = minTopCornerMean(gray, layout.weapon);
+			const lightSurface = cornerMin >= SPECIAL_READY_MIN_CORNER_MEAN;
+
+			let name: string | null = null;
+			let nameRaw = "";
+			let weapon: WeaponMatch | null = null;
+			const badgeDebug: (WeaponMatch | null)[] = [];
+			let abilities: (AbilityWithUnknown | null)[] = [];
+			if (!occluded) {
+				if (nameGlyphs) {
+					const band = copyRoi(gray, layout.name);
+					const parsed = parseName(band, nameGlyphs, {
+						binThreshold: NAME_BIN_THRESHOLD,
+					});
+					band.delete();
+					nameRaw = parsed.raw.text;
+					if (parsed.name.length > 0) name = parsed.name;
+					confidences.push(parsed.confidence);
+				}
+				const templates = lightSurface ? lightWeapons : cardWeapons;
+				if (templates) {
+					const crop = cropRoi(rgb, layout.weapon);
+					weapon = matchWeapon(crop, templates, {
+						inkThreshold: lightSurface
+							? SPECIAL_READY_INK_THRESHOLD
+							: MINIMAP_WEAPON_INK_THRESHOLD,
+					});
+					crop.delete();
+					weapon = resolveTieBySubTile(rgb, weapon, layout.subTile);
+					confidences.push(Math.max(0, weapon.score));
+				}
+				abilities = matchBadges(
+					rgb,
+					layout.badges,
+					lightSurface
+						? Math.max(
+								MINIMAP_ABILITY_INK_THRESHOLD,
+								Math.round(cornerMin) + 50,
+							)
+						: MINIMAP_ABILITY_INK_THRESHOLD,
+					confidences,
+					badgeDebug,
+				);
+			}
+			cardDebug.push({
+				slot: layout.slot,
+				presence,
+				crossFraction,
+				occluded,
+				cornerMin,
+				lightSurface,
+				nameRaw,
+				weapon,
+				badges: badgeDebug,
+			});
+
+			const floor = lightSurface
+				? SPECIAL_READY_WEAPON_MIN_SCORE
+				: WEAPON_MIN_SCORE;
+			const matched = weapon !== null && weapon.score >= floor ? weapon : null;
+			// an occluding cross-out is itself proof the card is drawn
+			const hasEvidence =
+				occluded ||
+				name !== null ||
+				matched !== null ||
+				abilities.some((a) => a !== null);
+			if (!hasEvidence) continue;
+			teammates.push({
+				slot: layout.slot,
+				name,
+				weaponId: matched ? toMainWeaponId(matched.id) : null,
+				abilities,
+			});
+		}
+		debug.cards = cardDebug;
+
+		// 2. enemy panel rows
+		const enemies: MinimapEnemy[] = [];
+		const enemyDebug: Record<string, unknown>[] = [];
+		for (const cy of ENEMY_ROW_CYS) {
+			const weaponRoi = enemyWeaponRoi(cy);
+			const presence = meanBrightness(lap, weaponRoi);
+			if (presence < PRESENCE_MIN_LAPLACIAN) {
+				enemyDebug.push({ cy, presence, skipped: true });
+				continue;
+			}
+			const crossFraction = saturatedFraction(hsv, enemyCrossRoi(cy));
+			const occluded = crossFraction >= CROSS_MIN_FRACTION;
+
+			// light camo rows: pick the template variant by the weapon box's
+			// corner brightness and raise the ink threshold past that background
+			const cornerMin = minTopCornerMean(gray, weaponRoi);
+			const lightSurface = cornerMin >= SPECIAL_READY_MIN_CORNER_MEAN;
+			const templates = lightSurface ? lightWeapons : cardWeapons;
+			const inkThreshold = lightSurface
+				? SPECIAL_READY_INK_THRESHOLD
+				: Math.max(MINIMAP_WEAPON_INK_THRESHOLD, Math.round(cornerMin) + 50);
+
+			let weapon: WeaponMatch | null = null;
+			if (templates) {
+				const crop = cropRoi(rgb, weaponRoi);
+				weapon = matchWeapon(crop, templates, { inkThreshold });
+				crop.delete();
+				weapon = resolveTieBySubTile(rgb, weapon, enemySubTileRoi(cy));
+				confidences.push(Math.max(0, weapon.score));
+			}
+			const badgeDebug: (WeaponMatch | null)[] = [];
+			const abilities: (AbilityWithUnknown | null)[] = occluded
+				? []
+				: matchBadges(
+						rgb,
+						ENEMY_BADGE_XS.map((cx) => [cx, cy] as const),
+						Math.max(MINIMAP_ABILITY_INK_THRESHOLD, Math.round(cornerMin) + 50),
+						confidences,
+						badgeDebug,
+					);
+			enemyDebug.push({
+				cy,
+				presence,
+				crossFraction,
+				occluded,
+				lightSurface,
+				cornerMin,
+				weapon,
+				badges: badgeDebug,
+			});
+
+			const floor = lightSurface
+				? SPECIAL_READY_WEAPON_MIN_SCORE
+				: WEAPON_MIN_SCORE;
+			const matched = weapon !== null && weapon.score >= floor ? weapon : null;
+			enemies.push({
+				name: null,
+				weaponId: matched ? toMainWeaponId(matched.id) : null,
+				abilities,
+			});
+		}
+		debug.enemies = enemyDebug;
+
+		const stageMatch = detectStage(frame, confidences);
+		debug.stage = stageMatch;
+
+		gray.delete();
+		rgb.delete();
+		hsv.delete();
+		lap.delete();
+
+		const confidence =
+			confidences.length > 0
+				? confidences.reduce((a, b) => a + b, 0) / confidences.length
+				: 0;
+
+		return [
+			{
+				type: MINIMAP_EVENT_TYPE,
+				t,
+				confidence,
+				data: {
+					stage: stageMatch?.stageId ?? null,
+					spectator: false,
+					teammates,
+					enemies,
+				},
+				debug,
+			},
+		];
+	}
+
+	// sufficientConfidence sits just under the measured clean-read floor
+	// (fixtures 0.746-0.800; confirmed scan events reach down to 0.699, and
+	// those below the floor fall back to stagnation). The refine override
+	// matters here because a map-open's confidence keeps fluctuating upward,
+	// resetting the stagnation counter — without it a ~0.9s parse runs at
+	// the dense cadence for the whole map-open
+	return {
+		id: "minimap",
+		refineIntervalS: 0.4,
+		sufficientConfidence: 0.73,
+		gate,
+		parse,
+	};
+}
diff --git a/app/features/scanner/core/detectors/minimap/rois.ts b/app/features/scanner/core/detectors/minimap/rois.ts
new file mode 100644
index 000000000..12570c8c7
--- /dev/null
+++ b/app/features/scanner/core/detectors/minimap/rois.ts
@@ -0,0 +1,254 @@
+/**
+ * ALL minimap ROI coordinates, in canonical 1920x1080 space. Calibrated
+ * against the minimap/ fixtures via tools/dump-crops.ts plus template
+ * relocation sweeps (badges sit on an exact 48px pitch, pinning origins).
+ *
+ * The in-match map overlay (X) draws over gaussian-blurred gameplay: four
+ * own-team cards (POV player bottom-left) and an enemy panel top-right,
+ * each with weapon icon art, sub/special tiles, three ability badges
+ * (⌀~44); a respawning player is struck through with a team-color X, and
+ * a charged special swaps the card background for gray-green camo.
+ * Constant chrome (close disc, Spawn Point pill) gates on shape since the
+ * pill label is localized.
+ */
+import type { Roi } from "../../canonical";
+
+/** "self" and "down" never coexist: the POV overlay has no down slot (the
+ * player's own card replaces it), the spectator grid has no self card. */
+export type CardSlot = "up" | "left" | "right" | "self" | "down";
+
+export interface CardLayout {
+	slot: CardSlot;
+	/** name text band (BlitzMain caps ~29px plus outline/descender margin) */
+	name: Roi;
+	/** main-weapon silhouette box (icons render ~31-48px tall) */
+	weapon: Roi;
+	/** sub-weapon tile: saturated team-color art, the ink-color anchor */
+	subTile: Roi;
+	/** the three main-ability badge centers, 48px pitch */
+	badges: readonly (readonly [number, number])[];
+	/** cross-out probe at card center: name/pill are unsaturated, X core isn't */
+	cross: Roi;
+}
+
+/**
+ * Right card = left shifted +1352px (verified only on the struck fixture).
+ * Self card differs: avatar leftmost, larger name inset, no d-pad.
+ */
+export const CARD_LAYOUTS: readonly CardLayout[] = [
+	{
+		slot: "up",
+		name: { x: 872, y: 46, w: 300, h: 44 },
+		weapon: { x: 860, y: 83, w: 84, h: 54 },
+		subTile: { x: 932, y: 98, w: 38, h: 41 },
+		badges: [
+			[1066, 114],
+			[1114, 114],
+			[1162, 114],
+		],
+		cross: { x: 925, y: 78, w: 60, h: 32 },
+	},
+	{
+		slot: "left",
+		name: { x: 198, y: 492, w: 300, h: 44 },
+		weapon: { x: 193, y: 529, w: 84, h: 54 },
+		subTile: { x: 265, y: 544, w: 38, h: 41 },
+		badges: [
+			[392, 564],
+			[440, 564],
+			[488, 564],
+		],
+		cross: { x: 258, y: 524, w: 60, h: 32 },
+	},
+	{
+		slot: "right",
+		name: { x: 1550, y: 492, w: 300, h: 44 },
+		weapon: { x: 1545, y: 529, w: 84, h: 54 },
+		subTile: { x: 1617, y: 544, w: 38, h: 41 },
+		badges: [
+			[1744, 564],
+			[1792, 564],
+			[1840, 564],
+		],
+		cross: { x: 1610, y: 524, w: 60, h: 32 },
+	},
+	{
+		slot: "self",
+		name: { x: 126, y: 942, w: 300, h: 46 },
+		weapon: { x: 118, y: 985, w: 94, h: 55 },
+		subTile: { x: 193, y: 995, w: 38, h: 36 },
+		badges: [
+			[320, 1014],
+			[368, 1014],
+			[416, 1014],
+		],
+		cross: { x: 255, y: 968, w: 60, h: 32 },
+	},
+];
+
+/** Enemy panel row centers (65px pitch) and per-row element boxes. */
+export const ENEMY_ROW_CYS = [82, 147, 213, 278] as const;
+
+export function enemyWeaponRoi(cy: number): Roi {
+	return { x: 1541, y: cy - 26, w: 58, h: 52 };
+}
+export function enemySubTileRoi(cy: number): Roi {
+	return { x: 1602, y: cy - 20, w: 39, h: 40 };
+}
+export const ENEMY_BADGE_XS = [1730, 1778, 1826] as const;
+/** X arms meet in the dark gap between special tile and first badge (unsaturated when clean). */
+export function enemyCrossRoi(cy: number): Roi {
+	return { x: 1685, y: cy - 12, w: 28, h: 24 };
+}
+
+/** Badge search box (badges ⌀~44; the box height keeps larger sets out). */
+export function badgeRoi(cx: number, cy: number): Roi {
+	return { x: cx - 26, y: cy - 26, w: 52, h: 52 };
+}
+export const BADGE_TEMPLATE_SIZES = [38, 42, 46] as const;
+/** Badge art fills the circle like the death panel's mains. */
+export const BADGE_ART_RATIO = 1.0;
+/**
+ * Badge ink threshold: near-black circles vs the enemy panel's translucent
+ * pink bleed (~150-180 in corners) — a constant penalty, ranking intact.
+ */
+export const MINIMAP_ABILITY_INK_THRESHOLD = 90;
+
+/** BlitzMain caps measure 28-29px on every card (self included). */
+export const NAME_TEXT_HEIGHT = 29;
+export const NAME_BIN_THRESHOLD = 170;
+
+/** Cross-out probe: fraction of saturated+bright HSV pixels. Struck 0.26-0.38, clean <=0.01. */
+export const CROSS_SATURATION_MIN = 110;
+export const CROSS_VALUE_MIN = 110;
+export const CROSS_MIN_FRACTION = 0.08;
+
+/**
+ * Weapon templates built with cropToArt (54px card box needs padding
+ * trimmed to fit larger icons — Splatana Stamper unmatchable otherwise).
+ * Dark surfaces match a bg-40 composite, special-ready camo a bg-150 one.
+ */
+/**
+ * Sub-tile silhouettes matched shape-only (specials.ts): survives team
+ * tint/camo/cross-out, used to split near-tied main-weapon icons.
+ */
+export const SUB_TILE_TEMPLATE_SIZES = [24, 27, 30, 33, 36] as const;
+
+export const CARD_WEAPON_BACKGROUND = 40;
+export const SPECIAL_READY_BACKGROUND = 150;
+export const MINIMAP_WEAPON_TEMPLATE_SIZES = [
+	40, 44, 48, 52, 56, 60, 64,
+] as const;
+export const MINIMAP_WEAPON_INK_THRESHOLD = CARD_WEAPON_BACKGROUND + 50;
+export const SPECIAL_READY_INK_THRESHOLD = SPECIAL_READY_BACKGROUND + 50;
+/**
+ * Corner mean above this = special-ready camo (measures 140-165); a dark
+ * card keeps at least one top corner <=90 despite avatar/cross-out bleed.
+ */
+export const SPECIAL_READY_MIN_CORNER_MEAN = 120;
+/**
+ * Camo surfaces score systematically lower (blob pattern depresses NCC):
+ * 0.45-0.61 on correct matches vs 0.77+ on dark surfaces.
+ */
+export const WEAPON_MIN_SCORE = 0.55;
+export const SPECIAL_READY_WEAPON_MIN_SCORE = 0.42;
+
+/**
+ * Overlay is crisp over a blurred scene: mean |Laplacian| over the name
+ * band/weapon box separates a drawn element from see-through background.
+ */
+export const PRESENCE_MIN_LAPLACIAN = 8;
+
+/**
+ * Close-button gate: white ✕ on a dark disc (center (110,92) ±4px). Bright
+ * probes trace the crossing point + four arms, dark probes sit in the
+ * cardinal gaps — a plain bright blob misses the arms and fails.
+ */
+export const GATE_CLOSE_X_BRIGHT: readonly Roi[] = [
+	{ x: 104, y: 88, w: 12, h: 10 },
+	{ x: 88, y: 72, w: 8, h: 10 },
+	{ x: 124, y: 72, w: 8, h: 10 },
+	{ x: 88, y: 108, w: 8, h: 10 },
+	{ x: 124, y: 108, w: 8, h: 10 },
+];
+export const GATE_CLOSE_X_DARK: readonly Roi[] = [
+	{ x: 104, y: 62, w: 12, h: 8 },
+	{ x: 104, y: 116, w: 12, h: 8 },
+	{ x: 76, y: 88, w: 8, h: 10 },
+	{ x: 136, y: 88, w: 8, h: 10 },
+];
+/** Dark ring/background just outside the close-button disc. */
+export const GATE_CLOSE_DARK_PROBES: readonly Roi[] = [
+	{ x: 88, y: 50, w: 20, h: 14 },
+	{ x: 88, y: 132, w: 20, h: 14 },
+	{ x: 58, y: 88, w: 14, h: 20 },
+	{ x: 132, y: 88, w: 14, h: 20 },
+];
+/** The white jump-arrows icon left of the (localized) pill label. */
+export const GATE_SPAWN_BRIGHT: Roi = { x: 888, y: 963, w: 60, h: 60 };
+export const GATE_SPAWN_DARK_PROBES: readonly Roi[] = [
+	{ x: 812, y: 958, w: 26, h: 14 },
+	{ x: 950, y: 1024, w: 60, h: 12 },
+];
+export const GATE_DARK_MAX_MEAN = 85;
+export const GATE_BRIGHT_MIN_MAX = 210;
+
+/**
+ * Spectator-variant gate: casted streams show the 8-player spectator
+ * screen and often cover the overlay gate's corner chrome, so this gates
+ * on the rarely-covered X jump-button disc beside the 8th card
+ * (bottom-right, center (1424,712) ±4px). Measured margins: bright>=249 /
+ * dark<=65 against the shared 210/85 thresholds.
+ */
+export const GATE_SPECTATOR_X_BRIGHT: readonly Roi[] = [
+	{ x: 1418, y: 706, w: 12, h: 12 },
+	{ x: 1411, y: 692, w: 12, h: 12 },
+	{ x: 1425, y: 692, w: 12, h: 12 },
+	{ x: 1411, y: 720, w: 12, h: 12 },
+	{ x: 1425, y: 720, w: 12, h: 12 },
+];
+export const GATE_SPECTATOR_X_DARK: readonly Roi[] = [
+	{ x: 1399, y: 708, w: 8, h: 8 },
+	{ x: 1441, y: 708, w: 8, h: 8 },
+	{ x: 1420, y: 682, w: 8, h: 8 },
+	{ x: 1420, y: 734, w: 8, h: 8 },
+];
+
+/**
+ * Spectator card grid: four cards per column, 120px row pitch, right =
+ * left +1348px. Left column is alpha team, right is bravo (reported as
+ * enemy rows). Mirrors the overlay's card layout; no struck/special-ready
+ * fixture attested yet, so those probes reuse overlay thresholds untuned.
+ */
+export const SPECTATOR_SLOTS: readonly CardSlot[] = [
+	"up",
+	"right",
+	"down",
+	"left",
+];
+export const SPECTATOR_ENEMY_DX = 1348;
+const SPECTATOR_ROW_PITCH = 120;
+
+export function spectatorCardLayout(
+	row: number,
+	dx: number,
+): Omit<CardLayout, "slot"> {
+	const dy = SPECTATOR_ROW_PITCH * row;
+	return {
+		name: { x: 198 + dx, y: 306 + dy, w: 310, h: 44 },
+		weapon: { x: 196 + dx, y: 350 + dy, w: 66, h: 54 },
+		subTile: { x: 264 + dx, y: 354 + dy, w: 38, h: 42 },
+		badges: [
+			[390 + dx, 374 + dy],
+			[438 + dx, 374 + dy],
+			[486 + dx, 374 + dy],
+		],
+		cross: { x: 344 + dx, y: 362 + dy, w: 20, h: 24 },
+	};
+}
+
+/**
+ * Spectator names tried at both heights, more confident read wins: blur
+ * across captures moves the best fit between 29 and 30 per card.
+ */
+export const SPECTATOR_NAME_TEXT_HEIGHTS = [29, 30] as const;
diff --git a/app/features/scanner/core/detectors/minimap/stage.ts b/app/features/scanner/core/detectors/minimap/stage.ts
new file mode 100644
index 000000000..ace2d744d
--- /dev/null
+++ b/app/features/scanner/core/detectors/minimap/stage.ts
@@ -0,0 +1,224 @@
+/**
+ * Stage identification for the minimap overlay by matching the drawn map
+ * against sendou.ink planner renders (assets/cv/planner/, one PNG per
+ * stage x mode, packed as a signature atlas).
+ *
+ * The map is drawn sharp over blurred gameplay, so a Laplacian edge mask
+ * isolates it; dropping saturated (team-ink) edges leaves a structural,
+ * ink-invariant signature. Downscaling+blurring also absorbs the POV (map
+ * fills screen) vs spectator (map smaller, centered) scale/offset
+ * difference, letting one atlas serve both via a translation search.
+ *
+ * Stage separates cleanly this way (NCC leads the next stage by
+ * ~0.17-0.26). Mode does NOT — the objective marker is the only per-mode
+ * difference and ink-invariance strips it — so the atlas keeps all five
+ * renders per stage and reports only the winning tile's stage; mode comes
+ * from map-start/scoreboard header instead.
+ */
+import type { StageId } from "~/modules/in-game-lists/types";
+import { getCV, type Mat } from "../../cv";
+import type { FrameData } from "../../image";
+
+/** Downscaled signature dimensions (canonical 1920x1080 / 16). */
+export const PLANNER_SIG_W = 120;
+export const PLANNER_SIG_H = 68;
+/** |Laplacian| floor separating render edges from the blur (blur ~0-5). */
+const EDGE_MIN = 24;
+/** HSV saturation at/above which an edge pixel is team ink, not structure. */
+const INK_SATURATION_MIN = 80;
+/** Half-range (signature px, ~16x canonical) of the alignment search. */
+const MATCH_RANGE = 8;
+/** Below this best NCC, or this lead over the next stage, report nothing. */
+const MIN_SCORE = 0.5;
+const MIN_MARGIN = 0.05;
+
+export interface PlannerStage {
+	/** "<stageId>-<MODE>", e.g. "6-SZ" */
+	key: string;
+	/** sendou stage id */
+	stageId: StageId;
+	/** unit-L2-normalized structural signature, row-major PLANNER_SIG_W x _H */
+	sig: Float32Array;
+}
+
+export interface StageMatch {
+	stageId: StageId;
+	/** best NCC of the winning stage */
+	score: number;
+	/** lead over the best-scoring other stage */
+	margin: number;
+}
+
+/**
+ * Ink-invariant structural signature of a canonical-normalized RGBA frame:
+ * downscaled, blurred, unit-L2-normalized float mask of the non-ink render
+ * edges. Shared by the build tool and the runtime matcher so the atlas and
+ * the live frame are computed identically.
+ */
+export function plannerSignature(frame: Mat): Float32Array {
+	const cv = getCV();
+	const gray = new cv.Mat();
+	cv.cvtColor(frame, gray, cv.COLOR_RGBA2GRAY);
+	const rgb = new cv.Mat();
+	cv.cvtColor(frame, rgb, cv.COLOR_RGBA2RGB);
+	const hsv = new cv.Mat();
+	cv.cvtColor(rgb, hsv, cv.COLOR_RGB2HSV);
+	rgb.delete();
+
+	const lap = new cv.Mat();
+	cv.Laplacian(gray, lap, cv.CV_16S, 3);
+	gray.delete();
+	const edges = new cv.Mat();
+	cv.convertScaleAbs(lap, edges);
+	lap.delete();
+	const mask = new cv.Mat();
+	cv.threshold(edges, mask, EDGE_MIN, 255, cv.THRESH_BINARY);
+	edges.delete();
+
+	// drop saturated (ink) edges, keeping only the structural skeleton
+	const n = mask.rows * mask.cols;
+	const md = mask.data;
+	const hd = hsv.data;
+	for (let i = 0; i < n; i++) {
+		if (hd[i * 3 + 1]! >= INK_SATURATION_MIN) md[i] = 0;
+	}
+	hsv.delete();
+
+	const down = new cv.Mat();
+	cv.resize(
+		mask,
+		down,
+		new cv.Size(PLANNER_SIG_W, PLANNER_SIG_H),
+		0,
+		0,
+		cv.INTER_AREA,
+	);
+	mask.delete();
+	const blur = new cv.Mat();
+	cv.GaussianBlur(down, blur, new cv.Size(5, 5), 0);
+	down.delete();
+
+	const out = new Float32Array(PLANNER_SIG_W * PLANNER_SIG_H);
+	const bd = blur.data;
+	let sumSq = 0;
+	for (let i = 0; i < out.length; i++) {
+		out[i] = bd[i]!;
+		sumSq += out[i]! * out[i]!;
+	}
+	blur.delete();
+	const norm = Math.sqrt(sumSq) || 1;
+	for (let i = 0; i < out.length; i++) out[i]! /= norm;
+	return out;
+}
+
+/** Dot product of `a` against `b` shifted by (dx, dy) over their overlap. */
+function shiftedDot(
+	a: Float32Array,
+	b: Float32Array,
+	dx: number,
+	dy: number,
+): number {
+	let dot = 0;
+	for (let y = 0; y < PLANNER_SIG_H; y++) {
+		const sy = y + dy;
+		if (sy < 0 || sy >= PLANNER_SIG_H) continue;
+		const ar = y * PLANNER_SIG_W;
+		const br = sy * PLANNER_SIG_W;
+		for (let x = 0; x < PLANNER_SIG_W; x++) {
+			const sx = x + dx;
+			if (sx < 0 || sx >= PLANNER_SIG_W) continue;
+			dot += a[ar + x]! * b[br + sx]!;
+		}
+	}
+	return dot;
+}
+
+/** Best NCC of two unit signatures over a small translation search. */
+function bestNcc(a: Float32Array, b: Float32Array): number {
+	let best = -1;
+	for (let dy = -MATCH_RANGE; dy <= MATCH_RANGE; dy += 2) {
+		for (let dx = -MATCH_RANGE; dx <= MATCH_RANGE; dx += 2) {
+			const v = shiftedDot(a, b, dx, dy);
+			if (v > best) best = v;
+		}
+	}
+	return best;
+}
+
+/**
+ * Identify the stage of a minimap frame's signature against the planner
+ * atlas. Returns null when no stage matches confidently (score floor) or two
+ * stages are too close to call (margin floor) — e.g. a stage not in the set.
+ */
+export function matchStage(
+	sig: Float32Array,
+	planners: readonly PlannerStage[],
+): StageMatch | null {
+	if (planners.length === 0) return null;
+	const byStage = new Map<StageId, number>();
+	for (const p of planners) {
+		const score = bestNcc(sig, p.sig);
+		const prev = byStage.get(p.stageId);
+		if (prev === undefined || score > prev) byStage.set(p.stageId, score);
+	}
+	let bestId: StageId | null = null;
+	let best = -1;
+	let second = -1;
+	for (const [id, score] of byStage) {
+		if (score > best) {
+			second = best;
+			best = score;
+			bestId = id;
+		} else if (score > second) {
+			second = score;
+		}
+	}
+	const margin = second < 0 ? best : best - second;
+	if (bestId === null || best < MIN_SCORE || margin < MIN_MARGIN) return null;
+	return {
+		stageId: bestId,
+		score: Math.round(best * 1000) / 1000,
+		margin: Math.round(margin * 1000) / 1000,
+	};
+}
+
+export interface PlannerManifest {
+	width: number;
+	height: number;
+	/** tiles packed left-to-right, top-to-bottom, this many per row */
+	cols: number;
+	/** tile keys in packing order */
+	keys: string[];
+}
+
+/**
+ * Slice the packed signature atlas (grayscale uint8 tiles) back into
+ * unit-normalized PlannerStage signatures. Mirrors loadGlyphSet's atlas
+ * convention; the build tool writes the atlas + manifest.
+ */
+export function loadPlannerStages(
+	atlas: FrameData,
+	manifest: PlannerManifest,
+): PlannerStage[] {
+	const { width, height, cols, keys } = manifest;
+	const aw = atlas.width;
+	const data = atlas.data;
+	return keys.map((key, i) => {
+		const tx = (i % cols) * width;
+		const ty = Math.floor(i / cols) * height;
+		const sig = new Float32Array(width * height);
+		let sumSq = 0;
+		for (let y = 0; y < height; y++) {
+			for (let x = 0; x < width; x++) {
+				// atlas is RGBA; the tiles are grayscale, so read the red channel
+				const v = data[((ty + y) * aw + (tx + x)) * 4]!;
+				sig[y * width + x] = v;
+				sumSq += v * v;
+			}
+		}
+		const norm = Math.sqrt(sumSq) || 1;
+		for (let j = 0; j < sig.length; j++) sig[j]! /= norm;
+		const stageId = Number(key.split("-")[0]) as StageId;
+		return { key, stageId, sig };
+	});
+}
diff --git a/app/features/scanner/core/detectors/objective/index.ts b/app/features/scanner/core/detectors/objective/index.ts
new file mode 100644
index 000000000..e4cd13ef2
--- /dev/null
+++ b/app/features/scanner/core/detectors/objective/index.ts
@@ -0,0 +1,360 @@
+/**
+ * ObjectiveDetector: parses the ranked in-match counter overlay top-center —
+ * each team's count plate, the penalty pill under it, which team is in
+ * control (controlling team's plate keeps its saturated team-color fill;
+ * otherwise near-black fill with digits in the team's ink color — see
+ * rois.ts), and the M:SS match timer above the plates.
+ *
+ * Digits are read as the trailing digit run (banner.ts) under several
+ * channel extractions — team-color ink on a black plate needs the
+ * brightest channel (dark blue ink is near-black in luminance), ink on a
+ * team-color fill needs the darkest channel — every extraction is tried at
+ * each threshold/size and the best-scoring read wins. A gate hit with no
+ * readable count on either side emits nothing (lookalike frame).
+ *
+ * `ObjectiveData` is a discriminated union on `mode`; only SZ exists so
+ * far. Identifying mode from the badge between the plates awaits TC/RM/CB
+ * fixtures.
+ */
+import { getCV, type Mat, minMaxLoc } from "../../cv";
+import {
+	type GlyphSet,
+	type RecognizedChar,
+	recognizeText,
+	scaleGlyphSet,
+} from "../../glyphs";
+import {
+	copyRoi,
+	maxBrightness,
+	maxChannel,
+	meanBrightness,
+	minChannel,
+	type Roi,
+} from "../../image";
+import {
+	type BannerScoreRead,
+	isBetterRead,
+	trailingDigitRun,
+} from "../scoreboard/banner";
+import type { ScoreboardResources } from "../scoreboard/index";
+import type { DetectedEvent, Detector, GateResult } from "../types";
+import {
+	CONTROL_PLATE_MIN_SATURATION,
+	GATE_PLATE_MAX_STD,
+	GATE_SCORE_MIN_MAX_BRIGHTNESS,
+	GATE_TIMER_MAX_MEAN,
+	GATE_TIMER_MIN_MAX_BRIGHTNESS,
+	PENALTY_BIN_THRESHOLD,
+	PENALTY_PROBE_MAX_MEAN,
+	PENALTY_PROBE_MAX_STD,
+	PENALTY_PROBE_ROIS,
+	PENALTY_ROIS,
+	PENALTY_TEXT_HEIGHT,
+	PLATE_PROBE_ROIS,
+	SCORE_BIN_THRESHOLDS,
+	SCORE_ROIS,
+	SCORE_TEXT_HEIGHTS,
+	TIMER_BIN_THRESHOLD,
+	TIMER_DARK_PROBES,
+	TIMER_DIGIT_MIN_CONF,
+	TIMER_DIGIT_MIN_HEIGHT_RATIO,
+	TIMER_DIGIT_ROI,
+	TIMER_TEXT_HEIGHT,
+} from "./rois";
+
+export type ObjectiveData = SplatZonesObjectiveData;
+
+export interface SplatZonesObjectiveData {
+	mode: "SZ";
+	/**
+	 * seconds shown on the match timer above the plates ("3:35" = 215);
+	 * null = unreadable. Counts down in regulation; the overtime display is
+	 * unattested so far.
+	 */
+	time: number | null;
+	/** displayed count per team, [alpha, bravo]; null = unreadable */
+	score: [number | null, number | null];
+	/** penalty pill value per team; null = no pill (or unreadable) */
+	penalty: [number | null, number | null];
+	/** which team currently holds the zone (team-color plate fill) */
+	control: [boolean, boolean];
+}
+
+export const OBJECTIVE_EVENT_TYPE = "Objective";
+
+/** How often the counter is worth checking (it changes at most 1/s). */
+const CHECK_INTERVAL_SECONDS = 1;
+
+/**
+ * Timeline content guard: consecutive counter reads merge only when they
+ * show the same state, so every actual tick/penalty/control change becomes
+ * its own event. `time` is deliberately not compared — the timer ticks
+ * every second, so comparing it would keep any two reads from ever merging.
+ */
+export function sameObjectiveData(a: unknown, b: unknown): boolean {
+	const da = a as ObjectiveData;
+	const db = b as ObjectiveData;
+	return (
+		da.mode === db.mode &&
+		da.score[0] === db.score[0] &&
+		da.score[1] === db.score[1] &&
+		da.penalty[0] === db.penalty[0] &&
+		da.penalty[1] === db.penalty[1] &&
+		da.control[0] === db.control[0] &&
+		da.control[1] === db.control[1]
+	);
+}
+
+interface SideRead {
+	score: BannerScoreRead;
+	penalty: BannerScoreRead | null;
+	control: boolean;
+	fill: { mean: number; saturation: number };
+}
+
+export function createObjectiveDetector(
+	resources: ScoreboardResources,
+): Detector<ObjectiveData> {
+	const cv = getCV();
+
+	const scoreSets: GlyphSet[] = resources.paintDigits
+		? SCORE_TEXT_HEIGHTS.map((h) =>
+				scaleGlyphSet(
+					resources.paintDigits!,
+					h / resources.paintDigits!.height,
+				),
+			)
+		: [];
+	const penaltySet: GlyphSet | null = resources.paintDigits
+		? scaleGlyphSet(
+				resources.paintDigits,
+				PENALTY_TEXT_HEIGHT / resources.paintDigits.height,
+			)
+		: null;
+	const timerSet: GlyphSet | null = resources.paintDigits
+		? scaleGlyphSet(
+				resources.paintDigits,
+				TIMER_TEXT_HEIGHT / resources.paintDigits.height,
+			)
+		: null;
+
+	/** Mean and standard deviation of a grayscale ROI. */
+	function meanStd(gray: Mat, roi: Roi): { mean: number; std: number } {
+		const crop = copyRoi(gray, roi);
+		const { data } = crop;
+		let sum = 0;
+		for (const v of data) sum += v;
+		const mean = sum / data.length;
+		let varSum = 0;
+		for (const v of data) varSum += (v - mean) ** 2;
+		crop.delete();
+		return { mean, std: Math.sqrt(varSum / data.length) };
+	}
+
+	function plateProbeOk(gray: Mat, roi: Roi): boolean {
+		return meanStd(gray, roi).std <= GATE_PLATE_MAX_STD;
+	}
+
+	function scoreInkOk(frame: Mat, roi: Roi): boolean {
+		const band = maxChannel(frame, roi);
+		const { maxVal } = minMaxLoc(band);
+		band.delete();
+		return maxVal >= GATE_SCORE_MIN_MAX_BRIGHTNESS;
+	}
+
+	function gate(frame: Mat): GateResult {
+		const gray = new cv.Mat();
+		cv.cvtColor(frame, gray, cv.COLOR_RGBA2GRAY);
+		const checks = [
+			...TIMER_DARK_PROBES.map(
+				(roi) => meanBrightness(gray, roi) <= GATE_TIMER_MAX_MEAN,
+			),
+			maxBrightness(gray, TIMER_DIGIT_ROI) >= GATE_TIMER_MIN_MAX_BRIGHTNESS,
+			plateProbeOk(gray, PLATE_PROBE_ROIS[0]),
+			plateProbeOk(gray, PLATE_PROBE_ROIS[1]),
+			scoreInkOk(frame, SCORE_ROIS[0]),
+			scoreInkOk(frame, SCORE_ROIS[1]),
+		];
+		gray.delete();
+		const passed = checks.filter(Boolean).length;
+		return { pass: passed === checks.length, score: passed / checks.length };
+	}
+
+	/**
+	 * Best trailing-digit read of the band across channel extractions,
+	 * thresholds, and glyph sizes (see module header for why one pass
+	 * cannot cover both plate styles).
+	 */
+	function readScore(frame: Mat, gray: Mat, roi: Roi): BannerScoreRead {
+		let best: BannerScoreRead = {
+			value: null,
+			confidence: 0,
+			digits: 0,
+			reading: "",
+		};
+		const bands = [
+			copyRoi(gray, roi),
+			minChannel(frame, roi),
+			maxChannel(frame, roi),
+		];
+		for (const band of bands) {
+			for (const set of scoreSets) {
+				for (const binThreshold of SCORE_BIN_THRESHOLDS) {
+					const raw = recognizeText(band, set, {
+						binThreshold,
+						spaceGap: Number.POSITIVE_INFINITY,
+						minCharScore: 0.3,
+					});
+					const read = trailingDigitRun(raw, set);
+					if (isBetterRead(read, best)) best = read;
+				}
+			}
+			band.delete();
+		}
+		return best;
+	}
+
+	/**
+	 * The match timer's M:SS over TIMER_DIGIT_ROI: white digits on the
+	 * near-black box the gate already anchored on. The colon's two dots stack
+	 * to well under the digit height floor, so a valid read is exactly three
+	 * full-height digits — the minute, then the two second digits.
+	 */
+	function readTimer(gray: Mat): { value: number | null; reading: string } {
+		if (!timerSet) return { value: null, reading: "" };
+		const band = copyRoi(gray, TIMER_DIGIT_ROI);
+		const raw = recognizeText(band, timerSet, {
+			binThreshold: TIMER_BIN_THRESHOLD,
+			spaceGap: Number.POSITIVE_INFINITY,
+			minCharScore: 0.3,
+		});
+		band.delete();
+		const isTimerDigit = (c: RecognizedChar) =>
+			c.score >= TIMER_DIGIT_MIN_CONF &&
+			c.y1 - c.y0 >= timerSet.height * TIMER_DIGIT_MIN_HEIGHT_RATIO;
+		const digits = raw.chars.filter(isTimerDigit).map((c) => Number(c.char));
+		if (digits.length !== 3 || digits.some(Number.isNaN)) {
+			return { value: null, reading: raw.text };
+		}
+		const [minutes, secondsTens, secondsOnes] = digits as [
+			number,
+			number,
+			number,
+		];
+		if (secondsTens >= 6) return { value: null, reading: raw.text };
+		return {
+			value: minutes * 60 + secondsTens * 10 + secondsOnes,
+			reading: raw.text,
+		};
+	}
+
+	/** Penalty pill: presence probes first, then the white "+N" digits. */
+	function readPenalty(
+		frame: Mat,
+		gray: Mat,
+		side: 0 | 1,
+	): BannerScoreRead | null {
+		if (!penaltySet) return null;
+		const pillLike = PENALTY_PROBE_ROIS[side].every((roi) => {
+			const { mean, std } = meanStd(gray, roi);
+			return mean <= PENALTY_PROBE_MAX_MEAN && std <= PENALTY_PROBE_MAX_STD;
+		});
+		if (!pillLike) return null;
+		const band = minChannel(frame, PENALTY_ROIS[side]);
+		const raw = recognizeText(band, penaltySet, {
+			binThreshold: PENALTY_BIN_THRESHOLD,
+			spaceGap: Number.POSITIVE_INFINITY,
+			minCharScore: 0.3,
+		});
+		band.delete();
+		return trailingDigitRun(raw, penaltySet);
+	}
+
+	/**
+	 * Control: the plate's fill (sampled over the probe strip) is the
+	 * saturated team-color style instead of the near-black fill shown while
+	 * not in control (see CONTROL_PLATE_MIN_SATURATION in rois.ts).
+	 */
+	function plateFill(
+		frame: Mat,
+		side: 0 | 1,
+	): { mean: number; saturation: number } {
+		const crop = copyRoi(frame, PLATE_PROBE_ROIS[side]);
+		const { data } = crop;
+		const channels = crop.channels();
+		let sum = 0;
+		let satSum = 0;
+		let count = 0;
+		for (let i = 0; i < data.length; i += channels) {
+			const r = data[i]!;
+			const g = data[i + 1]!;
+			const b = data[i + 2]!;
+			sum += Math.max(r, g, b);
+			satSum += Math.max(r, g, b) - Math.min(r, g, b);
+			count++;
+		}
+		crop.delete();
+		return { mean: sum / count, saturation: satSum / count };
+	}
+
+	function parse(frame: Mat, t: number): DetectedEvent<ObjectiveData>[] {
+		const gray = new cv.Mat();
+		cv.cvtColor(frame, gray, cv.COLOR_RGBA2GRAY);
+
+		const sides = [0 as const, 1 as const].map((side): SideRead => {
+			const score = readScore(frame, gray, SCORE_ROIS[side]);
+			const penalty = readPenalty(frame, gray, side);
+			const fill = plateFill(frame, side);
+			return {
+				score,
+				penalty,
+				control:
+					score.value !== null &&
+					fill.saturation >= CONTROL_PLATE_MIN_SATURATION,
+				fill,
+			};
+		}) as [SideRead, SideRead];
+		const timer = readTimer(gray);
+		gray.delete();
+
+		// no readable count on either side = the gate hit a lookalike
+		if (sides.every((side) => side.score.value === null)) return [];
+
+		const confidences = sides.flatMap((side) => [
+			...(side.score.value !== null ? [side.score.confidence] : []),
+			...(side.penalty?.value != null ? [side.penalty.confidence] : []),
+		]);
+		return [
+			{
+				type: OBJECTIVE_EVENT_TYPE,
+				t,
+				confidence: confidences.reduce((a, b) => a + b, 0) / confidences.length,
+				data: {
+					mode: "SZ",
+					time: timer.value,
+					score: [sides[0].score.value, sides[1].score.value],
+					penalty: [
+						sides[0].penalty?.value ?? null,
+						sides[1].penalty?.value ?? null,
+					],
+					control: [sides[0].control, sides[1].control],
+				},
+				debug: {
+					timerReading: timer.reading,
+					scoreReadings: sides.map((side) => side.score.reading),
+					scoreConfidences: sides.map((side) => side.score.confidence),
+					penaltyReadings: sides.map((side) => side.penalty?.reading ?? null),
+					plateFills: sides.map((side) => side.fill),
+				},
+			},
+		];
+	}
+
+	return {
+		id: "objective",
+		checkIntervalS: CHECK_INTERVAL_SECONDS,
+		attachFrame: false,
+		gate,
+		parse,
+	};
+}
diff --git a/app/features/scanner/core/detectors/objective/rois.ts b/app/features/scanner/core/detectors/objective/rois.ts
new file mode 100644
index 000000000..1f12bbe8e
--- /dev/null
+++ b/app/features/scanner/core/detectors/objective/rois.ts
@@ -0,0 +1,118 @@
+/**
+ * ALL objective-counter ROI coordinates, in canonical 1920x1080 space.
+ * Calibrated against the objective/ fixtures (pixel maps over the
+ * top-center band). Layout is only roughly mirror-symmetric around x=960
+ * (widest digit run "100" measures x816..888 left, x1039..1112 right), so
+ * score/plate-probe ROIs are measured per side, not mirrored.
+ *
+ * One counter plate per team flanks the mode's objective badge under the
+ * timer strip: small localized label line over big BlitzBold count
+ * digits (~41px). The controlling team's plate fills team-color; a
+ * non-controlling team (or both while neutral) is near-black with digits
+ * in team ink — the fill swap, not digit values, identifies control. A
+ * penalty adds a dark pill under the plate with a white "+N" (~29px).
+ */
+import { CANONICAL_WIDTH, type Roi } from "../../canonical";
+
+/** Mirror a left-side ROI across the frame's vertical center line. */
+function mirrorRoi(roi: Roi): Roi {
+	return { ...roi, x: CANONICAL_WIDTH - roi.x - roi.w };
+}
+
+/**
+ * Count digit band inside the plate below the label line. Wide enough
+ * for the full "100" run each side (x816..888 left, x1039..1112 right),
+ * clear of the plate rims (edge glow against a bright scene reads as ink).
+ */
+export const SCORE_ROIS: readonly [Roi, Roi] = [
+	{ x: 810, y: 156, w: 90, h: 46 },
+	{ x: 1034, y: 156, w: 84, h: 46 },
+];
+
+/**
+ * Penalty "+N" band inside the pill. The pill measures x 826..920,
+ * y 218..256 under the left plate; the band leaves the rounded ends out.
+ */
+export const PENALTY_ROIS: readonly [Roi, Roi] = (() => {
+	const left: Roi = { x: 832, y: 220, w: 82, h: 36 };
+	return [left, mirrorRoi(left)];
+})();
+
+/**
+ * Plate-fill probe strips inside each plate's LEFT rim, clear of the
+ * widest digit run (right strip isn't mirrored since that digit run
+ * reaches x1112). Both plate styles are a flat fill there (team color in
+ * control, near-black otherwise), so the gate accepts flatness (std)
+ * alone — fill brightness spans near-black to bright yellow.
+ */
+export const PLATE_PROBE_ROIS: readonly [Roi, Roi] = [
+	{ x: 800, y: 162, w: 10, h: 30 },
+	{ x: 1021, y: 162, w: 10, h: 30 },
+];
+
+/**
+ * Penalty-pill presence probes at the pill's rounded ends, clear of the
+ * widest "+100": translucent fill reads mid-dark and flat over any scene.
+ */
+export const PENALTY_PROBE_ROIS: readonly [[Roi, Roi], [Roi, Roi]] = (() => {
+	const leftPill: [Roi, Roi] = [
+		{ x: 828, y: 226, w: 8, h: 24 },
+		{ x: 910, y: 226, w: 8, h: 24 },
+	];
+	return [leftPill, [mirrorRoi(leftPill[1]), mirrorRoi(leftPill[0])]];
+})();
+
+export const GATE_PLATE_MAX_STD = 30;
+/** A count digit's brightest channel clears this on either plate style. */
+export const GATE_SCORE_MIN_MAX_BRIGHTNESS = 200;
+
+/**
+ * Gate anchor: the match timer above the plates — white M:SS digits in a
+ * near-black box only the in-match HUD draws. In-match HUD reads <=30 on
+ * each dark probe; every other screen lights one past 70. Turf War and
+ * the death cam (one centered pill) also show a timer — there the plate
+ * probes and no-readable-count parse confirmation carry the rejection.
+ */
+export const TIMER_DIGIT_ROI: Roi = { x: 908, y: 54, w: 100, h: 40 };
+export const TIMER_DARK_PROBES: readonly Roi[] = [
+	{ x: 915, y: 45, w: 80, h: 7 },
+	{ x: 897, y: 57, w: 8, h: 26 },
+	{ x: 1012, y: 57, w: 7, h: 26 },
+];
+export const GATE_TIMER_MAX_MEAN = 70;
+export const GATE_TIMER_MIN_MAX_BRIGHTNESS = 240;
+
+/**
+ * Timer's white M:SS digits measure 34px; the colon's dots stack under
+ * the digit height floor, so a plain height filter drops the colon.
+ */
+export const TIMER_TEXT_HEIGHT = 34;
+export const TIMER_BIN_THRESHOLD = 160;
+export const TIMER_DIGIT_MIN_CONF = 0.75;
+export const TIMER_DIGIT_MIN_HEIGHT_RATIO = 0.82;
+
+/**
+ * Count digits measure ~40-44px across attested plates; both scaled sets
+ * are tried, best trailing read wins (banner's settled/mid-pop pattern).
+ */
+export const SCORE_TEXT_HEIGHTS = [40, 44] as const;
+export const PENALTY_TEXT_HEIGHT = 29;
+
+/**
+ * Binarization thresholds vary with plate style (team-ink ~200+ on ~45
+ * black; white ~250 on team fills up to ~130 gray) — each read keeps its best.
+ */
+export const SCORE_BIN_THRESHOLDS = [160, 190] as const;
+
+/** Penalty pill: white digits on the translucent dark fill (~100 gray). */
+export const PENALTY_BIN_THRESHOLD = 170;
+export const PENALTY_PROBE_MAX_MEAN = 165;
+export const PENALTY_PROBE_MAX_STD = 30;
+
+/**
+ * Control = plate fill is team-color style (measured over the probe
+ * strip): even dark inks (deep blue ~130 spread at ~50 brightness) stay
+ * saturated, while a non-controlling/neutral plate is unsaturated
+ * (attested fills >=112 vs <=19).
+ */
+export const CONTROL_PLATE_MIN_SATURATION = 60;
diff --git a/app/features/scanner/core/detectors/registry.ts b/app/features/scanner/core/detectors/registry.ts
new file mode 100644
index 000000000..8ef957852
--- /dev/null
+++ b/app/features/scanner/core/detectors/registry.ts
@@ -0,0 +1,51 @@
+/**
+ * The full detector registry — the single source of truth for "every
+ * detector that runs on a frame". New event types get added here and are
+ * picked up by the analyzer worker.
+ */
+
+import { createDeathDetector } from "./death/index";
+import { createMapStartDetector } from "./map-start/index";
+import { createMinimapDetector } from "./minimap/index";
+import { createObjectiveDetector } from "./objective/index";
+import {
+	createScoreboardDetector,
+	SCOREBOARD_EVENT_TYPE,
+	type ScoreboardResources,
+} from "./scoreboard/index";
+import {
+	createScoreboardBattleLogDetector,
+	SCOREBOARD_BATTLE_LOG_EVENT_TYPE,
+} from "./scoreboard-battle-log/index";
+import {
+	createScoreboardBattleLogReplayDetector,
+	SCOREBOARD_BATTLE_LOG_REPLAY_EVENT_TYPE,
+} from "./scoreboard-battle-log-replay/index";
+import { createScoreboardOwnDetector } from "./scoreboard-own/index";
+import type { Detector } from "./types";
+
+/**
+ * Event types whose data is the full 8-player scoreboard shape
+ * (ScoreboardData): the results screen, the replay-browser detail, and the
+ * scoreboard-battle-log detail.
+ */
+export const SCOREBOARD_EVENT_TYPES: readonly string[] = [
+	SCOREBOARD_EVENT_TYPE,
+	SCOREBOARD_BATTLE_LOG_REPLAY_EVENT_TYPE,
+	SCOREBOARD_BATTLE_LOG_EVENT_TYPE,
+];
+
+export function createAllDetectors(
+	resources: ScoreboardResources,
+): Detector<unknown>[] {
+	return [
+		createScoreboardDetector(resources) as Detector<unknown>,
+		createScoreboardBattleLogReplayDetector(resources) as Detector<unknown>,
+		createScoreboardBattleLogDetector(resources) as Detector<unknown>,
+		createScoreboardOwnDetector(resources) as Detector<unknown>,
+		createDeathDetector(resources) as Detector<unknown>,
+		createMapStartDetector(resources) as Detector<unknown>,
+		createMinimapDetector(resources) as Detector<unknown>,
+		createObjectiveDetector(resources) as Detector<unknown>,
+	];
+}
diff --git a/app/features/scanner/core/detectors/scheduler.ts b/app/features/scanner/core/detectors/scheduler.ts
new file mode 100644
index 000000000..f32460b12
--- /dev/null
+++ b/app/features/scanner/core/detectors/scheduler.ts
@@ -0,0 +1,341 @@
+/**
+ * DetectorScheduler: decides which detectors check frame t, and which pay
+ * for a parse. Three concerns:
+ *
+ * - Cadence: `searchIntervalS` while a gate fails (default 0.25s — VoDs cut
+ *   screens to ~1s, below raw-gameplay lifetimes), dense `refineIntervalS`
+ *   once it passes, `checkIntervalS` as a hard cap exempt from suppression.
+ *   `nextDueT()` lets the caller skip a frame's readback when nothing's due.
+ * - Suppression: stops paying once a streak stagnates (`maxStagnantParses`
+ *   + a time floor, since a gate can fire during a screen's entry animation
+ *   before it's readable). `sufficientConfidence` suppresses immediately; a
+ *   gate `signature` moving past `signatureTolerance` ends the streak
+ *   (distinct browsed entries never drop those gates); `rearmCooldownS`
+ *   adds a cooldown on top (death: animated-background flicker).
+ * - Activity: tracks last gate pass + open-match state for the VoD scanner
+ *   to skip dead air.
+ *
+ * State keys to the scan's clock; `t` jumping backwards resets everything.
+ */
+
+import type { DetectedEvent } from "./types";
+
+export interface SchedulingInfo {
+	id: string;
+	checkIntervalS?: number;
+	searchIntervalS?: number;
+	refineIntervalS?: number;
+	sufficientConfidence?: number;
+	rearmCooldownS?: number;
+	maxStagnantParses?: number;
+}
+
+export interface SchedulerOptions {
+	/**
+	 * false = one-shot harness mode: every detector is due on every frame and
+	 * parses are never suppressed
+	 */
+	suppressSteadyFrames: boolean;
+	/** check cadence while a detector's gate is passing (per-detector
+	 * refineIntervalS overrides — for detectors whose parse is expensive
+	 * enough that the dense default multiplies real cost) */
+	refineIntervalS: number;
+	/** check cadence while a detector's gate is failing (per-detector
+	 * searchIntervalS overrides) */
+	searchIntervalS: number;
+	/** consecutive non-improving parses tolerated before suppression
+	 * (per-detector maxStagnantParses overrides) */
+	maxStagnantParses: number;
+	/** seconds without improvement tolerated before suppression */
+	stagnantAfterS: number;
+	/** minimum confidence gain that counts as an improvement */
+	minImprovement: number;
+	/**
+	 * a gate signature cell moving more than this since the streak's last
+	 * parse means the screen's content changed and the streak resets
+	 * (measured on battle log browsing: static-screen noise ≤2 per cell,
+	 * entry flips ≥57)
+	 */
+	signatureTolerance: number;
+	/** seconds without any gate pass before the scan counts as calm */
+	quietAfterS: number;
+	/** a match opened this long ago without closing is assumed abandoned */
+	matchOpenMaxS: number;
+	/** event types that open a match (map-start) */
+	matchOpeningTypes: readonly string[];
+	/** event types that close a match (the scoreboard family) */
+	matchClosingTypes: readonly string[];
+}
+
+const DEFAULT_SCHEDULER_OPTIONS: SchedulerOptions = {
+	suppressSteadyFrames: true,
+	refineIntervalS: 0.15,
+	searchIntervalS: 0.25,
+	maxStagnantParses: 6,
+	// give a screen ~3s to animate in and produce its best read, whatever
+	// the sampling cadence
+	stagnantAfterS: 3,
+	minImprovement: 0.001,
+	signatureTolerance: 12,
+	quietAfterS: 15,
+	matchOpenMaxS: 8 * 60,
+	matchOpeningTypes: [],
+	matchClosingTypes: [],
+};
+
+/** events below this are too dubious to drive match-open/close state */
+const MATCH_STATE_MIN_CONFIDENCE = 0.6;
+
+/** tolerated backwards jitter in t before the session counts as restarted */
+const RESET_TOLERANCE_S = 5;
+
+const INTERVAL_EPSILON_S = 1e-6;
+
+interface StreakState {
+	best: number;
+	stagnant: number;
+	lastImprovementT: number;
+	suppressed: boolean;
+	/** gate signature of the streak's last parsed frame */
+	signature: readonly number[] | undefined;
+}
+
+interface DetectorState {
+	info: SchedulingInfo;
+	lastCheckT: number | undefined;
+	gatePassing: boolean;
+	streak: StreakState | null;
+	/** signature reported by the latest passing gate */
+	lastGateSignature: readonly number[] | undefined;
+	/** parses skipped until this t after a sufficient read (rearmCooldownS) */
+	parseHoldUntilT: number;
+}
+
+export class DetectorScheduler {
+	#options: SchedulerOptions;
+	#states = new Map<string, DetectorState>();
+	#maxT = Number.NEGATIVE_INFINITY;
+	#lastActivityT = Number.NEGATIVE_INFINITY;
+	#matchOpenUntilT = Number.NEGATIVE_INFINITY;
+
+	constructor(
+		detectors: readonly SchedulingInfo[],
+		options: Partial<SchedulerOptions> = {},
+	) {
+		this.#options = { ...DEFAULT_SCHEDULER_OPTIONS, ...options };
+		for (const info of detectors) {
+			this.#states.set(info.id, freshState(info));
+		}
+	}
+
+	/** Drop all session state; `t` seeds the activity clock (chunk start). */
+	reset(t = Number.NEGATIVE_INFINITY): void {
+		for (const [id, state] of this.#states) {
+			this.#states.set(id, freshState(state.info));
+		}
+		this.#maxT = t;
+		this.#lastActivityT = t;
+		this.#matchOpenUntilT = Number.NEGATIVE_INFINITY;
+	}
+
+	/**
+	 * Earliest t at which any detector wants a check — frames before it can
+	 * skip analysis (and its canvas readback) entirely.
+	 */
+	nextDueT(): number {
+		let next = Number.POSITIVE_INFINITY;
+		for (const state of this.#states.values()) {
+			if (state.lastCheckT === undefined) return Number.NEGATIVE_INFINITY;
+			next = Math.min(next, state.lastCheckT + this.#interval(state));
+		}
+		return next;
+	}
+
+	/** Detector ids that should gate the frame at `t`. */
+	dueDetectors(t: number): string[] {
+		if (t + RESET_TOLERANCE_S < this.#maxT) this.reset(t);
+		// the first frame seeds the activity clock so a fresh session is never
+		// instantly calm — it has to earn its quiet period first
+		if (this.#lastActivityT === Number.NEGATIVE_INFINITY) {
+			this.#lastActivityT = t;
+		}
+		this.#maxT = Math.max(this.#maxT, t);
+		const due: string[] = [];
+		for (const [id, state] of this.#states) {
+			if (state.lastCheckT === undefined) {
+				due.push(id);
+				continue;
+			}
+			if (t - state.lastCheckT >= this.#interval(state) - INTERVAL_EPSILON_S) {
+				due.push(id);
+			}
+		}
+		return due;
+	}
+
+	/** Report a gate outcome for a detector this scheduler marked due. */
+	recordGate(
+		id: string,
+		t: number,
+		pass: boolean,
+		signature?: readonly number[],
+	): void {
+		const state = this.#states.get(id);
+		if (!state) return;
+		state.lastCheckT = t;
+		state.gatePassing = pass;
+		if (!pass) {
+			state.streak = null;
+			return;
+		}
+		this.#lastActivityT = Math.max(this.#lastActivityT, t);
+		if (
+			signature &&
+			state.streak?.signature &&
+			signaturesDiffer(
+				signature,
+				state.streak.signature,
+				this.#options.signatureTolerance,
+			)
+		) {
+			state.streak = null;
+		}
+		state.lastGateSignature = signature;
+	}
+
+	/** Whether the (passed) gate should be followed by a parse at `t`. */
+	shouldParse(id: string, t: number): boolean {
+		if (!this.#options.suppressSteadyFrames) return true;
+		const state = this.#states.get(id);
+		if (!state) return true;
+		if (state.info.checkIntervalS !== undefined) return true;
+		if (t < state.parseHoldUntilT) return false;
+		return !state.streak?.suppressed;
+	}
+
+	/** Report the outcome of a parse this scheduler approved. */
+	recordParse(
+		id: string,
+		t: number,
+		events: readonly Pick<DetectedEvent, "type" | "confidence">[],
+	): void {
+		this.#recordMatchState(t, events);
+		const state = this.#states.get(id);
+		if (!state || state.info.checkIntervalS !== undefined) return;
+		// no events counts as confidence 0: a false-firing gate on a static
+		// screen stagnates and gets suppressed just like a parsed one
+		const confidence = events.reduce(
+			(max, e) => Math.max(max, e.confidence),
+			0,
+		);
+		const { sufficientConfidence, rearmCooldownS } = state.info;
+		if (
+			sufficientConfidence !== undefined &&
+			confidence >= sufficientConfidence
+		) {
+			state.streak = {
+				best: confidence,
+				stagnant: 0,
+				lastImprovementT: t,
+				suppressed: true,
+				signature: state.lastGateSignature,
+			};
+			if (rearmCooldownS !== undefined) {
+				state.parseHoldUntilT = t + rearmCooldownS;
+			}
+			return;
+		}
+		if (!state.streak) {
+			state.streak = {
+				best: confidence,
+				stagnant: 0,
+				lastImprovementT: t,
+				suppressed: false,
+				signature: state.lastGateSignature,
+			};
+			return;
+		}
+		const streak = state.streak;
+		streak.signature = state.lastGateSignature;
+		if (confidence > streak.best + this.#options.minImprovement) {
+			streak.best = confidence;
+			streak.stagnant = 0;
+			streak.lastImprovementT = t;
+			return;
+		}
+		streak.stagnant += 1;
+		const maxStagnant =
+			state.info.maxStagnantParses ?? this.#options.maxStagnantParses;
+		if (
+			streak.stagnant >= maxStagnant &&
+			t - streak.lastImprovementT >= this.#options.stagnantAfterS
+		) {
+			streak.suppressed = true;
+		}
+	}
+
+	/**
+	 * True when the footage at `t` is dead air as far as detection goes: no
+	 * gate has passed for quietAfterS and no match is open — the VoD scanner
+	 * may skim by keyframes instead of decoding densely.
+	 */
+	calm(t: number): boolean {
+		if (!this.#options.suppressSteadyFrames) return false;
+		return (
+			t - this.#lastActivityT >= this.#options.quietAfterS &&
+			t >= this.#matchOpenUntilT
+		);
+	}
+
+	#interval(state: DetectorState): number {
+		if (!this.#options.suppressSteadyFrames) return 0;
+		const { info } = state;
+		if (info.checkIntervalS !== undefined) return info.checkIntervalS;
+		const search = info.searchIntervalS ?? this.#options.searchIntervalS;
+		// while suppressed only the gate keeps running (to spot the screen
+		// changing), which the sparser search cadence covers
+		if (state.streak?.suppressed) return search;
+		if (!state.gatePassing) return search;
+		return info.refineIntervalS ?? this.#options.refineIntervalS;
+	}
+
+	#recordMatchState(
+		t: number,
+		events: readonly Pick<DetectedEvent, "type" | "confidence">[],
+	): void {
+		for (const event of events) {
+			if (event.confidence < MATCH_STATE_MIN_CONFIDENCE) continue;
+			if (this.#options.matchOpeningTypes.includes(event.type)) {
+				this.#matchOpenUntilT = Math.max(
+					this.#matchOpenUntilT,
+					t + this.#options.matchOpenMaxS,
+				);
+			} else if (this.#options.matchClosingTypes.includes(event.type)) {
+				this.#matchOpenUntilT = Math.min(this.#matchOpenUntilT, t);
+			}
+		}
+	}
+}
+
+function freshState(info: SchedulingInfo): DetectorState {
+	return {
+		info,
+		lastCheckT: undefined,
+		gatePassing: false,
+		streak: null,
+		lastGateSignature: undefined,
+		parseHoldUntilT: Number.NEGATIVE_INFINITY,
+	};
+}
+
+function signaturesDiffer(
+	a: readonly number[],
+	b: readonly number[],
+	tolerance: number,
+): boolean {
+	if (a.length !== b.length) return true;
+	for (let i = 0; i < a.length; i++) {
+		if (Math.abs(a[i]! - b[i]!) > tolerance) return true;
+	}
+	return false;
+}
diff --git a/app/features/scanner/core/detectors/scoreboard-battle-log-replay/code.ts b/app/features/scanner/core/detectors/scoreboard-battle-log-replay/code.ts
new file mode 100644
index 000000000..86c9e1055
--- /dev/null
+++ b/app/features/scanner/core/detectors/scoreboard-battle-log-replay/code.ts
@@ -0,0 +1,134 @@
+/**
+ * Replay code recognition ("R6KE-DO64-3CXD-XVKL"): bright green text under
+ * the team panels. Green on the dark background lands below the default
+ * grayscale binarization threshold, so recognition runs on the green
+ * channel, where the glyphs are near-white.
+ */
+import { getCV, type Mat } from "../../cv";
+import {
+	type GlyphSet,
+	type RecognizedText,
+	recognizeText,
+} from "../../glyphs";
+import { cropRoi } from "../../image";
+import { REPLAY_CODE_ROI } from "./rois";
+
+/**
+ * FOT-RowdyStd's 'Q' is a '0' bowl with a small tail below the baseline;
+ * the bowl dominates template correlation, so a real Q ranks as '0' by a
+ * hair. Like the P/p rule in scoreboard/names.ts, the segment geometry
+ * decides what the templates cannot: a 0/O read whose ink reaches well
+ * below the line's baseline (the median ink bottom of the other
+ * alphanumerics) is a Q.
+ */
+const Q_TWINS = new Set(["0", "O"]);
+const Q_DESCENT_MIN_PX = 4;
+
+function resolveQsByDescent(raw: RecognizedText): string {
+	const anchors = raw.chars
+		.filter((c) => !Q_TWINS.has(c.char) && c.char !== "-")
+		.map((c) => c.y1)
+		.sort((a, b) => a - b);
+	if (anchors.length === 0) return raw.text;
+	const baseline = anchors[Math.floor(anchors.length / 2)]!;
+	return raw.chars
+		.map((c) =>
+			Q_TWINS.has(c.char) && c.y1 - baseline >= Q_DESCENT_MIN_PX ? "Q" : c.char,
+		)
+		.join("");
+}
+
+/**
+ * On blurry captures a narrow 'L' template can edge out the true 'U' by a
+ * hair. Segment geometry decides what templates can't: a U's right stroke
+ * fills the segment's top-right quadrant, where an L has no ink (measured
+ * 0.00-0.15 leak on true Ls vs 0.27+ on Us across fixtures). The margin only
+ * skips confident reads and stays generous, since no true L on the fixtures
+ * carries a 'U' candidate at all.
+ */
+const LU_SCORE_MARGIN = 0.12;
+const LU_INK_THRESHOLD = 150;
+const LU_TOP_RIGHT_MIN_FRACTION = 0.2;
+
+function resolveUsByTopRightInk(
+	raw: RecognizedText,
+	green: Mat,
+): RecognizedText {
+	const { cols, data } = green;
+	const chars = raw.chars.map((c) => {
+		if (c.char !== "L") return c;
+		const u = c.candidates?.find((k) => k.char === "U");
+		if (!u || c.score - u.score > LU_SCORE_MARGIN) return c;
+		const xMid = Math.ceil((c.x0 + c.x1) / 2);
+		const yMid = Math.floor((c.y0 + c.y1) / 2);
+		let ink = 0;
+		let total = 0;
+		for (let y = c.y0; y < yMid; y++) {
+			for (let x = xMid; x < c.x1; x++) {
+				total++;
+				if (data[y * cols + x]! > LU_INK_THRESHOLD) ink++;
+			}
+		}
+		return total > 0 && ink / total >= LU_TOP_RIGHT_MIN_FRACTION
+			? { ...c, char: "U" }
+			: c;
+	});
+	return { ...raw, chars, text: chars.map((c) => c.char).join("") };
+}
+
+export interface ParsedReplayCode {
+	/** normalized "XXXX-XXXX-XXXX-XXXX", or null when the shape is wrong */
+	code: string | null;
+	/** min glyph score across recognized characters */
+	confidence: number;
+	raw: RecognizedText;
+}
+
+const CODE_RE = /^[0-9A-Z]{4}(-[0-9A-Z]{4}){3}$/;
+
+/**
+ * Restrict a glyph set to the characters codes can contain — a shallow
+ * view over the same template mats, so dispose only the source set.
+ */
+export function codeCharsetOf(set: GlyphSet): GlyphSet {
+	const glyphs = set.glyphs.filter((g) => /^[0-9A-Z-]$/.test(g.char));
+	const widths = glyphs.map((g) => g.mat.cols).sort((a, b) => a - b);
+	return {
+		glyphs,
+		height: set.height,
+		medianWidth: widths[Math.floor(widths.length / 2)] ?? set.medianWidth,
+	};
+}
+
+/** rgb: full normalized frame in RGB (not RGBA). */
+export function parseReplayCode(rgb: Mat, glyphs: GlyphSet): ParsedReplayCode {
+	const cv = getCV();
+	const view = cropRoi(rgb, REPLAY_CODE_ROI);
+	const channels = new cv.MatVector();
+	cv.split(view, channels);
+	const g = channels.get(1);
+	const green = new cv.Mat();
+	g.copyTo(green);
+	g.delete();
+	channels.delete();
+	view.delete();
+
+	const raw = recognizeText(green, glyphs, {
+		spaceGap: Number.POSITIVE_INFINITY,
+		minCharScore: 0.3,
+	});
+	const resolved = resolveUsByTopRightInk(raw, green);
+	green.delete();
+
+	let text = resolveQsByDescent(resolved).toUpperCase();
+	// Dashes are thin and can drop out of segmentation; a clean 16-char
+	// alphanumeric read is unambiguous, so re-insert them.
+	if (/^[0-9A-Z]{16}$/.test(text)) {
+		text = text.replace(/(.{4})(?=.)/g, "$1-");
+	}
+	return {
+		code: CODE_RE.test(text) ? text : null,
+		confidence: raw.confidence,
+		raw,
+	};
+}
diff --git a/app/features/scanner/core/detectors/scoreboard-battle-log-replay/header.ts b/app/features/scanner/core/detectors/scoreboard-battle-log-replay/header.ts
new file mode 100644
index 000000000..c8be0ae78
--- /dev/null
+++ b/app/features/scanner/core/detectors/scoreboard-battle-log-replay/header.ts
@@ -0,0 +1,184 @@
+/**
+ * Replay-browser header parsing. Same black auto-sized tag style as the
+ * live scoreboard header, but different content: the top line holds the
+ * recording timestamp ("3/7/2026 22:28") followed by the stage, the bottom
+ * line the lobby (bold) followed by the mode.
+ *
+ * The timestamp is locale-formatted and open-ended, so it is validated by
+ * shape and kept as a raw string; stage and lobby+mode snap to the closed
+ * sets shared with the live header.
+ */
+import type { ModeShort, StageId } from "~/modules/in-game-lists/types";
+import type { ScannerLobby } from "../../../scanner-types";
+import type { Roi } from "../../canonical";
+import type { Mat } from "../../cv";
+import type { GlyphSet } from "../../glyphs";
+import { ALL_STAGE_ENTRIES, LOBBY_MODE_COMBOS } from "../../localized";
+import { closestBy } from "../../text";
+import { readTagBand } from "../scoreboard/header";
+import { HEADER_BOTTOM_BAND, HEADER_TOP_BAND } from "./rois";
+
+export interface ParsedReplayHeader {
+	timestamp: string | null;
+	stage: StageId | null;
+	lobby: ScannerLobby | null;
+	mode: ModeShort | null;
+	/** min of the closed-set match scores that were attempted */
+	confidence: number;
+	debug: {
+		topReading: string;
+		bottomReading: string;
+		stageScore: number;
+		bottomScore: number;
+	};
+}
+
+const MIN_MATCH_SCORE = 0.62;
+
+/**
+ * Lifted-blacks captures (720p streams upscaled and re-encoded) raise the
+ * tag background to ~80-115 gray, above readTagBand's default dark ceiling,
+ * so the tag-extent trim truncates the band to a sliver and the read comes
+ * back empty. A band whose closed-set snap fails is re-read with this
+ * ceiling; the retry is adopted only when it snaps at least as well.
+ */
+const TAG_DARK_MAX_LIFTED = 120;
+
+/**
+ * "3/7/2026 22:28" and friends; capture the rest of the line (the stage).
+ * The console formats the date per locale — "7.3.2026" (de), "2026/3/7"
+ * (ja) — so any . / - separated triple followed by a time is accepted.
+ * Adjacent skinny time digits can read with a spurious gap on compressed
+ * captures ("14:1 1"), so a lone space is tolerated between them and
+ * stripped when the timestamp is assembled. Not left-anchored: the
+ * battle log line leads with a rank icon on ranked lobbies, which reads as
+ * a junk glyph before the date.
+ */
+const TIMESTAMP_RE =
+	/(\d{1,4}[./-]\d{1,2}[./-]\d{1,4})\s+(\d(?: ?\d)?: ?\d ?\d)\s*(.*)$/;
+
+interface TopBandParse {
+	reading: string;
+	timestamp: string | null;
+	stage: StageId | null;
+	stageScore: number;
+}
+
+/**
+ * In the BlitzMain glyphs the digit forms are near-identical to their letter
+ * lookalikes (0/O, the 1/I/l/| bars), so a stage read can surface the digit
+ * ("R0M-en") and burn an edit the snap threshold cannot spare. Stage names
+ * are digit-free in every language (sole exception carries a '9'), so digits
+ * and bars fold to letters before snapping.
+ */
+function foldDigitLookalikes(s: string): string {
+	return s.replace(/0/g, "o").replace(/[1|]/g, "l");
+}
+
+function parseTopBand(reading: string): TopBandParse {
+	let timestamp: string | null = null;
+	let stage: StageId | null = null;
+	let stageScore = 0;
+	// The top band reads with the BlitzMain name glyphs, where 1/I/l/| are
+	// identical bars ("I9:04") and O rides a hair above 0 ("2O26"); in the
+	// digits-only timestamp every bar is a '1' and every O a '0'. Match on
+	// the normalized line, keep the stage part's original reading (the
+	// replacements are 1:1, so offsets line up).
+	const normalized = reading.replace(/[Il|]/g, "1").replace(/O/g, "0");
+	const m = TIMESTAMP_RE.exec(normalized);
+	const stageReading = m
+		? reading.slice(reading.length - m[3]!.length)
+		: reading;
+	if (m) timestamp = `${m[1]!} ${m[2]!.replace(/ /g, "")}`;
+	if (stageReading) {
+		const match = closestBy(
+			foldDigitLookalikes(stageReading),
+			ALL_STAGE_ENTRIES,
+			(e) => e.text,
+		);
+		if (match) {
+			stageScore = match.score;
+			if (match.score >= MIN_MATCH_SCORE) stage = match.entry.stageId;
+		}
+	}
+	return { reading, timestamp, stage, stageScore };
+}
+
+/** The two header tag bands; the battle log passes its own coordinates. */
+export interface ReplayHeaderBands {
+	top: Roi;
+	bottom: Roi;
+	/**
+	 * see TagBandOptions.tagLeadInMax; the battle log tags are not
+	 * left-anchored
+	 */
+	tagLeadInMax?: number;
+	/** see TagBandOptions.tagColumnFraction; the battle log tags are tilted */
+	tagColumnFraction?: number;
+}
+
+const REPLAY_BANDS: ReplayHeaderBands = {
+	top: HEADER_TOP_BAND,
+	bottom: HEADER_BOTTOM_BAND,
+};
+
+export function parseReplayHeader(
+	gray: Mat,
+	topGlyphs: GlyphSet,
+	bottomGlyphs: GlyphSet,
+	bands: ReplayHeaderBands = REPLAY_BANDS,
+): ParsedReplayHeader {
+	const leadIn = {
+		tagLeadInMax: bands.tagLeadInMax,
+		tagColumnFraction: bands.tagColumnFraction,
+	};
+	let top = parseTopBand(readTagBand(gray, bands.top, topGlyphs, leadIn));
+	if (top.stage === null) {
+		const retry = parseTopBand(
+			readTagBand(gray, bands.top, topGlyphs, {
+				...leadIn,
+				tagDarkMax: TAG_DARK_MAX_LIFTED,
+			}),
+		);
+		if (retry.stageScore >= top.stageScore) top = retry;
+	}
+
+	let bottomReading = readTagBand(gray, bands.bottom, bottomGlyphs, leadIn);
+	let bottomMatch = bottomReading
+		? closestBy(bottomReading, LOBBY_MODE_COMBOS, (c) => c.text)
+		: null;
+	if (!bottomMatch || bottomMatch.score < MIN_MATCH_SCORE) {
+		const reading = readTagBand(gray, bands.bottom, bottomGlyphs, {
+			...leadIn,
+			tagDarkMax: TAG_DARK_MAX_LIFTED,
+		});
+		const match = reading
+			? closestBy(reading, LOBBY_MODE_COMBOS, (c) => c.text)
+			: null;
+		if ((match?.score ?? 0) >= (bottomMatch?.score ?? 0)) {
+			bottomReading = reading;
+			bottomMatch = match;
+		}
+	}
+
+	let lobby: ScannerLobby | null = null;
+	let mode: ModeShort | null = null;
+	if (bottomMatch && bottomMatch.score >= MIN_MATCH_SCORE) {
+		lobby = bottomMatch.entry.lobby;
+		mode = bottomMatch.entry.mode;
+	}
+
+	return {
+		timestamp: top.timestamp,
+		stage: top.stage,
+		lobby,
+		mode,
+		confidence: Math.min(top.stageScore, bottomMatch?.score ?? 0),
+		debug: {
+			topReading: top.reading,
+			bottomReading,
+			stageScore: top.stageScore,
+			bottomScore: bottomMatch?.score ?? 0,
+		},
+	};
+}
diff --git a/app/features/scanner/core/detectors/scoreboard-battle-log-replay/index.ts b/app/features/scanner/core/detectors/scoreboard-battle-log-replay/index.ts
new file mode 100644
index 000000000..48f3dd43d
--- /dev/null
+++ b/app/features/scanner/core/detectors/scoreboard-battle-log-replay/index.ts
@@ -0,0 +1,460 @@
+/**
+ * ScoreboardBattleLogReplayDetector: parses the replay-browser detail
+ * screen — the same match data as the live scoreboard (header, team scores,
+ * 8 player rows) plus the recording timestamp and the replay code.
+ *
+ * Layout differs from the live scoreboard: the two team panels sit side by
+ * side and the replay owner's team may be on either side, so the
+ * VICTORY/DEFEAT panel tags are read to keep `players`/`matchScores`
+ * ordered winners-first like the live event. Field parsing reuses the
+ * scoreboard helpers with glyph sets rescaled to this screen's text sizes.
+ */
+import { getCV, type Mat } from "../../cv";
+import { type GlyphSet, recognizeText, scaleGlyphSet } from "../../glyphs";
+import {
+	cropRoi,
+	maxBrightness,
+	maxChannel,
+	meanBrightness,
+	type Roi,
+	roiSignature,
+} from "../../image";
+import { RESULT_TAG_ENTRIES } from "../../localized";
+import { closestBy } from "../../text";
+import {
+	FULL_COUNT_TEAM_SCORE,
+	KO_MATCH_SCORE,
+	MATCH_SCORE_MIN_CONF,
+} from "../scoreboard/banner";
+import { type ParsedNumber, parseNumber } from "../scoreboard/digits";
+import type {
+	ScoreboardData,
+	ScoreboardPlayer,
+	ScoreboardResources,
+	ScoreboardRowDebug,
+} from "../scoreboard/index";
+import { findPovIndex } from "../scoreboard/pov";
+import { parseScoreboardRow, type RowRois } from "../scoreboard/row";
+import type { DetectedEvent, Detector, GateResult } from "../types";
+import { codeCharsetOf, type ParsedReplayCode, parseReplayCode } from "./code";
+import { type ParsedReplayHeader, parseReplayHeader } from "./header";
+import {
+	CODE_TEXT_HEIGHT,
+	GATE_CODE_BLUE_MAX,
+	GATE_CODE_GREEN_MIN,
+	GATE_CODE_MIN_FRACTION,
+	GATE_FLAT_MAX_MEAN,
+	GATE_FLAT_MIN_MEAN,
+	GATE_GAP_MAX_MEAN,
+	GATE_GAP_PROBES,
+	GATE_TEXT_MIN_MAX,
+	gateFlatProbe,
+	HEADER_LINE_HEIGHT,
+	HEADER_TIMESTAMP_HEIGHT,
+	HEADER_TOP_BAND,
+	MATCH_SCORE_DIGIT_HEIGHT,
+	MATCH_SCORE_ROIS,
+	NAME_TEXT_HEIGHT,
+	nameRoi,
+	PAINT_DIGIT_HEIGHT,
+	PANEL_XS,
+	paintRoi,
+	paintSuffixRoi,
+	povArrowRoi,
+	REPLAY_CODE_ROI,
+	RESULT_TAG_TEXT_HEIGHT,
+	ROW_CENTERS,
+	resultTagRoi,
+	STAT_DIGIT_HEIGHT,
+	specialIconRoi,
+	statRoi,
+	TEAM_DIGIT_HEIGHT,
+	teamScoreRoi,
+	weaponRoi,
+} from "./rois";
+
+export interface ScoreboardBattleLogReplayData extends ScoreboardData {
+	/** recording timestamp as shown, e.g. "3/7/2026 22:28"; locale-formatted */
+	timestamp: string | null;
+	/** "XXXX-XXXX-XXXX-XXXX" */
+	replayCode: string | null;
+}
+
+export const SCOREBOARD_BATTLE_LOG_REPLAY_EVENT_TYPE =
+	"ScoreboardBattleLogReplay";
+
+/** Replay pills are mid-gray (~61), not near-black; see matchWeapon docs. */
+const REPLAY_INK_THRESHOLD = 90;
+
+/**
+ * White banner digits on saturated team color: applies to the "Score:"
+ * banners AND the team totals — a green DEFEAT panel weighs in at ~184
+ * on the green-heavy grayscale, above the default 150.
+ */
+const BANNER_BIN_THRESHOLD = 190;
+
+/** Canonical results the localized VICTORY/DEFEAT panel tags snap to. */
+type PanelResult = "VICTORY" | "DEFEAT";
+const RESULT_MIN_SCORE = 0.6;
+/**
+ * The chunky outlined tag letters bridge at the default 150 on the
+ * max-channel image; 190 keeps the cores separated (and drops the gray
+ * gear/signal icons trailing the text).
+ */
+const RESULT_TAG_BIN_THRESHOLD = 190;
+
+interface PanelParse {
+	players: ScoreboardPlayer[];
+	rows: ScoreboardRowDebug[];
+	teamScore: ParsedNumber | null;
+	matchScore: ParsedNumber | null;
+	result: PanelResult | null;
+	resultReading: string;
+	resultScore: number;
+	confidences: number[];
+}
+
+/** Fraction of ROI pixels matching the replay code's green (RGBA frame). */
+function greenFraction(frame: Mat, roi: Roi): number {
+	const cv = getCV();
+	const view = cropRoi(frame, roi);
+	const cont = new cv.Mat();
+	view.copyTo(cont);
+	view.delete();
+	const d = cont.data;
+	const n = cont.rows * cont.cols;
+	let green = 0;
+	for (let i = 0; i < n; i++) {
+		if (
+			d[i * 4 + 1]! > GATE_CODE_GREEN_MIN &&
+			d[i * 4 + 2]! < GATE_CODE_BLUE_MAX
+		)
+			green++;
+	}
+	cont.delete();
+	return n > 0 ? green / n : 0;
+}
+
+export function createScoreboardBattleLogReplayDetector(
+	resources: ScoreboardResources,
+): Detector<ScoreboardBattleLogReplayData> {
+	const cv = getCV();
+
+	const scaled = (set: GlyphSet | null, height: number): GlyphSet | null =>
+		set ? scaleGlyphSet(set, height / set.height) : null;
+
+	const nameGlyphs = scaled(resources.nameGlyphs, NAME_TEXT_HEIGHT);
+	const paintDigits = scaled(resources.paintDigits, PAINT_DIGIT_HEIGHT);
+	const statDigits = scaled(resources.statDigits, STAT_DIGIT_HEIGHT);
+	const teamBase = resources.teamDigits ?? resources.paintDigits;
+	const teamDigits = scaled(teamBase, TEAM_DIGIT_HEIGHT);
+	const matchScoreDigits = scaled(teamBase, MATCH_SCORE_DIGIT_HEIGHT);
+	/** Timestamp needs digits + '/' + ':' — only the names atlas has them. */
+	const headerTopGlyphs = scaled(resources.nameGlyphs, HEADER_TIMESTAMP_HEIGHT);
+	const headerBottomGlyphs = scaled(
+		resources.headerLineGlyphs,
+		HEADER_LINE_HEIGHT,
+	);
+	// Code and result tags render in FOT-RowdyStd — use the dedicated atlases
+	// when present; the BlitzMain-based fallbacks read them only roughly.
+	const resultGlyphs =
+		scaled(resources.replayResultGlyphs ?? null, RESULT_TAG_TEXT_HEIGHT) ??
+		scaled(resources.headerLineGlyphs, RESULT_TAG_TEXT_HEIGHT);
+	const codeGlyphs = resources.replayCodeGlyphs
+		? scaled(resources.replayCodeGlyphs, CODE_TEXT_HEIGHT)
+		: resources.nameGlyphs
+			? scaleGlyphSet(
+					codeCharsetOf(resources.nameGlyphs),
+					CODE_TEXT_HEIGHT / resources.nameGlyphs.height,
+				)
+			: null;
+
+	function gate(frame: Mat): GateResult {
+		const gray = new cv.Mat();
+		cv.cvtColor(frame, gray, cv.COLOR_RGBA2GRAY);
+
+		let flatOk = 0;
+		let suffixOk = 0;
+		for (const dx of PANEL_XS) {
+			for (const cy of ROW_CENTERS) {
+				const flat = meanBrightness(frame, gateFlatProbe(cy, dx));
+				if (flat >= GATE_FLAT_MIN_MEAN && flat <= GATE_FLAT_MAX_MEAN) flatOk++;
+				if (maxBrightness(gray, paintSuffixRoi(cy, dx)) > GATE_TEXT_MIN_MAX)
+					suffixOk++;
+			}
+		}
+		let gapOk = 0;
+		for (const roi of GATE_GAP_PROBES) {
+			if (meanBrightness(frame, roi) < GATE_GAP_MAX_MEAN) gapOk++;
+		}
+		const codeFraction = greenFraction(frame, REPLAY_CODE_ROI);
+
+		const rowCount = PANEL_XS.length * ROW_CENTERS.length;
+		const score =
+			(flatOk / rowCount +
+				suffixOk / rowCount +
+				gapOk / GATE_GAP_PROBES.length +
+				Math.min(1, codeFraction / (2 * GATE_CODE_MIN_FRACTION))) /
+			4;
+		const pass =
+			flatOk >= 7 &&
+			suffixOk >= 7 &&
+			gapOk === 2 &&
+			codeFraction >= GATE_CODE_MIN_FRACTION;
+		// browsing flips between replays never drop this gate, so it
+		// fingerprints the content that always differs between two battles
+		// (recording timestamp band + replay code) plus the name columns —
+		// the scheduler re-arms suppression when the fingerprint moves
+		const signature = pass ? contentSignature(gray) : undefined;
+		gray.delete();
+		return { pass, score, signature };
+	}
+
+	function contentSignature(gray: Mat): number[] {
+		const signature = roiSignature(gray, HEADER_TOP_BAND, 32, 2);
+		signature.push(...roiSignature(gray, REPLAY_CODE_ROI, 32, 1));
+		for (const dx of PANEL_XS) {
+			for (const cy of ROW_CENTERS) {
+				signature.push(...roiSignature(gray, nameRoi(cy, dx), 8, 1));
+			}
+		}
+		return signature;
+	}
+
+	function parsePanel(gray: Mat, rgb: Mat, dx: number): PanelParse {
+		const players: ScoreboardPlayer[] = [];
+		const rows: ScoreboardRowDebug[] = [];
+		const confidences: number[] = [];
+
+		const rowRois: RowRois = {
+			weapon: (cy) => weaponRoi(cy, dx),
+			specialIcon: (cy) => specialIconRoi(cy, dx),
+			paint: (cy) => paintRoi(cy, dx),
+			name: (cy) => nameRoi(cy, dx),
+			stat: (cy, i) => statRoi(cy, dx, i),
+			povArrow: (cy) => povArrowRoi(cy, dx),
+		};
+		const rowResources = {
+			weapons: resources.weapons,
+			specials: resources.specials,
+			paintDigits,
+			statDigits,
+			nameGlyphs,
+		};
+		for (const cy of ROW_CENTERS) {
+			// A short team (e.g. a 7-player private battle) renders no pill for
+			// the unused bottom row — just near-black panel background where the
+			// flat probe expects the mid-gray pill (the gate's flatOk >= 7 already
+			// tolerates the missing row). Skip it: no phantom player.
+			const flat = meanBrightness(rgb, gateFlatProbe(cy, dx));
+			if (flat < GATE_FLAT_MIN_MEAN || flat > GATE_FLAT_MAX_MEAN) continue;
+
+			// replay rows render smaller (icons ~26px, inside the live template
+			// set's slide range) on a lighter panel; the paint number is
+			// left-aligned so the "p" suffix lands inside the ROI on short paints
+			const row = parseScoreboardRow(
+				gray,
+				rgb,
+				cy,
+				rowRois,
+				rowResources,
+				confidences,
+				{
+					weaponInkThreshold: REPLAY_INK_THRESHOLD,
+					paintDropLoweredTrailing: true,
+				},
+			);
+			players.push(row.player);
+			rows.push(row.debug);
+		}
+
+		// The panel's point total is read only to recognize a knockout below
+		// (the count times five: only a knockout's full count reaches 500);
+		// it is never emitted as a score.
+		let teamScore: ParsedNumber | null = null;
+		if (teamDigits) {
+			const crop = cropRoi(gray, teamScoreRoi(dx));
+			teamScore = parseNumber(crop, teamDigits, {
+				binThreshold: BANNER_BIN_THRESHOLD,
+			});
+			crop.delete();
+			confidences.push(teamScore.confidence);
+		}
+
+		let matchScore: ParsedNumber | null = null;
+		if (matchScoreDigits) {
+			const crop = cropRoi(gray, MATCH_SCORE_ROIS[dx === 0 ? 0 : 1]!);
+			matchScore = parseNumber(crop, matchScoreDigits, {
+				binThreshold: BANNER_BIN_THRESHOLD,
+			});
+			if (
+				matchScore.confidence < MATCH_SCORE_MIN_CONF ||
+				(matchScore.value !== null && matchScore.value > KO_MATCH_SCORE)
+			) {
+				matchScore = { ...matchScore, value: null };
+			}
+			crop.delete();
+			confidences.push(matchScore.confidence);
+			// No number under the floor + a full team count = the KNOCKOUT! burst
+			// sitting where the banner's score would be. Report the count it won at
+			// rather than a hole; an unreadable banner on a lesser total stays null.
+			if (
+				matchScore.value === null &&
+				teamScore?.value === FULL_COUNT_TEAM_SCORE
+			) {
+				matchScore = { ...matchScore, value: KO_MATCH_SCORE };
+			}
+		}
+
+		let result: PanelParse["result"] = null;
+		let resultReading = "";
+		let resultScore = 0;
+		if (resultGlyphs) {
+			const bright = maxChannel(rgb, resultTagRoi(dx));
+			const raw = recognizeText(bright, resultGlyphs, {
+				binThreshold: RESULT_TAG_BIN_THRESHOLD,
+				spaceGap: Number.POSITIVE_INFINITY,
+				minCharScore: 0.25,
+			});
+			bright.delete();
+			resultReading = raw.text;
+			if (resultReading) {
+				const match = closestBy(
+					resultReading,
+					RESULT_TAG_ENTRIES,
+					(e) => e.text,
+				);
+				if (match) {
+					resultScore = match.score;
+					if (match.score >= RESULT_MIN_SCORE)
+						result = match.entry.canonical as PanelResult;
+				}
+			}
+		}
+
+		return {
+			players,
+			rows,
+			teamScore,
+			matchScore,
+			result,
+			resultReading,
+			resultScore,
+			confidences,
+		};
+	}
+
+	function parse(
+		frame: Mat,
+		t: number,
+	): DetectedEvent<ScoreboardBattleLogReplayData>[] {
+		const gray = new cv.Mat();
+		cv.cvtColor(frame, gray, cv.COLOR_RGBA2GRAY);
+		const rgb = new cv.Mat();
+		cv.cvtColor(frame, rgb, cv.COLOR_RGBA2RGB);
+
+		const [left, right] = PANEL_XS.map((dx) => parsePanel(gray, rgb, dx)) as [
+			PanelParse,
+			PanelParse,
+		];
+
+		// Winners first. Trust a confident VICTORY/DEFEAT tag read; when the
+		// tags are inconclusive, the higher "Score:" banner marks the winner
+		// (the shown match score decides the game). Default to left otherwise.
+		let swapped = false;
+		if (left.result !== null || right.result !== null) {
+			swapped = left.result === "DEFEAT" || right.result === "VICTORY";
+		} else if (
+			left.matchScore?.value != null &&
+			right.matchScore?.value != null
+		) {
+			swapped = right.matchScore.value > left.matchScore.value;
+		}
+		const [winner, loser] = swapped ? [right, left] : [left, right];
+		// POV arrow row, indexed into the winners-first players ordering
+		const povIndex = findPovIndex(
+			[...winner.rows, ...loser.rows].map((r) => r.povFraction),
+		);
+
+		let header: ParsedReplayHeader | null = null;
+		if (headerTopGlyphs && headerBottomGlyphs) {
+			header = parseReplayHeader(gray, headerTopGlyphs, headerBottomGlyphs);
+		}
+
+		let code: ParsedReplayCode | null = null;
+		if (codeGlyphs) {
+			code = parseReplayCode(rgb, codeGlyphs);
+		}
+
+		gray.delete();
+		rgb.delete();
+
+		const confidences = [
+			...winner.confidences,
+			...loser.confidences,
+			...(header ? [header.confidence] : []),
+			...(code ? [code.confidence] : []),
+		];
+		const confidence =
+			confidences.length > 0
+				? confidences.reduce((a, b) => a + b, 0) / confidences.length
+				: 0;
+
+		return [
+			{
+				type: SCOREBOARD_BATTLE_LOG_REPLAY_EVENT_TYPE,
+				t,
+				confidence,
+				data: {
+					lobby: header?.lobby ?? null,
+					mode: header?.mode ?? null,
+					stage: header?.stage ?? null,
+					timestamp: header?.timestamp ?? null,
+					replayCode: code?.code ?? null,
+					matchScores: [
+						winner.matchScore?.value ?? null,
+						loser.matchScore?.value ?? null,
+					],
+					players: [...winner.players, ...loser.players],
+					povIndex,
+				},
+				debug: {
+					rows: [...winner.rows, ...loser.rows],
+					teamScoreConf: [
+						winner.teamScore?.confidence ?? 0,
+						loser.teamScore?.confidence ?? 0,
+					],
+					matchScoreConf: [
+						winner.matchScore?.confidence ?? 0,
+						loser.matchScore?.confidence ?? 0,
+					],
+					header: header?.debug,
+					codeRaw: code?.raw.text,
+					winnerSide: swapped ? "right" : "left",
+					resultTags: {
+						left: {
+							reading: left.resultReading,
+							score: left.resultScore,
+							result: left.result,
+						},
+						right: {
+							reading: right.resultReading,
+							score: right.resultScore,
+							result: right.result,
+						},
+					},
+				},
+			},
+		];
+	}
+
+	// no rearm cooldown — distinct replays browsed in quick succession are
+	// told apart by content. sufficientConfidence just under the measured
+	// clean-read floor (fixtures 0.808-0.890)
+	return {
+		id: "scoreboard-battle-log-replay",
+		sufficientConfidence: 0.8,
+		gate,
+		parse,
+	};
+}
diff --git a/app/features/scanner/core/detectors/scoreboard-battle-log-replay/rois.ts b/app/features/scanner/core/detectors/scoreboard-battle-log-replay/rois.ts
new file mode 100644
index 000000000..a0377ab82
--- /dev/null
+++ b/app/features/scanner/core/detectors/scoreboard-battle-log-replay/rois.ts
@@ -0,0 +1,155 @@
+/**
+ * ALL scoreboard-battle-log-replay ROI coordinates, in canonical 1920x1080
+ * space. Calibrated against scoreboard-battle-log-replay/private-battle-
+ * splat-zones-hagglefish via tools/overlay-rois.ts and column-projection
+ * measurement.
+ *
+ * The replay-browser detail screen shows two team panels SIDE BY SIDE
+ * (right = left shifted by PANEL_DX), four gray pill rows each — mid-gray
+ * (~61) with darker gaps (~23), unlike the live scoreboard's near-black
+ * pills (~12). Below the panels: replay owner line + bright green replay
+ * code; above: two "Score:" banners and the stage-photo header (line 1 =
+ * timestamp + stage, line 2 = lobby + mode).
+ */
+import type { Roi } from "../../canonical";
+
+/** Vertical centers of the 4 player rows within each panel. */
+export const ROW_CENTERS = [573, 654, 735, 816] as const;
+
+/** Horizontal shift from a left-panel ROI to its right-panel twin. */
+export const PANEL_DX = 676;
+
+/** dx per panel: [left (index 0), right (index 1)]. */
+export const PANEL_XS = [0, PANEL_DX] as const;
+
+/**
+ * Weapon icon search region — full pill height so the largest template
+ * (64; icons render ~60-64px) fits with slide room (matchTemplate skips
+ * taller templates).
+ */
+export function weaponRoi(cy: number, dx: number): Roi {
+	return { x: 522 + dx, y: cy - 34, w: 96, h: 68 };
+}
+
+/**
+ * Special-weapon icon on a black disc above the third stat counter (~25x29
+ * art at x 1109-1134, y cy-29..cy). Only read to break near-tied weapon
+ * matches with different specials; box stays inside the disc since the
+ * mid-gray pill around it sits above matchSpecial's ink threshold.
+ */
+export function specialIconRoi(cy: number, dx: number): Roi {
+	return { x: 1104 + dx, y: cy - 32, w: 38, h: 33 };
+}
+
+/**
+ * Player name text region (white, left-aligned; descenders reach cy+18).
+ * Long names run into the paint column; parse paint first and trim at its
+ * leftmost digit. Kept narrower than the first glyph to dodge weapon-icon bleed.
+ */
+export function nameRoi(cy: number, dx: number): Roi {
+	return { x: 620 + dx, y: cy - 16, w: 226, h: 37 };
+}
+
+/**
+ * Paint digits, LEFT-aligned from x~843 (~18px pitch); the trailing "p"
+ * moves with digit count, so short (3-digit) paints put it inside this
+ * region — parseNumber's digit-only charset drops it.
+ */
+export function paintRoi(cy: number, dx: number): Roi {
+	return { x: 821 + dx, y: cy - 15, w: 88, h: 34 };
+}
+
+/**
+ * Gate anchor over the "p" after the paint number. Since it's left-aligned,
+ * "p" position tracks digit count (x 898-907 after 3 digits, 915-924
+ * after 4) — the probe spans both.
+ */
+export function paintSuffixRoi(cy: number, dx: number): Roi {
+	return { x: 896 + dx, y: cy - 13, w: 31, h: 26 };
+}
+
+/**
+ * Stat counter digits (zero-padded, "x" prefix excluded), cy+4..cy+23 —
+ * the top edge must stay below the stat icons, which bleed ink above it.
+ */
+export function statRoi(cy: number, dx: number, index: 0 | 1 | 2): Roi {
+	const x = [1000, 1057, 1114][index]!;
+	return { x: x + dx, y: cy + 3, w: 36, h: 24 };
+}
+
+/**
+ * POV arrow: smaller replay-browser arrow on the pill's left edge (x
+ * 487-530). Right edge stays short of the weapon-icon region (x 522+).
+ */
+export function povArrowRoi(cy: number, dx: number): Roi {
+	return { x: 480 + dx, y: cy - 32, w: 54, h: 56 };
+}
+
+/** Team totals ("440p") on the VICTORY/DEFEAT banner, digits ending x~1119. */
+export function teamScoreRoi(dx: number): Roi {
+	return { x: 1040 + dx, y: 481, w: 86, h: 36 };
+}
+
+/** VICTORY / DEFEAT tag on each panel banner — decides which panel won (owner's team may sit either side). */
+export function resultTagRoi(dx: number): Roi {
+	return { x: 540 + dx, y: 460, w: 220, h: 50 };
+}
+
+/** The colored "Score: NN" banners; digits after the constant label. */
+export const MATCH_SCORE_ROIS: readonly [Roi, Roi] = [
+	{ x: 742, y: 340, w: 130, h: 56 },
+	{ x: 1620, y: 340, w: 130, h: 56 },
+];
+
+/**
+ * Header bands on the stage-photo banner: line 1 timestamp + stage tag,
+ * line 2 lobby + mode. Tags size to their text; the header parser trims
+ * each band to the tag extent.
+ */
+export const HEADER_TOP_BAND: Roi = { x: 500, y: 68, w: 560, h: 46 };
+/**
+ * Wide lobby tags push the mode tag right ("Anarchy Battle (Open)" +
+ * "Rainmaker" ends x~1134), so the band runs past the longest observed pair.
+ */
+export const HEADER_BOTTOM_BAND: Roi = { x: 500, y: 124, w: 700, h: 58 };
+
+/**
+ * Bright green replay code line ("XXXX-XXXX-XXXX-XXXX"), left-aligned
+ * after the magnifier icon. Width tracks the glyphs, so a wide-letter
+ * code can run past x=913 — box extends into the background to fit it.
+ */
+export const REPLAY_CODE_ROI: Roi = { x: 574, y: 960, w: 400, h: 38 };
+
+/** Gate probe: flat pill background strip between paint "p" and first stat "x" — mid-gray here, not near-black. */
+export function gateFlatProbe(cy: number, dx: number): Roi {
+	return { x: 930 + dx, y: cy - 10, w: 42, h: 20 };
+}
+
+/** Dark gap between row 1 and row 2 pills, one strip per panel. */
+export const GATE_GAP_PROBES: readonly Roi[] = [
+	{ x: 560, y: 611, w: 540, h: 5 },
+	{ x: 560 + PANEL_DX, y: 611, w: 540, h: 5 },
+];
+
+/** Flat pill strips must sit in this mid-gray band. */
+export const GATE_FLAT_MIN_MEAN = 45;
+export const GATE_FLAT_MAX_MEAN = 78;
+/** The inter-pill gap is darker than the pills. */
+export const GATE_GAP_MAX_MEAN = 40;
+/** The paint "p" suffix region must contain bright pixels. */
+export const GATE_TEXT_MIN_MAX = 180;
+/** Replay-code color probe: fraction of REPLAY_CODE_ROI pixels that are green-ish (high G, low B) — unique to this screen. */
+export const GATE_CODE_GREEN_MIN = 140;
+export const GATE_CODE_BLUE_MAX = 90;
+export const GATE_CODE_MIN_FRACTION = 0.03;
+
+/** Text metrics measured on the fixture, used for glyph scaling / tooling. */
+export const NAME_TEXT_HEIGHT = 24;
+export const PAINT_DIGIT_HEIGHT = 26;
+export const STAT_DIGIT_HEIGHT = 20;
+export const TEAM_DIGIT_HEIGHT = 27;
+export const MATCH_SCORE_DIGIT_HEIGHT = 41;
+export const HEADER_TIMESTAMP_HEIGHT = 24;
+export const HEADER_LINE_HEIGHT = 29;
+export const RESULT_TAG_TEXT_HEIGHT = 27;
+export const CODE_TEXT_HEIGHT = 25;
diff --git a/app/features/scanner/core/detectors/scoreboard-battle-log/index.ts b/app/features/scanner/core/detectors/scoreboard-battle-log/index.ts
new file mode 100644
index 000000000..b0236f4fa
--- /dev/null
+++ b/app/features/scanner/core/detectors/scoreboard-battle-log/index.ts
@@ -0,0 +1,417 @@
+/**
+ * ScoreboardBattleLogDetector: parses the Recent Battles detail screen
+ * (battle log) — the same match data as the live scoreboard (header, team
+ * scores, 8 player rows) plus the recording timestamp, but no replay code.
+ *
+ * The two team panels sit STACKED (observed winner on top, confirmed by the
+ * VICTORY/DEFEAT tags) and the row text renders at the live scoreboard's
+ * sizes, so field parsing reuses the scoreboard helpers with the shared
+ * glyph sets unscaled — only the ROI geometry is this screen's own. The
+ * header is the replay browser's (timestamp + stage / lobby + mode tags),
+ * parsed with battle log bands.
+ */
+import { getCV, type Mat } from "../../cv";
+import { type GlyphSet, recognizeText, scaleGlyphSet } from "../../glyphs";
+import {
+	cropRoi,
+	maxBrightness,
+	maxChannel,
+	meanBrightness,
+	roiSignature,
+} from "../../image";
+import { RESULT_TAG_ENTRIES } from "../../localized";
+import { closestBy } from "../../text";
+import {
+	type BannerScoreRead,
+	FULL_COUNT_TEAM_SCORE,
+	parseBannerScore,
+	resolveMatchScores,
+} from "../scoreboard/banner";
+import { type ParsedNumber, parseNumber } from "../scoreboard/digits";
+import type {
+	ScoreboardData,
+	ScoreboardPlayer,
+	ScoreboardResources,
+	ScoreboardRowDebug,
+} from "../scoreboard/index";
+import { findPovIndex } from "../scoreboard/pov";
+import { parseScoreboardRow, type RowRois } from "../scoreboard/row";
+import {
+	type ParsedReplayHeader,
+	parseReplayHeader,
+} from "../scoreboard-battle-log-replay/header";
+import type { DetectedEvent, Detector, GateResult } from "../types";
+import {
+	GATE_COLOR_MIN_SATURATION,
+	GATE_COLOR_PROBES,
+	GATE_DARK_MAX_MEAN,
+	GATE_TEXT_MIN_MAX,
+	gateDarkProbe,
+	HEADER_BOTTOM_BAND,
+	HEADER_LINE_HEIGHT,
+	HEADER_TAG_COLUMN_FRACTION,
+	HEADER_TAG_LEAD_IN_MAX,
+	HEADER_TIMESTAMP_HEIGHT,
+	HEADER_TOP_BAND,
+	MATCH_SCORE_DIGIT_HEIGHT,
+	MATCH_SCORE_ROIS,
+	nameRoi,
+	PANEL_DYS,
+	paintRoi,
+	paintSuffixRoi,
+	povArrowRoi,
+	RESULT_TAG_TEXT_HEIGHT,
+	ROW_CENTERS,
+	resultTagRoi,
+	specialIconRoi,
+	statRoi,
+	teamScoreRoi,
+	weaponRoi,
+} from "./rois";
+
+export interface ScoreboardBattleLogData extends ScoreboardData {
+	/** recording timestamp as shown, e.g. "5/8/2026 19:16"; locale-formatted */
+	timestamp: string | null;
+}
+
+export const SCOREBOARD_BATTLE_LOG_EVENT_TYPE = "ScoreboardBattleLog";
+
+/**
+ * White outlined team totals on the panel's saturated color band — a yellow
+ * band grays at ~190, so binarize just above it (the digit cores are ~250).
+ */
+const TEAM_SCORE_BIN_THRESHOLD = 205;
+
+/** Canonical results the localized VICTORY/DEFEAT panel tags snap to. */
+type PanelResult = "VICTORY" | "DEFEAT";
+const RESULT_MIN_SCORE = 0.6;
+/**
+ * The tag letters render in the team's ink color on the gray stamp box
+ * (~75 gray, trailing status icons ~120), so binarize the max-channel
+ * image just above the icons — every ink color's brightest channel
+ * clears this.
+ */
+const RESULT_TAG_BIN_THRESHOLD = 140;
+
+interface PanelParse {
+	players: ScoreboardPlayer[];
+	rows: ScoreboardRowDebug[];
+	teamScore: ParsedNumber | null;
+	result: PanelResult | null;
+	resultReading: string;
+	resultScore: number;
+	confidences: number[];
+}
+
+export function createScoreboardBattleLogDetector(
+	resources: ScoreboardResources,
+): Detector<ScoreboardBattleLogData> {
+	const cv = getCV();
+
+	const scaled = (set: GlyphSet | null, height: number): GlyphSet | null =>
+		set ? scaleGlyphSet(set, height / set.height) : null;
+
+	const teamDigits = resources.teamDigits ?? resources.paintDigits;
+	const matchScoreSets = teamDigits
+		? [scaleGlyphSet(teamDigits, MATCH_SCORE_DIGIT_HEIGHT / teamDigits.height)]
+		: [];
+	/** Timestamp needs digits + '/' + ':' — only the names atlas has them. */
+	const headerTopGlyphs = scaled(resources.nameGlyphs, HEADER_TIMESTAMP_HEIGHT);
+	const headerBottomGlyphs = scaled(
+		resources.headerLineGlyphs,
+		HEADER_LINE_HEIGHT,
+	);
+	// The tags render in FOT-RowdyStd — use the dedicated atlas when present;
+	// the BlitzMain-based fallback reads them only roughly.
+	const resultGlyphs =
+		scaled(resources.replayResultGlyphs ?? null, RESULT_TAG_TEXT_HEIGHT) ??
+		scaled(resources.headerLineGlyphs, RESULT_TAG_TEXT_HEIGHT);
+
+	/** Mean-RGB saturation (max minus min channel) of a probe ROI. */
+	function probeSaturation(frame: Mat, roi: (typeof GATE_COLOR_PROBES)[0]) {
+		const view = cropRoi(frame, roi);
+		const cont = new cv.Mat();
+		view.copyTo(cont);
+		view.delete();
+		const d = cont.data;
+		const n = cont.rows * cont.cols;
+		let r = 0;
+		let g = 0;
+		let b = 0;
+		for (let i = 0; i < n; i++) {
+			r += d[i * 4]!;
+			g += d[i * 4 + 1]!;
+			b += d[i * 4 + 2]!;
+		}
+		cont.delete();
+		if (n === 0) return 0;
+		return (Math.max(r, g, b) - Math.min(r, g, b)) / n;
+	}
+
+	function gate(frame: Mat): GateResult {
+		const gray = new cv.Mat();
+		cv.cvtColor(frame, gray, cv.COLOR_RGBA2GRAY);
+
+		let darkOk = 0;
+		let suffixOk = 0;
+		for (const dy of PANEL_DYS) {
+			for (const base of ROW_CENTERS) {
+				const cy = base + dy;
+				if (meanBrightness(frame, gateDarkProbe(cy)) < GATE_DARK_MAX_MEAN)
+					darkOk++;
+				if (maxBrightness(gray, paintSuffixRoi(cy)) > GATE_TEXT_MIN_MAX)
+					suffixOk++;
+			}
+		}
+		let colorOk = 0;
+		for (const roi of GATE_COLOR_PROBES) {
+			if (probeSaturation(frame, roi) >= GATE_COLOR_MIN_SATURATION) colorOk++;
+		}
+
+		const rowCount = PANEL_DYS.length * ROW_CENTERS.length;
+		const score =
+			(darkOk / rowCount +
+				suffixOk / rowCount +
+				colorOk / GATE_COLOR_PROBES.length) /
+			3;
+		const pass = darkOk >= 7 && suffixOk >= 7 && colorOk === 3;
+		// browsing flips between entries never drop this gate, so it
+		// fingerprints the content that always differs between two battles
+		// (recording timestamp + stage tag) plus the name column — the
+		// scheduler re-arms suppression when the fingerprint moves
+		const signature = pass ? contentSignature(gray) : undefined;
+		gray.delete();
+		return { pass, score, signature };
+	}
+
+	function contentSignature(gray: Mat): number[] {
+		const signature = roiSignature(gray, HEADER_TOP_BAND, 32, 2);
+		for (const dy of PANEL_DYS) {
+			for (const base of ROW_CENTERS) {
+				signature.push(...roiSignature(gray, nameRoi(base + dy), 8, 1));
+			}
+		}
+		return signature;
+	}
+
+	function parsePanel(gray: Mat, rgb: Mat, dy: number): PanelParse {
+		const players: ScoreboardPlayer[] = [];
+		const rows: ScoreboardRowDebug[] = [];
+		const confidences: number[] = [];
+
+		const rowRois: RowRois = {
+			weapon: weaponRoi,
+			specialIcon: specialIconRoi,
+			paint: paintRoi,
+			name: nameRoi,
+			stat: statRoi,
+			povArrow: povArrowRoi,
+		};
+		for (const base of ROW_CENTERS) {
+			const row = parseScoreboardRow(
+				gray,
+				rgb,
+				base + dy,
+				rowRois,
+				resources,
+				confidences,
+			);
+			players.push(row.player);
+			rows.push(row.debug);
+		}
+
+		// The panel's point total is read only to recognize a knockout (the
+		// count times five: only a knockout's full count reaches 500); it is
+		// never emitted as a score.
+		let teamScore: ParsedNumber | null = null;
+		if (teamDigits) {
+			const crop = cropRoi(gray, teamScoreRoi(dy));
+			teamScore = parseNumber(crop, teamDigits, {
+				binThreshold: TEAM_SCORE_BIN_THRESHOLD,
+			});
+			crop.delete();
+			confidences.push(teamScore.confidence);
+		}
+
+		let result: PanelParse["result"] = null;
+		let resultReading = "";
+		let resultScore = 0;
+		if (resultGlyphs) {
+			const bright = maxChannel(rgb, resultTagRoi(dy));
+			const raw = recognizeText(bright, resultGlyphs, {
+				binThreshold: RESULT_TAG_BIN_THRESHOLD,
+				spaceGap: Number.POSITIVE_INFINITY,
+				minCharScore: 0.25,
+			});
+			bright.delete();
+			resultReading = raw.text;
+			if (resultReading) {
+				const match = closestBy(
+					resultReading,
+					RESULT_TAG_ENTRIES,
+					(e) => e.text,
+				);
+				if (match) {
+					resultScore = match.score;
+					if (match.score >= RESULT_MIN_SCORE)
+						result = match.entry.canonical as PanelResult;
+				}
+			}
+		}
+
+		return {
+			players,
+			rows,
+			teamScore,
+			result,
+			resultReading,
+			resultScore,
+			confidences,
+		};
+	}
+
+	function parse(
+		frame: Mat,
+		t: number,
+	): DetectedEvent<ScoreboardBattleLogData>[] {
+		const gray = new cv.Mat();
+		cv.cvtColor(frame, gray, cv.COLOR_RGBA2GRAY);
+		const rgb = new cv.Mat();
+		cv.cvtColor(frame, rgb, cv.COLOR_RGBA2RGB);
+
+		const [top, bottom] = PANEL_DYS.map((dy) => parsePanel(gray, rgb, dy)) as [
+			PanelParse,
+			PanelParse,
+		];
+
+		let left: BannerScoreRead | null = null;
+		let right: BannerScoreRead | null = null;
+		if (matchScoreSets.length > 0) {
+			left = parseBannerScore(gray, MATCH_SCORE_ROIS[0], matchScoreSets);
+			right = parseBannerScore(gray, MATCH_SCORE_ROIS[1], matchScoreSets);
+		}
+
+		const swapped = decideSwapped(top, bottom, left, right);
+		const [winner, loser] = swapped ? [bottom, top] : [top, bottom];
+		// POV arrow row, indexed into the winners-first players ordering
+		const povIndex = findPovIndex(
+			[...winner.rows, ...loser.rows].map((r) => r.povFraction),
+		);
+
+		const knockout = winner.teamScore?.value === FULL_COUNT_TEAM_SCORE;
+		let matchScores: [number | null, number | null] = [null, null];
+		let bannerDebug: object | undefined;
+		if (left && right) {
+			matchScores = resolveMatchScores({ left, right, knockout });
+			winner.confidences.push(left.confidence, right.confidence);
+			bannerDebug = { left, right, knockout };
+		}
+
+		let header: ParsedReplayHeader | null = null;
+		if (headerTopGlyphs && headerBottomGlyphs) {
+			header = parseReplayHeader(gray, headerTopGlyphs, headerBottomGlyphs, {
+				top: HEADER_TOP_BAND,
+				bottom: HEADER_BOTTOM_BAND,
+				tagLeadInMax: HEADER_TAG_LEAD_IN_MAX,
+				tagColumnFraction: HEADER_TAG_COLUMN_FRACTION,
+			});
+		}
+
+		gray.delete();
+		rgb.delete();
+
+		const confidences = [
+			...winner.confidences,
+			...loser.confidences,
+			...(header ? [header.confidence] : []),
+		];
+		const confidence =
+			confidences.length > 0
+				? confidences.reduce((a, b) => a + b, 0) / confidences.length
+				: 0;
+
+		return [
+			{
+				type: SCOREBOARD_BATTLE_LOG_EVENT_TYPE,
+				t,
+				confidence,
+				data: {
+					lobby: header?.lobby ?? null,
+					mode: header?.mode ?? null,
+					stage: header?.stage ?? null,
+					timestamp: header?.timestamp ?? null,
+					matchScores,
+					players: [...winner.players, ...loser.players],
+					povIndex,
+				},
+				debug: {
+					rows: [...winner.rows, ...loser.rows],
+					teamScoreConf: [
+						winner.teamScore?.confidence ?? 0,
+						loser.teamScore?.confidence ?? 0,
+					],
+					matchScore: bannerDebug,
+					header: header?.debug,
+					winnerSide: swapped ? "bottom" : "top",
+					resultTags: {
+						top: {
+							reading: top.resultReading,
+							score: top.resultScore,
+							result: top.result,
+						},
+						bottom: {
+							reading: bottom.resultReading,
+							score: bottom.resultScore,
+							result: bottom.result,
+						},
+					},
+				},
+			},
+		];
+	}
+
+	// no rearm cooldown — distinct battles browsed in quick succession are
+	// told apart by content: the gate signature re-arms scheduler suppression
+	// and the timeline merges via sameScoreboardMatch (same as the replay
+	// browser)
+	return {
+		id: "scoreboard-battle-log",
+		sufficientConfidence: 0.8,
+		gate,
+		parse,
+	};
+}
+
+/**
+ * Whether the winner sits in the bottom panel. A confident VICTORY/DEFEAT
+ * tag decides (the distressed tag texture usually reads below the floor);
+ * otherwise the panel totals are checked against the banner scores — the
+ * total is the count times five, and only a knockout winner's reaches 500.
+ * Default: winner on top, which every observed battle log screen shows.
+ */
+function decideSwapped(
+	top: PanelParse,
+	bottom: PanelParse,
+	left: BannerScoreRead | null,
+	right: BannerScoreRead | null,
+): boolean {
+	if (top.result !== null || bottom.result !== null) {
+		return top.result === "DEFEAT" || bottom.result === "VICTORY";
+	}
+	const topTotal = top.teamScore?.value ?? null;
+	const bottomTotal = bottom.teamScore?.value ?? null;
+	if (topTotal === FULL_COUNT_TEAM_SCORE) return false;
+	if (bottomTotal === FULL_COUNT_TEAM_SCORE) return true;
+	if (
+		left?.value != null &&
+		right?.value != null &&
+		topTotal !== null &&
+		bottomTotal !== null &&
+		topTotal !== bottomTotal
+	) {
+		const hi = Math.max(left.value, right.value) * 5;
+		const lo = Math.min(left.value, right.value) * 5;
+		if (topTotal === lo && bottomTotal === hi) return true;
+	}
+	return false;
+}
diff --git a/app/features/scanner/core/detectors/scoreboard-battle-log/rois.ts b/app/features/scanner/core/detectors/scoreboard-battle-log/rois.ts
new file mode 100644
index 000000000..a56027bde
--- /dev/null
+++ b/app/features/scanner/core/detectors/scoreboard-battle-log/rois.ts
@@ -0,0 +1,145 @@
+/**
+ * ALL scoreboard-battle-log ROI coordinates, in canonical 1920x1080 space.
+ * Calibrated against scoreboard-battle-log/private-battle-splat-zones-
+ * makomart and x-battle-clam-blitz-lemuria via scripts/scanner/dump-crops.ts
+ * and column-projection measurement.
+ *
+ * The Recent Battles detail screen shows two team panels STACKED (bottom =
+ * top shifted by PANEL_DY), four near-black pill rows each on a dark panel
+ * whose top band/border carry the team's ink color. Text sizes match the
+ * live scoreboard (row glyphs reused unscaled, only columns differ). Above
+ * the panels: split "Score:"/KNOCKOUT! banner and stage-photo header
+ * (line 1 = timestamp + stage, line 2 = lobby + mode). No replay code line.
+ */
+import type { Roi } from "../../canonical";
+
+/** Vertical centers of the 4 player rows within the top panel. */
+export const ROW_CENTERS = [453, 519, 585, 651] as const;
+
+/** Vertical shift from a top-panel ROI to its bottom-panel twin. */
+export const PANEL_DY = 366;
+
+/** dy per panel: [top (index 0), bottom (index 1)]. */
+export const PANEL_DYS = [0, PANEL_DY] as const;
+
+/**
+ * Weapon icon search region — icons render at live-scoreboard sizes; 56px
+ * height excludes larger replay-browser templates (matchTemplate skips them).
+ */
+export function weaponRoi(cy: number): Roi {
+	return { x: 1040, y: cy - 28, w: 76, h: 56 };
+}
+
+/**
+ * Special-weapon icon on the pill above the third stat counter (~x
+ * 1645-1692, y cy-20..cy+2). Only read to break near-tied weapon matches
+ * with different specials; bounded at cy+2 to keep counter digits out.
+ */
+export function specialIconRoi(cy: number): Roi {
+	return { x: 1642, y: cy - 24, w: 52, h: 26 };
+}
+
+/**
+ * Player name text region (white, left-aligned x=1114). Long names run
+ * into paint; parse paint first and trim at its leftmost digit.
+ */
+export function nameRoi(cy: number): Roi {
+	return { x: 1110, y: cy - 14, w: 208, h: 32 };
+}
+
+/** Paint amount digits, right-aligned ending at x=1396 (the "p" suffix is excluded). */
+export function paintRoi(cy: number): Roi {
+	return { x: 1312, y: cy - 17, w: 88, h: 34 };
+}
+
+/** The constant white "p" after the paint number — used as a gate anchor. */
+export function paintSuffixRoi(cy: number): Roi {
+	return { x: 1398, y: cy - 14, w: 18, h: 28 };
+}
+
+/** Stat counter digits (two, zero-padded; the small "x" prefix is excluded). */
+export function statRoi(cy: number, index: 0 | 1 | 2): Roi {
+	const x = [1530, 1593, 1656][index]!;
+	return { x, y: cy + 3, w: 30, h: 22 };
+}
+
+/**
+ * POV arrow on the panel left of the pill (x 977-1024). Right edge stays
+ * short of the pill's rounded cap (~x 1032).
+ */
+export function povArrowRoi(cy: number): Roi {
+	return { x: 968, y: cy - 32, w: 60, h: 62 };
+}
+
+/**
+ * Team point totals ("500 p") on the colored top band, ending x=1704.
+ * Only read to recognize a knockout (winner total 500), not the score.
+ */
+export function teamScoreRoi(dy: number): Roi {
+	return { x: 1614, y: 371 + dy, w: 96, h: 38 };
+}
+
+/**
+ * VICTORY/DEFEAT tag on each panel's top band — confirms which panel won
+ * (observed always the top one; letters render in team ink on gray stamp).
+ */
+export function resultTagRoi(dy: number): Roi {
+	return { x: 990, y: 358 + dy, w: 215, h: 52 };
+}
+
+/**
+ * The two sides of the "Score:" banner above the panels. Left follows the
+ * localized label (from x~985), right ends x~1744. A knockout replaces
+ * the winning side's value with the KNOCKOUT! burst.
+ */
+export const MATCH_SCORE_ROIS: readonly [Roi, Roi] = [
+	{ x: 985, y: 278, w: 265, h: 40 },
+	{ x: 1648, y: 278, w: 100, h: 40 },
+];
+
+/**
+ * Header bands on the stage-photo banner. Line 1: timestamp + stage tag
+ * (rank icon on ranked lobbies shifts the left edge); line 2: lobby
+ * (bold, x=809) + mode. Bands hug the tag rows tightly since the photo
+ * below has bright pixels that would ink glyph bottoms; readTagBand scans
+ * for the tag start (HEADER_TAG_LEAD_IN_MAX) instead of anchoring an edge.
+ */
+export const HEADER_TOP_BAND: Roi = { x: 800, y: 74, w: 668, h: 32 };
+export const HEADER_BOTTOM_BAND: Roi = { x: 800, y: 122, w: 728, h: 46 };
+export const HEADER_TAG_LEAD_IN_MAX = 40;
+/** see TagBandOptions.tagColumnFraction — the tags are subtly tilted */
+export const HEADER_TAG_COLUMN_FRACTION = 0.75;
+
+/**
+ * Gate probe: strip between paint "p" (ends 1413) and first stat "x"
+ * (starts 1517) is always empty pill background (near-black ~20).
+ */
+export function gateDarkProbe(cy: number): Roi {
+	return { x: 1422, y: cy - 10, w: 78, h: 20 };
+}
+
+/**
+ * Ink-color probes discriminate against two lookalike results screens:
+ * panels' top bands and score banner are saturated team color here (109+),
+ * while the live scoreboard is neutral gray and the replay browser only
+ * saturated at the first spot (its own banner).
+ */
+export const GATE_COLOR_PROBES: readonly Roi[] = [
+	{ x: 1300, y: 382, w: 100, h: 16 },
+	{ x: 1300, y: 748, w: 100, h: 16 },
+	{ x: 1400, y: 292, w: 60, h: 14 },
+];
+
+/** Mean-RGB saturation (max minus min channel) floor for the color probes. */
+export const GATE_COLOR_MIN_SATURATION = 60;
+
+/** The strip between p suffix and stats must stay near-black. */
+export const GATE_DARK_MAX_MEAN = 45;
+/** The paint "p" suffix region must contain bright (white) pixels. */
+export const GATE_TEXT_MIN_MAX = 180;
+
+/** Text metrics measured on the fixtures, used for glyph scaling / tooling. */
+export const MATCH_SCORE_DIGIT_HEIGHT = 28;
+export const HEADER_TIMESTAMP_HEIGHT = 21;
+export const HEADER_LINE_HEIGHT = 26;
+export const RESULT_TAG_TEXT_HEIGHT = 30;
diff --git a/app/features/scanner/core/detectors/scoreboard-own/abilities.ts b/app/features/scanner/core/detectors/scoreboard-own/abilities.ts
new file mode 100644
index 000000000..8de287a3e
--- /dev/null
+++ b/app/features/scanner/core/detectors/scoreboard-own/abilities.ts
@@ -0,0 +1,32 @@
+/**
+ * Ability badge templates for the personal-results gear cards. Same
+ * composite-and-resize pipeline as the death panel (death/abilities.ts),
+ * at this screen's smaller badge sizes and its gray-strip ink threshold.
+ */
+import type { FrameData } from "../../image";
+import { type AbilityTemplates, buildAbilityRole } from "../death/abilities";
+import {
+	OWN_ABILITY_ART_RATIO,
+	OWN_ABILITY_INK_THRESHOLD,
+	OWN_ABILITY_MAIN_SIZES,
+	OWN_ABILITY_SUB_SIZES,
+} from "./rois";
+
+export function prepareOwnAbilityTemplates(
+	icons: { id: string; image: FrameData }[],
+): AbilityTemplates {
+	return {
+		mains: buildAbilityRole(
+			icons,
+			OWN_ABILITY_MAIN_SIZES,
+			OWN_ABILITY_ART_RATIO,
+			OWN_ABILITY_INK_THRESHOLD,
+		),
+		subs: buildAbilityRole(
+			icons,
+			OWN_ABILITY_SUB_SIZES,
+			OWN_ABILITY_ART_RATIO,
+			OWN_ABILITY_INK_THRESHOLD,
+		),
+	};
+}
diff --git a/app/features/scanner/core/detectors/scoreboard-own/index.ts b/app/features/scanner/core/detectors/scoreboard-own/index.ts
new file mode 100644
index 000000000..3954e28ac
--- /dev/null
+++ b/app/features/scanner/core/detectors/scoreboard-own/index.ts
@@ -0,0 +1,268 @@
+/**
+ * ScoreboardOwnDetector: parses the personal results screen (the "your
+ * results" view after a match) — lobby/mode/stage from the header tags
+ * (identical to the live scoreboard header, parsing is shared), the
+ * player's main weapon from the weapon card's title tag, and the own gear
+ * abilities from the three gear cards' badge strips.
+ *
+ * The weapon arrives as text: the title is OCR'd with the death-weapon
+ * atlas (the only atlas carrying the weapon-name charset) rescaled to this
+ * screen's title size, then snapped against every language's main-weapon
+ * names at once and reported under its canonical English name.
+ */
+
+import type {
+	AbilityWithUnknown,
+	MainWeaponId,
+	ModeShort,
+	StageId,
+} from "~/modules/in-game-lists/types";
+import {
+	type ScannerLobby,
+	toAbilityWithUnknown,
+	toMainWeaponId,
+} from "../../../scanner-types";
+import { getCV, type Mat } from "../../cv";
+import { type GlyphSet, recognizeText, scaleGlyphSet } from "../../glyphs";
+import { copyRoi, cropRoi, maxBrightness, meanBrightness } from "../../image";
+import { closestBy, matchKey } from "../../text";
+import { LOCALIZED_WEAPON_NAMES } from "../death/localized-messages";
+import { ALL_WEAPON_ENTRIES, type WeaponEntry } from "../death/weapon-names";
+import { type ParsedHeader, parseHeader } from "../scoreboard/header";
+import type { ScoreboardResources } from "../scoreboard/index";
+import { matchWeapon, type WeaponMatch } from "../scoreboard/weapons";
+import type { DetectedEvent, Detector, GateResult } from "../types";
+import {
+	GATE_PANEL_MAX_MEAN,
+	GATE_PANEL_PROBES,
+	GATE_STRIP_MAX_MEAN,
+	GATE_STRIP_MIN_MEAN,
+	GATE_TEXT_MIN_MAX,
+	GATE_TITLE_TEXT_PROBES,
+	GEAR_ROWS,
+	gateStripProbe,
+	gearMainRoi,
+	gearSubRoi,
+	OWN_ABILITY_INK_THRESHOLD,
+	WEAPON_TITLE_BAND,
+	WEAPON_TITLE_BIN_THRESHOLD,
+	WEAPON_TITLE_TEXT_HEIGHT,
+} from "./rois";
+
+export interface ScoreboardOwnData {
+	/** from the header tag; null when unreadable */
+	lobby: ScannerLobby | null;
+	mode: ModeShort | null;
+	stage: StageId | null;
+	/** the player's main weapon; null if unreadable */
+	weaponId: MainWeaponId | null;
+	/**
+	 * own gear abilities, [head, clothes, shoes] rows of
+	 * [main, sub, sub, sub] ability ids
+	 */
+	abilities: AbilityWithUnknown[][];
+}
+
+export const SCOREBOARD_OWN_EVENT_TYPE = "ScoreboardOwn";
+
+/** Snapped weapon reading below this is reported as null (kept in debug). */
+const WEAPON_MIN_SCORE = 0.55;
+
+interface WeaponCandidate {
+	text: string;
+	entry: WeaponEntry;
+}
+
+/**
+ * Every string the weapon card title can show: all languages' localized
+ * main-weapon names plus the canonical English names (localized-messages
+ * omits names identical to English).
+ */
+let weaponCandidates: WeaponCandidate[] | null = null;
+function mainWeaponCandidates(): WeaponCandidate[] {
+	if (weaponCandidates) return weaponCandidates;
+	const mains = ALL_WEAPON_ENTRIES.filter((e) => e.type === "MAIN");
+	const byName = new Map(mains.map((e) => [e.name, e]));
+	const seen = new Set<string>();
+	weaponCandidates = [];
+	const push = (text: string, entry: WeaponEntry | undefined) => {
+		const k = matchKey(text);
+		if (!entry || seen.has(k)) return;
+		seen.add(k);
+		weaponCandidates!.push({ text, entry });
+	};
+	for (const entry of mains) push(entry.name, entry);
+	for (const names of Object.values(LOCALIZED_WEAPON_NAMES)) {
+		for (const { text, name } of names) push(text, byName.get(name));
+	}
+	return weaponCandidates;
+}
+
+export function createScoreboardOwnDetector(
+	resources: ScoreboardResources,
+): Detector<ScoreboardOwnData> {
+	const cv = getCV();
+
+	const titleGlyphs: GlyphSet | null = resources.deathWeaponGlyphs
+		? scaleGlyphSet(
+				resources.deathWeaponGlyphs,
+				WEAPON_TITLE_TEXT_HEIGHT / resources.deathWeaponGlyphs.height,
+			)
+		: null;
+	const abilities = resources.ownAbilities ?? null;
+
+	function gate(frame: Mat): GateResult {
+		let panelOk = 0;
+		for (const roi of GATE_PANEL_PROBES) {
+			if (meanBrightness(frame, roi) < GATE_PANEL_MAX_MEAN) panelOk++;
+		}
+
+		const gray = new cv.Mat();
+		cv.cvtColor(frame, gray, cv.COLOR_RGBA2GRAY);
+		let textOk = 0;
+		for (const roi of GATE_TITLE_TEXT_PROBES) {
+			if (maxBrightness(gray, roi) > GATE_TEXT_MIN_MAX) textOk++;
+		}
+		gray.delete();
+
+		let stripOk = 0;
+		for (let row = 0; row < GEAR_ROWS; row++) {
+			const mean = meanBrightness(frame, gateStripProbe(row));
+			if (mean >= GATE_STRIP_MIN_MEAN && mean <= GATE_STRIP_MAX_MEAN) stripOk++;
+		}
+
+		const score =
+			(panelOk / GATE_PANEL_PROBES.length +
+				textOk / GATE_TITLE_TEXT_PROBES.length +
+				stripOk / GEAR_ROWS) /
+			3;
+		const pass =
+			panelOk === GATE_PANEL_PROBES.length &&
+			textOk === GATE_TITLE_TEXT_PROBES.length &&
+			stripOk === GEAR_ROWS;
+		return { pass, score };
+	}
+
+	function parse(frame: Mat, t: number): DetectedEvent<ScoreboardOwnData>[] {
+		const gray = new cv.Mat();
+		cv.cvtColor(frame, gray, cv.COLOR_RGBA2GRAY);
+		const rgb = new cv.Mat();
+		cv.cvtColor(frame, rgb, cv.COLOR_RGBA2RGB);
+
+		const confidences: number[] = [];
+
+		// header tags sit at the live scoreboard's positions — shared parser
+		let header: ParsedHeader | null = null;
+		if (resources.headerLobbyGlyphs && resources.headerLineGlyphs) {
+			header = parseHeader(
+				gray,
+				resources.headerLobbyGlyphs,
+				resources.headerLineGlyphs,
+			);
+			confidences.push(header.confidence);
+		}
+
+		// Weapon card title, snapped to the main-weapon closed set. The band is
+		// recognized whole, NOT via readTagBand: the tag is fixed-width (the
+		// band lies entirely inside it, there is nothing to trim away), and the
+		// extent trim actively harms it — long names render horizontally
+		// condensed, whose dense antialiased columns fail the dark-or-bright
+		// tag-column test and truncate the read mid-name.
+		let weapon: string | null = null;
+		let weaponId: MainWeaponId | null = null;
+		let weaponScore = 0;
+		let weaponReading = "";
+		if (titleGlyphs) {
+			const band = copyRoi(gray, WEAPON_TITLE_BAND);
+			weaponReading = recognizeText(band, titleGlyphs, {
+				binThreshold: WEAPON_TITLE_BIN_THRESHOLD,
+				spaceGap: 9,
+				minCharScore: 0.3,
+			}).text.trim();
+			band.delete();
+			const match = weaponReading
+				? closestBy(weaponReading, mainWeaponCandidates(), (c) => c.text)
+				: null;
+			if (match) {
+				weaponScore = match.score;
+				if (match.score >= WEAPON_MIN_SCORE) {
+					weapon = match.entry.entry.name;
+					weaponId = toMainWeaponId(match.entry.entry.id);
+				}
+			}
+			confidences.push(weaponScore);
+		}
+
+		// gear-card ability strips: [head, clothes, shoes] x [main, sub, sub, sub]
+		const abilityRows: AbilityWithUnknown[][] = [];
+		const abilityDebug: (WeaponMatch | null)[][] = [];
+		if (abilities) {
+			for (let row = 0; row < GEAR_ROWS; row++) {
+				const ids: AbilityWithUnknown[] = [];
+				const debug: (WeaponMatch | null)[] = [];
+				const mainCrop = cropRoi(rgb, gearMainRoi(row));
+				const main = matchWeapon(mainCrop, abilities.mains, {
+					inkThreshold: OWN_ABILITY_INK_THRESHOLD,
+				});
+				mainCrop.delete();
+				ids.push(toAbilityWithUnknown(main.id) ?? "UNKNOWN");
+				debug.push(main);
+				confidences.push(Math.max(0, main.score));
+				for (let slot = 0; slot < 3; slot++) {
+					const crop = cropRoi(rgb, gearSubRoi(row, slot));
+					const sub = matchWeapon(crop, abilities.subs, {
+						inkThreshold: OWN_ABILITY_INK_THRESHOLD,
+					});
+					crop.delete();
+					ids.push(toAbilityWithUnknown(sub.id) ?? "UNKNOWN");
+					debug.push(sub);
+					confidences.push(Math.max(0, sub.score));
+				}
+				abilityRows.push(ids);
+				abilityDebug.push(debug);
+			}
+		}
+
+		gray.delete();
+		rgb.delete();
+
+		const confidence =
+			confidences.length > 0
+				? confidences.reduce((a, b) => a + b, 0) / confidences.length
+				: 0;
+
+		return [
+			{
+				type: SCOREBOARD_OWN_EVENT_TYPE,
+				t,
+				confidence,
+				data: {
+					lobby: header?.lobby ?? null,
+					mode: header?.mode ?? null,
+					stage: header?.stage ?? null,
+					weaponId,
+					abilities: abilityRows,
+				},
+				debug: {
+					header: header?.debug,
+					weaponName: weapon,
+					weaponReading,
+					weaponScore,
+					abilityRows: abilityDebug.map((row) =>
+						row.map((m) => m && { top: m.top, score: m.score }),
+					),
+				},
+			},
+		];
+	}
+
+	// just under the measured clean-read floor (fixtures 0.562-0.669,
+	// confirmed scan events 0.612-0.635 — this screen's ability-grid scores
+	// keep the mean low even on perfect reads)
+	return {
+		id: "scoreboard-own",
+		sufficientConfidence: 0.55,
+		gate,
+		parse,
+	};
+}
diff --git a/app/features/scanner/core/detectors/scoreboard-own/rois.ts b/app/features/scanner/core/detectors/scoreboard-own/rois.ts
new file mode 100644
index 000000000..6a4fd3465
--- /dev/null
+++ b/app/features/scanner/core/detectors/scoreboard-own/rois.ts
@@ -0,0 +1,90 @@
+/**
+ * ALL scoreboard-own ROI coordinates, in canonical 1920x1080 space.
+ * Calibrated against scoreboard-own/private-battle-splat-zones-museum via
+ * tools/dump-crops.ts and column/row projection measurement.
+ *
+ * The personal results screen ("your results") shows the same header tags
+ * as the live scoreboard (same positions, reuses its bands) over a dark
+ * panel (~35) with the player's banner, medals list, and four bottom
+ * cards: weapon card (yellow-bordered title tag, big render on white
+ * square) then one gear card per slot, each with a gray ability strip of
+ * one main badge (⌀~49) and three sub badges (⌀~38).
+ */
+import type { Roi } from "../../canonical";
+
+/**
+ * Weapon card title tag interior (black, white name left-aligned). Band
+ * starts inside the tag so readTagBand's extent trim anchors immediately.
+ */
+export const WEAPON_TITLE_BAND: Roi = { x: 876, y: 766, w: 200, h: 32 };
+/** Tight cap height of the title text at 1080p. */
+export const WEAPON_TITLE_TEXT_HEIGHT = 18;
+/** White-core title text on the black tag binarizes high, like the burst text. */
+export const WEAPON_TITLE_BIN_THRESHOLD = 190;
+
+/** Gear cards [head, clothes, shoes]: main-ability badge center x per row. */
+export const GEAR_MAIN_CXS = [1142, 1372, 1602] as const;
+/** Sub badge center x offsets from the row's main badge center. */
+const GEAR_SUB_DXS = [48, 88, 127] as const;
+/** All badges share one vertical center (the ability strip line). */
+export const GEAR_BADGE_CY = 927;
+export const GEAR_ROWS = 3;
+
+/**
+ * Search boxes around each badge; heights double as the size filter
+ * (matchTemplate skips templates taller than the ROI).
+ */
+export function gearMainRoi(row: number): Roi {
+	const cx = GEAR_MAIN_CXS[row]!;
+	return { x: cx - 32, y: GEAR_BADGE_CY - 32, w: 64, h: 64 };
+}
+
+export function gearSubRoi(row: number, slot: number): Roi {
+	const cx = GEAR_MAIN_CXS[row]! + GEAR_SUB_DXS[slot]!;
+	return { x: cx - 26, y: GEAR_BADGE_CY - 26, w: 52, h: 52 };
+}
+
+/** Template heights (px at 1080p) per badge role (main ⌀~49, sub ⌀~38). */
+export const OWN_ABILITY_MAIN_SIZES = [45, 49, 53] as const;
+export const OWN_ABILITY_SUB_SIZES = [34, 38, 42] as const;
+/**
+ * Icon art diameter as fraction of badge box: ratio peaks at 1.0 for both
+ * roles (art overflows the circle slightly), so the ring contributes nothing.
+ */
+export const OWN_ABILITY_ART_RATIO = 1.0;
+/**
+ * Ink threshold inside a badge box. Unlike the death panel these sit on a
+ * light-gray strip (~140-155); 170 keeps the strip out while art still
+ * clears it on its max channel.
+ */
+export const OWN_ABILITY_INK_THRESHOLD = 170;
+
+/**
+ * Gate probes. Results panel is uniform dark (~35, edge ~54) at spots
+ * dodging the banner/medals/cards; each title tag holds bright white
+ * text at its left edge; the strip's gray shows after the third sub badge.
+ */
+export const GATE_PANEL_PROBES: readonly Roi[] = [
+	{ x: 860, y: 245, w: 30, h: 20 },
+	{ x: 1690, y: 395, w: 30, h: 20 },
+	{ x: 875, y: 695, w: 30, h: 20 },
+	{ x: 1400, y: 985, w: 30, h: 20 },
+];
+export const GATE_PANEL_MAX_MEAN = 65;
+
+/** Left edge of each card's title text (weapon card first). */
+export const GATE_TITLE_TEXT_PROBES: readonly Roi[] = [
+	{ x: 880, y: 768, w: 70, h: 26 },
+	{ x: 1090, y: 768, w: 70, h: 26 },
+	{ x: 1319, y: 768, w: 70, h: 26 },
+	{ x: 1550, y: 768, w: 70, h: 26 },
+];
+/** Title text regions must contain bright (white) pixels. */
+export const GATE_TEXT_MIN_MAX = 180;
+
+/** Gray ability-strip gap after the third sub badge, one per gear card. */
+export function gateStripProbe(row: number): Roi {
+	return { x: GEAR_MAIN_CXS[row]! + 148, y: 917, w: 10, h: 18 };
+}
+export const GATE_STRIP_MIN_MEAN = 110;
+export const GATE_STRIP_MAX_MEAN = 200;
diff --git a/app/features/scanner/core/detectors/scoreboard/banner.ts b/app/features/scanner/core/detectors/scoreboard/banner.ts
new file mode 100644
index 000000000..13f2fd718
--- /dev/null
+++ b/app/features/scanner/core/detectors/scoreboard/banner.ts
@@ -0,0 +1,286 @@
+/**
+ * "Score:" banner parsing for the results screens. Each side of the colored
+ * banner shows one team's game score (0-100) as white BlitzBold digits after
+ * a localized label — some languages render no label at all, so the digits'
+ * x position is not fixed. A knockout replaces the winning side's value with
+ * the localized KNOCKOUT! burst, whose letters only weakly match digit
+ * templates (real digits score 0.9+); the knockout itself is recognized from
+ * the winner's team total instead (the box prints the count times five, and
+ * only a knockout's full 100 count reaches 500). The score value bounces as
+ * it lands, so a frame may catch the digits settled or mid-pop — this module
+ * parses at every size and binarization threshold and keeps the best
+ * read (valid over none, longer digit run over shorter, then confidence).
+ */
+import { getCV, type Mat } from "../../cv";
+import {
+	type GlyphSet,
+	type RecognizedChar,
+	type RecognizedText,
+	recognizeText,
+} from "../../glyphs";
+import { copyRoi, type Roi } from "../../image";
+
+/** The count a knockout wins at — the burst hides it, so it is never read. */
+export const KO_MATCH_SCORE = 100;
+
+/**
+ * The team box prints the count times five ("440 p" alongside a 88 banner),
+ * so a knockout's full 100 count shows as 500 — a total only a knockout
+ * reaches, which is what separates a burst-covered banner from an unread one.
+ */
+export const FULL_COUNT_TEAM_SCORE = KO_MATCH_SCORE * 5;
+
+/**
+ * Replay-screen reads below this floor are discarded rather than trusted as
+ * a score — burst/label letters overlapping a score ROI match digit
+ * templates at ~0.4 there.
+ */
+export const MATCH_SCORE_MIN_CONF = 0.6;
+
+/**
+ * Char floor for the live banner's trailing-digit run. KNOCKOUT! letters
+ * have matched digit templates at up to 0.62 (the ko-hagglefish fixture's
+ * "07"), while genuine banner digits score 0.79+ across every fixture —
+ * including 720p upscales.
+ */
+const DIGIT_MIN_CONF = 0.75;
+
+/** White banner digits on saturated team color (yellow ink grays at ~170). */
+const BANNER_SCORE_BIN_THRESHOLD = 205;
+
+/**
+ * Second binarization pass for pale team colors: a light banner (gray ~220,
+ * with the wave-crest highlight brighter still) binarizes solid white at the
+ * base threshold, gluing label and digits into one giant unmatchable blob
+ * that can swallow all but the last digit. Only the ~250 digit ink survives
+ * this threshold. Every pass always runs; a swallowed background can only
+ * shorten the digit run, never lengthen it, so the longer run wins
+ * regardless of confidence (the truncated read's surviving digit is genuine
+ * ink and scores just as well).
+ */
+const BANNER_SCORE_BRIGHT_BIN_THRESHOLD = 240;
+
+/**
+ * Third pass for the brightest banners: a yellow battle-log banner grays at
+ * ~245 near the wave crest, so even the bright pass keeps label ink attached
+ * and erodes the digits below the confidence floor. Only the ~250 digit
+ * cores survive this threshold.
+ */
+const BANNER_SCORE_BRIGHTEST_BIN_THRESHOLD = 248;
+
+/**
+ * Digits of one number nearly touch; anything further apart than this
+ * fraction of a digit width is the label (or an unreadable glyph) ending
+ * the run.
+ */
+const DIGIT_GAP_MAX_RATIO = 0.55;
+
+/**
+ * A score digit spans the set's full height; the label's lowercase letters
+ * top out ~0.75 of it, so they cannot pass as digits even when their shapes
+ * correlate.
+ */
+const DIGIT_MIN_HEIGHT_RATIO = 0.82;
+
+/**
+ * The banner's bright wave-crest highlight can dip into the score line as a
+ * wide ~12px-tall streak whose columns merge into the digits' segments and
+ * ruin their ink extents. Every real digit is at least ~26px tall, so ink
+ * components shorter than this are wiped before recognition.
+ */
+const MIN_COMPONENT_HEIGHT = 20;
+
+export interface BannerScoreRead {
+	/** the side's score; null when unread (knockout burst, blur, label-only) */
+	value: number | null;
+	/** min glyph score across the accepted digits (0 when none) */
+	confidence: number;
+	/** digits in the accepted run (0 when unread) */
+	digits: number;
+	/** best raw reading, for debugging */
+	reading: string;
+}
+
+const EMPTY_READ: BannerScoreRead = {
+	value: null,
+	confidence: 0,
+	digits: 0,
+	reading: "",
+};
+
+/**
+ * Reads one banner side's score from `roi`: recognizes with each digit set
+ * (one per on-screen text size) at each binarization threshold and keeps
+ * the best read — a valid value beats none, a longer digit run beats a
+ * shorter one, confidence breaks ties. The score is the trailing run of
+ * full-height, confidently-matched digits — everything the localized label
+ * or the KNOCKOUT! burst leaves in the ROI fails at least one of those
+ * tests.
+ */
+export function parseBannerScore(
+	gray: Mat,
+	roi: Roi,
+	sets: readonly GlyphSet[],
+): BannerScoreRead {
+	const crop = copyRoi(gray, roi);
+	clearShortBlobs(crop);
+	let best = EMPTY_READ;
+	for (const binThreshold of [
+		BANNER_SCORE_BIN_THRESHOLD,
+		BANNER_SCORE_BRIGHT_BIN_THRESHOLD,
+		BANNER_SCORE_BRIGHTEST_BIN_THRESHOLD,
+	]) {
+		for (const set of sets) {
+			const raw = recognizeText(crop, set, {
+				binThreshold,
+				spaceGap: Number.POSITIVE_INFINITY,
+				minCharScore: 0.3,
+			});
+			const read = trailingDigitRun(raw, set);
+			if (isBetterRead(read, best)) best = read;
+		}
+	}
+	crop.delete();
+	return best;
+}
+
+/**
+ * Winner-first score pair from the two banner sides. A confirmed knockout
+ * (winner team total = 500) dominates: the winner reports the full count no
+ * matter what was read off the burst-covered side, and the loser is the
+ * more confident read (genuine digits score well clear of burst letters
+ * that survive the floor). Without a knockout, ranked scores never tie, so
+ * when both sides read the higher value is the winner's; one unreadable
+ * side cannot be attributed to a team, so nothing is reported.
+ */
+export function resolveMatchScores({
+	left,
+	right,
+	knockout,
+}: {
+	left: BannerScoreRead;
+	right: BannerScoreRead;
+	knockout: boolean;
+}): [number | null, number | null] {
+	if (knockout) {
+		const loser =
+			left.value !== null && right.value !== null
+				? left.confidence >= right.confidence
+					? left
+					: right
+				: left.value !== null
+					? left
+					: right;
+		return [KO_MATCH_SCORE, loser.value];
+	}
+	if (left.value !== null && right.value !== null) {
+		return left.value >= right.value
+			? [left.value, right.value]
+			: [right.value, left.value];
+	}
+	return [null, null];
+}
+
+/** Zero out ink components shorter than any digit (see MIN_COMPONENT_HEIGHT). */
+function clearShortBlobs(band: Mat): void {
+	const cv = getCV();
+	const bin = new cv.Mat();
+	cv.threshold(band, bin, BANNER_SCORE_BIN_THRESHOLD, 255, cv.THRESH_BINARY);
+	const labels = new cv.Mat();
+	const stats = new cv.Mat();
+	const centroids = new cv.Mat();
+	const count = cv.connectedComponentsWithStats(
+		bin,
+		labels,
+		stats,
+		centroids,
+		8,
+	);
+	bin.delete();
+	centroids.delete();
+	const s = stats.data32S;
+	const short = new Uint8Array(count);
+	for (let i = 1; i < count; i++) {
+		short[i] = s[i * 5 + cv.CC_STAT_HEIGHT]! < MIN_COMPONENT_HEIGHT ? 1 : 0;
+	}
+	stats.delete();
+	const lab = labels.data32S;
+	const out = band.data;
+	for (let i = 0; i < out.length; i++) {
+		if (short[lab[i]!]!) out[i] = 0;
+	}
+	labels.delete();
+}
+
+/**
+ * Read preference shared by every multi-attempt digit read: a valid value
+ * beats none, a longer digit run beats a shorter one, confidence breaks
+ * ties.
+ */
+export function isBetterRead(
+	read: BannerScoreRead,
+	best: BannerScoreRead,
+): boolean {
+	if ((read.value !== null) !== (best.value !== null)) {
+		return read.value !== null;
+	}
+	if (read.digits !== best.digits) return read.digits > best.digits;
+	return read.confidence > best.confidence;
+}
+
+export interface TrailingDigitOptions {
+	/** char floor a glyph must clear to count as a digit of the number */
+	minCharScore?: number;
+	/** min ink height as a fraction of the set height (drops labels, '+') */
+	minHeightRatio?: number;
+	/** values above this are rejected as misreads */
+	maxValue?: number;
+}
+
+/**
+ * The trailing run of full-height, confidently-matched digits of a
+ * recognized line — the number-on-a-plate read shared by the score banner
+ * and the objective counters, where a localized label / burst / '+' sign
+ * precedes the digits and must fail at least one of the floors.
+ */
+export function trailingDigitRun(
+	raw: RecognizedText,
+	set: GlyphSet,
+	options: TrailingDigitOptions = {},
+): BannerScoreRead {
+	const {
+		minCharScore = DIGIT_MIN_CONF,
+		minHeightRatio = DIGIT_MIN_HEIGHT_RATIO,
+		maxValue = KO_MATCH_SCORE,
+	} = options;
+	const maxGap = Math.max(4, Math.round(set.medianWidth * DIGIT_GAP_MAX_RATIO));
+	const isScoreDigit = (c: RecognizedChar) =>
+		c.score >= minCharScore && c.y1 - c.y0 >= set.height * minHeightRatio;
+
+	const run: RecognizedChar[] = [];
+	let i = raw.chars.length - 1;
+	for (; i >= 0; i--) {
+		const c = raw.chars[i]!;
+		if (!isScoreDigit(c)) break;
+		if (run.length > 0 && run[0]!.x0 - c.x1 > maxGap) break;
+		run.unshift(c);
+	}
+	if (run.length === 0) return { ...EMPTY_READ, reading: raw.text };
+	// A further digit left of the run means an unreadable glyph split the
+	// number (turf war percentages read "48", ".", "7") — the tail is not
+	// the score.
+	for (let k = i; k >= 0; k--) {
+		if (isScoreDigit(raw.chars[k]!)) {
+			return { ...EMPTY_READ, reading: raw.text };
+		}
+	}
+
+	const value = Number.parseInt(run.map((c) => c.char).join(""), 10);
+	if (value > maxValue) return { ...EMPTY_READ, reading: raw.text };
+	return {
+		value,
+		confidence: Math.min(...run.map((c) => c.score)),
+		digits: run.length,
+		reading: raw.text,
+	};
+}
diff --git a/app/features/scanner/core/detectors/scoreboard/digits.ts b/app/features/scanner/core/detectors/scoreboard/digits.ts
new file mode 100644
index 000000000..2abe4e296
--- /dev/null
+++ b/app/features/scanner/core/detectors/scoreboard/digits.ts
@@ -0,0 +1,58 @@
+/**
+ * Number field parsing on top of glyph recognition.
+ */
+import type { Mat } from "../../cv";
+import {
+	type GlyphSet,
+	type RecognizedText,
+	recognizeText,
+} from "../../glyphs";
+
+export interface ParsedNumber {
+	value: number | null;
+	/** min glyph score across recognized digits */
+	confidence: number;
+	/** x of the leftmost digit, relative to the crop (null when nothing found) */
+	leftX: number | null;
+	raw: RecognizedText;
+}
+
+/**
+ * Digits share a cap line; a lowercase suffix ("p") starts at x-height,
+ * ~7px lower at the sizes we parse. A trailing char whose ink top sits at
+ * least this far below the other chars' top line is the suffix, not a digit.
+ */
+const LOWERED_TRAILING_MIN_PX = 5;
+
+export function parseNumber(
+	gray: Mat,
+	digits: GlyphSet,
+	options: { binThreshold?: number; dropLoweredTrailing?: boolean } = {},
+): ParsedNumber {
+	const raw = recognizeText(gray, digits, {
+		spaceGap: Number.POSITIVE_INFINITY,
+		minCharScore: 0.3,
+		binThreshold: options.binThreshold,
+	});
+	// The replay paint column is left-aligned, so its "p" suffix moves with
+	// the digit count and can land inside the ROI, where the digit-only
+	// charset misreads it (a "6"). The geometry still tells it apart.
+	let chars = raw.chars;
+	if (options.dropLoweredTrailing && chars.length > 1) {
+		const capY0 = Math.min(...chars.slice(0, -1).map((c) => c.y0));
+		if (chars[chars.length - 1]!.y0 - capY0 >= LOWERED_TRAILING_MIN_PX) {
+			chars = chars.slice(0, -1);
+		}
+	}
+	const text = chars.map((c) => c.char).join("");
+	const isNumeric = /^[0-9]+$/.test(text);
+	return {
+		value: isNumeric ? Number.parseInt(text, 10) : null,
+		confidence:
+			chars.length > 0
+				? Math.min(...chars.map((c) => c.score))
+				: raw.confidence,
+		leftX: chars.length > 0 ? chars[0]!.x0 : null,
+		raw,
+	};
+}
diff --git a/app/features/scanner/core/detectors/scoreboard/header.ts b/app/features/scanner/core/detectors/scoreboard/header.ts
new file mode 100644
index 000000000..03c7bd307
--- /dev/null
+++ b/app/features/scanner/core/detectors/scoreboard/header.ts
@@ -0,0 +1,193 @@
+/**
+ * Header parsing: lobby type ("X Battle"), mode ("Splat Zones") and stage
+ * ("Scorch Gorge") from the black tags above the team boxes.
+ *
+ * Tags auto-size to their text, so the stage's x position depends on mode
+ * length. Each band is trimmed to the tag extent (near-black bg + white
+ * text; the map thumbnail around it is mid-brightness), then OCR'd as one
+ * line and snapped against every language's mode × stage combos
+ * (core/localized.ts) — reported values are always sendou.ink ids.
+ */
+import type { ModeShort, StageId } from "~/modules/in-game-lists/types";
+import type { ScannerLobby } from "../../../scanner-types";
+import { getCV, type Mat } from "../../cv";
+import {
+	type GlyphSet,
+	type RecognizeOptions,
+	recognizeText,
+} from "../../glyphs";
+import { copyRoi } from "../../image";
+import { ALL_LOBBY_ENTRIES, MODE_STAGE_COMBOS } from "../../localized";
+import { closestBy } from "../../text";
+import { HEADER_LINE_BAND, HEADER_LOBBY_BAND } from "./rois";
+
+export interface ParsedHeader {
+	lobby: ScannerLobby | null;
+	mode: ModeShort | null;
+	stage: StageId | null;
+	/** min of the closed-set match scores that were attempted */
+	confidence: number;
+	debug: {
+		lobbyReading: string;
+		lineReading: string;
+		lobbyScore: number;
+		lineScore: number;
+	};
+}
+
+/** Accept a closed-set match only above this score (1 = exact). */
+const MIN_MATCH_SCORE = 0.62;
+
+/** A column belongs to a tag when nearly all its pixels are dark bg or bright text. */
+const TAG_COLUMN_FRACTION = 0.85;
+const TAG_DARK_MAX = 75;
+const TAG_BRIGHT_MIN = 165;
+/** Stop extending the tag after this many consecutive non-tag columns. */
+const TAG_GAP_TOLERANCE = 6;
+
+/**
+ * Trim a band crop to the black-tag extent: the longest run of tag columns
+ * starting within `maxLeadIn` of the left edge (a dark photo edge can fake
+ * a short run before the real tag), each run extended right until the tag
+ * ends. Returns a zero-width range when no tag is present at all.
+ */
+function tagExtent(
+	crop: Mat,
+	darkMax: number,
+	maxLeadIn: number,
+	columnFraction: number,
+): { start: number; end: number } {
+	const { cols, rows, data } = crop;
+	let best = { start: 0, end: 0 };
+	let start = -1;
+	let end = 0;
+	let gap = 0;
+	const takeRun = () => {
+		if (start !== -1 && end - start > best.end - best.start) {
+			best = { start, end };
+		}
+		start = -1;
+		gap = 0;
+	};
+	for (let x = 0; x < cols; x++) {
+		let tagLike = 0;
+		for (let y = 0; y < rows; y++) {
+			const v = data[y * cols + x]!;
+			if (v < darkMax || v > TAG_BRIGHT_MIN) tagLike++;
+		}
+		if (tagLike / rows >= columnFraction) {
+			if (start === -1) {
+				if (x > maxLeadIn) break;
+				start = x;
+			}
+			end = x + 1;
+			gap = 0;
+		} else if (start !== -1 && ++gap > TAG_GAP_TOLERANCE) {
+			takeRun();
+		} else if (start === -1 && x > maxLeadIn) {
+			break;
+		}
+	}
+	takeRun();
+	return best;
+}
+
+export interface TagBandOptions extends RecognizeOptions {
+	/**
+	 * Dark ceiling for the tag-extent trim. Lifted-blacks captures (720p
+	 * streams upscaled and re-encoded) raise the tag background above the
+	 * default, truncating the trim to a sliver — callers whose closed-set
+	 * snap fails retry with a lifted ceiling.
+	 */
+	tagDarkMax?: number;
+	/**
+	 * Non-tag columns tolerated before the tag begins. The battle log tags
+	 * are not left-anchored (a leading rank icon shifts line 1 per lobby
+	 * type), so its bands start on the stage photo and scan for the tag.
+	 */
+	tagLeadInMax?: number;
+	/**
+	 * Tag-like row fraction a column must reach. The battle log tags are
+	 * subtly tilted, so a horizontal band always catches a few photo rows
+	 * above or below the box — those bands pass a looser fraction.
+	 */
+	tagColumnFraction?: number;
+}
+
+/**
+ * OCR one header band: trim the crop to the black-tag extent, then
+ * recognize it as a single line. Shared with the scoreboard-battle-log-replay
+ * header, whose tags have the same style at different positions/sizes.
+ */
+export function readTagBand(
+	gray: Mat,
+	band: { x: number; y: number; w: number; h: number },
+	glyphs: GlyphSet,
+	options: TagBandOptions = {},
+): string {
+	const crop = copyRoi(gray, band);
+	const { start, end } = tagExtent(
+		crop,
+		options.tagDarkMax ?? TAG_DARK_MAX,
+		options.tagLeadInMax ?? TAG_GAP_TOLERANCE,
+		options.tagColumnFraction ?? TAG_COLUMN_FRACTION,
+	);
+	if (end - start < 12) {
+		crop.delete();
+		return "";
+	}
+	const cv = getCV();
+	const view = crop.roi(new cv.Rect(start, 0, end - start, crop.rows));
+	const trimmed = new cv.Mat();
+	view.copyTo(trimmed);
+	view.delete();
+	crop.delete();
+	const result = recognizeText(trimmed, glyphs, {
+		spaceGap: 9,
+		minCharScore: 0.3,
+		...options,
+	});
+	trimmed.delete();
+	return result.text.trim();
+}
+
+export function parseHeader(
+	gray: Mat,
+	lobbyGlyphs: GlyphSet,
+	lineGlyphs: GlyphSet,
+): ParsedHeader {
+	const lobbyReading = readTagBand(gray, HEADER_LOBBY_BAND, lobbyGlyphs);
+	const lineReading = readTagBand(gray, HEADER_LINE_BAND, lineGlyphs);
+
+	const lobbyMatch = lobbyReading
+		? closestBy(lobbyReading, ALL_LOBBY_ENTRIES, (e) => e.text)
+		: null;
+	const lineMatch = lineReading
+		? closestBy(lineReading, MODE_STAGE_COMBOS, (c) => c.text)
+		: null;
+
+	const lobby =
+		lobbyMatch && lobbyMatch.score >= MIN_MATCH_SCORE
+			? lobbyMatch.entry.lobby
+			: null;
+	let mode: ModeShort | null = null;
+	let stage: StageId | null = null;
+	if (lineMatch && lineMatch.score >= MIN_MATCH_SCORE) {
+		mode = lineMatch.entry.mode;
+		stage = lineMatch.entry.stageId;
+	}
+
+	const attempted = [lobbyMatch?.score ?? 0, lineMatch?.score ?? 0];
+	return {
+		lobby,
+		mode,
+		stage,
+		confidence: Math.min(...attempted),
+		debug: {
+			lobbyReading,
+			lineReading,
+			lobbyScore: lobbyMatch?.score ?? 0,
+			lineScore: lineMatch?.score ?? 0,
+		},
+	};
+}
diff --git a/app/features/scanner/core/detectors/scoreboard/index.ts b/app/features/scanner/core/detectors/scoreboard/index.ts
new file mode 100644
index 000000000..a7720def2
--- /dev/null
+++ b/app/features/scanner/core/detectors/scoreboard/index.ts
@@ -0,0 +1,332 @@
+/**
+ * ScoreboardDetector: parses the end-of-match results scoreboard
+ * (team scores + 8 rows of weapon / name / paint / splats / deaths / specials).
+ */
+import type {
+	MainWeaponId,
+	ModeShort,
+	StageId,
+} from "~/modules/in-game-lists/types";
+import type { ScannerLobby } from "../../../scanner-types";
+import { getCV, type Mat } from "../../cv";
+import { type GlyphSet, scaleGlyphSet } from "../../glyphs";
+import { cropRoi, maxBrightness, meanBrightness } from "../../image";
+import type { DetectedEvent, Detector, GateResult } from "../types";
+import {
+	FULL_COUNT_TEAM_SCORE,
+	parseBannerScore,
+	resolveMatchScores,
+} from "./banner";
+import { parseNumber } from "./digits";
+import { type ParsedHeader, parseHeader } from "./header";
+import { findPovIndex } from "./pov";
+import {
+	GATE_DARK_MAX_MEAN,
+	GATE_PANEL_MAX_MEAN,
+	GATE_PANEL_PROBES,
+	GATE_TEXT_MIN_MAX,
+	gateDarkProbe,
+	MATCH_SCORE_DIGIT_HEIGHTS,
+	MATCH_SCORE_ROIS,
+	nameRoi,
+	PAINT_DIGIT_HEIGHT,
+	paintRoi,
+	paintSuffixRoi,
+	povArrowRoi,
+	ROW_CENTERS,
+	specialIconRoi,
+	statRoi,
+	TEAM_DIGIT_HEIGHT,
+	TEAM_SCORE_ROIS,
+	weaponRoi,
+} from "./rois";
+import { parseScoreboardRow, type RowRois } from "./row";
+import type { SpecialMatch, SpecialTemplate } from "./specials";
+import type { WeaponMatch, WeaponTemplate } from "./weapons";
+
+export interface ScoreboardPlayer {
+	name: string;
+	/** sendou main-weapon id; null when the row's weapon was unreadable */
+	weaponId: MainWeaponId | null;
+	paint: number | null;
+	/** kills+assists (the combined counter as shown) */
+	ka: number | null;
+	d: number | null;
+	s: number | null;
+}
+
+export interface ScoreboardData {
+	/** from the header tag; null when unreadable */
+	lobby: ScannerLobby | null;
+	mode: ModeShort | null;
+	stage: StageId | null;
+	/**
+	 * the "Score:" banner game scores, [winner, loser]; a knockout's winner
+	 * reports 100 (the burst hides the real banner)
+	 */
+	matchScores: [number | null, number | null];
+	/** 8 players: rows 0-3 winning team, rows 4-7 losing team */
+	players: ScoreboardPlayer[];
+	/**
+	 * index into `players` of the recording player's row, marked by the
+	 * yellow arrow; null when no arrow is found (spectator/overhead footage)
+	 */
+	povIndex: number | null;
+}
+
+export interface ScoreboardRowDebug {
+	weapon: WeaponMatch | null;
+	/** row's special icon match, when it was consulted for a weapon tie */
+	special?: SpecialMatch;
+	paintScore: number;
+	nameScore: number;
+	statScores: [number, number, number];
+	/** fraction of the row's POV-arrow probe that is arrow-yellow */
+	povFraction: number;
+}
+
+export interface ScoreboardResources {
+	weapons: WeaponTemplate[];
+	/**
+	 * Special-weapon silhouettes (assets/cv/specials). Optional: without
+	 * them, near-tied weapon icons (Splash- vs Sploosh-o-matic) stay decided
+	 * by icon score alone.
+	 */
+	specials?: SpecialTemplate[] | null;
+	/** digit templates at paint size (h~28); team scores reuse these, scaled */
+	paintDigits: GlyphSet | null;
+	/** digit templates at stat-counter size (h~17) */
+	statDigits: GlyphSet | null;
+	/**
+	 * digit templates for team totals (h~33, outlined, on team-color box).
+	 * Optional: falls back to scaled paint digits, at reduced accuracy.
+	 */
+	teamDigits: GlyphSet | null;
+	nameGlyphs: GlyphSet | null;
+	/** header tag glyphs: lobby line, and the mode+stage line */
+	headerLobbyGlyphs: GlyphSet | null;
+	headerLineGlyphs: GlyphSet | null;
+	/**
+	 * Replay-browser extras (FOT-RowdyStd face, unlike everything above):
+	 * the replay code line, and the VICTORY/DEFEAT panel tags. Optional:
+	 * the replay detector falls back to rescaled name/header glyphs, at
+	 * reduced accuracy.
+	 */
+	replayCodeGlyphs?: GlyphSet | null;
+	replayResultGlyphs?: GlyphSet | null;
+	/**
+	 * Death-screen extras. Optional: the death detector skips the fields it
+	 * has no resources for. The weapon atlas carries both Blitz faces; the
+	 * tag-name atlas is BlitzBold + Rowdy (kana).
+	 */
+	abilities?: import("../death/abilities").AbilityTemplates | null;
+	deathWeaponGlyphs?: GlyphSet | null;
+	/**
+	 * JA death-message glyphs (Kurokane/Rowdy condensed + fixture crops),
+	 * built at the on-screen text's native size. Optional: without them JA
+	 * death screens fail the constant-line confirmation and emit nothing.
+	 */
+	deathWeaponJaGlyphs?: GlyphSet | null;
+	deathTagNameGlyphs?: GlyphSet | null;
+	/**
+	 * The main-weapon icons again, rebuilt at the death burst's icon size
+	 * (~124px vs the rows' 40-64px). Optional: without them the death
+	 * detector cannot recover the killer's weapon when the message text is
+	 * unreadable (e.g. the WIPEOUT banner covering the weapon name line).
+	 */
+	deathBurstWeapons?: WeaponTemplate[] | null;
+	/**
+	 * Personal-results extras: the same ability icons rebuilt at the gear
+	 * cards' badge sizes (scoreboard-own/abilities.ts). Optional: without
+	 * them the scoreboard-own detector skips the ability grid.
+	 */
+	ownAbilities?: import("../death/abilities").AbilityTemplates | null;
+	/**
+	 * Map-start intro extras: the big BlitzBold mode title, and the BlitzMain
+	 * stage name (whose atlas also reads the "MODE" label, rescaled).
+	 * Optional: without them the map-start detector emits nothing.
+	 */
+	mapStartModeGlyphs?: GlyphSet | null;
+	mapStartStageGlyphs?: GlyphSet | null;
+	/**
+	 * Minimap extras (minimap/rois.ts documents the screen): the main-weapon
+	 * icons composited on the card-pill background for the teammate cards'
+	 * light silhouettes, a light-background variant for highlighted enemy
+	 * rows, and the ability icons at the cards' badge size. Optional: without
+	 * them the minimap detector skips the corresponding fields (enemy rows
+	 * fall back to the standard `weapons` set). Names reuse `nameGlyphs`.
+	 */
+	minimapCardWeapons?: WeaponTemplate[] | null;
+	minimapLightWeapons?: WeaponTemplate[] | null;
+	minimapAbilities?: WeaponTemplate[] | null;
+	/**
+	 * Sub-weapon silhouettes (assets/cv/sub-weapons) at the minimap sub
+	 * tile's sizes. Optional: without them, near-tied minimap weapon icons
+	 * whose kits differ only by sub (plain vs Custom Dualie Squelchers) stay
+	 * decided by icon score alone.
+	 */
+	minimapSubWeapons?: SpecialTemplate[] | null;
+	/**
+	 * Planner-map structural signatures (assets/cv/planner) used by the
+	 * minimap detector to identify the stage. Optional: without them the
+	 * minimap event's `stage` stays null.
+	 */
+	plannerStages?: import("../minimap/stage").PlannerStage[] | null;
+}
+
+export const SCOREBOARD_EVENT_TYPE = "Scoreboard";
+
+export function createScoreboardDetector(
+	resources: ScoreboardResources,
+): Detector<ScoreboardData> {
+	const cv = getCV();
+	const teamDigits =
+		resources.teamDigits ??
+		(resources.paintDigits
+			? scaleGlyphSet(
+					resources.paintDigits,
+					TEAM_DIGIT_HEIGHT / PAINT_DIGIT_HEIGHT,
+				)
+			: null);
+	const matchScoreSets = teamDigits
+		? MATCH_SCORE_DIGIT_HEIGHTS.map((height) =>
+				scaleGlyphSet(teamDigits, height / teamDigits.height),
+			)
+		: [];
+
+	function gate(frame: Mat): GateResult {
+		const gray = new cv.Mat();
+		cv.cvtColor(frame, gray, cv.COLOR_RGBA2GRAY);
+
+		let darkOk = 0;
+		let suffixOk = 0;
+		for (const cy of ROW_CENTERS) {
+			if (meanBrightness(frame, gateDarkProbe(cy)) < GATE_DARK_MAX_MEAN)
+				darkOk++;
+			if (maxBrightness(gray, paintSuffixRoi(cy)) > GATE_TEXT_MIN_MAX)
+				suffixOk++;
+		}
+		let panelOk = 0;
+		for (const roi of GATE_PANEL_PROBES) {
+			if (meanBrightness(frame, roi) < GATE_PANEL_MAX_MEAN) panelOk++;
+		}
+		gray.delete();
+
+		const score =
+			(darkOk / ROW_CENTERS.length +
+				suffixOk / ROW_CENTERS.length +
+				panelOk / GATE_PANEL_PROBES.length) /
+			3;
+		const pass = darkOk >= 7 && suffixOk >= 6 && panelOk >= 2;
+		return { pass, score };
+	}
+
+	function parse(frame: Mat, t: number): DetectedEvent<ScoreboardData>[] {
+		const gray = new cv.Mat();
+		cv.cvtColor(frame, gray, cv.COLOR_RGBA2GRAY);
+		const rgb = new cv.Mat();
+		cv.cvtColor(frame, rgb, cv.COLOR_RGBA2RGB);
+
+		const players: ScoreboardPlayer[] = [];
+		const rowDebug: ScoreboardRowDebug[] = [];
+		const confidences: number[] = [];
+
+		const rowRois: RowRois = {
+			weapon: weaponRoi,
+			specialIcon: specialIconRoi,
+			paint: paintRoi,
+			name: nameRoi,
+			stat: statRoi,
+			povArrow: povArrowRoi,
+		};
+		for (const cy of ROW_CENTERS) {
+			const row = parseScoreboardRow(
+				gray,
+				rgb,
+				cy,
+				rowRois,
+				resources,
+				confidences,
+			);
+			players.push(row.player);
+			rowDebug.push(row.debug);
+		}
+		const povIndex = findPovIndex(rowDebug.map((r) => r.povFraction));
+
+		let header: ParsedHeader | null = null;
+		if (resources.headerLobbyGlyphs && resources.headerLineGlyphs) {
+			header = parseHeader(
+				gray,
+				resources.headerLobbyGlyphs,
+				resources.headerLineGlyphs,
+			);
+			confidences.push(header.confidence);
+		}
+
+		// The winner's team total is read only to recognize a knockout: the
+		// box prints the count times five, and only a knockout's full 100
+		// count reaches 500 (the banner value it would confirm is hidden
+		// under the KNOCKOUT! burst).
+		let knockout = false;
+		let winnerTotalConf = 0;
+		if (teamDigits) {
+			// The total sits on the team-colored box (light swirl pattern),
+			// so binarize more aggressively than on the black pills.
+			const crop = cropRoi(gray, TEAM_SCORE_ROIS[0]);
+			const winnerTotal = parseNumber(crop, teamDigits, {
+				binThreshold: 175,
+			});
+			crop.delete();
+			knockout = winnerTotal.value === FULL_COUNT_TEAM_SCORE;
+			winnerTotalConf = winnerTotal.confidence;
+		}
+
+		let matchScores: [number | null, number | null] = [null, null];
+		let bannerDebug: object | undefined;
+		if (matchScoreSets.length > 0) {
+			const left = parseBannerScore(gray, MATCH_SCORE_ROIS[0], matchScoreSets);
+			const right = parseBannerScore(gray, MATCH_SCORE_ROIS[1], matchScoreSets);
+			matchScores = resolveMatchScores({ left, right, knockout });
+			confidences.push(left.confidence, right.confidence);
+			bannerDebug = { left, right, knockout, winnerTotalConf };
+		}
+
+		gray.delete();
+		rgb.delete();
+
+		const confidence =
+			confidences.length > 0
+				? confidences.reduce((a, b) => a + b, 0) / confidences.length
+				: 0;
+
+		return [
+			{
+				type: SCOREBOARD_EVENT_TYPE,
+				t,
+				confidence,
+				data: {
+					lobby: header?.lobby ?? null,
+					mode: header?.mode ?? null,
+					stage: header?.stage ?? null,
+					matchScores,
+					players,
+					povIndex,
+				},
+				debug: {
+					rows: rowDebug,
+					matchScore: bannerDebug,
+					header: header?.debug,
+				},
+			},
+		];
+	}
+
+	// just under the measured clean-read floor (fixtures 0.865-0.899,
+	// confirmed scan events down to 0.799)
+	return {
+		id: "scoreboard",
+		sufficientConfidence: 0.79,
+		gate,
+		parse,
+	};
+}
diff --git a/app/features/scanner/core/detectors/scoreboard/kits.ts b/app/features/scanner/core/detectors/scoreboard/kits.ts
new file mode 100644
index 000000000..4705a6b48
--- /dev/null
+++ b/app/features/scanner/core/detectors/scoreboard/kits.ts
@@ -0,0 +1,30 @@
+/**
+ * Main-weapon kits (sub + special ids) keyed by in-game main weapon id,
+ * derived directly from sendou.ink's weapon params (no generated copy).
+ * Special ids match assets/cv/specials/<id>.png; the results scoreboard
+ * shows each player's special icon above the specials counter, which lets
+ * near-tied weapon icon matches be disambiguated by kit. The minimap's
+ * sub-tile disambiguation (assets/cv/sub-weapons) reads `sub` the same way.
+ */
+import { weaponParams } from "~/features/build-analyzer/data/weapon-params";
+import type {
+	SpecialWeaponId,
+	SubWeaponId,
+} from "~/modules/in-game-lists/types";
+
+export interface WeaponKit {
+	/** sendou.ink sub weapon id */
+	sub: SubWeaponId;
+	/** sendou.ink special weapon id, matching assets/cv/specials */
+	special: SpecialWeaponId;
+}
+
+export const WEAPON_KITS: ReadonlyMap<string, WeaponKit> = new Map(
+	Object.entries(weaponParams.weaponKits).map(([id, kit]) => [
+		id,
+		{
+			sub: kit.subWeaponId as SubWeaponId,
+			special: kit.specialWeaponId as SpecialWeaponId,
+		},
+	]),
+);
diff --git a/app/features/scanner/core/detectors/scoreboard/names.ts b/app/features/scanner/core/detectors/scoreboard/names.ts
new file mode 100644
index 000000000..e1d37fa01
--- /dev/null
+++ b/app/features/scanner/core/detectors/scoreboard/names.ts
@@ -0,0 +1,229 @@
+/**
+ * Player name recognition: glyph matching over the name ROI.
+ */
+import type { Mat } from "../../cv";
+import {
+	type GlyphSet,
+	type RecognizedChar,
+	type RecognizedText,
+	recognizeText,
+} from "../../glyphs";
+
+export interface ParsedName {
+	name: string;
+	/** min glyph score; 0 when ink was present but nothing recognized */
+	confidence: number;
+	raw: RecognizedText;
+}
+
+/**
+ * BlitzMain renders 'I', 'l', '|', and '1' as near-identical bars — no pixel
+ * evidence separates them, so fall back to context, by decreasing weight of
+ * evidence: a bar next to a lowercase letter is overwhelmingly an 'l' in
+ * latin names ("Olise"), next to a digit it's a '1' ("Jrod_14"), next to an
+ * uppercase letter it's an 'I' ("SHIP"), a bare bar hanging off an
+ * underscore is a numbered-alt suffix ("gori_1"), and with no latin/digit
+ * context at all (kana, symbols, edges) 'l' is the common case in the wild.
+ * (This will genuinely miss e.g. "McIntosh", but so would a human reading
+ * the pixels.)
+ */
+const BAR_CHARS = new Set(["I", "l", "|", "1"]);
+
+function normalizeBars(name: string): string {
+	const chars = [...name];
+	// Context is the nearest NON-BAR char within the word: consecutive bars
+	// ("ll" in "Chill") must all resolve from the same real-letter neighbor,
+	// not from each other's arbitrary raw reading. Underscores bound words
+	// like spaces do — "gori_1"'s lowercase must not leak across the
+	// separator onto the suffix.
+	const neighbor = (i: number, step: -1 | 1): string | undefined => {
+		for (let j = i + step; j >= 0 && j < chars.length; j += step) {
+			const c = chars[j]!;
+			if (c === " " || c === "_") return undefined;
+			if (!BAR_CHARS.has(c)) return c;
+		}
+		return undefined;
+	};
+	const test = (re: RegExp) => (c: string | undefined) =>
+		c !== undefined && re.test(c);
+	const isLower = test(/\p{Ll}/u);
+	const isDigit = test(/\d/);
+	const isUpper = test(/\p{Lu}/u);
+	return chars
+		.map((c, i) => {
+			if (!BAR_CHARS.has(c)) return c;
+			const left = neighbor(i, -1);
+			const right = neighbor(i, 1);
+			if (isLower(left) || isLower(right)) return "l";
+			if (isDigit(left) || isDigit(right)) return "1";
+			if (isUpper(left) || isUpper(right)) return "I";
+			if (chars[i - 1] === "_" || chars[i + 1] === "_") return "1";
+			return "l";
+		})
+		.join("");
+}
+
+/**
+ * The kana long-vowel bar 'ー' and the ASCII hyphen '-' are horizontal-bar
+ * homoglyphs the same way the vertical bars are: both are a single
+ * horizontal stroke whose length difference drowns in capture blur, so
+ * which template wins is noise ("ドラグ-ン"). Resolve by script context —
+ * a kana neighbor reads 'ー', a Latin/digit neighbor reads '-', and with
+ * no context the raw pick stands.
+ */
+const LONG_BAR_CHARS = new Set(["-", "ー"]);
+
+function normalizeLongBars(name: string): string {
+	const chars = [...name];
+	const neighbor = (i: number, step: -1 | 1): string | undefined => {
+		for (let j = i + step; j >= 0 && j < chars.length; j += step) {
+			const c = chars[j]!;
+			if (c === " " || c === "_") return undefined;
+			if (!LONG_BAR_CHARS.has(c)) return c;
+		}
+		return undefined;
+	};
+	const test = (re: RegExp) => (c: string | undefined) =>
+		c !== undefined && re.test(c);
+	const isKana = test(/[ぁ-ヾ]/u);
+	const isLatinOrDigit = test(/[a-zA-Z0-9]/);
+	return chars
+		.map((c, i) => {
+			if (!LONG_BAR_CHARS.has(c)) return c;
+			const left = neighbor(i, -1);
+			const right = neighbor(i, 1);
+			if (isKana(left) || isKana(right)) return "ー";
+			if (isLatinOrDigit(left) || isLatinOrDigit(right)) return "-";
+			return c;
+		})
+		.join("");
+}
+
+/**
+ * BlitzMain's 'O' and '0' are the same rounded box at capture fidelity —
+ * which template wins is noise — so, like the bars, resolve by context via
+ * the nearest unambiguous neighbor in the word: a digit neighbor keeps '0',
+ * an uppercase neighbor reads 'O' ("AHOO"), after a lowercase letter it's a
+ * stylized digit ("y0s"), and word-initial before lowercase it's a
+ * capitalized name ("Olise").
+ */
+function normalizeOhs(name: string): string {
+	const chars = [...name];
+	const ambiguous = (c: string | undefined) => c === "O" || c === "0";
+	const neighbor = (i: number, step: -1 | 1): string | undefined => {
+		for (let j = i + step; j >= 0 && j < chars.length; j += step) {
+			const c = chars[j]!;
+			if (c === " ") return undefined;
+			if (!ambiguous(c)) return c;
+		}
+		return undefined;
+	};
+	const test = (re: RegExp) => (c: string | undefined) =>
+		c !== undefined && re.test(c);
+	const isDigit = test(/\d/);
+	const isUpper = test(/\p{Lu}/u);
+	const isLower = test(/\p{Ll}/u);
+	return chars
+		.map((c, i) => {
+			if (!ambiguous(c)) return c;
+			const left = neighbor(i, -1);
+			const right = neighbor(i, 1);
+			if (isDigit(left) || isDigit(right)) return "0";
+			if (isUpper(left) || isUpper(right)) return "O";
+			if (isLower(left)) return "0";
+			if (isLower(right)) return "O";
+			return c;
+		})
+		.join("");
+}
+
+/**
+ * The round dots '.', '・', and '·' tight-crop to near-identical blobs, so
+ * which template wins is noise. Vertical position decides in one direction
+ * only: a period sits on the baseline, so a dot floating well above it
+ * cannot be '.' — reread it as the best-scoring middle-dot candidate. The
+ * reverse does not hold: BlitzMain draws '・' ON the baseline in some names
+ * (scoreboard/robot row 5, "..・"), so baseline dots stay with the template
+ * ranking, where the exact fixture crops separate the sizes.
+ */
+const DOT_CHARS = new Set([".", "・", "·"]);
+const DOT_BASELINE_SLACK_PX = 3;
+
+function fixRaisedDots(raw: RecognizedText): RecognizedText {
+	if (!raw.chars.some((c) => c.char === ".")) return raw;
+	const anchors = raw.chars
+		.filter((c) => !DOT_CHARS.has(c.char))
+		.map((c) => c.y1)
+		.sort((a, b) => a - b);
+	if (anchors.length === 0) return raw;
+	const baseline = anchors[Math.floor(anchors.length / 2)]!;
+	const chars = raw.chars.map((c) => {
+		if (c.char !== "." || baseline - c.y1 <= DOT_BASELINE_SLACK_PX) return c;
+		const alt = c.candidates?.find(
+			(k) => DOT_CHARS.has(k.char) && k.char !== ".",
+		);
+		return { ...c, char: alt?.char ?? "・" };
+	});
+	let ci = 0;
+	const text = [...raw.text]
+		.map((ch) => (ch === " " ? ch : chars[ci++]!.char))
+		.join("");
+	return { ...raw, text, chars };
+}
+
+/**
+ * BlitzMain's 'P' and 'p' tight-crop to the same stem-and-bowl shape, so the
+ * template scores between them are noise — but unlike the bars and ohs the
+ * pixels do decide: 'p' hangs below the baseline while 'P' sits on it. The
+ * templates lose that position, the segment keeps it. Take the baseline as
+ * the median ink bottom of the non-twin glyphs (most chars rest exactly on
+ * it, so the median shrugs off real descenders and symbols) and pick the
+ * case by whether the segment descends past it. Skipped when no other glyph
+ * anchors the baseline.
+ */
+const DESCENDER_TWINS: Record<string, [upper: string, lower: string]> = {
+	P: ["P", "p"],
+	p: ["P", "p"],
+};
+const DESCENT_MIN_PX = 3;
+
+function resolveCaseByDescent(raw: RecognizedText): string {
+	if (!raw.chars.some((c) => c.char in DESCENDER_TWINS)) return raw.text;
+	const anchors = raw.chars
+		.filter((c) => !(c.char in DESCENDER_TWINS))
+		.map((c) => c.y1)
+		.sort((a, b) => a - b);
+	if (anchors.length === 0) return raw.text;
+	const baseline = anchors[Math.floor(anchors.length / 2)]!;
+	let ci = 0;
+	return [...raw.text]
+		.map((ch) => {
+			if (ch === " ") return ch;
+			const rc: RecognizedChar = raw.chars[ci++]!;
+			const twin = DESCENDER_TWINS[rc.char];
+			if (!twin) return rc.char;
+			return rc.y1 - baseline >= DESCENT_MIN_PX ? twin[1] : twin[0];
+		})
+		.join("");
+}
+
+export function parseName(
+	gray: Mat,
+	glyphs: GlyphSet,
+	options: { spaceGap?: number; binThreshold?: number } = {},
+): ParsedName {
+	const raw = recognizeText(gray, glyphs, {
+		spaceGap: options.spaceGap ?? 7,
+		binThreshold: options.binThreshold,
+		minCharScore: 0.35,
+	});
+	return {
+		name: normalizeLongBars(
+			normalizeOhs(
+				normalizeBars(resolveCaseByDescent(fixRaisedDots(raw)).trim()),
+			),
+		),
+		confidence: raw.confidence,
+		raw,
+	};
+}
diff --git a/app/features/scanner/core/detectors/scoreboard/pov.ts b/app/features/scanner/core/detectors/scoreboard/pov.ts
new file mode 100644
index 000000000..dda76ebc6
--- /dev/null
+++ b/app/features/scanner/core/detectors/scoreboard/pov.ts
@@ -0,0 +1,71 @@
+/**
+ * POV arrow detection: both results screens mark the recording player's row
+ * with a solid yellow arrow at the row's left edge (absent in spectator or
+ * overhead footage). The arrow is the only saturated pure-yellow blob in
+ * that strip — team-ink yellows there are patterned/duller and stay under
+ * the mask thresholds — so a plain color-mask pixel count decides, no
+ * template needed.
+ */
+import { getCV, type Mat } from "../../cv";
+import { cropRoi, type Roi } from "../../image";
+
+const YELLOW_R_MIN = 190;
+const YELLOW_G_MIN = 180;
+const YELLOW_B_MAX = 90;
+/** Pure arrow yellow has R≈G; team golds/chartreuse skew one channel. */
+const YELLOW_RG_MAX_DIFF = 60;
+
+/** Arrow pixels fill ~15-30% of the probe ROI; arrow-less rows measure ~0. */
+const POV_MIN_FRACTION = 0.05;
+/**
+ * If the runner-up row reaches this share of the best row's fraction, the
+ * yellow is ambient (team ink leaking into the strip), not the arrow.
+ */
+const POV_RUNNER_UP_MAX_RATIO = 0.5;
+
+/** Fraction of `roi` pixels that are arrow-yellow. `rgb` is a 3-channel RGB mat. */
+export function povYellowFraction(rgb: Mat, roi: Roi): number {
+	const cv = getCV();
+	const view = cropRoi(rgb, roi);
+	const cont = new cv.Mat();
+	view.copyTo(cont);
+	view.delete();
+	const d = cont.data;
+	const n = cont.rows * cont.cols;
+	let yellow = 0;
+	for (let i = 0; i < n; i++) {
+		const r = d[i * 3]!;
+		const g = d[i * 3 + 1]!;
+		const b = d[i * 3 + 2]!;
+		if (
+			r > YELLOW_R_MIN &&
+			g > YELLOW_G_MIN &&
+			b < YELLOW_B_MAX &&
+			Math.abs(r - g) < YELLOW_RG_MAX_DIFF
+		) {
+			yellow++;
+		}
+	}
+	cont.delete();
+	return n > 0 ? yellow / n : 0;
+}
+
+/**
+ * Pick the arrow row from per-row yellow fractions: the best row must clear
+ * POV_MIN_FRACTION and stand clear of the runner-up; null means no arrow.
+ */
+export function findPovIndex(fractions: readonly number[]): number | null {
+	let best = -1;
+	for (let i = 0; i < fractions.length; i++) {
+		if (best < 0 || fractions[i]! > fractions[best]!) best = i;
+	}
+	if (best < 0 || fractions[best]! < POV_MIN_FRACTION) return null;
+	for (let i = 0; i < fractions.length; i++) {
+		if (
+			i !== best &&
+			fractions[i]! > fractions[best]! * POV_RUNNER_UP_MAX_RATIO
+		)
+			return null;
+	}
+	return best;
+}
diff --git a/app/features/scanner/core/detectors/scoreboard/rois.ts b/app/features/scanner/core/detectors/scoreboard/rois.ts
new file mode 100644
index 000000000..2fe9eb092
--- /dev/null
+++ b/app/features/scanner/core/detectors/scoreboard/rois.ts
@@ -0,0 +1,120 @@
+/**
+ * ALL scoreboard ROI coordinates, in canonical 1920x1080 space.
+ * Calibrated against scoreboard/xbattle-splat-zones-ko via
+ * tools/overlay-rois.ts and column-projection measurement.
+ *
+ * The results-screen scoreboard is a fixed-layout panel on the right side:
+ * two team boxes (top = winner, bottom = loser), 4 dark "pill" rows each,
+ * white text on the pills. Per row, left to right: avatar, weapon icon,
+ * name (left-aligned from x=1125), paint ("842p", digits right-aligned
+ * ending at x=1409, constant "p" glyph at 1411-1424), three stat counters
+ * ("x12", zero-padded 2 digits) under the splat/death/special icons.
+ */
+import type { Roi } from "../../canonical";
+
+/** Vertical centers of the 8 player rows: 4 winner rows, then 4 loser rows. */
+export const ROW_CENTERS = [416, 482, 547, 613, 770, 836, 901, 967] as const;
+
+/**
+ * Weapon icon search region within a row. matchTemplate skips templates
+ * taller than the region, so 56px fits the largest live icon while
+ * excluding replay-browser template sizes.
+ */
+export function weaponRoi(cy: number): Roi {
+	return { x: 1054, y: cy - 28, w: 67, h: 56 };
+}
+
+/**
+ * Player name text region (white, left-aligned x=1126). Long names run
+ * into the paint column; parse paint first and trim at its leftmost digit.
+ */
+export function nameRoi(cy: number): Roi {
+	return { x: 1122, y: cy - 14, w: 208, h: 32 };
+}
+
+/** Paint amount digits, right-aligned ending at x=1409 (the "p" suffix is excluded). */
+export function paintRoi(cy: number): Roi {
+	return { x: 1325, y: cy - 17, w: 84, h: 34 };
+}
+
+/** The constant white "p" after the paint number — used as a gate anchor. */
+export function paintSuffixRoi(cy: number): Roi {
+	return { x: 1409, y: cy - 14, w: 18, h: 28 };
+}
+
+/** Stat counter digits (two, zero-padded; the small "x" prefix at 1477/1540/1603 is excluded). */
+export function statRoi(cy: number, index: 0 | 1 | 2): Roi {
+	const x = [1484, 1547, 1610][index]!;
+	return { x, y: cy + 1, w: 32, h: 23 };
+}
+
+/**
+ * Special-weapon icon above the specials counter (~22px art, team ink
+ * color). Bounded at cy+1 so counter digits stay out of the binarized shape.
+ */
+export function specialIconRoi(cy: number): Roi {
+	return { x: 1595, y: cy - 29, w: 40, h: 30 };
+}
+
+/**
+ * POV arrow: yellow arrow marking the recording player's row, left of the
+ * avatar (x 933-985). Right edge stays short of the avatar circle (~x 995).
+ */
+export function povArrowRoi(cy: number): Roi {
+	return { x: 930, y: cy - 32, w: 58, h: 56 };
+}
+
+/**
+ * Team point totals ("500 p"), right-aligned ending x=1658. Only read to
+ * recognize a knockout (winner total 500) — not the match score.
+ */
+export const TEAM_SCORE_ROIS: readonly [Roi, Roi] = [
+	{ x: 1530, y: 330, w: 132, h: 44 },
+	{ x: 1530, y: 684, w: 132, h: 44 },
+];
+
+/**
+ * The two sides of the "Score:" banner. Left is left-aligned from x~946,
+ * right right-aligned ending x~1691 (x~1712 mid-pop) — digits bounce
+ * ~28-39px as the value lands (MATCH_SCORE_DIGIT_HEIGHTS).
+ */
+export const MATCH_SCORE_ROIS: readonly [Roi, Roi] = [
+	{ x: 935, y: 231, w: 230, h: 50 },
+	{ x: 1600, y: 231, w: 125, h: 50 },
+];
+
+/** Banner score digit sizes: settled, and the landing bounce's peak. */
+export const MATCH_SCORE_DIGIT_HEIGHTS = [28, 39] as const;
+
+/**
+ * Gate probe: the strip between the paint "p" suffix (ends 1424) and the
+ * first stat "x" (starts 1477) is always empty pill background (near-black).
+ */
+export function gateDarkProbe(cy: number): Roi {
+	return { x: 1434, y: cy - 10, w: 38, h: 20 };
+}
+
+/** Panel background probes (dark gray ~35) outside the team boxes. */
+export const GATE_PANEL_PROBES: readonly Roi[] = [
+	{ x: 800, y: 500, w: 30, h: 30 },
+	{ x: 800, y: 900, w: 30, h: 30 },
+	{ x: 1770, y: 930, w: 30, h: 30 },
+];
+
+export const GATE_DARK_MAX_MEAN = 60;
+export const GATE_PANEL_MAX_MEAN = 85;
+/** The paint "p" suffix region must contain bright (white) pixels. */
+export const GATE_TEXT_MIN_MAX = 180;
+
+/**
+ * Header bands: lobby tag ("X Battle") on its own line, mode+stage share
+ * the next. Tags size to their text, so bands are generous — header.ts
+ * trims each to the actual tag extent.
+ */
+export const HEADER_LOBBY_BAND: Roi = { x: 828, y: 42, w: 330, h: 30 };
+export const HEADER_LINE_BAND: Roi = { x: 828, y: 88, w: 580, h: 40 };
+
+/** Text metrics measured on the fixture, used by atlas tooling. */
+export const PAINT_DIGIT_HEIGHT = 28;
+/** Same tight height as paint digits, but rendered in the bold face (BlitzBold). */
+export const TEAM_DIGIT_HEIGHT = 28;
diff --git a/app/features/scanner/core/detectors/scoreboard/row.ts b/app/features/scanner/core/detectors/scoreboard/row.ts
new file mode 100644
index 000000000..892823ba8
--- /dev/null
+++ b/app/features/scanner/core/detectors/scoreboard/row.ts
@@ -0,0 +1,146 @@
+/**
+ * The shared scoreboard row parse — weapon (with special-icon tie-break),
+ * paint, name trimmed at the leftmost paint digit, stat counters — used by
+ * both the results scoreboard and the replay-browser detail screen. The
+ * callers differ only in ROI geometry (the replay panels are dx-shifted),
+ * glyph sets (replay rows are smaller, so it passes rescaled sets), and two
+ * match options.
+ */
+import { toMainWeaponId } from "../../../scanner-types";
+import type { Mat } from "../../cv";
+import type { GlyphSet } from "../../glyphs";
+import { cropRoi, type Roi } from "../../image";
+import { type ParsedNumber, parseNumber } from "./digits";
+import type { ScoreboardPlayer, ScoreboardRowDebug } from "./index";
+import { parseName } from "./names";
+import { povYellowFraction } from "./pov";
+import {
+	disambiguateWeaponBySpecial,
+	matchSpecial,
+	type SpecialMatch,
+	type SpecialTemplate,
+	tiedWeaponsWithDistinctSpecials,
+} from "./specials";
+import { matchWeapon, type WeaponMatch, type WeaponTemplate } from "./weapons";
+
+/** Per-row ROI geometry; the replay detector closes these over its panel dx. */
+export interface RowRois {
+	weapon(cy: number): Roi;
+	specialIcon(cy: number): Roi;
+	paint(cy: number): Roi;
+	name(cy: number): Roi;
+	stat(cy: number, i: 0 | 1 | 2): Roi;
+	povArrow(cy: number): Roi;
+}
+
+export interface RowResources {
+	weapons: WeaponTemplate[];
+	specials?: SpecialTemplate[] | null;
+	paintDigits: GlyphSet | null;
+	statDigits: GlyphSet | null;
+	nameGlyphs: GlyphSet | null;
+}
+
+export interface RowOptions {
+	/** passed through to matchWeapon (replay rows sit on a lighter panel) */
+	weaponInkThreshold?: number;
+	/**
+	 * replay only: the left-aligned paint number puts the "p" suffix inside
+	 * the ROI when the paint has fewer than 4 digits
+	 */
+	paintDropLoweredTrailing?: boolean;
+}
+
+/** Parses one player row; per-field confidences append to `confidences`. */
+export function parseScoreboardRow(
+	gray: Mat,
+	rgb: Mat,
+	cy: number,
+	rois: RowRois,
+	resources: RowResources,
+	confidences: number[],
+	options: RowOptions = {},
+): { player: ScoreboardPlayer; debug: ScoreboardRowDebug } {
+	let weapon: WeaponMatch | null = null;
+	let special: SpecialMatch | undefined;
+	if (resources.weapons.length > 0) {
+		const crop = cropRoi(rgb, rois.weapon(cy));
+		weapon = matchWeapon(
+			crop,
+			resources.weapons,
+			options.weaponInkThreshold !== undefined
+				? { inkThreshold: options.weaponInkThreshold }
+				: {},
+		);
+		crop.delete();
+		// near-tied icons with different kit specials: let the row's special
+		// icon break the tie
+		if (resources.specials?.length && tiedWeaponsWithDistinctSpecials(weapon)) {
+			const spCrop = cropRoi(rgb, rois.specialIcon(cy));
+			special = matchSpecial(spCrop, resources.specials);
+			spCrop.delete();
+			weapon = disambiguateWeaponBySpecial(weapon, special);
+		}
+		confidences.push(Math.max(0, weapon.score));
+	}
+
+	// paint (parse first so the name region can be trimmed at the digits)
+	let paint: ParsedNumber | null = null;
+	const pRoi = rois.paint(cy);
+	if (resources.paintDigits) {
+		const crop = cropRoi(gray, pRoi);
+		paint = parseNumber(crop, resources.paintDigits, {
+			dropLoweredTrailing: options.paintDropLoweredTrailing,
+		});
+		crop.delete();
+		confidences.push(paint.confidence);
+	}
+
+	// name, trimmed at the leftmost paint digit
+	let name: ReturnType<typeof parseName> | null = null;
+	if (resources.nameGlyphs) {
+		const base = rois.name(cy);
+		const paintLeftAbs =
+			paint && paint.leftX !== null ? pRoi.x + paint.leftX : pRoi.x + pRoi.w;
+		const w = Math.min(base.w, Math.max(0, paintLeftAbs - 6 - base.x));
+		if (w > 8) {
+			const crop = cropRoi(gray, { ...base, w });
+			name = parseName(crop, resources.nameGlyphs);
+			crop.delete();
+			confidences.push(name.confidence);
+		}
+	}
+
+	// stat counters
+	const statValues: (number | null)[] = [null, null, null];
+	const statScores: [number, number, number] = [0, 0, 0];
+	if (resources.statDigits) {
+		for (const i of [0, 1, 2] as const) {
+			const crop = cropRoi(gray, rois.stat(cy, i));
+			const parsed = parseNumber(crop, resources.statDigits);
+			crop.delete();
+			statValues[i] = parsed.value;
+			statScores[i] = parsed.confidence;
+			confidences.push(parsed.confidence);
+		}
+	}
+
+	return {
+		player: {
+			name: name?.name ?? "",
+			weaponId: weapon ? toMainWeaponId(weapon.id) : null,
+			paint: paint?.value ?? null,
+			ka: statValues[0] ?? null,
+			d: statValues[1] ?? null,
+			s: statValues[2] ?? null,
+		},
+		debug: {
+			weapon,
+			special,
+			paintScore: paint?.confidence ?? 0,
+			nameScore: name?.confidence ?? 0,
+			statScores,
+			povFraction: povYellowFraction(rgb, rois.povArrow(cy)),
+		},
+	};
+}
diff --git a/app/features/scanner/core/detectors/scoreboard/specials.ts b/app/features/scanner/core/detectors/scoreboard/specials.ts
new file mode 100644
index 000000000..9cb1a867e
--- /dev/null
+++ b/app/features/scanner/core/detectors/scoreboard/specials.ts
@@ -0,0 +1,272 @@
+/**
+ * Kit-icon identification: the team-tinted sub/special tiles next to a
+ * player's main weapon (scoreboard: special icon above the specials
+ * counter; minimap: sub-weapon tile). Tiles render the same art in each
+ * team's ink hue, so unlike weapon icons the match is shape-only: alpha
+ * silhouette vs the binarized search region, NCC + ink-coverage penalty.
+ *
+ * Low pixel budget (~22px specials, ~30px minimap subs) is enough because
+ * it only splits main weapons whose *icons* are near-ties (Splash- vs
+ * Sploosh-o-matic) — near-tie icon twins ship with far-apart kit
+ * silhouettes (stamp vs crab, bomb vs beakon).
+ */
+import { getCV, type Mat, minMaxLoc } from "../../cv";
+import type { FrameData } from "../../image";
+import { WEAPON_KITS } from "./kits";
+import type { WeaponMatch } from "./weapons";
+
+/** Icon heights (px at 1080p) to try; the row renders it at ~22px. */
+const SPECIAL_TEMPLATE_SIZES = [19, 21, 23, 25] as const;
+
+/** Colored icon ink vs the near-black pill, on max(r,g,b). */
+const SPECIAL_INK_THRESHOLD = 48;
+
+export interface SpecialTemplate {
+	id: string;
+	/** binary silhouette + ink pixel count at each templateSizes entry */
+	sizes: { mat: Mat; ink: number }[];
+}
+
+export interface SpecialMatch {
+	id: string;
+	score: number;
+	top: { id: string; score: number }[];
+}
+
+/**
+ * Build binary silhouette templates from raw RGBA icon images (128x128 with
+ * alpha): tight-crop the alpha extent, binarize, downscale to each height.
+ * `templateSizes` defaults to the scoreboard's special-icon sizes; the
+ * minimap builds its sub-weapon set at the sub tile's larger sizes.
+ */
+export function prepareSpecialTemplates(
+	icons: { id: string; image: FrameData }[],
+	templateSizes: readonly number[] = SPECIAL_TEMPLATE_SIZES,
+): SpecialTemplate[] {
+	const cv = getCV();
+	return icons.map(({ id, image }) => {
+		const { width, height, data } = image;
+		let xMin = width;
+		let xMax = -1;
+		let yMin = height;
+		let yMax = -1;
+		for (let y = 0; y < height; y++) {
+			for (let x = 0; x < width; x++) {
+				if (data[(y * width + x) * 4 + 3]! > 128) {
+					if (x < xMin) xMin = x;
+					if (x > xMax) xMax = x;
+					if (y < yMin) yMin = y;
+					if (y > yMax) yMax = y;
+				}
+			}
+		}
+		const w = Math.max(1, xMax - xMin + 1);
+		const h = Math.max(1, yMax - yMin + 1);
+		const silhouette = new cv.Mat(h, w, cv.CV_8UC1, new cv.Scalar(0));
+		const dst = silhouette.data;
+		for (let y = 0; y < h; y++) {
+			for (let x = 0; x < w; x++) {
+				if (data[((y + yMin) * width + x + xMin) * 4 + 3]! > 128) {
+					dst[y * w + x] = 255;
+				}
+			}
+		}
+		const sizes = templateSizes.map((size) => {
+			const scale = size / Math.max(w, h);
+			const resized = new cv.Mat();
+			cv.resize(
+				silhouette,
+				resized,
+				new cv.Size(
+					Math.max(1, Math.round(w * scale)),
+					Math.max(1, Math.round(h * scale)),
+				),
+				0,
+				0,
+				cv.INTER_AREA,
+			);
+			// re-binarize the interpolated edges so template and search region
+			// live on the same two-level scale
+			const mat = new cv.Mat();
+			cv.threshold(resized, mat, 127, 255, cv.THRESH_BINARY);
+			resized.delete();
+			let ink = 0;
+			for (const v of mat.data) if (v > 0) ink++;
+			return { mat, ink };
+		});
+		silhouette.delete();
+		return { id, sizes };
+	});
+}
+
+/**
+ * searchRgb: RGB crop of the row's special-icon ROI (view is fine).
+ * The region is binarized on max(r,g,b) so any ink tint reads as shape.
+ */
+export function matchSpecial(
+	searchRgb: Mat,
+	templates: SpecialTemplate[],
+): SpecialMatch {
+	const cv = getCV();
+
+	// binarized copy of the search region (pixel access needs a copy)
+	const cont = new cv.Mat();
+	searchRgb.copyTo(cont);
+	const { rows, cols } = cont;
+	const binary = new cv.Mat(rows, cols, cv.CV_8UC1, new cv.Scalar(0));
+	const src = cont.data;
+	const dst = binary.data;
+	let searchInk = 0;
+	for (let i = 0; i < rows * cols; i++) {
+		const v = Math.max(src[i * 3]!, src[i * 3 + 1]!, src[i * 3 + 2]!);
+		if (v > SPECIAL_INK_THRESHOLD) {
+			dst[i] = 255;
+			searchInk++;
+		}
+	}
+	cont.delete();
+
+	const result = new cv.Mat();
+	const ranked: { id: string; score: number }[] = [];
+	for (const template of templates) {
+		let score = -1;
+		for (const { mat, ink } of template.sizes) {
+			if (mat.rows > binary.rows || mat.cols > binary.cols) continue;
+			cv.matchTemplate(binary, mat, result, cv.TM_CCOEFF_NORMED);
+			const { maxVal } = minMaxLoc(result);
+			const r =
+				Math.min(ink, searchInk) / Math.max(Math.max(ink, searchInk), 1);
+			const adjusted = maxVal * (0.75 + 0.25 * r);
+			if (adjusted > score) score = adjusted;
+		}
+		ranked.push({ id: template.id, score });
+	}
+	result.delete();
+	binary.delete();
+	ranked.sort((a, b) => b.score - a.score);
+	return {
+		id: ranked[0]?.id ?? "unknown",
+		score: ranked[0]?.score ?? -1,
+		top: ranked,
+	};
+}
+
+/** Weapon-icon score gap under which two candidates count as a tie. */
+const WEAPON_TIE_MARGIN = 0.04;
+
+/**
+ * Icon twins whose art differs only by the nozzle (Splash- vs
+ * Sploosh-o-matic share the body, gauge and handle). On the replay
+ * browser's dim, drop-shadowed rendering the wrong twin can beat the right
+ * one by far more than WEAPON_TIE_MARGIN (0.15 observed on the
+ * brinewater-1411 fixture), so whenever both appear among the top
+ * candidates the kit evidence is consulted regardless of the icon-score
+ * gap — the KIT_DECISION_MARGIN still guards the actual re-rank.
+ * Symmetric pairs, extended per attested fixture need only.
+ */
+const ICON_TWINS: ReadonlyMap<string, string> = new Map([
+	["0", "20"], // Sploosh-o-matic <-> Splash-o-matic
+	["20", "0"],
+]);
+
+/**
+ * The kit-icon evidence must separate the tied kits' entries by at least
+ * this much to override the icon ranking: the shape matcher's own confusions
+ * (Wave Breaker vs Ink Vac/Reef Slider on ~22px of silhouette) all land
+ * inside this band, while true silhouette splits (stamp vs crab) clear it.
+ */
+const KIT_DECISION_MARGIN = 0.06;
+
+type KitPart = "sub" | "special";
+
+/**
+ * Weapon-icon candidates tied within WEAPON_TIE_MARGIN (plus the leader's
+ * ICON_TWIN at any gap) whose kits carry different subs/specials — the only
+ * case the kit icon can help with. Returns null when the icon match already
+ * decided (or the kit part can't).
+ */
+function tiedWeaponsWithDistinctKit(
+	match: WeaponMatch,
+	part: KitPart,
+): { id: string; score: number }[] | null {
+	const leader = match.top[0];
+	if (!leader) return null;
+	const tied = match.top.filter(
+		(t) => leader.score - t.score < WEAPON_TIE_MARGIN,
+	);
+	const twinId = ICON_TWINS.get(leader.id);
+	if (twinId && !tied.some((t) => t.id === twinId)) {
+		const twin = match.top.find((t) => t.id === twinId);
+		if (twin) tied.push(twin);
+	}
+	if (tied.length < 2) return null;
+	const parts = new Set(
+		tied
+			.map((t) => WEAPON_KITS.get(t.id)?.[part])
+			.filter((s) => s !== undefined),
+	);
+	return parts.size >= 2 ? tied : null;
+}
+
+export function tiedWeaponsWithDistinctSpecials(
+	match: WeaponMatch,
+): { id: string; score: number }[] | null {
+	return tiedWeaponsWithDistinctKit(match, "special");
+}
+
+export function tiedWeaponsWithDistinctSubs(
+	match: WeaponMatch,
+): { id: string; score: number }[] | null {
+	return tiedWeaponsWithDistinctKit(match, "sub");
+}
+
+/**
+ * Re-rank tied weapon candidates by how well their kits' sub/special
+ * matches the tile evidence. Only reorders on decisive evidence; ties whose
+ * kit entries all score alike keep the icon-match order.
+ */
+function disambiguateWeaponByKit(
+	match: WeaponMatch,
+	evidence: SpecialMatch,
+	part: KitPart,
+): WeaponMatch {
+	const tied = tiedWeaponsWithDistinctKit(match, part);
+	if (!tied) return match;
+	// worst-possible floor: adjusted NCC never drops below -1
+	const kitScore = (weaponId: string): number => {
+		const kit = WEAPON_KITS.get(weaponId);
+		if (!kit) return -1;
+		return evidence.top.find((t) => t.id === String(kit[part]))?.score ?? -1;
+	};
+	const ranked = [...tied].sort((a, b) => kitScore(b.id) - kitScore(a.id));
+	const winner = ranked[0]!;
+	if (winner.id === match.id) return match;
+	const runnerUp = ranked.find((t) => kitScore(t.id) < kitScore(winner.id));
+	if (
+		!runnerUp ||
+		kitScore(winner.id) - kitScore(runnerUp.id) < KIT_DECISION_MARGIN
+	) {
+		return match;
+	}
+	const top = [winner, ...match.top.filter((t) => t.id !== winner.id)].slice(
+		0,
+		3,
+	);
+	const flag: Partial<WeaponMatch> =
+		part === "special" ? { specialResolved: true } : { subResolved: true };
+	return { ...match, id: winner.id, score: winner.score, top, ...flag };
+}
+
+export function disambiguateWeaponBySpecial(
+	match: WeaponMatch,
+	special: SpecialMatch,
+): WeaponMatch {
+	return disambiguateWeaponByKit(match, special, "special");
+}
+
+export function disambiguateWeaponBySub(
+	match: WeaponMatch,
+	sub: SpecialMatch,
+): WeaponMatch {
+	return disambiguateWeaponByKit(match, sub, "sub");
+}
diff --git a/app/features/scanner/core/detectors/scoreboard/weapons.ts b/app/features/scanner/core/detectors/scoreboard/weapons.ts
new file mode 100644
index 000000000..e4ee26767
--- /dev/null
+++ b/app/features/scanner/core/detectors/scoreboard/weapons.ts
@@ -0,0 +1,367 @@
+/**
+ * Weapon icon identification: NCC of every candidate icon (pre-scaled to a
+ * few sizes) against the row's weapon ROI, with an ink-coverage penalty so a
+ * small template can't win by matching a lucky sub-window of a bigger icon
+ * (the template's opaque area should match the ink actually present).
+ *
+ * Large template sets run coarse-to-fine: every icon first ranked at quarter
+ * resolution (same scoring), then only the shortlist re-matched at full res.
+ * Small sets (ability badges) skip the coarse pass — not worth it below ~2x
+ * the shortlist size.
+ */
+import { getCV, type Mat, minMaxLoc } from "../../cv";
+import type { FrameData } from "../../image";
+
+/**
+ * Icon heights (px at 1080p) to try. The live scoreboard renders in-row
+ * icons at ~44-56px; the replay browser at ~60-64px. The oversized entries
+ * are skipped inside the live detector's 56px-tall weapon ROI at match
+ * time, so they only ever compete on the replay screen.
+ */
+const WEAPON_TEMPLATE_SIZES = [40, 44, 48, 52, 56, 60, 64] as const;
+
+/** Row pill background the icons sit on (near-black). */
+const PILL_BACKGROUND = 12;
+
+/** Pixels brighter than this count as icon ink (pill is ~10-15). */
+const INK_THRESHOLD = 40;
+
+/**
+ * Scoped chargers' icons differ from their unscoped twins only by the scope
+ * tube, which is near-black and sits on the near-black pill — measurably
+ * invisible at ~50px (a synthetic scoped row probes *darker* in the scope
+ * band than a real unscoped row does from barrel bleed). When the two
+ * variants score within noise of each other, resolve to the unscoped one
+ * (matches labeled fixtures and typical usage) and flag the ambiguity.
+ * Map: scoped id -> unscoped id.
+ */
+const SCOPED_TWINS: ReadonlyMap<string, string> = new Map([
+	["2040", "2030"], // Splat Scope -> Splat Charger
+	["2041", "2031"], // Z+F variants
+	["2070", "2060"], // E-liter 4K Scope -> E-liter 4K
+	["2071", "2061"], // Custom variants
+]);
+const TWIN_MARGIN = 0.05;
+
+/** Coarse-pass resolution, relative to full templates. */
+const COARSE_SCALE = 0.25;
+/** How many coarse-ranked ids survive into the full-resolution pass. */
+const COARSE_SHORTLIST = 16;
+
+export interface TemplateSize {
+	mat: Mat;
+	ink: number;
+	/** the same template at COARSE_SCALE, for the coarse ranking pass */
+	coarse: { mat: Mat; ink: number };
+}
+
+export interface WeaponTemplate {
+	id: string;
+	/** RGB template + ink pixel count at each candidate size */
+	sizes: TemplateSize[];
+}
+
+export interface WeaponMatch {
+	id: string;
+	score: number;
+	top: { id: string; score: number }[];
+	/** true when a scoped/unscoped twin tie was resolved by the unscoped prior */
+	twinAmbiguous?: boolean;
+	/** true when a near-tie was re-ranked by the row's special icon (specials.ts) */
+	specialResolved?: boolean;
+	/** true when a near-tie was re-ranked by the minimap sub tile (specials.ts) */
+	subResolved?: boolean;
+}
+
+/** Icon-ink pixel count of a continuous RGB mat (NOT an ROI view). */
+function countInkRgb(mat: Mat, threshold: number): number {
+	let ink = 0;
+	const d = mat.data;
+	const n = mat.rows * mat.cols;
+	for (let i = 0; i < n; i++) {
+		const v = Math.max(d[i * 3]!, d[i * 3 + 1]!, d[i * 3 + 2]!);
+		if (v > threshold) ink++;
+	}
+	return ink;
+}
+
+/**
+ * Downscale a composited RGB icon to each candidate size, with the coarse
+ * variant and ink counts matchWeapon needs. Ink is counted on the resized
+ * pixels, not scaled from source alpha (which undercounts antialiased edges
+ * and can flip the coverage ratio toward a wrong icon).
+ *
+ * `referenceSize` scales by size/referenceSize instead of resizing to a
+ * size×size square — "the art as it renders inside a size-sized padded
+ * square" — letting a template whose icon square is taller than the ROI
+ * still compete when its art fits (see prepareWeaponTemplates cropToArt).
+ */
+export function buildTemplateSizes(
+	composited: Mat,
+	sizes: readonly number[],
+	inkThreshold: number,
+	referenceSize?: number,
+): TemplateSize[] {
+	const cv = getCV();
+	return sizes.map((size) => {
+		const mat = new cv.Mat();
+		if (referenceSize) {
+			const scale = size / referenceSize;
+			cv.resize(
+				composited,
+				mat,
+				new cv.Size(
+					Math.max(1, Math.round(composited.cols * scale)),
+					Math.max(1, Math.round(composited.rows * scale)),
+				),
+				0,
+				0,
+				cv.INTER_AREA,
+			);
+		} else {
+			cv.resize(composited, mat, new cv.Size(size, size), 0, 0, cv.INTER_AREA);
+		}
+		const coarseMat = new cv.Mat();
+		cv.resize(
+			mat,
+			coarseMat,
+			new cv.Size(0, 0),
+			COARSE_SCALE,
+			COARSE_SCALE,
+			cv.INTER_AREA,
+		);
+		return {
+			mat,
+			ink: countInkRgb(mat, inkThreshold),
+			coarse: { mat: coarseMat, ink: countInkRgb(coarseMat, inkThreshold) },
+		};
+	});
+}
+
+/**
+ * Build match-ready templates from raw RGBA icon images (256x256 with
+ * alpha): composite over the pill background, then downscale to each size.
+ * Screens whose pills aren't near-black (minimap cards, camo surfaces)
+ * override `background` and `inkThreshold` (must clear the new background
+ * or ink counts saturate).
+ *
+ * `cropToArt` trims each template to the icon's alpha bbox (source icons
+ * carry generous transparent padding) while keeping the padded-square scale
+ * semantics — without it, a screen rendering icons near the ROI height
+ * (minimap cards, ~56-60px in a 54px box) can never match, since matchWeapon
+ * skips templates taller/wider than the ROI.
+ */
+export function prepareWeaponTemplates(
+	icons: { id: string; image: FrameData }[],
+	templateSizes: readonly number[] = WEAPON_TEMPLATE_SIZES,
+	options: {
+		background?: number;
+		inkThreshold?: number;
+		cropToArt?: boolean;
+	} = {},
+): WeaponTemplate[] {
+	const cv = getCV();
+	const background = options.background ?? PILL_BACKGROUND;
+	const inkThreshold = options.inkThreshold ?? INK_THRESHOLD;
+	return icons.map(({ id, image }) => {
+		const rgba = cv.matFromImageData(image as unknown as ImageData);
+		const source = options.cropToArt ? cropToAlphaBbox(rgba) : rgba;
+		const composited = compositeOnBackground(source, background);
+		if (source !== rgba) source.delete();
+		const referenceSize = options.cropToArt ? rgba.cols : undefined;
+		rgba.delete();
+		const sizes = buildTemplateSizes(
+			composited,
+			templateSizes,
+			inkThreshold,
+			referenceSize,
+		);
+		composited.delete();
+		return { id, sizes };
+	});
+}
+
+/** Alpha threshold and margin (source px) for the cropToArt bounding box. */
+const ART_ALPHA_MIN = 32;
+const ART_BBOX_MARGIN = 6;
+
+function cropToAlphaBbox(rgba: Mat): Mat {
+	const cv = getCV();
+	const d = rgba.data;
+	const cols = rgba.cols;
+	const rows = rgba.rows;
+	let x0 = cols;
+	let y0 = rows;
+	let x1 = -1;
+	let y1 = -1;
+	for (let y = 0; y < rows; y++) {
+		const rowBase = y * cols * 4 + 3;
+		for (let x = 0; x < cols; x++) {
+			if (d[rowBase + x * 4]! >= ART_ALPHA_MIN) {
+				if (x < x0) x0 = x;
+				if (x > x1) x1 = x;
+				if (y < y0) y0 = y;
+				if (y > y1) y1 = y;
+			}
+		}
+	}
+	if (x1 < 0) {
+		const copy = new cv.Mat();
+		rgba.copyTo(copy);
+		return copy;
+	}
+	x0 = Math.max(0, x0 - ART_BBOX_MARGIN);
+	y0 = Math.max(0, y0 - ART_BBOX_MARGIN);
+	x1 = Math.min(cols - 1, x1 + ART_BBOX_MARGIN);
+	y1 = Math.min(rows - 1, y1 + ART_BBOX_MARGIN);
+	const view = rgba.roi(new cv.Rect(x0, y0, x1 - x0 + 1, y1 - y0 + 1));
+	const out = new cv.Mat();
+	view.copyTo(out); // ROI views: .data/.clone broken in this build, copy out
+	view.delete();
+	return out;
+}
+
+function compositeOnBackground(rgba: Mat, background: number): Mat {
+	const cv = getCV();
+	const out = new cv.Mat(rgba.rows, rgba.cols, cv.CV_8UC3);
+	const src = rgba.data;
+	const dst = out.data;
+	const n = rgba.rows * rgba.cols;
+	for (let i = 0; i < n; i++) {
+		const a = src[i * 4 + 3]! / 255;
+		dst[i * 3] = Math.round(src[i * 4]! * a + background * (1 - a));
+		dst[i * 3 + 1] = Math.round(src[i * 4 + 1]! * a + background * (1 - a));
+		dst[i * 3 + 2] = Math.round(src[i * 4 + 2]! * a + background * (1 - a));
+	}
+	return out;
+}
+
+/**
+ * Coarse pass: rank every template by its best quarter-resolution score
+ * (same NCC + ink-coverage formula as the full pass) and return the
+ * COARSE_SHORTLIST ids worth full-resolution matching. Scoped ids drag
+ * their unscoped twin along so the twin tie-break always has both scores.
+ * Returns null when no coarse template fits (caller falls back to the
+ * full set, which then skips the same templates and reports unknown).
+ */
+function coarseShortlist(
+	searchRgb: Mat,
+	templates: WeaponTemplate[],
+	inkThreshold: number,
+): Set<string> | null {
+	const cv = getCV();
+	const region = new cv.Mat();
+	cv.resize(
+		searchRgb,
+		region,
+		new cv.Size(0, 0),
+		COARSE_SCALE,
+		COARSE_SCALE,
+		cv.INTER_AREA,
+	);
+	const searchInk = countInkRgb(region, inkThreshold);
+
+	const result = new cv.Mat();
+	const scored: { id: string; score: number }[] = [];
+	const searchRows = searchRgb.rows;
+	const searchCols = searchRgb.cols;
+	const regionRows = region.rows;
+	const regionCols = region.cols;
+	for (const template of templates) {
+		let score = -1;
+		for (const { mat, coarse } of template.sizes) {
+			// gate on the *full-res* dims so a size competes here iff it competes
+			// in the full pass, then also require the coarse pair to fit
+			if (mat.rows > searchRows || mat.cols > searchCols) continue;
+			if (coarse.mat.rows > regionRows || coarse.mat.cols > regionCols)
+				continue;
+			cv.matchTemplate(region, coarse.mat, result, cv.TM_CCOEFF_NORMED);
+			const { maxVal } = minMaxLoc(result);
+			const r =
+				Math.min(coarse.ink, searchInk) /
+				Math.max(Math.max(coarse.ink, searchInk), 1);
+			const adjusted = maxVal * (0.75 + 0.25 * r);
+			if (adjusted > score) score = adjusted;
+		}
+		if (score > -1) scored.push({ id: template.id, score });
+	}
+	result.delete();
+	region.delete();
+	if (scored.length === 0) return null;
+
+	scored.sort((a, b) => b.score - a.score);
+	const ids = new Set(scored.slice(0, COARSE_SHORTLIST).map((s) => s.id));
+	for (const id of [...ids]) {
+		const twin = SCOPED_TWINS.get(id);
+		if (twin) ids.add(twin);
+	}
+	return ids;
+}
+
+/**
+ * searchRgb: RGB crop of the row's weapon ROI (view is fine).
+ * inkThreshold separates icon ink from the pill background in the search
+ * region — raise it on screens whose pills are lighter than the live
+ * scoreboard's (~12), e.g. the replay browser (~61), or everything counts
+ * as ink and the coverage penalty collapses.
+ */
+export function matchWeapon(
+	searchRgb: Mat,
+	templates: WeaponTemplate[],
+	options: { inkThreshold?: number } = {},
+): WeaponMatch {
+	const cv = getCV();
+	const inkThreshold = options.inkThreshold ?? INK_THRESHOLD;
+
+	// icon ink present in the search region (pixel access needs a copy)
+	const cont = new cv.Mat();
+	searchRgb.copyTo(cont);
+	const searchInk = countInkRgb(cont, inkThreshold);
+	cont.delete();
+
+	// shortlist large sets at coarse resolution first; below ~2x the shortlist
+	// size the coarse pass costs more calls than it saves
+	let pool = templates;
+	if (templates.length > COARSE_SHORTLIST * 2) {
+		const ids = coarseShortlist(searchRgb, templates, inkThreshold);
+		if (ids) pool = templates.filter((t) => ids.has(t.id));
+	}
+
+	const result = new cv.Mat();
+	const best = new Map<string, number>();
+	const searchRows = searchRgb.rows;
+	const searchCols = searchRgb.cols;
+	for (const template of pool) {
+		let score = -1;
+		for (const { mat, ink } of template.sizes) {
+			if (mat.rows > searchRows || mat.cols > searchCols) continue;
+			cv.matchTemplate(searchRgb, mat, result, cv.TM_CCOEFF_NORMED);
+			const { maxVal } = minMaxLoc(result);
+			const r =
+				Math.min(ink, searchInk) / Math.max(Math.max(ink, searchInk), 1);
+			const adjusted = maxVal * (0.75 + 0.25 * r);
+			if (adjusted > score) score = adjusted;
+		}
+		best.set(template.id, score);
+	}
+	result.delete();
+	const ranked = [...best.entries()]
+		.map(([id, score]) => ({ id, score }))
+		.sort((a, b) => b.score - a.score);
+	const top = ranked.slice(0, 3);
+	let first = top[0] ?? { id: "unknown", score: -1 };
+	let twinAmbiguous = false;
+	const unscopedId = SCOPED_TWINS.get(first.id);
+	if (unscopedId) {
+		const twin = ranked.find((r) => r.id === unscopedId);
+		if (twin && first.score - twin.score < TWIN_MARGIN) {
+			twinAmbiguous = true;
+			first = twin;
+			const i = top.findIndex((t) => t.id === twin.id);
+			if (i >= 0) top.splice(i, 1);
+			top.unshift(twin);
+			top.length = Math.min(top.length, 3);
+		}
+	}
+	return { id: first.id, score: first.score, top, twinAmbiguous };
+}
diff --git a/app/features/scanner/core/detectors/telemetry.ts b/app/features/scanner/core/detectors/telemetry.ts
new file mode 100644
index 000000000..ae951ea4d
--- /dev/null
+++ b/app/features/scanner/core/detectors/telemetry.ts
@@ -0,0 +1,85 @@
+/**
+ * Scan telemetry: counters the analyzer accumulates so scan performance is
+ * measurable instead of guessed at — how many frames were decoded vs.
+ * actually analyzed, where detector time goes (gate vs. parse), how much
+ * work scheduling saved, and how much of a VoD was covered in skim mode.
+ * Plain JSON so it travels over the worker boundary as-is.
+ */
+
+export interface DetectorTelemetry {
+	/** frames on which the detector's gate ran */
+	checks: number;
+	gatePasses: number;
+	gateMs: number;
+	parses: number;
+	parseMs: number;
+	/** gate passed but parse() was skipped (suppression / cooldown) */
+	suppressedParses: number;
+}
+
+export interface ScanTelemetry {
+	decodedFrames: number;
+	/** frames that went through canvas readback + normalize + detectors */
+	analyzedFrames: number;
+	/** video seconds covered by dense sequential decode (chunk scan) */
+	activeVideoS: number;
+	/** video seconds covered by keyframe-hop skimming (chunk scan) */
+	skimVideoS: number;
+	wallMs: number;
+	detectors: Record<string, DetectorTelemetry>;
+}
+
+/** Fresh all-zero telemetry for one scan/session. */
+export function createScanTelemetry(): ScanTelemetry {
+	return {
+		decodedFrames: 0,
+		analyzedFrames: 0,
+		activeVideoS: 0,
+		skimVideoS: 0,
+		wallMs: 0,
+		detectors: {},
+	};
+}
+
+/** Get-or-create the per-detector counters bucket. */
+export function detectorTelemetry(
+	telemetry: ScanTelemetry,
+	id: string,
+): DetectorTelemetry {
+	const existing = telemetry.detectors[id];
+	if (existing) return existing;
+	const created: DetectorTelemetry = {
+		checks: 0,
+		gatePasses: 0,
+		gateMs: 0,
+		parses: 0,
+		parseMs: 0,
+		suppressedParses: 0,
+	};
+	telemetry.detectors[id] = created;
+	return created;
+}
+
+/** Sum telemetry across parallel chunk scans into one report. */
+export function mergeScanTelemetry(
+	parts: readonly ScanTelemetry[],
+): ScanTelemetry {
+	const out = createScanTelemetry();
+	for (const part of parts) {
+		out.decodedFrames += part.decodedFrames;
+		out.analyzedFrames += part.analyzedFrames;
+		out.activeVideoS += part.activeVideoS;
+		out.skimVideoS += part.skimVideoS;
+		out.wallMs = Math.max(out.wallMs, part.wallMs);
+		for (const [id, d] of Object.entries(part.detectors)) {
+			const bucket = detectorTelemetry(out, id);
+			bucket.checks += d.checks;
+			bucket.gatePasses += d.gatePasses;
+			bucket.gateMs += d.gateMs;
+			bucket.parses += d.parses;
+			bucket.parseMs += d.parseMs;
+			bucket.suppressedParses += d.suppressedParses;
+		}
+	}
+	return out;
+}
diff --git a/app/features/scanner/core/detectors/types.ts b/app/features/scanner/core/detectors/types.ts
new file mode 100644
index 000000000..d2df596d5
--- /dev/null
+++ b/app/features/scanner/core/detectors/types.ts
@@ -0,0 +1,101 @@
+import type { Mat } from "../cv";
+
+export interface DetectedEvent<TData = unknown> {
+	type: string;
+	/** seconds into the stream/video */
+	t: number;
+	/** 0..1 aggregate confidence; TimelineBuilder drops events below threshold */
+	confidence: number;
+	data: TData;
+	/** per-field match scores etc. for the harness/debugging; not persisted upstream */
+	debug?: Record<string, unknown>;
+}
+
+export interface GateResult {
+	pass: boolean;
+	/** raw score of the gate check, for tuning */
+	score: number;
+	/**
+	 * which screen variant the gate recognized, for detectors that gate more
+	 * than one (minimap: "overlay" | "spectator") — parse() branches on it
+	 * instead of re-running the gate probes
+	 */
+	variant?: string;
+	/**
+	 * coarse content fingerprint (grid-cell means over content ROIs, see
+	 * image.ts roiSignature) — the scheduler re-arms a suppressed streak
+	 * when it moves, for screens whose distinct real occurrences keep the
+	 * gate passing (browsing battle log / replay entries)
+	 */
+	signature?: number[];
+}
+
+/**
+ * A detector recognizes one event type on a canonical 1920x1080 RGBA frame.
+ * gate() must be cheap (probes / tiny template match); parse() may be expensive
+ * and only runs when gate() passes. Callers pass the gate result they already
+ * computed into parse(); a detector must still cope without it (re-deriving
+ * whatever it needs) so one-shot tools can call parse() directly.
+ */
+export interface Detector<TData = unknown> {
+	id: string;
+	/**
+	 * Minimum seconds between checks in *both* scheduling phases: frames
+	 * inside the interval skip gate and parse entirely
+	 * (core/detectors/scheduler.ts, applied by the analyzer worker). Also
+	 * exempts the detector from steady-frame suppression: it marks a screen
+	 * that stays up for minutes with *changing* content, which the
+	 * stagnating-confidence heuristic would wrongly silence.
+	 */
+	checkIntervalS?: number;
+	/**
+	 * Check cadence while the gate keeps failing (the search phase); unset =
+	 * the scheduler's default (0.25s). Don't reason from raw-gameplay screen
+	 * lifetimes here: produced/casted VoDs cut screens (results, intros) to
+	 * as little as ~1s with transition flicker eating frames inside that
+	 * window, so the search cadence must sample it several times. Gates
+	 * cost ~1.6ms, so searching at the analysis floor is effectively free;
+	 * only override upward with strong evidence.
+	 */
+	searchIntervalS?: number;
+	/**
+	 * Check cadence while the gate is passing (the refine phase); unset =
+	 * the scheduler's dense default (0.15s). Only for detectors whose parse
+	 * is expensive enough that refining at the dense cadence multiplies
+	 * real cost — the sparser cadence still has to sample the screen's
+	 * lifetime several times.
+	 */
+	refineIntervalS?: number;
+	/**
+	 * Consecutive non-improving parses tolerated before stagnation
+	 * suppression; unset = the scheduler's default (6). Lower for expensive
+	 * parses to cap the worst-case cost of a stagnant streak.
+	 */
+	maxStagnantParses?: number;
+	/**
+	 * A parse reaching this confidence ends the streak's refinement
+	 * immediately: the timeline keeps the best read per merge window, so a
+	 * read this good cannot be improved upon in any way that matters.
+	 * Set just under the detector's measured clean-read confidence floor
+	 * (fixture-suite reads + confirmed scan events), so a streak's first
+	 * full read suppresses the rest; degraded-footage reads below the
+	 * floor fall back to stagnation-based suppression.
+	 */
+	sufficientConfidence?: number;
+	/**
+	 * After a sufficient read, skip parses for this long even across gate
+	 * drops — for overlays whose animated background flickers the gate
+	 * (death). Only safe when the event type's timeline merge is purely
+	 * time-based and the cooldown fits inside the merge window, so every
+	 * parse the cooldown skips would have merged into the same event anyway.
+	 */
+	rearmCooldownS?: number;
+	/**
+	 * false = worker results for this detector's events ship without the
+	 * analyzed-frame PNG — for detectors whose events fire continuously,
+	 * where a stored frame per event would balloon IndexedDB.
+	 */
+	attachFrame?: boolean;
+	gate(frame: Mat): GateResult;
+	parse(frame: Mat, t: number, gate?: GateResult): DetectedEvent<TData>[];
+}
diff --git a/app/features/scanner/core/glyphs.ts b/app/features/scanner/core/glyphs.ts
new file mode 100644
index 000000000..9f37482ef
--- /dev/null
+++ b/app/features/scanner/core/glyphs.ts
@@ -0,0 +1,592 @@
+/**
+ * Glyph-template text recognition: font/size/position are known, so instead
+ * of OCR we segment the crop by column projection and classify each segment
+ * via sliding NCC against grayscale glyph templates (native scale;
+ * scaleGlyphSet pre-scales for larger text like team scores). Accuracy
+ * details: matching runs on the *masked* grayscale crop (background zeroed
+ * via a dilated binary mask) so colored backgrounds behave like black pills
+ * while antialiasing survives; scores carry an ink-coverage penalty (else a
+ * narrow template inside a wider glyph wins, e.g. 'c' outscoring 'o');
+ * segments wider than the median glyph split at deep projection dips ('T'
+ * overhangs merge into the next letter); multi-stroke glyphs with a stroke
+ * gap (katakana パ/ハ/リ) segment as fragments no template matches, so close
+ * pairs are re-classified merged and kept only when the merge decisively
+ * outscores both fragments.
+ */
+import { getCV, type Mat } from "./cv";
+import type { FrameData } from "./image";
+
+interface AtlasGlyphMeta {
+	char: string;
+	x: number;
+	y: number;
+	w: number;
+	h: number;
+	/**
+	 * Template origin: "fixture" = exact pixel crop from a labeled frame
+	 * (high fidelity, sparse coverage); "font" = rendered from game fonts
+	 * (full coverage, imperfect). Recognition takes the max score, so
+	 * fixture glyphs win where they exist.
+	 */
+	source?: "fixture" | "font";
+}
+
+export interface AtlasMeta {
+	/** nominal glyph height in canonical-1080p pixels */
+	height: number;
+	glyphs: AtlasGlyphMeta[];
+}
+
+interface Glyph {
+	char: string;
+	/** grayscale white-on-black, tight box */
+	mat: Mat;
+	/** count of pixels above the binarization threshold */
+	ink: number;
+	/** exact fixture crop vs font-rendered approximation */
+	source: "fixture" | "font";
+}
+
+export interface GlyphSet {
+	glyphs: Glyph[];
+	height: number;
+	/** median tight-box glyph width, used for split/space heuristics */
+	medianWidth: number;
+}
+
+const TEMPLATE_BIN_THRESHOLD = 128;
+
+/** Slice glyph templates out of an atlas image using its metadata. */
+export function loadGlyphSet(atlas: FrameData, meta: AtlasMeta): GlyphSet {
+	const cv = getCV();
+	const full = cv.matFromImageData(atlas as unknown as ImageData);
+	const gray = new cv.Mat();
+	cv.cvtColor(full, gray, cv.COLOR_RGBA2GRAY);
+	full.delete();
+
+	const glyphs: Glyph[] = meta.glyphs.map((g) => {
+		// NB: .data/.clone() are broken on ROI views in this opencv.js build;
+		// always copyTo into a fresh mat before pixel access.
+		const view = gray.roi(new cv.Rect(g.x, g.y, g.w, g.h));
+		const cell = new cv.Mat();
+		view.copyTo(cell);
+		view.delete();
+		const mat = tightCropGray(cell, TEMPLATE_BIN_THRESHOLD);
+		cell.delete();
+		let ink = 0;
+		for (const v of mat.data) if (v > TEMPLATE_BIN_THRESHOLD) ink++;
+		// untagged glyphs predate hybrid atlases and were all fixture crops
+		return { char: g.char, mat, ink, source: g.source ?? "fixture" };
+	});
+	gray.delete();
+	const widths = glyphs.map((g) => g.mat.cols).sort((a, b) => a - b);
+	const medianWidth = widths[Math.floor(widths.length / 2)] ?? 8;
+	return { glyphs, height: meta.height, medianWidth };
+}
+
+/** Resize every glyph by `factor` (e.g. to reuse paint digits for team scores). */
+export function scaleGlyphSet(set: GlyphSet, factor: number): GlyphSet {
+	const cv = getCV();
+	const glyphs = set.glyphs.map((g) => {
+		const mat = new cv.Mat();
+		cv.resize(g.mat, mat, new cv.Size(0, 0), factor, factor, cv.INTER_CUBIC);
+		let ink = 0;
+		for (const v of mat.data) if (v > TEMPLATE_BIN_THRESHOLD) ink++;
+		return { char: g.char, mat, ink, source: g.source };
+	});
+	return {
+		glyphs,
+		height: Math.round(set.height * factor),
+		medianWidth: Math.round(set.medianWidth * factor),
+	};
+}
+
+/** Crop a grayscale mat to the tight bounds of its above-threshold pixels. */
+function tightCropGray(gray: Mat, threshold: number): Mat {
+	const cv = getCV();
+	const { cols, rows, data } = gray;
+	let xMin = cols;
+	let xMax = -1;
+	let yMin = rows;
+	let yMax = -1;
+	for (let y = 0; y < rows; y++) {
+		for (let x = 0; x < cols; x++) {
+			if (data[y * cols + x]! > threshold) {
+				if (x < xMin) xMin = x;
+				if (x > xMax) xMax = x;
+				if (y < yMin) yMin = y;
+				if (y > yMax) yMax = y;
+			}
+		}
+	}
+	const out = new cv.Mat();
+	if (xMax < 0) {
+		gray.copyTo(out);
+		return out;
+	}
+	const view = gray.roi(
+		new cv.Rect(xMin, yMin, xMax - xMin + 1, yMax - yMin + 1),
+	);
+	view.copyTo(out);
+	view.delete();
+	return out;
+}
+
+export interface RecognizedChar {
+	char: string;
+	score: number;
+	/** segment bounds relative to the crop */
+	x0: number;
+	x1: number;
+	/** segment ink extent relative to the crop (y1 exclusive), for baseline checks */
+	y0: number;
+	y1: number;
+	/** runner-up candidates for this segment (debugging/tuning aid) */
+	candidates?: {
+		char: string;
+		score: number;
+		ncc: number;
+		source: "fixture" | "font";
+	}[];
+}
+
+export interface RecognizedText {
+	text: string;
+	chars: RecognizedChar[];
+	/** min char score (0 when ink was present but nothing was recognized) */
+	confidence: number;
+}
+
+export interface RecognizeOptions {
+	/** binarization threshold for segmentation/masking (white text) */
+	binThreshold?: number;
+	/** min white pixels for a column to count as ink */
+	minColumnPixels?: number;
+	/** gaps wider than this emit a space; Infinity disables spaces */
+	spaceGap?: number;
+	/** discard chars scoring below this */
+	minCharScore?: number;
+}
+
+interface Segment {
+	x0: number;
+	x1: number;
+}
+
+function columnProfile(binary: Mat): number[] {
+	const { cols, rows, data } = binary;
+	const profile = new Array<number>(cols).fill(0);
+	for (let y = 0; y < rows; y++) {
+		for (let x = 0; x < cols; x++) {
+			if (data[y * cols + x]! > 0) profile[x]!++;
+		}
+	}
+	return profile;
+}
+
+function segmentColumns(profile: number[], minColumnPixels: number): Segment[] {
+	const segments: Segment[] = [];
+	let start = -1;
+	for (let x = 0; x < profile.length; x++) {
+		const on = profile[x]! > minColumnPixels;
+		if (on && start < 0) start = x;
+		if (!on && start >= 0) {
+			if (x - start >= 2) segments.push({ x0: start, x1: x });
+			start = -1;
+		}
+	}
+	if (start >= 0 && profile.length - start >= 2) {
+		segments.push({ x0: start, x1: profile.length });
+	}
+	return segments;
+}
+
+/** Distance from `w` to the nearest positive multiple of `unit`. */
+function widthError(w: number, unit: number): number {
+	const n = Math.max(1, Math.round(w / unit));
+	return Math.abs(w - n * unit);
+}
+
+function splitWideSegment(
+	profile: number[],
+	seg: Segment,
+	medianWidth: number,
+): Segment[] {
+	const maxCharWidth = Math.round(medianWidth * 1.5);
+	if (seg.x1 - seg.x0 <= maxCharWidth) return [seg];
+	// Split at the dip deepest relative to its neighboring peaks, not raw
+	// minimum: the raw min can land inside a thin-but-real stroke (a 'T' top
+	// bar profiles as low as the blurred gap to the next glyph).
+	const leftMax = new Array<number>(seg.x1).fill(0);
+	const rightMax = new Array<number>(seg.x1).fill(0);
+	let running = 0;
+	for (let i = seg.x0; i < seg.x1; i++) {
+		leftMax[i] = running;
+		running = Math.max(running, profile[i]!);
+	}
+	running = 0;
+	for (let i = seg.x1 - 1; i >= seg.x0; i--) {
+		rightMax[i] = running;
+		running = Math.max(running, profile[i]!);
+	}
+	let best = -1;
+	let bestRatio = Number.POSITIVE_INFINITY;
+	for (let i = seg.x0 + 3; i < seg.x1 - 3; i++) {
+		const ratio =
+			profile[i]! / Math.max(1, Math.min(leftMax[i]!, rightMax[i]!));
+		if (ratio < bestRatio) {
+			bestRatio = ratio;
+			best = i;
+		}
+	}
+	if (best < 0 || bestRatio > 0.45) return [seg];
+	// The dip is often a plateau of equally-low columns whose ink ownership
+	// is ambiguous; cut at whichever edge leaves the left part closest to a
+	// whole glyph width.
+	let lo = best;
+	let hi = best;
+	while (lo - 1 >= seg.x0 + 3 && profile[lo - 1]! <= profile[best]!) lo--;
+	while (hi + 1 < seg.x1 - 3 && profile[hi + 1]! <= profile[best]!) hi++;
+	const cut =
+		widthError(lo - seg.x0, medianWidth) <=
+		widthError(hi + 1 - seg.x0, medianWidth)
+			? lo
+			: hi + 1;
+	return [
+		...splitWideSegment(profile, { x0: seg.x0, x1: cut }, medianWidth),
+		...splitWideSegment(profile, { x0: cut, x1: seg.x1 }, medianWidth),
+	];
+}
+
+interface SegmentInfo extends Segment {
+	ink: number;
+	height: number;
+	/** ink extent rows (y1 exclusive) */
+	y0: number;
+	y1: number;
+}
+
+function measureSegment(binary: Mat, seg: Segment): SegmentInfo {
+	const { cols, data, rows } = binary;
+	let ink = 0;
+	let yMin = rows;
+	let yMax = -1;
+	for (let y = 0; y < rows; y++) {
+		for (let x = seg.x0; x < seg.x1; x++) {
+			if (data[y * cols + x]! > 0) {
+				ink++;
+				if (y < yMin) yMin = y;
+				if (y > yMax) yMax = y;
+			}
+		}
+	}
+	return {
+		...seg,
+		ink,
+		height: Math.max(0, yMax - yMin + 1),
+		y0: Math.min(yMin, rows),
+		y1: yMax + 1,
+	};
+}
+
+/**
+ * Fixture crops are ground truth; a font glyph must beat one by this margin
+ * to win (stops 'I' noise-edging out an exact 'l' crop). Keep tight — at
+ * 0.04 a fixture crop of a genuinely different char ('h' vs 'b') can
+ * displace a correct font match.
+ */
+const FIXTURE_TIEBREAK = 0.02;
+
+function classifySegment(
+	masked: Mat,
+	seg: SegmentInfo,
+	set: GlyphSet,
+	/**
+	 * Exact early-reject floor: a score can never exceed its precomputed
+	 * bound, so a caller that only needs to know whether any glyph can beat
+	 * `scoreFloor` (mergeSplitGlyphs) lets the bound-sorted loop stop as soon
+	 * as none can. Scores that ARE computed come out identical — but the
+	 * returned list omits sub-floor candidates, so pass it only for probes.
+	 */
+	scoreFloor = Number.NEGATIVE_INFINITY,
+): { char: string; score: number; ncc: number; source: "fixture" | "font" }[] {
+	const cv = getCV();
+	const segWidth = seg.x1 - seg.x0;
+	const pad = 5;
+	// NB: Mat dimension/data accessors go through embind (validateThis etc.)
+	// and are expensive — hoist them out of the per-glyph/per-pixel loops.
+	const maskedRows = masked.rows;
+	const x0 = Math.max(0, seg.x0 - pad);
+	const x1 = Math.min(masked.cols, seg.x1 + pad);
+	const regionCols = x1 - x0;
+	// Crop the search region vertically to the segment's ink rows: line crops
+	// can run far taller than the text (the death tag band is ~2x its glyphs),
+	// and every extra row multiplies matchTemplate work while only offering
+	// placements away from the ink no correct match can occupy. The slack
+	// keeps every hRatio-eligible template (tRows <= 1.3 * seg.height)
+	// placeable: seg.height + 2 * (0.15 * seg.height + 2) >= 1.3 * seg.height.
+	const vSlack = Math.ceil(0.15 * seg.height) + 2;
+	const y0 = Math.max(0, seg.y0 - vSlack);
+	const y1 = Math.min(maskedRows, seg.y1 + vSlack);
+	const regionRows = y1 - y0;
+	const region = masked.roi(new cv.Rect(x0, y0, regionCols, regionRows));
+
+	// Both penalty factors below depend only on the glyph and the segment, and
+	// NCC <= 1, so their product bounds the score a glyph can reach before any
+	// matching runs. Matching in descending-bound order lets the loop stop as
+	// soon as no remaining glyph could come within FIXTURE_TIEBREAK of the
+	// best — those can neither win nor take part in the fixture tie-break.
+	const eligible: {
+		glyph: Glyph;
+		tRows: number;
+		tCols: number;
+		r: number;
+		hr: number;
+		bound: number;
+	}[] = [];
+	for (const glyph of set.glyphs) {
+		const t = glyph.mat;
+		const tRows = t.rows;
+		const tCols = t.cols;
+		if (tRows > regionRows || tCols > regionCols) continue;
+		const wRatio = tCols / Math.max(segWidth, 1);
+		if (wRatio < 0.4 || wRatio > 2.5) continue;
+		const hRatio = tRows / Math.max(seg.height, 1);
+		// a template sliding freely inside a taller region can score high on a
+		// fragment of the segment (an 'l' bar inside a 'c'), so reject templates
+		// much taller or shorter than the segment's ink extent
+		if (hRatio < 0.5 || hRatio > 1.3) continue;
+		// ink-coverage penalty: templates should explain the segment's ink
+		const r =
+			Math.min(glyph.ink, seg.ink) / Math.max(Math.max(glyph.ink, seg.ink), 1);
+		// height-mismatch penalty: an x-height template sliding on an ascender/
+		// descender glyph ('o' on 'b' or 'g') can correlate well on the bowl
+		// alone; matching heights should outrank it
+		const hr =
+			Math.min(tRows, seg.height) / Math.max(tRows, Math.max(seg.height, 1));
+		eligible.push({
+			glyph,
+			tRows,
+			tCols,
+			r,
+			hr,
+			bound: (0.7 + 0.3 * r) * (0.85 + 0.15 * hr),
+		});
+	}
+	eligible.sort((a, b) => b.bound - a.bound);
+
+	const result = new cv.Mat();
+	const candidates: {
+		char: string;
+		score: number;
+		ncc: number;
+		source: "fixture" | "font";
+	}[] = [];
+	// Only consider placements that cover most of the segment: the region
+	// is padded, so a freely-sliding template can otherwise score a perfect
+	// match on the *neighboring* glyph inside the pad (an 'l' template next
+	// to a narrow 'i' segment matches the adjacent real 'l' at 0.97+), or
+	// on a fragment of the segment (a 't' stem on the left bar of a 'b').
+	const minOverlap = 0.7 * segWidth;
+	// In probe mode only the boolean "can any glyph beat the floor" matters,
+	// so the loop can stop as soon as either answer is certain: no remaining
+	// bound reaches the floor, or a computed score already cleared it.
+	const probeMode = scoreFloor !== Number.NEGATIVE_INFINITY;
+	let bestScore = scoreFloor;
+	for (const { glyph, tRows, tCols, r, hr, bound } of eligible) {
+		if (bound < bestScore - FIXTURE_TIEBREAK) break;
+		if (probeMode && (bound <= scoreFloor || bestScore > scoreFloor)) break;
+		cv.matchTemplate(region, glyph.mat, result, cv.TM_CCOEFF_NORMED);
+		const rCols = regionCols - tCols + 1;
+		const rRows = regionRows - tRows + 1;
+		// overlap(sx) is concave in sx, so the valid placements form one
+		// contiguous rx interval — find its edges, then scan row-major
+		const overlapAt = (rx: number) =>
+			Math.min(x0 + rx + tCols, seg.x1) - Math.max(x0 + rx, seg.x0);
+		let lo = 0;
+		while (lo < rCols && overlapAt(lo) < minOverlap) lo++;
+		let hi = rCols - 1;
+		while (hi >= lo && overlapAt(hi) < minOverlap) hi--;
+		if (hi < lo) continue;
+		let maxVal = Number.NEGATIVE_INFINITY;
+		const scores = result.data32F;
+		for (let ry = 0, rowBase = 0; ry < rRows; ry++, rowBase += rCols) {
+			for (let rx = lo; rx <= hi; rx++) {
+				const v = scores[rowBase + rx]!;
+				if (v > maxVal) maxVal = v;
+			}
+		}
+		const score = maxVal * (0.7 + 0.3 * r) * (0.85 + 0.15 * hr);
+		if (Number.isFinite(score)) {
+			if (score > bestScore) bestScore = score;
+			candidates.push({
+				char: glyph.char,
+				score,
+				ncc: maxVal,
+				source: glyph.source,
+			});
+		}
+	}
+	result.delete();
+	region.delete();
+	candidates.sort((a, b) => b.score - a.score);
+	const top = candidates[0];
+	if (top && top.source === "font") {
+		const fixture = candidates.find(
+			(c) =>
+				c.source === "fixture" &&
+				top.score - c.score < FIXTURE_TIEBREAK &&
+				// ...but only when the fixture's raw correlation is also competitive;
+				// a fixture crop of a *different* char that merely lands near the top
+				// score via the ink penalty must not displace a well-matching font glyph
+				top.ncc - c.ncc < FIXTURE_TIEBREAK,
+		);
+		if (fixture && fixture !== top) {
+			candidates.splice(candidates.indexOf(fixture), 1);
+			candidates.unshift(fixture);
+		}
+	}
+	return candidates.slice(0, 5);
+}
+
+interface ClassifiedSegment {
+	seg: SegmentInfo;
+	ranked: ReturnType<typeof classifySegment>;
+}
+
+/**
+ * Multi-stroke glyphs whose strokes never connect (katakana ハ/パ/リ and kin)
+ * segment as two fragments no full-glyph template can match (width-ratio
+ * filter rejects a wide template on a narrow fragment). Close neighbor pairs
+ * are re-classified merged and kept only when the merge beats both fragments
+ * by a clear margin — genuine pairs ("rn", "VV") already read well alone, so
+ * a lookalike merge ('m', 'W') can't clear it. Kana gaps run wide (い's
+ * strokes sit ~0.4 medianWidth apart at tag-name scale), so
+ * MERGE_MAX_GAP_RATIO reaches past that while staying below the space gap
+ * (0.55), so merges never bridge a real word break.
+ */
+const MERGE_MAX_GAP_RATIO = 0.45;
+const MERGE_MARGIN = 0.02;
+
+function mergeSplitGlyphs(
+	items: ClassifiedSegment[],
+	binary: Mat,
+	masked: Mat,
+	set: GlyphSet,
+): void {
+	const maxGap = Math.max(3, Math.round(set.medianWidth * MERGE_MAX_GAP_RATIO));
+	const maxCharWidth = Math.round(set.medianWidth * 1.5);
+	for (let i = 0; i + 1 < items.length; ) {
+		const a = items[i]!;
+		const b = items[i + 1]!;
+		const gap = b.seg.x0 - a.seg.x1;
+		const width = b.seg.x1 - a.seg.x0;
+		if (gap > maxGap || width > maxCharWidth) {
+			i++;
+			continue;
+		}
+		const seg = measureSegment(binary, { x0: a.seg.x0, x1: b.seg.x1 });
+		const fragmentBest = Math.max(
+			a.ranked[0]?.score ?? 0,
+			b.ranked[0]?.score ?? 0,
+		);
+		const floor = fragmentBest + MERGE_MARGIN;
+		// Probe with the floor first: most neighbor pairs are genuine letter
+		// pairs whose merge can't win, and the floor lets the bound-sorted
+		// matching stop almost immediately. The probe's computed scores are
+		// exact, so "no candidate beats the floor" is a definitive reject.
+		const probe = classifySegment(masked, seg, set, floor);
+		let merged = false;
+		if (probe.some((c) => c.score > floor)) {
+			// full run (rare): the winning merge's ranked list must also carry
+			// the sub-floor runner-up candidates downstream consumers see
+			const ranked = classifySegment(masked, seg, set);
+			if ((ranked[0]?.score ?? 0) > floor) {
+				// stay at i: the merged segment may absorb yet another stroke
+				items.splice(i, 2, { seg, ranked });
+				merged = true;
+			}
+		}
+		if (!merged) i++;
+	}
+}
+
+/**
+ * Recognize white-on-dark text in a grayscale crop.
+ * The crop must be tight vertically (one text line).
+ */
+export function recognizeText(
+	gray: Mat,
+	set: GlyphSet,
+	options: RecognizeOptions = {},
+): RecognizedText {
+	const cv = getCV();
+	const {
+		binThreshold = 150,
+		minColumnPixels = 1,
+		spaceGap = Math.max(5, Math.round(set.medianWidth * 0.55)),
+		minCharScore = 0.4,
+	} = options;
+
+	const binary = new cv.Mat();
+	cv.threshold(gray, binary, binThreshold, 255, cv.THRESH_BINARY);
+
+	// mask the gray crop so background patterns don't take part in matching,
+	// dilated so antialiased glyph edges survive
+	const mask = new cv.Mat();
+	const kernel = cv.getStructuringElement(cv.MORPH_RECT, new cv.Size(3, 3));
+	cv.dilate(binary, mask, kernel, new cv.Point(-1, -1), 2);
+	kernel.delete();
+	const masked = new cv.Mat(gray.rows, gray.cols, cv.CV_8UC1, new cv.Scalar(0));
+	gray.copyTo(masked, mask);
+	mask.delete();
+
+	const profile = columnProfile(binary);
+	const segments = segmentColumns(profile, minColumnPixels)
+		.flatMap((s) => splitWideSegment(profile, s, set.medianWidth))
+		.map((s) => measureSegment(binary, s));
+
+	const items: ClassifiedSegment[] = segments.map((seg) => ({
+		seg,
+		ranked: classifySegment(masked, seg, set),
+	}));
+	mergeSplitGlyphs(items, binary, masked, set);
+
+	const chars: RecognizedChar[] = [];
+	let text = "";
+	let prevEnd: number | null = null;
+	for (const { seg, ranked } of items) {
+		if (prevEnd !== null && seg.x0 - prevEnd > spaceGap && text.length > 0) {
+			text += " ";
+		}
+		const top = ranked[0];
+		if (top && top.score >= minCharScore) {
+			chars.push({
+				char: top.char,
+				score: top.score,
+				x0: seg.x0,
+				x1: seg.x1,
+				y0: seg.y0,
+				y1: seg.y1,
+				candidates: ranked.map((c) => ({
+					char: c.char,
+					score: c.score,
+					ncc: c.ncc,
+					source: c.source,
+				})),
+			});
+			text += top.char;
+		}
+		prevEnd = seg.x1;
+	}
+	binary.delete();
+	masked.delete();
+
+	const confidence =
+		chars.length > 0
+			? Math.min(...chars.map((c) => c.score))
+			: segments.length > 0
+				? 0
+				: 1;
+	return { text, chars, confidence };
+}
diff --git a/app/features/scanner/core/image.ts b/app/features/scanner/core/image.ts
new file mode 100644
index 000000000..fcf9a0854
--- /dev/null
+++ b/app/features/scanner/core/image.ts
@@ -0,0 +1,186 @@
+/**
+ * Environment-agnostic frame representation and helpers.
+ * A FrameData is RGBA, same layout as browser ImageData — Node code builds it
+ * from @napi-rs/canvas, browser code from a canvas or VideoFrame.
+ */
+
+import { CANONICAL_HEIGHT, CANONICAL_WIDTH, type Roi } from "./canonical";
+import { getCV, type Mat, meanOf, minMaxLoc } from "./cv";
+
+export type { Roi };
+
+export interface FrameData {
+	width: number;
+	height: number;
+	/** RGBA, 4 bytes per pixel */
+	data: Uint8ClampedArray;
+}
+
+export function toMat(frame: FrameData): Mat {
+	const cv = getCV();
+	// matFromImageData only reads width/height/data, so FrameData is compatible
+	return cv.matFromImageData(frame as unknown as ImageData);
+}
+
+/**
+ * Normalize any input frame to the canonical 1920x1080 RGBA mat that all ROI
+ * constants are defined against. Returns a new mat; caller owns both.
+ */
+export function normalizeFrame(src: Mat): Mat {
+	const cv = getCV();
+	const dst = new cv.Mat();
+	if (src.cols === CANONICAL_WIDTH && src.rows === CANONICAL_HEIGHT) {
+		src.copyTo(dst);
+		return dst;
+	}
+	const interpolation =
+		src.cols > CANONICAL_WIDTH ? cv.INTER_AREA : cv.INTER_CUBIC;
+	cv.resize(
+		src,
+		dst,
+		new cv.Size(CANONICAL_WIDTH, CANONICAL_HEIGHT),
+		0,
+		0,
+		interpolation,
+	);
+	return dst;
+}
+
+/**
+ * Crop a rect out of a mat. Returns a view: fine as *input* to OpenCV calls
+ * (matchTemplate, mean, resize, ...) but NEVER read `.data` off it — in this
+ * opencv.js build both `.data` and `.clone()` mishandle non-continuous views.
+ * Use copyRoi when pixel access is needed.
+ */
+export function cropRoi(src: Mat, roi: Roi): Mat {
+	const cv = getCV();
+	return src.roi(new cv.Rect(roi.x, roi.y, roi.w, roi.h));
+}
+
+/** Crop a rect into a fresh continuous mat (safe for `.data` access). */
+export function copyRoi(src: Mat, roi: Roi): Mat {
+	const view = cropRoi(src, roi);
+	const out = new (getCV().Mat)();
+	view.copyTo(out);
+	view.delete();
+	return out;
+}
+
+/**
+ * Mean brightness of a ROI: the average of the first three channels on a
+ * color mat, the single channel's mean on a grayscale (or |Laplacian|) mat.
+ * The shared probe primitive of every detector gate.
+ */
+export function meanBrightness(mat: Mat, roi: Roi): number {
+	const view = cropRoi(mat, roi);
+	const m = meanOf(view);
+	view.delete();
+	return mat.channels() >= 3 ? (m[0]! + m[1]! + m[2]!) / 3 : m[0]!;
+}
+
+/** Brightest pixel of a grayscale ROI. */
+export function maxBrightness(gray: Mat, roi: Roi): number {
+	const view = cropRoi(gray, roi);
+	const { maxVal } = minMaxLoc(view);
+	view.delete();
+	return maxVal;
+}
+
+function channelExtreme(
+	mat: Mat,
+	roi: Roi | undefined,
+	op: "min" | "max",
+): Mat {
+	const cv = getCV();
+	const view = roi ? cropRoi(mat, roi) : null;
+	const src = view ?? mat;
+	const channels = new cv.MatVector();
+	cv.split(src, channels);
+	const r = channels.get(0);
+	const g = channels.get(1);
+	const b = channels.get(2);
+	const rg = new cv.Mat();
+	const out = new cv.Mat();
+	if (op === "max") {
+		cv.max(r, g, rg);
+		cv.max(rg, b, out);
+	} else {
+		cv.min(r, g, rg);
+		cv.min(rg, b, out);
+	}
+	rg.delete();
+	r.delete();
+	g.delete();
+	b.delete();
+	if (mat.channels() === 4) channels.get(3).delete();
+	channels.delete();
+	view?.delete();
+	return out;
+}
+
+/** Brightest channel per pixel, so colored text binarizes like white. */
+export function maxChannel(mat: Mat, roi?: Roi): Mat {
+	return channelExtreme(mat, roi, "max");
+}
+
+/** Per-pixel min of R/G/B — drops color-tinted brightness, keeps white. */
+export function minChannel(mat: Mat, roi?: Roi): Mat {
+	return channelExtreme(mat, roi, "min");
+}
+
+/**
+ * Coarse content fingerprint of a grayscale ROI: the mean brightness of each
+ * cell in a cols x rows grid over the region. Cheap enough for gates.
+ * Consecutive frames of one static screen move a cell by ≤~2 while different
+ * text/content moves cells by tens (measured on battle log browsing footage)
+ * — the scheduler compares fingerprints to re-arm suppression when a passing
+ * gate's screen flips to a new real occurrence (GateResult.signature).
+ */
+export function roiSignature(
+	gray: Mat,
+	roi: Roi,
+	cols: number,
+	rows: number,
+): number[] {
+	const cv = getCV();
+	const view = cropRoi(gray, roi);
+	const small = new cv.Mat();
+	cv.resize(view, small, new cv.Size(cols, rows), 0, 0, cv.INTER_AREA);
+	view.delete();
+	const cells = Array.from(small.data as Uint8Array, Number);
+	small.delete();
+	return cells;
+}
+
+/** |Laplacian| response of a grayscale mat; caller owns the result. */
+export function laplacianAbs(gray: Mat): Mat {
+	const cv = getCV();
+	const lap = new cv.Mat();
+	cv.Laplacian(gray, lap, cv.CV_16S, 3, 1, 0, cv.BORDER_DEFAULT);
+	const abs8 = new cv.Mat();
+	cv.convertScaleAbs(lap, abs8);
+	lap.delete();
+	return abs8;
+}
+
+export function matToFrameData(mat: Mat): FrameData {
+	const cv = getCV();
+	const rgba = new cv.Mat();
+	if (mat.type() === cv.CV_8UC4) {
+		mat.copyTo(rgba);
+	} else if (mat.type() === cv.CV_8UC3) {
+		cv.cvtColor(mat, rgba, cv.COLOR_RGB2RGBA);
+	} else if (mat.type() === cv.CV_8UC1) {
+		cv.cvtColor(mat, rgba, cv.COLOR_GRAY2RGBA);
+	} else {
+		rgba.delete();
+		throw new Error(`unsupported mat type ${mat.type()}`);
+	}
+	const out: FrameData = {
+		width: rgba.cols,
+		height: rgba.rows,
+		data: new Uint8ClampedArray(rgba.data),
+	};
+	rgba.delete();
+	return out;
+}
diff --git a/app/features/scanner/core/localized-entries.ts b/app/features/scanner/core/localized-entries.ts
new file mode 100644
index 000000000..0c9b07242
--- /dev/null
+++ b/app/features/scanner/core/localized-entries.ts
@@ -0,0 +1,2171 @@
+/**
+ * GENERATED by scripts/scanner/build-localized-entries.ts from the splat3 repo's
+ * language dumps — do not edit by hand; regenerate when the game adds
+ * content. Localized versus-UI strings for every game language, each
+ * mapped to the sendou.ink id it means (core/localized.ts derives the
+ * flattened match sets detectors snap OCR output against).
+ */
+import type { ModeShort, StageId } from "~/modules/in-game-lists/types";
+import type { ScannerLobby } from "../scanner-types";
+
+export interface LocalizedLobby {
+	text: string;
+	lobby: ScannerLobby;
+}
+
+export interface LocalizedMode {
+	text: string;
+	mode: ModeShort;
+}
+
+export interface LocalizedStage {
+	text: string;
+	stageId: StageId;
+}
+
+export interface LanguageEntries {
+	lang: string;
+	/** the intro splash's constant "MODE" label */
+	modeLabel: string;
+	/** replay-browser winner/loser panel tags */
+	victory: string;
+	defeat: string;
+	lobbies: LocalizedLobby[];
+	modes: LocalizedMode[];
+	/** two-line intro-splash wrap variants ("Muschel-\nchaos"), space-joined */
+	modeWraps: LocalizedMode[];
+	stages: LocalizedStage[];
+}
+
+export const LANGUAGE_ENTRIES: readonly LanguageEntries[] = [
+	{
+		lang: "CNzh",
+		modeLabel: "规则",
+		victory: "WIN！",
+		defeat: "LOSE...",
+		lobbies: [
+			{
+				text: "X比赛",
+				lobby: "X",
+			},
+			{
+				text: "蛮颓比赛（挑战）",
+				lobby: "SERIES",
+			},
+			{
+				text: "蛮颓比赛（开放）",
+				lobby: "OPEN",
+			},
+			{
+				text: "私人比赛",
+				lobby: "PRIVATE",
+			},
+		],
+		modes: [
+			{
+				text: "占地对战",
+				mode: "TW",
+			},
+			{
+				text: "真格区域",
+				mode: "SZ",
+			},
+			{
+				text: "真格塔楼",
+				mode: "TC",
+			},
+			{
+				text: "真格鱼虎对战",
+				mode: "RM",
+			},
+			{
+				text: "真格蛤蜊",
+				mode: "CB",
+			},
+		],
+		modeWraps: [],
+		stages: [
+			{
+				text: "龙宫转运站",
+				stageId: 23,
+			},
+			{
+				text: "臭鱼干温泉",
+				stageId: 13,
+			},
+			{
+				text: "醋饭海洋世界",
+				stageId: 11,
+			},
+			{
+				text: "十路通高架桥下",
+				stageId: 24,
+			},
+			{
+				text: "贝见亭",
+				stageId: 21,
+			},
+			{
+				text: "鳗鲶区",
+				stageId: 1,
+			},
+			{
+				text: "鱼露遗迹",
+				stageId: 15,
+			},
+			{
+				text: "鬼头刀SPA度假区",
+				stageId: 7,
+			},
+			{
+				text: "比目鱼住宅区",
+				stageId: 12,
+			},
+			{
+				text: "真鲭跨海大桥",
+				stageId: 5,
+			},
+			{
+				text: "座头购物中心",
+				stageId: 10,
+			},
+			{
+				text: "鲟鱼造船厂",
+				stageId: 9,
+			},
+			{
+				text: "鬼蝠鲼玛利亚号",
+				stageId: 14,
+			},
+			{
+				text: "金眼鲷美术馆",
+				stageId: 6,
+			},
+			{
+				text: "旗鱼机场",
+				stageId: 22,
+			},
+			{
+				text: "葱鲔鱼煤矿场",
+				stageId: 20,
+			},
+			{
+				text: "鱼肉碎金属",
+				stageId: 4,
+			},
+			{
+				text: "塔拉波特购物公园",
+				stageId: 17,
+			},
+			{
+				text: "高脚经济特区",
+				stageId: 18,
+			},
+			{
+				text: "竹蛏疏洪道",
+				stageId: 3,
+			},
+			{
+				text: "大比目鱼海运中心",
+				stageId: 19,
+			},
+			{
+				text: "海女美术大学",
+				stageId: 8,
+			},
+			{
+				text: "昆布赛道",
+				stageId: 16,
+			},
+			{
+				text: "烟管鱼市场",
+				stageId: 2,
+			},
+			{
+				text: "温泉花大峡谷",
+				stageId: 0,
+			},
+		],
+	},
+	{
+		lang: "EUde",
+		modeLabel: "Kampfart",
+		victory: "Sieg!",
+		defeat: "Verloren...",
+		lobbies: [
+			{
+				text: "X-Kampf",
+				lobby: "X",
+			},
+			{
+				text: "Anarchie-Kampf (Serie)",
+				lobby: "SERIES",
+			},
+			{
+				text: "Anarchie-Kampf (Offen)",
+				lobby: "OPEN",
+			},
+			{
+				text: "Privater Kampf",
+				lobby: "PRIVATE",
+			},
+		],
+		modes: [
+			{
+				text: "Revierkampf",
+				mode: "TW",
+			},
+			{
+				text: "Herrschaft",
+				mode: "SZ",
+			},
+			{
+				text: "Turm-Kommando",
+				mode: "TC",
+			},
+			{
+				text: "Operation Goldfisch",
+				mode: "RM",
+			},
+			{
+				text: "Muschelchaos",
+				mode: "CB",
+			},
+		],
+		modeWraps: [
+			{
+				text: "Revier- kampf",
+				mode: "TW",
+			},
+			{
+				text: "Muschel- chaos",
+				mode: "CB",
+			},
+		],
+		stages: [
+			{
+				text: "Bahnhof Lemuria",
+				stageId: 23,
+			},
+			{
+				text: "Kusaya-Quellen",
+				stageId: 13,
+			},
+			{
+				text: "Flunder-Funpark",
+				stageId: 11,
+			},
+			{
+				text: "Dekabahnstation",
+				stageId: 24,
+			},
+			{
+				text: "ROM & RAMen",
+				stageId: 21,
+			},
+			{
+				text: "Streifenaal-Straße",
+				stageId: 1,
+			},
+			{
+				text: "Um'ami-Ruinen",
+				stageId: 15,
+			},
+			{
+				text: "Mahi-Mahi-Resort",
+				stageId: 7,
+			},
+			{
+				text: "Schollensiedlung",
+				stageId: 12,
+			},
+			{
+				text: "Makrelenbrücke",
+				stageId: 5,
+			},
+			{
+				text: "Cetacea-Markt",
+				stageId: 10,
+			},
+			{
+				text: "Störwerft",
+				stageId: 9,
+			},
+			{
+				text: "Manta Maria",
+				stageId: 14,
+			},
+			{
+				text: "Pinakoithek",
+				stageId: 6,
+			},
+			{
+				text: "La Ola Airport",
+				stageId: 22,
+			},
+			{
+				text: "Blauflossen-Depot",
+				stageId: 20,
+			},
+			{
+				text: "Aalstahl-Metallwerk",
+				stageId: 4,
+			},
+			{
+				text: "Talerfisch & Pock",
+				stageId: 17,
+			},
+			{
+				text: "Seespinnen-Skyline",
+				stageId: 18,
+			},
+			{
+				text: "Schwertmuschel-Reservoir",
+				stageId: 3,
+			},
+			{
+				text: "Frachtschiff Schwerfisch",
+				stageId: 19,
+			},
+			{
+				text: "Perlmutt-Akademie",
+				stageId: 8,
+			},
+			{
+				text: "Buckelwal-Piste",
+				stageId: 16,
+			},
+			{
+				text: "Schnapperchen-Basar",
+				stageId: 2,
+			},
+			{
+				text: "Sengkluft",
+				stageId: 0,
+			},
+		],
+	},
+	{
+		lang: "EUen",
+		modeLabel: "Mode",
+		victory: "VICTORY",
+		defeat: "DEFEAT",
+		lobbies: [
+			{
+				text: "X Battle",
+				lobby: "X",
+			},
+			{
+				text: "Anarchy Battle (Series)",
+				lobby: "SERIES",
+			},
+			{
+				text: "Anarchy Battle (Open)",
+				lobby: "OPEN",
+			},
+			{
+				text: "Private Battle",
+				lobby: "PRIVATE",
+			},
+		],
+		modes: [
+			{
+				text: "Turf War",
+				mode: "TW",
+			},
+			{
+				text: "Splat Zones",
+				mode: "SZ",
+			},
+			{
+				text: "Tower Control",
+				mode: "TC",
+			},
+			{
+				text: "Rainmaker",
+				mode: "RM",
+			},
+			{
+				text: "Clam Blitz",
+				mode: "CB",
+			},
+		],
+		modeWraps: [],
+		stages: [
+			{
+				text: "Lemuria Hub",
+				stageId: 23,
+			},
+			{
+				text: "Brinewater Springs",
+				stageId: 13,
+			},
+			{
+				text: "Wahoo World",
+				stageId: 11,
+			},
+			{
+				text: "Urchin Underpass",
+				stageId: 24,
+			},
+			{
+				text: "Robo ROM-en",
+				stageId: 21,
+			},
+			{
+				text: "Eeltail Alley",
+				stageId: 1,
+			},
+			{
+				text: "Um'ami Ruins",
+				stageId: 15,
+			},
+			{
+				text: "Mahi-Mahi Resort",
+				stageId: 7,
+			},
+			{
+				text: "Flounder Heights",
+				stageId: 12,
+			},
+			{
+				text: "Hammerhead Bridge",
+				stageId: 5,
+			},
+			{
+				text: "MakoMart",
+				stageId: 10,
+			},
+			{
+				text: "Sturgeon Shipyard",
+				stageId: 9,
+			},
+			{
+				text: "Manta Maria",
+				stageId: 14,
+			},
+			{
+				text: "Museum d'Alfonsino",
+				stageId: 6,
+			},
+			{
+				text: "Marlin Airport",
+				stageId: 22,
+			},
+			{
+				text: "Bluefin Depot",
+				stageId: 20,
+			},
+			{
+				text: "Mincemeat Metalworks",
+				stageId: 4,
+			},
+			{
+				text: "Barnacle & Dime",
+				stageId: 17,
+			},
+			{
+				text: "Crableg Capital",
+				stageId: 18,
+			},
+			{
+				text: "Undertow Spillway",
+				stageId: 3,
+			},
+			{
+				text: "Shipshape Cargo Co.",
+				stageId: 19,
+			},
+			{
+				text: "Inkblot Art Academy",
+				stageId: 8,
+			},
+			{
+				text: "Humpback Pump Track",
+				stageId: 16,
+			},
+			{
+				text: "Hagglefish Market",
+				stageId: 2,
+			},
+			{
+				text: "Scorch Gorge",
+				stageId: 0,
+			},
+		],
+	},
+	{
+		lang: "EUes",
+		modeLabel: "Estilo",
+		victory: "¡Victoria!",
+		defeat: "Derrota",
+		lobbies: [
+			{
+				text: "Combate X",
+				lobby: "X",
+			},
+			{
+				text: "Combate caótico (formal)",
+				lobby: "SERIES",
+			},
+			{
+				text: "Combate caótico (informal)",
+				lobby: "OPEN",
+			},
+			{
+				text: "Combate privado",
+				lobby: "PRIVATE",
+			},
+		],
+		modes: [
+			{
+				text: "Territorial",
+				mode: "TW",
+			},
+			{
+				text: "Pintazonas",
+				mode: "SZ",
+			},
+			{
+				text: "Torre",
+				mode: "TC",
+			},
+			{
+				text: "Pez dorado",
+				mode: "RM",
+			},
+			{
+				text: "Asalto almeja",
+				mode: "CB",
+			},
+		],
+		modeWraps: [
+			{
+				text: "Terri- torial",
+				mode: "TW",
+			},
+			{
+				text: "Pinta- zonas",
+				mode: "SZ",
+			},
+		],
+		stages: [
+			{
+				text: "Terminal Dragón",
+				stageId: 23,
+			},
+			{
+				text: "Balneario Aguasal",
+				stageId: 13,
+			},
+			{
+				text: "Pirañalandia",
+				stageId: 11,
+			},
+			{
+				text: "Parque Viaducto",
+				stageId: 24,
+			},
+			{
+				text: "Factoría RAMen",
+				stageId: 21,
+			},
+			{
+				text: "Callejones Crustáceo",
+				stageId: 1,
+			},
+			{
+				text: "Ruinas Ceviche",
+				stageId: 15,
+			},
+			{
+				text: "Spa Cala Bacalao",
+				stageId: 7,
+			},
+			{
+				text: "Complejo Medusa",
+				stageId: 12,
+			},
+			{
+				text: "Puente Salmón",
+				stageId: 5,
+			},
+			{
+				text: "Ultramarinos Orca",
+				stageId: 10,
+			},
+			{
+				text: "Astillero Beluga",
+				stageId: 9,
+			},
+			{
+				text: "Corbeta Corvina",
+				stageId: 14,
+			},
+			{
+				text: "Museo del Pargo",
+				stageId: 6,
+			},
+			{
+				text: "Aeropuerto Marlín",
+				stageId: 22,
+			},
+			{
+				text: "Mina costera",
+				stageId: 20,
+			},
+			{
+				text: "Desguace Mero",
+				stageId: 4,
+			},
+			{
+				text: "Centro Comercial Fletán",
+				stageId: 17,
+			},
+			{
+				text: "Distrito Rascalópodo",
+				stageId: 18,
+			},
+			{
+				text: "Cisterna Navajuela",
+				stageId: 3,
+			},
+			{
+				text: "Carguero Platija",
+				stageId: 19,
+			},
+			{
+				text: "Instituto Coralino",
+				stageId: 8,
+			},
+			{
+				text: "Tiburódromo",
+				stageId: 16,
+			},
+			{
+				text: "Mercado Lenguado",
+				stageId: 2,
+			},
+			{
+				text: "Desfiladero Fumarola",
+				stageId: 0,
+			},
+		],
+	},
+	{
+		lang: "EUfr",
+		modeLabel: "Mode",
+		victory: "Victoire !",
+		defeat: "Défaite...",
+		lobbies: [
+			{
+				text: "Match X",
+				lobby: "X",
+			},
+			{
+				text: "Match anarchie (série)",
+				lobby: "SERIES",
+			},
+			{
+				text: "Match anarchie (ouvert)",
+				lobby: "OPEN",
+			},
+			{
+				text: "Match privé",
+				lobby: "PRIVATE",
+			},
+		],
+		modes: [
+			{
+				text: "Guerre de territoire",
+				mode: "TW",
+			},
+			{
+				text: "Défense de zone",
+				mode: "SZ",
+			},
+			{
+				text: "Expédition risquée",
+				mode: "TC",
+			},
+			{
+				text: "Mission Bazookarpe",
+				mode: "RM",
+			},
+			{
+				text: "Pluie de palourdes",
+				mode: "CB",
+			},
+		],
+		modeWraps: [],
+		stages: [
+			{
+				text: "Gare Aiguillat",
+				stageId: 23,
+			},
+			{
+				text: "Sources Sauret",
+				stageId: 13,
+			},
+			{
+				text: "Parc Carapince",
+				stageId: 11,
+			},
+			{
+				text: "Passage Turbot",
+				stageId: 24,
+			},
+			{
+				text: "Arène Méca-ramen",
+				stageId: 21,
+			},
+			{
+				text: "Banlieue Balibot",
+				stageId: 1,
+			},
+			{
+				text: "Ruines Uma'mi",
+				stageId: 15,
+			},
+			{
+				text: "Club Ca$halot",
+				stageId: 7,
+			},
+			{
+				text: "Lotissement Filament",
+				stageId: 12,
+			},
+			{
+				text: "Pont Esturgeon",
+				stageId: 5,
+			},
+			{
+				text: "Supermarché Cétacé",
+				stageId: 10,
+			},
+			{
+				text: "Chantier Narval",
+				stageId: 9,
+			},
+			{
+				text: "Manta Maria",
+				stageId: 14,
+			},
+			{
+				text: "Galeries Guppy",
+				stageId: 6,
+			},
+			{
+				text: "Terminal Rorqual",
+				stageId: 22,
+			},
+			{
+				text: "Mine marine",
+				stageId: 20,
+			},
+			{
+				text: "Casse Rascasse",
+				stageId: 4,
+			},
+			{
+				text: "Halles de Port-merlu",
+				stageId: 17,
+			},
+			{
+				text: "Quartier Crabe-ciels",
+				stageId: 18,
+			},
+			{
+				text: "Réservoir Rigadelle",
+				stageId: 3,
+			},
+			{
+				text: "Chaland Flétan",
+				stageId: 19,
+			},
+			{
+				text: "Institut Calam'arts",
+				stageId: 8,
+			},
+			{
+				text: "Piste Méroule",
+				stageId: 16,
+			},
+			{
+				text: "Marché Grefin",
+				stageId: 2,
+			},
+			{
+				text: "Canyon aux colonnes",
+				stageId: 0,
+			},
+		],
+	},
+	{
+		lang: "EUit",
+		modeLabel: "Modalità",
+		victory: "Vittoria",
+		defeat: "Sconfitta",
+		lobbies: [
+			{
+				text: "Partita X",
+				lobby: "X",
+			},
+			{
+				text: "Partita anarchica (Serie)",
+				lobby: "SERIES",
+			},
+			{
+				text: "Partita anarchica (Aperta)",
+				lobby: "OPEN",
+			},
+			{
+				text: "Partita privata",
+				lobby: "PRIVATE",
+			},
+		],
+		modes: [
+			{
+				text: "Mischia mollusca",
+				mode: "TW",
+			},
+			{
+				text: "Zona splat",
+				mode: "SZ",
+			},
+			{
+				text: "Torre mobile",
+				mode: "TC",
+			},
+			{
+				text: "Bazookarp",
+				mode: "RM",
+			},
+			{
+				text: "Vongol gol",
+				mode: "CB",
+			},
+		],
+		modeWraps: [],
+		stages: [
+			{
+				text: "Stazione Lemuria",
+				stageId: 23,
+			},
+			{
+				text: "Fermenterme",
+				stageId: 13,
+			},
+			{
+				text: "Soglioland",
+				stageId: 11,
+			},
+			{
+				text: "Periferia urbana",
+				stageId: 24,
+			},
+			{
+				text: "Roboramen",
+				stageId: 21,
+			},
+			{
+				text: "Sobborgo Siluriano",
+				stageId: 1,
+			},
+			{
+				text: "Rovine Salsadipesce",
+				stageId: 15,
+			},
+			{
+				text: "Villanguilla",
+				stageId: 7,
+			},
+			{
+				text: "Cime Sogliolose",
+				stageId: 12,
+			},
+			{
+				text: "Ponte Sgombro",
+				stageId: 5,
+			},
+			{
+				text: "Mercatotano",
+				stageId: 10,
+			},
+			{
+				text: "Cantiere Pinnenere",
+				stageId: 9,
+			},
+			{
+				text: "Manta Maria",
+				stageId: 14,
+			},
+			{
+				text: "Museo di Cefalò",
+				stageId: 6,
+			},
+			{
+				text: "Aeroporto Ondabianca",
+				stageId: 22,
+			},
+			{
+				text: "Molo Mollusco",
+				stageId: 20,
+			},
+			{
+				text: "Discarica Tritatutto",
+				stageId: 4,
+			},
+			{
+				text: "Empolporio",
+				stageId: 17,
+			},
+			{
+				text: "Granchiacieli",
+				stageId: 18,
+			},
+			{
+				text: "Cisterna Cernia",
+				stageId: 3,
+			},
+			{
+				text: "Platessa Trasporti S.r.l.",
+				stageId: 19,
+			},
+			{
+				text: "Campus Hippocampus",
+				stageId: 8,
+			},
+			{
+				text: "Tintodromo Montecarpa",
+				stageId: 16,
+			},
+			{
+				text: "Mercato Fruttato",
+				stageId: 2,
+			},
+			{
+				text: "Grank Canyon",
+				stageId: 0,
+			},
+		],
+	},
+	{
+		lang: "EUnl",
+		modeLabel: "Vechtstijl",
+		victory: "Gewonnen!",
+		defeat: "Verloren...",
+		lobbies: [
+			{
+				text: "X-gevecht",
+				lobby: "X",
+			},
+			{
+				text: "Chaosgevecht (sessie)",
+				lobby: "SERIES",
+			},
+			{
+				text: "Chaosgevecht (open)",
+				lobby: "OPEN",
+			},
+			{
+				text: "Privégevecht",
+				lobby: "PRIVATE",
+			},
+		],
+		modes: [
+			{
+				text: "Grondoorlog",
+				mode: "TW",
+			},
+			{
+				text: "Spetterzone",
+				mode: "SZ",
+			},
+			{
+				text: "Torentwist",
+				mode: "TC",
+			},
+			{
+				text: "Bazookarper",
+				mode: "RM",
+			},
+			{
+				text: "Schelpenstrijd",
+				mode: "CB",
+			},
+		],
+		modeWraps: [
+			{
+				text: "Grond- oorlog",
+				mode: "TW",
+			},
+			{
+				text: "Spetter- zone",
+				mode: "SZ",
+			},
+			{
+				text: "Toren- twist",
+				mode: "TC",
+			},
+			{
+				text: "Bazoo- karper",
+				mode: "RM",
+			},
+			{
+				text: "Schelpen- strijd",
+				mode: "CB",
+			},
+		],
+		stages: [
+			{
+				text: "Lemurië Centraal",
+				stageId: 23,
+			},
+			{
+				text: "Barbeelbaden",
+				stageId: 13,
+			},
+			{
+				text: "Waterwonderland",
+				stageId: 11,
+			},
+			{
+				text: "Knooppunt Kabeljauw",
+				stageId: 24,
+			},
+			{
+				text: "Bami-Byte",
+				stageId: 21,
+			},
+			{
+				text: "Forelviaduct",
+				stageId: 1,
+			},
+			{
+				text: "Ruisvoornruïnes",
+				stageId: 15,
+			},
+			{
+				text: "El Dorade-resort",
+				stageId: 7,
+			},
+			{
+				text: "Baleinbuurt",
+				stageId: 12,
+			},
+			{
+				text: "Brandingbrug",
+				stageId: 5,
+			},
+			{
+				text: "Bultrugbazaar",
+				stageId: 10,
+			},
+			{
+				text: "Walruswerf",
+				stageId: 9,
+			},
+			{
+				text: "Klipvisklipper",
+				stageId: 14,
+			},
+			{
+				text: "Galerie Le Guppy",
+				stageId: 6,
+			},
+			{
+				text: "Trekvis Airport",
+				stageId: 22,
+			},
+			{
+				text: "Blauwvin-depot",
+				stageId: 20,
+			},
+			{
+				text: "Zilversmelt-hoogovens",
+				stageId: 4,
+			},
+			{
+				text: "Winkelcentrum Poon & Zeehaan",
+				stageId: 17,
+			},
+			{
+				text: "Visstickdistrict",
+				stageId: 18,
+			},
+			{
+				text: "Baarsreservoir",
+				stageId: 3,
+			},
+			{
+				text: "Tarbot Transport",
+				stageId: 19,
+			},
+			{
+				text: "Koraalcampus",
+				stageId: 8,
+			},
+			{
+				text: "Lekkerbektrack",
+				stageId: 16,
+			},
+			{
+				text: "Boter-bij-de-vismarkt",
+				stageId: 2,
+			},
+			{
+				text: "Roggentrog",
+				stageId: 0,
+			},
+		],
+	},
+	{
+		lang: "EUru",
+		modeLabel: "Режим",
+		victory: "Успех!",
+		defeat: "Провал",
+		lobbies: [
+			{
+				text: "Бой X",
+				lobby: "X",
+			},
+			{
+				text: "Стихийный бой (серия)",
+				lobby: "SERIES",
+			},
+			{
+				text: "Стихийный бой (открытый)",
+				lobby: "OPEN",
+			},
+			{
+				text: "Частный бой",
+				lobby: "PRIVATE",
+			},
+		],
+		modes: [
+			{
+				text: "Бой за район",
+				mode: "TW",
+			},
+			{
+				text: "Бой за зоны",
+				mode: "SZ",
+			},
+			{
+				text: "Бой за башню",
+				mode: "TC",
+			},
+			{
+				text: "Мегакарп",
+				mode: "RM",
+			},
+			{
+				text: "Устробол",
+				mode: "CB",
+			},
+		],
+		modeWraps: [
+			{
+				text: "Устро- бол",
+				mode: "CB",
+			},
+		],
+		stages: [
+			{
+				text: "Вокзал Лемурия",
+				stageId: 23,
+			},
+			{
+				text: "Тухловодск",
+				stageId: 13,
+			},
+			{
+				text: "Луна-парк «Язь»",
+				stageId: 11,
+			},
+			{
+				text: "Район Дека",
+				stageId: 24,
+			},
+			{
+				text: "«Роборамэн»",
+				stageId: 21,
+			},
+			{
+				text: "Угрево-Скатово",
+				stageId: 1,
+			},
+			{
+				text: "Рыбожирные руины",
+				stageId: 15,
+			},
+			{
+				text: "Спа-курорт «Золотая рыбка»",
+				stageId: 7,
+			},
+			{
+				text: "Микрорайон «Камбалово»",
+				stageId: 12,
+			},
+			{
+				text: "Акулий мост",
+				stageId: 5,
+			},
+			{
+				text: "«Горбуша-Маркет»",
+				stageId: 10,
+			},
+			{
+				text: "Осетровые верфи",
+				stageId: 9,
+			},
+			{
+				text: "«Манта-Мария»",
+				stageId: 14,
+			},
+			{
+				text: "Галерея «Де Берикс»",
+				stageId: 6,
+			},
+			{
+				text: "Аэропорт Пенково",
+				stageId: 22,
+			},
+			{
+				text: "Тунцовое депо",
+				stageId: 20,
+			},
+			{
+				text: "Цех «Тартар»",
+				stageId: 4,
+			},
+			{
+				text: "УсоногТорг",
+				stageId: 17,
+			},
+			{
+				text: "Крабхэттен",
+				stageId: 18,
+			},
+			{
+				text: "Приливослив",
+				stageId: 3,
+			},
+			{
+				text: "«Палтус-карго»",
+				stageId: 19,
+			},
+			{
+				text: "Академия «Лепота»",
+				stageId: 8,
+			},
+			{
+				text: "Велозал «9-й вал»",
+				stageId: 16,
+			},
+			{
+				text: "Рынок «Свисторыб»",
+				stageId: 2,
+			},
+			{
+				text: "Опаленное ущелье",
+				stageId: 0,
+			},
+		],
+	},
+	{
+		lang: "JPja",
+		modeLabel: "ルール",
+		victory: "WIN！",
+		defeat: "LOSE...",
+		lobbies: [
+			{
+				text: "Xマッチ",
+				lobby: "X",
+			},
+			{
+				text: "バンカラマッチ（チャレンジ）",
+				lobby: "SERIES",
+			},
+			{
+				text: "バンカラマッチ（オープン）",
+				lobby: "OPEN",
+			},
+			{
+				text: "プライベートマッチ",
+				lobby: "PRIVATE",
+			},
+		],
+		modes: [
+			{
+				text: "ナワバリバトル",
+				mode: "TW",
+			},
+			{
+				text: "ガチエリア",
+				mode: "SZ",
+			},
+			{
+				text: "ガチヤグラ",
+				mode: "TC",
+			},
+			{
+				text: "ガチホコバトル",
+				mode: "RM",
+			},
+			{
+				text: "ガチアサリ",
+				mode: "CB",
+			},
+		],
+		modeWraps: [],
+		stages: [
+			{
+				text: "リュウグウターミナル",
+				stageId: 23,
+			},
+			{
+				text: "クサヤ温泉",
+				stageId: 13,
+			},
+			{
+				text: "スメーシーワールド",
+				stageId: 11,
+			},
+			{
+				text: "デカライン高架下",
+				stageId: 24,
+			},
+			{
+				text: "バイガイ亭",
+				stageId: 21,
+			},
+			{
+				text: "ゴンズイ地区",
+				stageId: 1,
+			},
+			{
+				text: "ナンプラー遺跡",
+				stageId: 15,
+			},
+			{
+				text: "マヒマヒリゾート＆スパ",
+				stageId: 7,
+			},
+			{
+				text: "ヒラメが丘団地",
+				stageId: 12,
+			},
+			{
+				text: "マサバ海峡大橋",
+				stageId: 5,
+			},
+			{
+				text: "ザトウマーケット",
+				stageId: 10,
+			},
+			{
+				text: "チョウザメ造船",
+				stageId: 9,
+			},
+			{
+				text: "マンタマリア号",
+				stageId: 14,
+			},
+			{
+				text: "キンメダイ美術館",
+				stageId: 6,
+			},
+			{
+				text: "カジキ空港",
+				stageId: 22,
+			},
+			{
+				text: "ネギトロ炭鉱",
+				stageId: 20,
+			},
+			{
+				text: "ナメロウ金属",
+				stageId: 4,
+			},
+			{
+				text: "タラポートショッピングパーク",
+				stageId: 17,
+			},
+			{
+				text: "タカアシ経済特区",
+				stageId: 18,
+			},
+			{
+				text: "マテガイ放水路",
+				stageId: 3,
+			},
+			{
+				text: "オヒョウ海運",
+				stageId: 19,
+			},
+			{
+				text: "海女美術大学",
+				stageId: 8,
+			},
+			{
+				text: "コンブトラック",
+				stageId: 16,
+			},
+			{
+				text: "ヤガラ市場",
+				stageId: 2,
+			},
+			{
+				text: "ユノハナ大渓谷",
+				stageId: 0,
+			},
+		],
+	},
+	{
+		lang: "KRko",
+		modeLabel: "룰",
+		victory: "WIN!",
+		defeat: "LOSE…",
+		lobbies: [
+			{
+				text: "X 매치",
+				lobby: "X",
+			},
+			{
+				text: "카오폴리스 매치(챌린지)",
+				lobby: "SERIES",
+			},
+			{
+				text: "카오폴리스 매치(오픈)",
+				lobby: "OPEN",
+			},
+			{
+				text: "프라이빗 매치",
+				lobby: "PRIVATE",
+			},
+		],
+		modes: [
+			{
+				text: "영역 배틀",
+				mode: "TW",
+			},
+			{
+				text: "랭크 에어리어",
+				mode: "SZ",
+			},
+			{
+				text: "랭크 타워",
+				mode: "TC",
+			},
+			{
+				text: "랭크 피시 배틀",
+				mode: "RM",
+			},
+			{
+				text: "랭크 바지락",
+				mode: "CB",
+			},
+		],
+		modeWraps: [],
+		stages: [
+			{
+				text: "용궁 터미널",
+				stageId: 23,
+			},
+			{
+				text: "과메기 온천",
+				stageId: 13,
+			},
+			{
+				text: "초밥 월드",
+				stageId: 11,
+			},
+			{
+				text: "데카 라인 고가 밑",
+				stageId: 24,
+			},
+			{
+				text: "수랑정",
+				stageId: 21,
+			},
+			{
+				text: "메기 지구",
+				stageId: 1,
+			},
+			{
+				text: "남플라 유적",
+				stageId: 15,
+			},
+			{
+				text: "만새기 리조트＆스파",
+				stageId: 7,
+			},
+			{
+				text: "넙치 언덕 단지",
+				stageId: 12,
+			},
+			{
+				text: "고등어 해협 대교",
+				stageId: 5,
+			},
+			{
+				text: "혹등 마켓",
+				stageId: 10,
+			},
+			{
+				text: "철갑상어 조선소",
+				stageId: 9,
+			},
+			{
+				text: "만타 마리아호",
+				stageId: 14,
+			},
+			{
+				text: "도미 미술관",
+				stageId: 6,
+			},
+			{
+				text: "청새치 공항",
+				stageId: 22,
+			},
+			{
+				text: "참치 탄광",
+				stageId: 20,
+			},
+			{
+				text: "나메로우 금속",
+				stageId: 4,
+			},
+			{
+				text: "대구 포트 쇼핑 파크",
+				stageId: 17,
+			},
+			{
+				text: "거미게 경제특구",
+				stageId: 18,
+			},
+			{
+				text: "맛조개 방수로",
+				stageId: 3,
+			},
+			{
+				text: "광어 해운",
+				stageId: 19,
+			},
+			{
+				text: "해녀 미술 대학",
+				stageId: 8,
+			},
+			{
+				text: "다시마 트랙",
+				stageId: 16,
+			},
+			{
+				text: "대치 시장",
+				stageId: 2,
+			},
+			{
+				text: "석순 대협곡",
+				stageId: 0,
+			},
+		],
+	},
+	{
+		lang: "TWzh",
+		modeLabel: "規則",
+		victory: "WIN！",
+		defeat: "LOSE……",
+		lobbies: [
+			{
+				text: "X比賽",
+				lobby: "X",
+			},
+			{
+				text: "蠻頹比賽（挑戰）",
+				lobby: "SERIES",
+			},
+			{
+				text: "蠻頹比賽（開放）",
+				lobby: "OPEN",
+			},
+			{
+				text: "私人比賽",
+				lobby: "PRIVATE",
+			},
+		],
+		modes: [
+			{
+				text: "占地對戰",
+				mode: "TW",
+			},
+			{
+				text: "真格區域",
+				mode: "SZ",
+			},
+			{
+				text: "真格塔樓",
+				mode: "TC",
+			},
+			{
+				text: "真格魚虎對戰",
+				mode: "RM",
+			},
+			{
+				text: "真格蛤蜊",
+				mode: "CB",
+			},
+		],
+		modeWraps: [],
+		stages: [
+			{
+				text: "龍宮轉運站",
+				stageId: 23,
+			},
+			{
+				text: "臭魚乾溫泉",
+				stageId: 13,
+			},
+			{
+				text: "醋飯海洋世界",
+				stageId: 11,
+			},
+			{
+				text: "十路通高架橋下",
+				stageId: 24,
+			},
+			{
+				text: "貝見亭",
+				stageId: 21,
+			},
+			{
+				text: "鰻鯰區",
+				stageId: 1,
+			},
+			{
+				text: "魚露遺跡",
+				stageId: 15,
+			},
+			{
+				text: "鬼頭刀SPA度假區",
+				stageId: 7,
+			},
+			{
+				text: "比目魚住宅區",
+				stageId: 12,
+			},
+			{
+				text: "真鯖跨海大橋",
+				stageId: 5,
+			},
+			{
+				text: "座頭購物中心",
+				stageId: 10,
+			},
+			{
+				text: "鱘魚造船廠",
+				stageId: 9,
+			},
+			{
+				text: "鬼蝠魟瑪利亞號",
+				stageId: 14,
+			},
+			{
+				text: "金眼鯛美術館",
+				stageId: 6,
+			},
+			{
+				text: "旗魚機場",
+				stageId: 22,
+			},
+			{
+				text: "蔥鮪魚煤礦場",
+				stageId: 20,
+			},
+			{
+				text: "魚肉碎金屬",
+				stageId: 4,
+			},
+			{
+				text: "塔拉波特購物公園",
+				stageId: 17,
+			},
+			{
+				text: "高腳經濟特區",
+				stageId: 18,
+			},
+			{
+				text: "竹蟶疏洪道",
+				stageId: 3,
+			},
+			{
+				text: "大比目魚海運中心",
+				stageId: 19,
+			},
+			{
+				text: "海女美術大學",
+				stageId: 8,
+			},
+			{
+				text: "昆布賽道",
+				stageId: 16,
+			},
+			{
+				text: "煙管魚市場",
+				stageId: 2,
+			},
+			{
+				text: "溫泉花大峽谷",
+				stageId: 0,
+			},
+		],
+	},
+	{
+		lang: "USen",
+		modeLabel: "Mode",
+		victory: "VICTORY",
+		defeat: "DEFEAT",
+		lobbies: [
+			{
+				text: "X Battle",
+				lobby: "X",
+			},
+			{
+				text: "Anarchy Battle (Series)",
+				lobby: "SERIES",
+			},
+			{
+				text: "Anarchy Battle (Open)",
+				lobby: "OPEN",
+			},
+			{
+				text: "Private Battle",
+				lobby: "PRIVATE",
+			},
+		],
+		modes: [
+			{
+				text: "Turf War",
+				mode: "TW",
+			},
+			{
+				text: "Splat Zones",
+				mode: "SZ",
+			},
+			{
+				text: "Tower Control",
+				mode: "TC",
+			},
+			{
+				text: "Rainmaker",
+				mode: "RM",
+			},
+			{
+				text: "Clam Blitz",
+				mode: "CB",
+			},
+		],
+		modeWraps: [],
+		stages: [
+			{
+				text: "Lemuria Hub",
+				stageId: 23,
+			},
+			{
+				text: "Brinewater Springs",
+				stageId: 13,
+			},
+			{
+				text: "Wahoo World",
+				stageId: 11,
+			},
+			{
+				text: "Urchin Underpass",
+				stageId: 24,
+			},
+			{
+				text: "Robo ROM-en",
+				stageId: 21,
+			},
+			{
+				text: "Eeltail Alley",
+				stageId: 1,
+			},
+			{
+				text: "Um'ami Ruins",
+				stageId: 15,
+			},
+			{
+				text: "Mahi-Mahi Resort",
+				stageId: 7,
+			},
+			{
+				text: "Flounder Heights",
+				stageId: 12,
+			},
+			{
+				text: "Hammerhead Bridge",
+				stageId: 5,
+			},
+			{
+				text: "MakoMart",
+				stageId: 10,
+			},
+			{
+				text: "Sturgeon Shipyard",
+				stageId: 9,
+			},
+			{
+				text: "Manta Maria",
+				stageId: 14,
+			},
+			{
+				text: "Museum d'Alfonsino",
+				stageId: 6,
+			},
+			{
+				text: "Marlin Airport",
+				stageId: 22,
+			},
+			{
+				text: "Bluefin Depot",
+				stageId: 20,
+			},
+			{
+				text: "Mincemeat Metalworks",
+				stageId: 4,
+			},
+			{
+				text: "Barnacle & Dime",
+				stageId: 17,
+			},
+			{
+				text: "Crableg Capital",
+				stageId: 18,
+			},
+			{
+				text: "Undertow Spillway",
+				stageId: 3,
+			},
+			{
+				text: "Shipshape Cargo Co.",
+				stageId: 19,
+			},
+			{
+				text: "Inkblot Art Academy",
+				stageId: 8,
+			},
+			{
+				text: "Humpback Pump Track",
+				stageId: 16,
+			},
+			{
+				text: "Hagglefish Market",
+				stageId: 2,
+			},
+			{
+				text: "Scorch Gorge",
+				stageId: 0,
+			},
+		],
+	},
+	{
+		lang: "USes",
+		modeLabel: "Estilo",
+		victory: "¡Victoria!",
+		defeat: "Derrota",
+		lobbies: [
+			{
+				text: "Combate X",
+				lobby: "X",
+			},
+			{
+				text: "Combate caótico (formal)",
+				lobby: "SERIES",
+			},
+			{
+				text: "Combate caótico (informal)",
+				lobby: "OPEN",
+			},
+			{
+				text: "Combate privado",
+				lobby: "PRIVATE",
+			},
+		],
+		modes: [
+			{
+				text: "Territorial",
+				mode: "TW",
+			},
+			{
+				text: "Pintazonas",
+				mode: "SZ",
+			},
+			{
+				text: "Torreón",
+				mode: "TC",
+			},
+			{
+				text: "Pez dorado",
+				mode: "RM",
+			},
+			{
+				text: "Asalto almeja",
+				mode: "CB",
+			},
+		],
+		modeWraps: [],
+		stages: [
+			{
+				text: "Terminal Dragón",
+				stageId: 23,
+			},
+			{
+				text: "Balneario Aguasal",
+				stageId: 13,
+			},
+			{
+				text: "Pirañalandia",
+				stageId: 11,
+			},
+			{
+				text: "Parque Viaducto",
+				stageId: 24,
+			},
+			{
+				text: "Factoría RAMen",
+				stageId: 21,
+			},
+			{
+				text: "Callejones Crustáceo",
+				stageId: 1,
+			},
+			{
+				text: "Ruinas Ceviche",
+				stageId: 15,
+			},
+			{
+				text: "Spa Cala Bacalao",
+				stageId: 7,
+			},
+			{
+				text: "Complejo Medusa",
+				stageId: 12,
+			},
+			{
+				text: "Puente Salmón",
+				stageId: 5,
+			},
+			{
+				text: "Ultramarinos Orca",
+				stageId: 10,
+			},
+			{
+				text: "Astillero Beluga",
+				stageId: 9,
+			},
+			{
+				text: "Corbeta Corvina",
+				stageId: 14,
+			},
+			{
+				text: "Museo del Pargo",
+				stageId: 6,
+			},
+			{
+				text: "Aeropuerto Marlín",
+				stageId: 22,
+			},
+			{
+				text: "Mina costera",
+				stageId: 20,
+			},
+			{
+				text: "Desguace Mero",
+				stageId: 4,
+			},
+			{
+				text: "Unicentro Carite",
+				stageId: 17,
+			},
+			{
+				text: "Distrito Rascalópodo",
+				stageId: 18,
+			},
+			{
+				text: "Desagüe Navajuela",
+				stageId: 3,
+			},
+			{
+				text: "Carguero Platija",
+				stageId: 19,
+			},
+			{
+				text: "Instituto Coralino",
+				stageId: 8,
+			},
+			{
+				text: "Tiburódromo",
+				stageId: 16,
+			},
+			{
+				text: "Mercado Lenguado",
+				stageId: 2,
+			},
+			{
+				text: "Desfiladero Fumarola",
+				stageId: 0,
+			},
+		],
+	},
+	{
+		lang: "USfr",
+		modeLabel: "Mode",
+		victory: "Victoire!",
+		defeat: "Défaite...",
+		lobbies: [
+			{
+				text: "Match X",
+				lobby: "X",
+			},
+			{
+				text: "Match anarchie (série)",
+				lobby: "SERIES",
+			},
+			{
+				text: "Match anarchie (ouvert)",
+				lobby: "OPEN",
+			},
+			{
+				text: "Match privé",
+				lobby: "PRIVATE",
+			},
+		],
+		modes: [
+			{
+				text: "Guerre de territoire",
+				mode: "TW",
+			},
+			{
+				text: "Défense de zone",
+				mode: "SZ",
+			},
+			{
+				text: "Expédition risquée",
+				mode: "TC",
+			},
+			{
+				text: "Mission Bazookarpe",
+				mode: "RM",
+			},
+			{
+				text: "Pluie de palourdes",
+				mode: "CB",
+			},
+		],
+		modeWraps: [],
+		stages: [
+			{
+				text: "Gare Aiguillat",
+				stageId: 23,
+			},
+			{
+				text: "Sources Sauret",
+				stageId: 13,
+			},
+			{
+				text: "Parc Carapince",
+				stageId: 11,
+			},
+			{
+				text: "Passage Turbot",
+				stageId: 24,
+			},
+			{
+				text: "Arène Méca-ramen",
+				stageId: 21,
+			},
+			{
+				text: "Banlieue Balibot",
+				stageId: 1,
+			},
+			{
+				text: "Ruines Uma'mi",
+				stageId: 15,
+			},
+			{
+				text: "Spa C-ta-C",
+				stageId: 7,
+			},
+			{
+				text: "Appartements Filament",
+				stageId: 12,
+			},
+			{
+				text: "Pont Esturgeon",
+				stageId: 5,
+			},
+			{
+				text: "Supermarché Cétacé",
+				stageId: 10,
+			},
+			{
+				text: "Chantier Narval",
+				stageId: 9,
+			},
+			{
+				text: "Manta Maria",
+				stageId: 14,
+			},
+			{
+				text: "Galeries Guppy",
+				stageId: 6,
+			},
+			{
+				text: "Terminal Rorqual",
+				stageId: 22,
+			},
+			{
+				text: "Mine marine",
+				stageId: 20,
+			},
+			{
+				text: "Casse Rascasse",
+				stageId: 4,
+			},
+			{
+				text: "Halles de Port-merlu",
+				stageId: 17,
+			},
+			{
+				text: "Quartier Crabe-ciels",
+				stageId: 18,
+			},
+			{
+				text: "Réservoir Rigadelle",
+				stageId: 3,
+			},
+			{
+				text: "Cargo Flétan",
+				stageId: 19,
+			},
+			{
+				text: "Institut Calm'arts",
+				stageId: 8,
+			},
+			{
+				text: "Piste Méroule",
+				stageId: 16,
+			},
+			{
+				text: "Marché Grefin",
+				stageId: 2,
+			},
+			{
+				text: "Canyon aux colonnes",
+				stageId: 0,
+			},
+		],
+	},
+];
diff --git a/app/features/scanner/core/localized.ts b/app/features/scanner/core/localized.ts
new file mode 100644
index 000000000..df2f1ac80
--- /dev/null
+++ b/app/features/scanner/core/localized.ts
@@ -0,0 +1,104 @@
+/**
+ * Flattened localized match sets derived from the generated
+ * localized-entries.ts: detectors snap OCR output against every language's
+ * strings at once and report the sendou.ink id, so ingestion works no
+ * matter which language the player runs the game in. Combos (mode+stage,
+ * lobby+mode) stay within one language — on-screen text never mixes
+ * languages — which keeps the cross product from inventing pairings no UI
+ * would show.
+ */
+import type { ModeShort, StageId } from "~/modules/in-game-lists/types";
+import type { ScannerLobby } from "../scanner-types";
+import {
+	LANGUAGE_ENTRIES,
+	type LocalizedLobby,
+	type LocalizedMode,
+	type LocalizedStage,
+} from "./localized-entries";
+import { matchKey } from "./text";
+
+function dedupe<T>(items: T[], keyOf: (item: T) => string): T[] {
+	const seen = new Set<string>();
+	return items.filter((item) => {
+		const k = keyOf(item);
+		if (seen.has(k)) return false;
+		seen.add(k);
+		return true;
+	});
+}
+
+const byText = (e: { text: string }) => matchKey(e.text);
+
+export const ALL_LOBBY_ENTRIES: readonly LocalizedLobby[] = dedupe(
+	LANGUAGE_ENTRIES.flatMap((l) => l.lobbies),
+	byText,
+);
+
+/** Single-line mode names plus the intro splash's two-line wrap variants. */
+export const ALL_MODE_ENTRIES: readonly LocalizedMode[] = dedupe(
+	LANGUAGE_ENTRIES.flatMap((l) => [...l.modes, ...l.modeWraps]),
+	byText,
+);
+
+export const ALL_STAGE_ENTRIES: readonly LocalizedStage[] = dedupe(
+	LANGUAGE_ENTRIES.flatMap((l) => l.stages),
+	byText,
+);
+
+/** Every language's constant "MODE" intro-splash label. */
+export const ALL_MODE_LABELS: readonly string[] = dedupe(
+	LANGUAGE_ENTRIES.map((l) => l.modeLabel),
+	matchKey,
+);
+
+/** Replay-browser panel tags; canonical is "VICTORY" or "DEFEAT". */
+export const RESULT_TAG_ENTRIES: readonly {
+	text: string;
+	canonical: string;
+}[] = dedupe(
+	LANGUAGE_ENTRIES.flatMap((l) => [
+		{ text: l.victory, canonical: "VICTORY" },
+		{ text: l.defeat, canonical: "DEFEAT" },
+	]),
+	byText,
+);
+
+export interface ModeStageCombo {
+	text: string;
+	mode: ModeShort;
+	stageId: StageId;
+}
+
+/** The scoreboard header's "<mode> <stage>" line, per language. */
+export const MODE_STAGE_COMBOS: readonly ModeStageCombo[] = dedupe(
+	LANGUAGE_ENTRIES.flatMap((l) =>
+		l.modes.flatMap((mode) =>
+			l.stages.map((stage) => ({
+				text: `${mode.text} ${stage.text}`,
+				mode: mode.mode,
+				stageId: stage.stageId,
+			})),
+		),
+	),
+	byText,
+);
+
+export interface LobbyModeCombo {
+	text: string;
+	lobby: ScannerLobby;
+	mode: ModeShort;
+}
+
+/** The replay-browser header's "<lobby> <mode>" line, per language. */
+export const LOBBY_MODE_COMBOS: readonly LobbyModeCombo[] = dedupe(
+	LANGUAGE_ENTRIES.flatMap((l) =>
+		l.lobbies.flatMap((lobby) =>
+			l.modes.map((mode) => ({
+				text: `${lobby.text} ${mode.text}`,
+				lobby: lobby.lobby,
+				mode: mode.mode,
+			})),
+		),
+	),
+	byText,
+);
diff --git a/app/features/scanner/core/match-builder.ts b/app/features/scanner/core/match-builder.ts
new file mode 100644
index 000000000..10f4f1776
--- /dev/null
+++ b/app/features/scanner/core/match-builder.ts
@@ -0,0 +1,541 @@
+/**
+ * Groups a detected-event timeline into ScannerMatch objects
+ * (scanner-match.ts). A MapStart opens a match, a scoreboard-type event
+ * closes one, and deaths in between belong to it; a scoreboard with no
+ * preceding MapStart claims the last 8 minutes of deaths. Between delimiters
+ * (casted footage has none) minimaps group per map by stage change and time
+ * gap, since a Splatoon game runs a few minutes. A match is emitted only
+ * when a scoreboard or minimaps back it (a MapStart with a missed results
+ * screen identifies nothing), regardless of lobby/outcome —
+ * `ingestSkipReasons` filters those. Deaths are harvested onto player rows
+ * as enemy builds (ability-harvest.ts).
+ */
+import type { MainWeaponId, StageId } from "~/modules/in-game-lists/types";
+import { harvestAbilities } from "./ability-harvest";
+import { DEATH_EVENT_TYPE, type DeathData } from "./detectors/death/index";
+import {
+	MAP_START_EVENT_TYPE,
+	type MapStartData,
+} from "./detectors/map-start/index";
+import {
+	MINIMAP_EVENT_TYPE,
+	type MinimapData,
+} from "./detectors/minimap/index";
+import {
+	OBJECTIVE_EVENT_TYPE,
+	type ObjectiveData,
+} from "./detectors/objective/index";
+import { SCOREBOARD_EVENT_TYPES } from "./detectors/registry";
+import type { ScoreboardData } from "./detectors/scoreboard/index";
+import {
+	SCOREBOARD_BATTLE_LOG_EVENT_TYPE,
+	type ScoreboardBattleLogData,
+} from "./detectors/scoreboard-battle-log/index";
+import {
+	SCOREBOARD_BATTLE_LOG_REPLAY_EVENT_TYPE,
+	type ScoreboardBattleLogReplayData,
+} from "./detectors/scoreboard-battle-log-replay/index";
+import type { DetectedEvent } from "./detectors/types";
+import { parseReplayTimestamp } from "./replay-time";
+import type {
+	ScannerMatch,
+	ScannerMatchObjective,
+	ScannerMatchObjectiveSample,
+	ScannerMatchPlayer,
+	ScannerMatchTeam,
+} from "./scanner-match";
+
+/** The lobby header value private battles (tournament games) carry. */
+const TOURNAMENT_LOBBY = "PRIVATE";
+
+/**
+ * How far back a scoreboard with no preceding MapStart claims deaths as its
+ * match — matches run well under 8 minutes, so anything older is another
+ * (undelimited) match's.
+ */
+const FALLBACK_WINDOW_SECONDS = 480;
+
+/**
+ * Two minimaps more than this far apart cannot be the same game, so they
+ * open separate matches even on the same stage.
+ */
+const MATCH_GAP_SECONDS = 300;
+
+const PLAYERS_PER_TEAM = 4;
+
+/**
+ * Slack the ended-early check gives a match before calling it a disconnect:
+ * a counter read is a snapshot of numbers that keep moving, and the results
+ * screen is only read some seconds after the last whistle.
+ */
+const EARLY_END_MARGIN_SECONDS = 10;
+
+export interface BuiltMatch<E extends DetectedEvent> {
+	match: ScannerMatch;
+	/**
+	 * the input events the match was built from, chronological — the
+	 * send-status unit for callers with richer event records (StoredEvent)
+	 */
+	sources: E[];
+}
+
+/**
+ * Splits a timeline into ScannerMatch objects, chronological. Event types
+ * that identify no match (ScoreboardOwn) are ignored. Every input event ends
+ * up in at most one match's `sources` — orphan pools are cleared the moment
+ * a boundary claims or invalidates them.
+ */
+export function buildScannerMatches<E extends DetectedEvent>(
+	events: readonly E[],
+): BuiltMatch<E>[] {
+	const sorted = events.toSorted((a, b) => a.t - b.t);
+	const built: BuiltMatch<E>[] = [];
+	const nextStage = buildNextStageMap(sorted);
+
+	let open: OpenMatch<E> | null = null;
+	// deaths/objective reads seen with no match open to anchor them yet
+	let orphanDeaths: E[] = [];
+	let orphanObjectives: E[] = [];
+	const finalize = (): void => {
+		if (!open) return;
+		if (open.scoreboard || open.minimaps.length > 0) {
+			built.push(toBuiltMatch(open));
+		}
+		open = null;
+	};
+
+	for (const event of sorted) {
+		if (event.type === MAP_START_EVENT_TYPE) {
+			// a new match intro abandons any match whose scoreboard was missed
+			finalize();
+			open = startMatch();
+			open.mapStart = event;
+			vote(open.stageVotes, (event.data as MapStartData).stage);
+			orphanDeaths = [];
+			orphanObjectives = [];
+		} else if (SCOREBOARD_EVENT_TYPES.includes(event.type)) {
+			if (!open) {
+				open = startMatch();
+				open.deaths = orphanDeaths.filter(
+					(death) => event.t - death.t <= FALLBACK_WINDOW_SECONDS,
+				);
+				open.objectives = orphanObjectives.filter(
+					(objective) => event.t - objective.t <= FALLBACK_WINDOW_SECONDS,
+				);
+			}
+			open.scoreboard = event;
+			vote(open.stageVotes, (event.data as ScoreboardData).stage);
+			finalize();
+			orphanDeaths = [];
+			orphanObjectives = [];
+		} else if (event.type === MINIMAP_EVENT_TYPE) {
+			const stage = (event.data as MinimapData).stage;
+			if (open) {
+				// a stage change only splits when the next read doesn't refute
+				// it: a lone disagreeing frame is a misread to fold in as a
+				// minority vote, not a match boundary
+				const current = leadingStage(open.stageVotes);
+				const stageChanged =
+					current !== null &&
+					stage !== null &&
+					stage !== current &&
+					(nextStage.get(event) ?? stage) === stage;
+				const gapTooBig =
+					open.lastMinimapT !== null &&
+					event.t - open.lastMinimapT > MATCH_GAP_SECONDS;
+				if (stageChanged || gapTooBig) finalize();
+			}
+			open ??= startMatch();
+			open.minimaps.push(event);
+			open.lastMinimapT = event.t;
+			vote(open.stageVotes, stage);
+		} else if (event.type === DEATH_EVENT_TYPE) {
+			(open?.deaths ?? orphanDeaths).push(event);
+		} else if (event.type === OBJECTIVE_EVENT_TYPE) {
+			(open?.objectives ?? orphanObjectives).push(event);
+		}
+	}
+	finalize();
+
+	return built;
+}
+
+/** Why a built match is held back from /ingest; absent = it is sent. */
+export type IngestSkipReason =
+	/** not a tournament (Private Battle) game */
+	| "lobby"
+	/** a disconnect ended it before it could be decided */
+	| "disconnect";
+
+/**
+ * Which built matches are not worth sending to /ingest, and why. Kept out:
+ * non-tournament lobbies (unread lobbies get the benefit of the doubt), and
+ * games a disconnect cut short — proven either by counter reads showing the
+ * game couldn't have ended on its own (see `endedEarly`), or by the same
+ * map/mode being replayed right after with a score. Replay evidence only
+ * ever arrives after the fact, so a live scan may already have sent the
+ * abandoned game before its replay is detected; the counter-read check is
+ * what catches it in the moment.
+ */
+export function ingestSkipReasons<E extends DetectedEvent>(
+	built: readonly BuiltMatch<E>[],
+): Map<BuiltMatch<E>, IngestSkipReason> {
+	const reasons = new Map<BuiltMatch<E>, IngestSkipReason>();
+	for (const [index, candidate] of built.entries()) {
+		const { match } = candidate;
+		if (match.lobby !== null && match.lobby !== TOURNAMENT_LOBBY) {
+			reasons.set(candidate, "lobby");
+		} else if (endedEarly(match) || wasReplayed(built, index)) {
+			reasons.set(candidate, "disconnect");
+		}
+	}
+	return reasons;
+}
+
+/**
+ * Objective-counter reads that landed on a match whose detected mode is not
+ * Splat Zones — the SZ parser (the only one so far) misreading another
+ * mode's counter overlay. The builder already leaves such a match's
+ * `objective` null; callers should delete these events from their stores.
+ */
+export function invalidObjectiveEvents<E extends DetectedEvent>(
+	built: readonly BuiltMatch<E>[],
+): E[] {
+	return built
+		.filter((b) => b.match.mode !== null && b.match.mode !== "SZ")
+		.flatMap((b) =>
+			b.sources.filter((event) => event.type === OBJECTIVE_EVENT_TYPE),
+		);
+}
+
+/**
+ * Whether a disconnect ended the match before it could be decided: it has a
+ * results screen but no score on it, and its last counter read still needed
+ * more game left than the footage gave it. From that read a game can end no
+ * sooner than the clock running out, or the lower counter falling to zero at
+ * its 1/s cap (a knockout) with any penalty worked off first — so when even
+ * that came due after the match was already over, it was cut short.
+ */
+function endedEarly(match: ScannerMatch): boolean {
+	// no results screen at all: an unfinished scan, not an unfinished game
+	if (match.winner === null) return false;
+	if (match.matchScores !== null) return false;
+	const lastSample = match.objective?.samples.at(-1);
+	if (!lastSample || match.endsAt === null) return false;
+
+	const soonestEnd = secondsUntilSoonestEnd(lastSample);
+	if (soonestEnd === null) return false;
+
+	const secondsLeftInFootage = match.endsAt - lastSample.t;
+	return soonestEnd - secondsLeftInFootage > EARLY_END_MARGIN_SECONDS;
+}
+
+function secondsUntilSoonestEnd(
+	sample: ScannerMatchObjectiveSample,
+): number | null {
+	const knockouts = sample.score.map((score, team) =>
+		score === null ? null : score + (sample.penalty[team] ?? 0),
+	);
+	const seconds = [sample.time, ...knockouts].filter(
+		(value): value is number => value !== null,
+	);
+	return seconds.length > 0 ? Math.min(...seconds) : null;
+}
+
+/**
+ * Whether the scoreless match at `index` was played again right after: the
+ * run of matches following it on the same mode and stage is the same game
+ * restarted, so one of them reaching a score means the earlier attempts
+ * ended in a disconnect. The run stops at the first other map, which keeps
+ * the same map coming up again later in the scan out of it.
+ */
+function wasReplayed<E extends DetectedEvent>(
+	built: readonly BuiltMatch<E>[],
+	index: number,
+): boolean {
+	const { match } = built[index]!;
+	if (match.matchScores !== null) return false;
+	if (match.mode === null || match.stage === null) return false;
+
+	for (const later of built.slice(index + 1)) {
+		if (later.match.mode !== match.mode || later.match.stage !== match.stage) {
+			return false;
+		}
+		if (later.match.matchScores !== null) return true;
+	}
+	return false;
+}
+
+/** A match being accumulated as the timeline is walked. */
+interface OpenMatch<E extends DetectedEvent> {
+	mapStart: E | null;
+	minimaps: E[];
+	deaths: E[];
+	/** objective-counter reads; become the match's `objective` samples */
+	objectives: E[];
+	scoreboard: E | null;
+	/**
+	 * per-stage read counts (a MapStart's stage seeds it); the plurality
+	 * winner delimits same-vs-next map so one misread frame can't poison
+	 * the whole match
+	 */
+	stageVotes: Map<StageId, number>;
+	/** t of the last minimap added, for the gap check */
+	lastMinimapT: number | null;
+}
+
+function startMatch<E extends DetectedEvent>(): OpenMatch<E> {
+	return {
+		mapStart: null,
+		minimaps: [],
+		deaths: [],
+		objectives: [],
+		scoreboard: null,
+		stageVotes: new Map(),
+		lastMinimapT: null,
+	};
+}
+
+/**
+ * For each minimap event, the next minimap's non-null stage read (walked
+ * backwards) — the refutation signal for the stage-change split.
+ */
+function buildNextStageMap<E extends DetectedEvent>(
+	sorted: readonly E[],
+): Map<E, StageId | null> {
+	const nextStage = new Map<E, StageId | null>();
+	let carry: StageId | null = null;
+	for (let i = sorted.length - 1; i >= 0; i--) {
+		const event = sorted[i]!;
+		if (event.type !== MINIMAP_EVENT_TYPE) continue;
+		nextStage.set(event, carry);
+		carry = (event.data as MinimapData).stage ?? carry;
+	}
+	return nextStage;
+}
+
+function vote(votes: Map<StageId, number>, stage: StageId | null): void {
+	if (stage !== null) votes.set(stage, (votes.get(stage) ?? 0) + 1);
+}
+
+/** Plurality stage of the reads so far; insertion order breaks ties. */
+function leadingStage(votes: Map<StageId, number>): StageId | null {
+	let winner: StageId | null = null;
+	let best = 0;
+	for (const [stage, count] of votes) {
+		if (count > best) {
+			winner = stage;
+			best = count;
+		}
+	}
+	return winner;
+}
+
+function toBuiltMatch<E extends DetectedEvent>(
+	open: OpenMatch<E>,
+): BuiltMatch<E> {
+	const sources = [
+		...(open.mapStart ? [open.mapStart] : []),
+		...open.minimaps,
+		...open.deaths,
+		...open.objectives,
+		...(open.scoreboard ? [open.scoreboard] : []),
+	].sort((a, b) => a.t - b.t);
+
+	const board = open.scoreboard?.data as ScoreboardData | undefined;
+	const start = open.mapStart?.data as MapStartData | undefined;
+	// the replay-browser and battle log screens both carry the recording
+	// timestamp; only the former a replay code
+	const timestamped =
+		open.scoreboard?.type === SCOREBOARD_BATTLE_LOG_REPLAY_EVENT_TYPE ||
+		open.scoreboard?.type === SCOREBOARD_BATTLE_LOG_EVENT_TYPE
+			? (open.scoreboard.data as ScoreboardBattleLogData &
+					Partial<ScoreboardBattleLogReplayData>)
+			: undefined;
+	const deaths = open.deaths.map((event) => event.data as DeathData);
+	const objectives = open.objectives.map((event) => ({
+		t: event.t,
+		data: event.data as ObjectiveData,
+	}));
+
+	const mode = board?.mode ?? start?.mode ?? null;
+
+	const match: ScannerMatch = {
+		startsAt:
+			sources.length > 0 ? Math.max(0, Math.floor(sources[0]!.t)) : null,
+		endsAt: floorOrNull(open.scoreboard?.t ?? open.minimaps.at(-1)?.t),
+		playedAt: playedAt(open.scoreboard, timestamped),
+		lobby: board?.lobby ?? null,
+		mode,
+		stage: board?.stage ?? start?.stage ?? leadingStage(open.stageVotes),
+		matchScores: board?.matchScores.some((score) => score !== null)
+			? board.matchScores
+			: null,
+		replayCode: timestamped?.replayCode ?? null,
+		cast: open.minimaps.some((event) => (event.data as MinimapData).spectator),
+		// only the SZ counter is parsed — reads on a known other-mode match
+		// are misreads of a lookalike overlay, not progress data
+		objective:
+			mode === null || mode === "SZ" ? buildObjective(objectives, board) : null,
+		teams: board
+			? teamsFromScoreboard(board, deaths)
+			: teamsFromMinimaps(
+					open.minimaps.map((event) => event.data as MinimapData),
+					deaths,
+				),
+		winner: board ? 0 : null,
+		pov:
+			board && board.povIndex !== null
+				? {
+						team: board.povIndex < PLAYERS_PER_TEAM ? 0 : 1,
+						index: board.povIndex % PLAYERS_PER_TEAM,
+					}
+				: null,
+	};
+
+	return { match, sources };
+}
+
+function floorOrNull(t: number | undefined): number | null {
+	return t === undefined ? null : Math.max(0, Math.floor(t));
+}
+
+/**
+ * The counter reads as `objective` samples in `teams` order. The on-screen
+ * plates put the POV/alpha side left, which already is teams[0] for a
+ * minimap-grouped match; a scoreboard-closed match's teams are winner-first,
+ * so the sides swap when the POV seat sat on the losing team — or, with no
+ * POV arrow read, when the right plate's count got lower (in SZ the winner
+ * is the team whose remaining count went furthest down; ties keep the order
+ * as read).
+ */
+function buildObjective(
+	objectives: readonly { t: number; data: ObjectiveData }[],
+	board: ScoreboardData | undefined,
+): ScannerMatchObjective | null {
+	if (objectives.length === 0) return null;
+	const swap = board
+		? board.povIndex !== null
+			? board.povIndex >= PLAYERS_PER_TEAM
+			: bestCount(objectives, 1) < bestCount(objectives, 0)
+		: false;
+	const samples = objectives.map(({ t, data }): ScannerMatchObjectiveSample => {
+		const [a, b] = swap ? ([1, 0] as const) : ([0, 1] as const);
+		return {
+			t: Math.max(0, Math.floor(t)),
+			time: data.time,
+			score: [data.score[a], data.score[b]],
+			penalty: [data.penalty[a], data.penalty[b]],
+			control: [data.control[a], data.control[b]],
+		};
+	});
+	return { mode: "SZ", samples };
+}
+
+/** The lowest count a side's plate ever showed; Infinity when never read. */
+function bestCount(
+	objectives: readonly { data: ObjectiveData }[],
+	side: 0 | 1,
+): number {
+	return Math.min(
+		...objectives.map(
+			({ data }) => data.score[side] ?? Number.POSITIVE_INFINITY,
+		),
+	);
+}
+
+/**
+ * The wall-clock time the match was played: a replay/battle log screen's
+ * on-screen recording timestamp (anchored to when the screen was seen, not
+ * a possibly much later send), else the closing scoreboard's detection
+ * time. Detection times ride richer event records (StoredEvent) and are
+ * read structurally so the builder stays generic.
+ */
+function playedAt(
+	scoreboard: DetectedEvent | null,
+	timestamped: ScoreboardBattleLogData | undefined,
+): number | null {
+	if (!scoreboard) return null;
+	const detectedAt = (scoreboard as { detectedAt?: number }).detectedAt ?? null;
+	if (timestamped?.timestamp) {
+		const recorded = parseReplayTimestamp(timestamped.timestamp, {
+			now: detectedAt ?? undefined,
+		});
+		if (recorded !== null) return recorded;
+	}
+	return detectedAt;
+}
+
+function teamsFromScoreboard(
+	board: ScoreboardData,
+	deaths: readonly DeathData[],
+): [ScannerMatchTeam, ScannerMatchTeam] {
+	const abilities = harvestAbilities(board.players, deaths);
+	const players = board.players.map((player, i): ScannerMatchPlayer => {
+		const build = abilities.get(i);
+		return {
+			name: player.name.trim() || null,
+			weaponId: player.weaponId,
+			paint: player.paint,
+			ka: player.ka,
+			d: player.d,
+			s: player.s,
+			...(build ? { abilities: build } : null),
+		};
+	});
+	return [
+		{ players: players.slice(0, PLAYERS_PER_TEAM) },
+		{ players: players.slice(PLAYERS_PER_TEAM) },
+	];
+}
+
+/**
+ * Players merged across a match's minimap frames, alpha side then bravo:
+ * weapons and names are fixed for a match, so a slot missed in one frame is
+ * filled from another (first frame that read it wins).
+ */
+function teamsFromMinimaps(
+	frames: readonly MinimapData[],
+	deaths: readonly DeathData[],
+): [ScannerMatchTeam, ScannerMatchTeam] {
+	const alpha = mergeSlots(frames.map((frame) => frame.teammates));
+	const bravo = mergeSlots(frames.map((frame) => frame.enemies));
+
+	const players = [...alpha, ...bravo];
+	const abilities = harvestAbilities(players, deaths);
+	const withAbilities = players.map((player, i) => {
+		const build = abilities.get(i);
+		return build ? { ...player, abilities: build } : player;
+	});
+
+	return [
+		{ players: withAbilities.slice(0, alpha.length) },
+		{ players: withAbilities.slice(alpha.length) },
+	];
+}
+
+/** For each slot index, the first frame's non-null read of each field. */
+function mergeSlots(
+	frames: Array<Array<{ name: string | null; weaponId: MainWeaponId | null }>>,
+): ScannerMatchPlayer[] {
+	const width = Math.max(0, ...frames.map((frame) => frame.length));
+	const out: ScannerMatchPlayer[] = [];
+	for (let i = 0; i < width; i++) {
+		const reads = frames
+			.map((frame) => frame[i])
+			.filter((read) => read !== undefined);
+		out.push({
+			name:
+				reads
+					.map((read) => read.name?.trim() || null)
+					.find((n) => n !== null) ?? null,
+			weaponId:
+				reads.map((read) => read.weaponId).find((id) => id !== null) ?? null,
+			paint: null,
+			ka: null,
+			d: null,
+			s: null,
+		});
+	}
+	return out;
+}
diff --git a/app/features/scanner/core/match-sets.ts b/app/features/scanner/core/match-sets.ts
new file mode 100644
index 000000000..ef112ebad
--- /dev/null
+++ b/app/features/scanner/core/match-sets.ts
@@ -0,0 +1,88 @@
+/**
+ * Divide a chronological run of ScannerMatches into sets — consecutive games
+ * played by the same eight players (a Bo3/Bo5 between two teams). Rosters
+ * are compared by in-game names pooled across both teams (scoreboards list
+ * winners first, so team sides swap between games): names match fuzzily
+ * because two OCR reads of the same name can differ by a glyph or two, and
+ * one differing player is tolerated as a sub between games. A match with no
+ * readable names is inconclusive and never opens a new set.
+ */
+import type { ScannerMatch } from "./scanner-match";
+import { matchKey, rankBy } from "./text";
+
+/**
+ * closestBy score two reads of the same name must reach — 0.7 forgives one
+ * bad glyph on a four-letter name, two on longer ones.
+ */
+const SAME_NAME_SCORE = 0.7;
+
+/** Players allowed to differ between consecutive games of one set. */
+const MAX_SUBS_PER_GAME = 1;
+
+/**
+ * For each match its 1-based set number, aligned by index with the input;
+ * matches must be in chronological order. Numbers only ever step up by one:
+ * a match whose roster disagrees with the current set's opens the next set.
+ */
+export function assignMatchSets(matches: readonly ScannerMatch[]): number[] {
+	const setNumbers: number[] = [];
+	let setNumber = 1;
+	let roster: string[] | null = null;
+	for (const match of matches) {
+		const names = rosterNames(match);
+		if (names.length > 0) {
+			if (roster !== null && !sameRoster(roster, names)) setNumber++;
+			roster = names;
+		}
+		setNumbers.push(setNumber);
+	}
+	return setNumbers;
+}
+
+function rosterNames(match: ScannerMatch): string[] {
+	return match.teams
+		.flatMap((team) => team.players)
+		.map((player) => player.name)
+		.filter((name): name is string => name !== null);
+}
+
+/**
+ * Whether two rosters read as the same eight players: every name of the
+ * smaller roster must find a partner in the other, short of
+ * MAX_SUBS_PER_GAME misses. Partial reads compare only what both saw, so a
+ * minimap-sourced half-roster still chains a set together.
+ */
+function sameRoster(a: readonly string[], b: readonly string[]): boolean {
+	const remaining = [...b];
+	let matched = 0;
+	for (const name of a) {
+		const partner = rankBy(name, remaining, (entry) => entry).find(
+			({ entry, score }) =>
+				score >= SAME_NAME_SCORE || sharedPrefixRead(name, entry),
+		);
+		if (partner) {
+			matched++;
+			remaining.splice(remaining.indexOf(partner.entry), 1);
+		}
+	}
+	return Math.min(a.length, b.length) - matched <= MAX_SUBS_PER_GAME;
+}
+
+/**
+ * Whether two reads of a name agree on a leading prefix long enough that the
+ * difference reads as tail damage, not another player. CJK names run 2-4
+ * glyphs, so a single truncated (れた → れ) or garbled (ほった → ほっ′`)
+ * tail glyph sinks the edit-distance score below any usable threshold while
+ * the OCR damage sits, as it nearly always does, at the end of the row.
+ */
+function sharedPrefixRead(a: string, b: string): boolean {
+	const keyA = matchKey(a);
+	const keyB = matchKey(b);
+	const shorter = Math.min(keyA.length, keyB.length);
+	if (shorter === 0) return false;
+	let prefix = 0;
+	while (prefix < shorter && keyA[prefix] === keyB[prefix]) prefix++;
+	// a whole-read prefix is a truncation; a 2+ glyph prefix covering two
+	// thirds of the shorter read is a solid read with a garbled tail
+	return prefix === shorter || (prefix >= 2 && prefix * 3 >= shorter * 2);
+}
diff --git a/app/features/scanner/core/replay-time.ts b/app/features/scanner/core/replay-time.ts
new file mode 100644
index 000000000..d9fab2aff
--- /dev/null
+++ b/app/features/scanner/core/replay-time.ts
@@ -0,0 +1,143 @@
+/**
+ * Turns the replay browser's on-screen recording timestamp (locale-formatted
+ * by the console, e.g. "3/7/2026 22:28", "7.3.2026 22:28", "2026/3/7 22:28")
+ * into a UTC epoch, read in the local timezone. The string carries no
+ * timezone or day/month-order marker, so ambiguous day-vs-month (both ≤ 12)
+ * resolves in three steps: hour 0 or ≥13 proves a 24h clock (12h consoles
+ * render AM/PM) and 24h locales are near-universally day-first, except
+ * en-US which is 12h; failing that, the browser locale's date-part order
+ * decides; finally, since the console's locale and the browser's can still
+ * disagree, a recency check swaps day/month when that reading lands near now
+ * while the un-swapped one doesn't (replays are near-always ingested soon
+ * after recording).
+ */
+
+const TIMESTAMP_RE =
+	/^(\d{1,4})[./-](\d{1,4})[./-](\d{1,4})\s+(\d{1,2}):(\d{2})$/;
+
+/** How far in the past a reading may land and still count as "recent". */
+const RECENT_PAST_MS = 30 * 24 * 60 * 60 * 1000;
+/** Forward tolerance for console-vs-browser clock and timezone skew. */
+const FUTURE_SLACK_MS = 24 * 60 * 60 * 1000;
+
+type Ymd = { year: number; month: number; day: number };
+
+/**
+ * Parses a replay timestamp into UTC epoch milliseconds, or null when the
+ * string doesn't form a valid date. `locale` defaults to the environment's;
+ * `now` (default `Date.now()`) anchors the recency disambiguation — pass the
+ * moment the replay screen was on-screen, not the send time.
+ */
+export function parseReplayTimestamp(
+	raw: string,
+	{ locale, now }: { locale?: string; now?: number } = {},
+): number | null {
+	const m = TIMESTAMP_RE.exec(raw.trim());
+	if (!m) return null;
+	const dateParts = [Number(m[1]!), Number(m[2]!), Number(m[3]!)];
+	const hours = Number(m[4]!);
+	const minutes = Number(m[5]!);
+	if (hours > 23 || minutes > 59) return null;
+
+	// hour 0 or ≥13 only occurs on a 24h clock, and 24h locales are
+	// near-universally day-first; only an ambiguous hour falls back to the
+	// browser locale, which may not match the console's
+	const is24hClock = hours === 0 || hours >= 13;
+	const resolved = resolveDateParts(
+		dateParts,
+		is24hClock ? true : dayBeforeMonth(locale),
+	);
+	if (!resolved) return null;
+
+	const preferred = toEpoch(resolved.preferred, hours, minutes);
+	if (preferred === null) return null;
+
+	if (resolved.swapped) {
+		const swapped = toEpoch(resolved.swapped, hours, minutes);
+		const ref = now ?? Date.now();
+		if (
+			swapped !== null &&
+			isRecent(swapped, ref) &&
+			!isRecent(preferred, ref)
+		) {
+			return swapped;
+		}
+	}
+	return preferred;
+}
+
+function isRecent(t: number, ref: number): boolean {
+	return t >= ref - RECENT_PAST_MS && t <= ref + FUTURE_SLACK_MS;
+}
+
+function toEpoch(
+	{ year, month, day }: Ymd,
+	hours: number,
+	minutes: number,
+): number | null {
+	const date = new Date(year, month - 1, day, hours, minutes);
+	// the Date constructor rolls invalid dates over (31/2 → 2/3); reject those
+	if (
+		date.getFullYear() !== year ||
+		date.getMonth() !== month - 1 ||
+		date.getDate() !== day
+	) {
+		return null;
+	}
+	return date.getTime();
+}
+
+/**
+ * Splits the three date segments into year/month/day. The year is the
+ * segment with ≥3 digits (leading for ja-style "2026/3/7", trailing
+ * otherwise); with no such segment the last one is a 2-digit year. Day vs
+ * month resolves by magnitude when one exceeds 12, else by the caller's
+ * order guess (year-first formats are month-first — no locale writes Y/D/M);
+ * a guessed split also reports the swapped reading for the recency check.
+ */
+function resolveDateParts(
+	parts: number[],
+	guessDayFirst: boolean,
+): { preferred: Ymd; swapped: Ymd | null } | null {
+	let year: number;
+	let rest: [number, number];
+	let dayFirst: boolean;
+	let orderKnown = false;
+	if (parts[0]! >= 100) {
+		year = parts[0]!;
+		rest = [parts[1]!, parts[2]!];
+		dayFirst = false;
+		orderKnown = true;
+	} else {
+		year = parts[2]! >= 100 ? parts[2]! : 2000 + parts[2]!;
+		rest = [parts[0]!, parts[1]!];
+		dayFirst = guessDayFirst;
+	}
+
+	const [a, b] = rest;
+	let day: number;
+	let month: number;
+	let guessed = false;
+	if (a > 12 && b > 12) return null;
+	if (a > 12) [day, month] = [a, b];
+	else if (b > 12) [month, day] = [a, b];
+	else {
+		[day, month] = dayFirst ? [a, b] : [b, a];
+		guessed = !orderKnown && a !== b;
+	}
+
+	if (month < 1 || month > 12 || day < 1 || day > 31) return null;
+	return {
+		preferred: { year, month, day },
+		swapped: guessed ? { year, month: day, day: month } : null,
+	};
+}
+
+function dayBeforeMonth(locale: string | undefined): boolean {
+	const parts = new Intl.DateTimeFormat(locale).formatToParts(
+		new Date(2000, 0, 2),
+	);
+	const dayIndex = parts.findIndex((p) => p.type === "day");
+	const monthIndex = parts.findIndex((p) => p.type === "month");
+	return dayIndex !== -1 && monthIndex !== -1 && dayIndex < monthIndex;
+}
diff --git a/app/features/scanner/core/resources.ts b/app/features/scanner/core/resources.ts
new file mode 100644
index 000000000..b94dfe8bc
--- /dev/null
+++ b/app/features/scanner/core/resources.ts
@@ -0,0 +1,216 @@
+/**
+ * Environment-agnostic assembly of ScoreboardResources. Node (filesystem)
+ * and the worker (HTTP) inject only the four IO primitives; every resource
+ * key, icon directory, template option set, and atlas name lives here once,
+ * so adding a resource cannot desync the two loaders. Icon/atlas decoding is
+ * eager (cheap), but template prep and atlas slicing are deferred behind
+ * memoized getters — a test process loads the full bundle while its one
+ * detector touches only a slice, and unused sets (four weapon-template
+ * builds alone are ~7k resizes) dominated startup.
+ */
+
+import { abilities as abilityList } from "~/modules/in-game-lists/abilities";
+import {
+	mainWeaponIds,
+	specialWeaponIds,
+	subWeaponIds,
+} from "~/modules/in-game-lists/weapon-ids";
+import { prepareAbilityTemplates } from "./detectors/death/abilities";
+import { BURST_ICON_TEMPLATE_SIZES } from "./detectors/death/rois";
+import { prepareMinimapAbilityTemplates } from "./detectors/minimap/abilities";
+import {
+	CARD_WEAPON_BACKGROUND,
+	MINIMAP_WEAPON_INK_THRESHOLD,
+	MINIMAP_WEAPON_TEMPLATE_SIZES,
+	SPECIAL_READY_BACKGROUND,
+	SPECIAL_READY_INK_THRESHOLD,
+	SUB_TILE_TEMPLATE_SIZES,
+} from "./detectors/minimap/rois";
+import type { PlannerStage } from "./detectors/minimap/stage";
+import type { ScoreboardResources } from "./detectors/scoreboard/index";
+import { prepareSpecialTemplates } from "./detectors/scoreboard/specials";
+import { prepareWeaponTemplates } from "./detectors/scoreboard/weapons";
+import { prepareOwnAbilityTemplates } from "./detectors/scoreboard-own/abilities";
+import type { GlyphSet } from "./glyphs";
+import type { FrameData } from "./image";
+
+export interface ResourceIO {
+	/** decoded RGBA of the shared game icon img/<dir>/<id>.avif */
+	readIcon(dir: string, id: string): Promise<FrameData>;
+	/** glyph atlas by name as a (possibly lazy) getter; () => null when absent */
+	loadAtlas(name: string): Promise<() => GlyphSet | null>;
+	/** planner signature atlas as a getter; () => null when absent */
+	loadPlannerStages(): Promise<() => PlannerStage[] | null>;
+}
+
+/** resource key → atlas name under assets/cv/glyphs/ */
+const ATLASES = {
+	paintDigits: "scoreboard-paint-digits",
+	statDigits: "scoreboard-stat-digits",
+	teamDigits: "scoreboard-team-digits",
+	nameGlyphs: "scoreboard-names",
+	headerLobbyGlyphs: "scoreboard-header-lobby",
+	headerLineGlyphs: "scoreboard-header-line",
+	replayCodeGlyphs: "scoreboard-replay-code",
+	replayResultGlyphs: "scoreboard-replay-result",
+	deathWeaponGlyphs: "death-weapon",
+	deathWeaponJaGlyphs: "death-weapon-ja",
+	deathTagNameGlyphs: "death-tag-name",
+	mapStartModeGlyphs: "map-start-mode",
+	mapStartStageGlyphs: "map-start-stage",
+} as const;
+
+/** Memoize an expensive template/atlas build for the lazy resource getters. */
+function lazy<T>(build: () => T): () => T {
+	let value: T;
+	let built = false;
+	return () => {
+		if (!built) {
+			value = build();
+			built = true;
+		}
+		return value;
+	};
+}
+
+/** Requires loadOpenCV() to have resolved. */
+export async function assembleScoreboardResources(
+	io: ResourceIO,
+): Promise<ScoreboardResources> {
+	const icons = (dir: string, ids: readonly (number | string)[]) =>
+		Promise.all(
+			ids.map(async (id) => ({
+				id: String(id),
+				image: await io.readIcon(dir, String(id)),
+			})),
+		);
+
+	const [
+		weaponIcons,
+		specialIcons,
+		subIcons,
+		abilityIcons,
+		plannerStages,
+		atlasEntries,
+	] = await Promise.all([
+		icons("main-weapons", mainWeaponIds),
+		icons("special-weapons", specialWeaponIds),
+		icons("sub-weapons", subWeaponIds),
+		// UNKNOWN is the garbled-badge template: it competes in matching and
+		// wins on unreadable slots (see toAbilityWithUnknown in scanner-types.ts)
+		icons("abilities", [
+			...abilityList.map((ability) => ability.name),
+			"UNKNOWN",
+		]),
+		io.loadPlannerStages(),
+		Promise.all(
+			(Object.entries(ATLASES) as [keyof typeof ATLASES, string][]).map(
+				async ([key, name]) => [key, await io.loadAtlas(name)] as const,
+			),
+		),
+	]);
+	const atlas = Object.fromEntries(atlasEntries) as Record<
+		keyof typeof ATLASES,
+		() => GlyphSet | null
+	>;
+
+	const weapons = lazy(() => prepareWeaponTemplates(weaponIcons));
+	const deathBurstWeapons = lazy(() =>
+		prepareWeaponTemplates(weaponIcons, BURST_ICON_TEMPLATE_SIZES),
+	);
+	const minimapCardWeapons = lazy(() =>
+		prepareWeaponTemplates(weaponIcons, MINIMAP_WEAPON_TEMPLATE_SIZES, {
+			background: CARD_WEAPON_BACKGROUND,
+			inkThreshold: MINIMAP_WEAPON_INK_THRESHOLD,
+			cropToArt: true,
+		}),
+	);
+	const minimapLightWeapons = lazy(() =>
+		prepareWeaponTemplates(weaponIcons, MINIMAP_WEAPON_TEMPLATE_SIZES, {
+			background: SPECIAL_READY_BACKGROUND,
+			inkThreshold: SPECIAL_READY_INK_THRESHOLD,
+			cropToArt: true,
+		}),
+	);
+	const specials = lazy(() => prepareSpecialTemplates(specialIcons));
+	const minimapSubWeapons = lazy(() =>
+		prepareSpecialTemplates(subIcons, SUB_TILE_TEMPLATE_SIZES),
+	);
+	const abilities = lazy(() => prepareAbilityTemplates(abilityIcons));
+	const ownAbilities = lazy(() => prepareOwnAbilityTemplates(abilityIcons));
+	const minimapAbilities = lazy(() =>
+		prepareMinimapAbilityTemplates(abilityIcons),
+	);
+
+	return {
+		get weapons() {
+			return weapons();
+		},
+		get deathBurstWeapons() {
+			return deathBurstWeapons();
+		},
+		get minimapCardWeapons() {
+			return minimapCardWeapons();
+		},
+		get minimapLightWeapons() {
+			return minimapLightWeapons();
+		},
+		get specials() {
+			return specials();
+		},
+		get minimapSubWeapons() {
+			return minimapSubWeapons();
+		},
+		get abilities() {
+			return abilities();
+		},
+		get ownAbilities() {
+			return ownAbilities();
+		},
+		get minimapAbilities() {
+			return minimapAbilities();
+		},
+		get plannerStages() {
+			return plannerStages();
+		},
+		get paintDigits() {
+			return atlas.paintDigits();
+		},
+		get statDigits() {
+			return atlas.statDigits();
+		},
+		get teamDigits() {
+			return atlas.teamDigits();
+		},
+		get nameGlyphs() {
+			return atlas.nameGlyphs();
+		},
+		get headerLobbyGlyphs() {
+			return atlas.headerLobbyGlyphs();
+		},
+		get headerLineGlyphs() {
+			return atlas.headerLineGlyphs();
+		},
+		get replayCodeGlyphs() {
+			return atlas.replayCodeGlyphs();
+		},
+		get replayResultGlyphs() {
+			return atlas.replayResultGlyphs();
+		},
+		get deathWeaponGlyphs() {
+			return atlas.deathWeaponGlyphs();
+		},
+		get deathWeaponJaGlyphs() {
+			return atlas.deathWeaponJaGlyphs();
+		},
+		get deathTagNameGlyphs() {
+			return atlas.deathTagNameGlyphs();
+		},
+		get mapStartModeGlyphs() {
+			return atlas.mapStartModeGlyphs();
+		},
+		get mapStartStageGlyphs() {
+			return atlas.mapStartStageGlyphs();
+		},
+	};
+}
diff --git a/app/features/scanner/core/scanner-match.ts b/app/features/scanner/core/scanner-match.ts
new file mode 100644
index 000000000..adba07492
--- /dev/null
+++ b/app/features/scanner/core/scanner-match.ts
@@ -0,0 +1,100 @@
+/**
+ * ScannerMatch — the unit the scanner hands to the rest of sendou.ink: one
+ * detected game with everything the scan could read. Built from the event
+ * timeline by core/match-builder.ts; validated at the boundaries by
+ * scannerMatchSchema (../scanner-schemas.ts). Every field is nullable —
+ * a match may be partial (features/scanner-ingest merges partials).
+ */
+import type {
+	AbilityWithUnknown,
+	MainWeaponId,
+	ModeShort,
+	StageId,
+} from "~/modules/in-game-lists/types";
+import type { ScannerLobby } from "../scanner-types";
+
+export interface ScannerMatchPlayer {
+	/** in-game name; null when unread (e.g. minimap POV enemy rows show none) */
+	name: string | null;
+	/** sendou main-weapon id; null when no frame read the slot */
+	weaponId: MainWeaponId | null;
+	paint: number | null;
+	ka: number | null;
+	d: number | null;
+	s: number | null;
+	/** [head, clothes, shoes] ability rows harvested from death screens */
+	abilities?: AbilityWithUnknown[][];
+}
+
+export interface ScannerMatchTeam {
+	/** up to 4 players; slots the scan never saw are absent */
+	players: ScannerMatchPlayer[];
+}
+
+export interface ScannerMatchObjectiveSample {
+	/** whole seconds into the video/stream the counter was read at */
+	t: number;
+	/**
+	 * seconds shown on the match timer at the read ("3:35" = 215); null =
+	 * unreadable. The game clock is the axis to graph progress on — score
+	 * moves at most 1/s against it.
+	 */
+	time: number | null;
+	/** displayed count per team, in `teams` order; null = unreadable */
+	score: [number | null, number | null];
+	/** penalty pill value per team; null = no pill (or unreadable) */
+	penalty: [number | null, number | null];
+	/** which team held the objective at the read */
+	control: [boolean, boolean];
+}
+
+/**
+ * Objective-counter progress over the match. Samples are chronological and
+ * deduped to state changes, with an unchanged state re-confirmed every ~10s
+ * while the counter stays on screen — so consecutive samples further apart
+ * than that were not observed in between (capture gap, covered HUD): render
+ * such stretches as unknown instead of interpolating.
+ */
+export interface ScannerMatchObjective {
+	mode: "SZ";
+	samples: ScannerMatchObjectiveSample[];
+}
+
+export interface ScannerMatch {
+	/** whole seconds into the video/stream the match starts at */
+	startsAt: number | null;
+	/** whole seconds into the video/stream the match was last seen at */
+	endsAt: number | null;
+	/**
+	 * wall-clock ms the game was played: a replay scoreboard's recording
+	 * time, else the closing scoreboard's detection time; null on VoD scans
+	 */
+	playedAt: number | null;
+	lobby: ScannerLobby | null;
+	mode: ModeShort | null;
+	stage: StageId | null;
+	/**
+	 * the "Score:" banner game scores (0-100) in `teams` order, from a
+	 * results/replay screen; a knockout's winner reports 100. Null when no
+	 * such screen was seen.
+	 */
+	matchScores: [number | null, number | null] | null;
+	replayCode: string | null;
+	/** spectator/casted footage (the 8-player spectator map screen was seen) */
+	cast: boolean;
+	/**
+	 * counter progress samples in `teams` order (the on-screen left plate is
+	 * the POV/alpha side; the builder reorients when teams[0] is the other
+	 * side); null when no counter was read
+	 */
+	objective: ScannerMatchObjective | null;
+	/**
+	 * on-screen order: scoreboard rows 0-3 are teams[0] (the winners),
+	 * minimap alpha/own side is teams[0]
+	 */
+	teams: [ScannerMatchTeam, ScannerMatchTeam];
+	/** scoreboard-sourced matches know it (0); minimap-only matches don't */
+	winner: 0 | 1 | null;
+	/** the POV player's seat, when a scoreboard identified it */
+	pov: { team: 0 | 1; index: number } | null;
+}
diff --git a/app/features/scanner/core/text.ts b/app/features/scanner/core/text.ts
new file mode 100644
index 000000000..dfc05c5ab
--- /dev/null
+++ b/app/features/scanner/core/text.ts
@@ -0,0 +1,143 @@
+/**
+ * Small text utilities: edit distance and closed-set snapping for OCR output.
+ */
+
+function editDistance(a: string, b: string): number {
+	const dp = Array.from({ length: a.length + 1 }, (_, i) => {
+		const row = new Array<number>(b.length + 1).fill(0);
+		row[0] = i;
+		return row;
+	});
+	for (let j = 0; j <= b.length; j++) dp[0]![j] = j;
+	for (let i = 1; i <= a.length; i++) {
+		for (let j = 1; j <= b.length; j++) {
+			dp[i]![j] = Math.min(
+				dp[i - 1]![j]! + 1,
+				dp[i]![j - 1]! + 1,
+				dp[i - 1]![j - 1]! + (a[i - 1] === b[j - 1] ? 0 : 1),
+			);
+		}
+	}
+	return dp[a.length]![b.length]!;
+}
+
+/**
+ * Case-, space- and diacritic-insensitive comparison key (é≈e), so OCR
+ * confusing an accented glyph with its base form stays a near-match across
+ * the localized closed sets.
+ */
+export function matchKey(s: string): string {
+	return s
+		.toLowerCase()
+		.normalize("NFD")
+		.replace(/[\u0300-\u036f]/g, "")
+		.replace(/\s+/g, "");
+}
+
+export interface ClosestMatch<T> {
+	entry: T;
+	/** 1 = exact (ignoring case/spaces/diacritics), 0 = nothing in common */
+	score: number;
+}
+
+/** Snap an OCR reading to the closest of a closed set of arbitrary entries. */
+export function closestBy<T>(
+	reading: string,
+	entries: readonly T[],
+	textOf: (entry: T) => string,
+): ClosestMatch<T> | null {
+	const r = matchKey(reading);
+	let best: ClosestMatch<T> | null = null;
+	for (const entry of entries) {
+		const e = matchKey(textOf(entry));
+		const d = editDistance(r, e);
+		const score = 1 - d / Math.max(r.length, e.length, 1);
+		if (!best || score > best.score) best = { entry, score };
+	}
+	return best;
+}
+
+/** Snap an OCR reading to the closest entry of a closed set of strings. */
+export function closestEntry<T extends string>(
+	reading: string,
+	entries: readonly T[],
+): ClosestMatch<T> | null {
+	return closestBy(reading, entries, (e) => e);
+}
+
+/** Rank every entry of a closed set against an OCR reading, best first. */
+export function rankBy<T>(
+	reading: string,
+	entries: readonly T[],
+	textOf: (entry: T) => string,
+): ClosestMatch<T>[] {
+	const r = matchKey(reading);
+	return entries
+		.map((entry) => {
+			const e = matchKey(textOf(entry));
+			const d = editDistance(r, e);
+			return { entry, score: 1 - d / Math.max(r.length, e.length, 1) };
+		})
+		.sort((a, b) => b.score - a.score);
+}
+
+/**
+ * One recognized text segment with its ranked alternatives — structurally
+ * compatible with glyphs.ts RecognizedChar, kept minimal here so string
+ * utilities stay decoupled from the recognition module.
+ */
+export interface ReadSegment {
+	candidates?: readonly { char: string; score: number }[];
+}
+
+/**
+ * Rank a closed set against the segment *candidate lists* of a recognized
+ * line instead of its greedy top-1-per-segment string. On low-fidelity
+ * captures (720p upscaled) the right glyph often sits at rank 2-3 of a
+ * segment while the top-1 string is garbage; plain edit distance can't see
+ * it, this can. Alignment is a weighted edit distance: matching a segment
+ * to a target char costs 1 minus that char's score in the segment's
+ * candidate list (1 when absent), insert/delete cost 1. Scores land well
+ * below rankBy's for the same quality of match (a correct char still costs
+ * 1 - templateScore), so the two scales must not share thresholds.
+ */
+export function rankByRead<T>(
+	segments: readonly ReadSegment[],
+	entries: readonly T[],
+	textOf: (entry: T) => string,
+): ClosestMatch<T>[] {
+	// per-segment candidate score by match key (max wins when keys collide,
+	// e.g. dakuten variants folding onto one base kana)
+	const segScores = segments.map((seg) => {
+		const m = new Map<string, number>();
+		for (const c of seg.candidates ?? []) {
+			const k = matchKey(c.char);
+			const s = Math.max(0, Math.min(1, c.score));
+			if (s > (m.get(k) ?? 0)) m.set(k, s);
+		}
+		return m;
+	});
+	const n = segScores.length;
+	return entries
+		.map((entry) => {
+			const t = matchKey(textOf(entry));
+			const m = t.length;
+			const dp = Array.from({ length: n + 1 }, () =>
+				new Array<number>(m + 1).fill(0),
+			);
+			for (let i = 1; i <= n; i++) dp[i]![0] = i;
+			for (let j = 1; j <= m; j++) dp[0]![j] = j;
+			for (let i = 1; i <= n; i++) {
+				for (let j = 1; j <= m; j++) {
+					const sub = 1 - (segScores[i - 1]!.get(t[j - 1]!) ?? 0);
+					dp[i]![j] = Math.min(
+						dp[i - 1]![j]! + 1,
+						dp[i]![j - 1]! + 1,
+						dp[i - 1]![j - 1]! + sub,
+					);
+				}
+			}
+			return { entry, score: 1 - dp[n]![m]! / Math.max(n, m, 1) };
+		})
+		.sort((a, b) => b.score - a.score);
+}
diff --git a/app/features/scanner/core/timeline/index.ts b/app/features/scanner/core/timeline/index.ts
new file mode 100644
index 000000000..c07c5a8cc
--- /dev/null
+++ b/app/features/scanner/core/timeline/index.ts
@@ -0,0 +1,99 @@
+/**
+ * TimelineBuilder: minimal event stream cleanup for the POC.
+ * Same-type events within a merge window collapse into one, keeping the
+ * highest-confidence version; events below a confidence floor are dropped.
+ */
+
+import {
+	OBJECTIVE_EVENT_TYPE,
+	sameObjectiveData,
+} from "../detectors/objective/index";
+import { SCOREBOARD_EVENT_TYPE } from "../detectors/scoreboard/index";
+import { SCOREBOARD_BATTLE_LOG_EVENT_TYPE } from "../detectors/scoreboard-battle-log/index";
+import { SCOREBOARD_BATTLE_LOG_REPLAY_EVENT_TYPE } from "../detectors/scoreboard-battle-log-replay/index";
+import type { DetectedEvent } from "../detectors/types";
+import { sameScoreboardMatch } from "./same-scoreboard";
+
+export interface TimelineOptions {
+	/** same-type events closer than this (seconds) merge */
+	mergeWindow: number;
+	/**
+	 * per-type mergeWindow overrides: repeatable events need a window shorter
+	 * than the minimum spacing between two real occurrences
+	 */
+	mergeWindowByType: Record<string, number>;
+	/**
+	 * per-type content guard: same-type events inside the window merge only
+	 * when this returns true for their data — screens whose distinct real
+	 * occurrences can appear seconds apart (replay browsing) need content,
+	 * not time, to tell them apart. Absent = merge on time alone.
+	 */
+	sameEventDataByType: Record<string, (a: unknown, b: unknown) => boolean>;
+	/** events below this confidence are dropped */
+	minConfidence: number;
+}
+
+const DEFAULT_TIMELINE_OPTIONS: TimelineOptions = {
+	mergeWindow: 30,
+	// the death screen shows for ~5s and respawn takes ~8.5s, so repeat frames
+	// of one death land within the window while consecutive deaths are outside;
+	// players flick the map open for 1-3s and each open is a fresh sample
+	// (slots read differently across opens), so minimap frames merge only
+	// within one open
+	// objective counter reads repeat every check second; the content guard
+	// below keeps every actual change while the window collapses static
+	// stretches into one event per state
+	mergeWindowByType: { Death: 8, Minimap: 5, [OBJECTIVE_EVENT_TYPE]: 10 },
+	sameEventDataByType: {
+		[SCOREBOARD_EVENT_TYPE]: sameScoreboardMatch,
+		[SCOREBOARD_BATTLE_LOG_REPLAY_EVENT_TYPE]: sameScoreboardMatch,
+		[SCOREBOARD_BATTLE_LOG_EVENT_TYPE]: sameScoreboardMatch,
+		[OBJECTIVE_EVENT_TYPE]: sameObjectiveData,
+	},
+	minConfidence: 0.6,
+};
+
+export type TimelineAction =
+	| { action: "added"; event: DetectedEvent }
+	| { action: "replaced"; event: DetectedEvent; replaced: DetectedEvent }
+	| { action: "merged"; into: DetectedEvent }
+	| { action: "dropped"; reason: "low-confidence" };
+
+export class TimelineBuilder {
+	#events: DetectedEvent[] = [];
+	#options: TimelineOptions;
+
+	constructor(options: Partial<TimelineOptions> = {}) {
+		this.#options = { ...DEFAULT_TIMELINE_OPTIONS, ...options };
+	}
+
+	get events(): readonly DetectedEvent[] {
+		return this.#events;
+	}
+
+	push(event: DetectedEvent): TimelineAction {
+		if (event.confidence < this.#options.minConfidence) {
+			return { action: "dropped", reason: "low-confidence" };
+		}
+		const window =
+			this.#options.mergeWindowByType[event.type] ?? this.#options.mergeWindow;
+		const same = this.#options.sameEventDataByType[event.type];
+		const near = this.#events.find(
+			(e) =>
+				e.type === event.type &&
+				Math.abs(e.t - event.t) <= window &&
+				(same?.(e.data, event.data) ?? true),
+		);
+		if (!near) {
+			this.#events.push(event);
+			this.#events.sort((a, b) => a.t - b.t);
+			return { action: "added", event };
+		}
+		if (event.confidence > near.confidence) {
+			this.#events[this.#events.indexOf(near)] = event;
+			this.#events.sort((a, b) => a.t - b.t);
+			return { action: "replaced", event, replaced: near };
+		}
+		return { action: "merged", into: near };
+	}
+}
diff --git a/app/features/scanner/core/timeline/same-scoreboard.ts b/app/features/scanner/core/timeline/same-scoreboard.ts
new file mode 100644
index 000000000..572fb99ec
--- /dev/null
+++ b/app/features/scanner/core/timeline/same-scoreboard.ts
@@ -0,0 +1,96 @@
+/**
+ * Content guard for merging scoreboard-shaped events (results screen,
+ * replay-browser detail). The replay browser lets users flip between
+ * different matches' detail screens within seconds, so a time window alone
+ * can't tell "same board, re-sampled" from "next replay opened." Two events
+ * are treated as the same match unless something decisive says otherwise;
+ * every check tolerates read jitter (glyph misreads, a flipped winner side,
+ * fields that only read on some frames), so a split only happens on
+ * evidence that survives that noise.
+ */
+import type { ScoreboardData } from "../detectors/scoreboard/index";
+import type { ScoreboardBattleLogReplayData } from "../detectors/scoreboard-battle-log-replay/index";
+
+/**
+ * Replay codes of the same replay re-read on a low-fidelity capture differ
+ * in a few glyphs (U/V, G/C confusions); different replays share almost no
+ * positions. Split only past this many mismatched characters.
+ */
+const CODE_DIFF_MIN = 7;
+
+/**
+ * Paint totals are per-match fingerprints that read reliably (big digits).
+ * Compared only when both events read at least this many of the 8 rows.
+ */
+const PAINT_MIN_READ = 6;
+
+/** Positions where two equal-length strings disagree (∞ on length mismatch). */
+function charDiff(a: string, b: string): number {
+	if (a.length !== b.length) return Number.POSITIVE_INFINITY;
+	let n = 0;
+	for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) n++;
+	return n;
+}
+
+/** Size of the multiset intersection of two number lists. */
+function multisetOverlap(a: number[], b: number[]): number {
+	const counts = new Map<number, number>();
+	for (const v of a) counts.set(v, (counts.get(v) ?? 0) + 1);
+	let n = 0;
+	for (const v of b) {
+		const c = counts.get(v) ?? 0;
+		if (c > 0) {
+			counts.set(v, c - 1);
+			n++;
+		}
+	}
+	return n;
+}
+
+/** The non-null paint values, order-free (winner side can flip between reads). */
+function paints(data: Partial<ScoreboardData>): number[] {
+	return (data.players ?? [])
+		.map((p) => p.paint)
+		.filter((p): p is number => p !== null);
+}
+
+/**
+ * Whether two scoreboard events plausibly show the same match. Fields are
+ * only compared when both sides read them, so a null read never splits.
+ */
+export function sameScoreboardMatch(a: unknown, b: unknown): boolean {
+	const da = a as Partial<ScoreboardData> &
+		Partial<ScoreboardBattleLogReplayData>;
+	const db = b as Partial<ScoreboardData> &
+		Partial<ScoreboardBattleLogReplayData>;
+
+	const stageA = da.stage ?? null;
+	const stageB = db.stage ?? null;
+	if (stageA !== null && stageB !== null && stageA !== stageB) return false;
+
+	// replay detail screens: the recording timestamp and the replay code
+	// both identify the replay (timestamp reads are shape-validated, so a
+	// garbled read comes back null rather than as a different valid time)
+	const tsA = da.timestamp ?? null;
+	const tsB = db.timestamp ?? null;
+	if (tsA !== null && tsB !== null && tsA !== tsB) return false;
+	const codeA = da.replayCode ?? null;
+	const codeB = db.replayCode ?? null;
+	if (
+		codeA !== null &&
+		codeB !== null &&
+		charDiff(codeA, codeB) >= CODE_DIFF_MIN
+	)
+		return false;
+
+	// same lobby, different map: names stay identical, but the paint totals
+	// are distinctive per match — near-zero overlap means a different board
+	const pa = paints(da);
+	const pb = paints(db);
+	if (pa.length >= PAINT_MIN_READ && pb.length >= PAINT_MIN_READ) {
+		if (multisetOverlap(pa, pb) < Math.min(pa.length, pb.length) / 2)
+			return false;
+	}
+
+	return true;
+}
diff --git a/app/features/scanner/node/assets-dir.ts b/app/features/scanner/node/assets-dir.ts
new file mode 100644
index 000000000..60dfbee05
--- /dev/null
+++ b/app/features/scanner/node/assets-dir.ts
@@ -0,0 +1,18 @@
+/**
+ * Where Node-side code (tests, atlas builders) reads and writes the scanner
+ * asset sets. SCANNER_ASSETS_DIR holds the scanner-specific atlases (glyphs, planner
+ * signatures; overridable with the env var of the same name) — its version
+ * segment must match the worker-side ATLAS_BASE (worker/resources.ts).
+ * GAME_IMG_DIR is the sibling sendou-ink/assets checkout's shared `img/**`
+ * tree the game icons are read from — the same files the CDN mirrors.
+ * xxx: atlases temporarily live in this repo's public/ while the feature
+ * is in development; move them to the assets repo later
+ */
+export const SCANNER_ASSETS_DIR =
+	process.env.SCANNER_ASSETS_DIR ??
+	new URL("../../../../public/scanner/v1", import.meta.url).pathname;
+
+export const GAME_IMG_DIR = new URL(
+	"../../../../../assets/assets/img",
+	import.meta.url,
+).pathname;
diff --git a/app/features/scanner/node/fixtures.ts b/app/features/scanner/node/fixtures.ts
new file mode 100644
index 000000000..8806eaa50
--- /dev/null
+++ b/app/features/scanner/node/fixtures.ts
@@ -0,0 +1,173 @@
+/**
+ * Fixture discovery and detector execution for tests and tools.
+ *
+ * A fixture is a directory under app/features/scanner/tests/fixtures/<detector>/<case-name>/ containing
+ * frame.png or frame.jpg (raw capture, any resolution — normalization happens
+ * inside the pipeline under test) and expected.json.
+ */
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import type {
+	AbilityWithUnknown,
+	MainWeaponId,
+	ModeShort,
+	StageId,
+} from "~/modules/in-game-lists/types";
+import type { ScoreboardData } from "../core/detectors/scoreboard/index";
+import type {
+	DetectedEvent,
+	Detector,
+	GateResult,
+} from "../core/detectors/types";
+import { normalizeFrame, toMat } from "../core/image";
+import type { ScannerLobby } from "../scanner-types";
+import { readImage } from "./image-io";
+
+export const FIXTURES_DIR = new URL("../tests/fixtures", import.meta.url)
+	.pathname;
+
+interface ExpectedPlayer {
+	name?: string;
+	weaponId?: MainWeaponId | null;
+	paint?: number;
+	ka?: number;
+	d?: number;
+	s?: number;
+}
+
+interface ExpectedMinimapTeammate {
+	slot?: "up" | "left" | "right" | "self";
+	name?: string | null;
+	/** informational for the human corrector; tests compare weaponId */
+	weaponLabel?: string | null;
+	weaponId?: MainWeaponId | null;
+	abilities?: (AbilityWithUnknown | null)[];
+}
+
+interface ExpectedMinimapEnemy {
+	/** spectator frames only: the screen shows bravo-team names */
+	name?: string | null;
+	/** informational for the human corrector; tests compare weaponId */
+	weaponLabel?: string | null;
+	weaponId?: MainWeaponId | null;
+	abilities?: (AbilityWithUnknown | null)[];
+}
+
+interface ExpectedScoreboard {
+	event:
+		| "Scoreboard"
+		| "ScoreboardBattleLogReplay"
+		| "ScoreboardBattleLog"
+		| "ScoreboardOwn"
+		| "Death"
+		| "MapStart"
+		| "Minimap"
+		| "Objective"
+		| "none";
+	data?: {
+		lobby?: ScannerLobby;
+		mode?: ModeShort;
+		stage?: StageId;
+		/** informational for the human corrector; tests compare `stage` */
+		stageLabel?: string;
+		/** ScoreboardBattleLogReplay + ScoreboardBattleLog only */
+		timestamp?: string;
+		/** ScoreboardBattleLogReplay only */
+		replayCode?: string;
+		/** the "Score:" banner game scores, [winner, loser]; KO winner = 100 */
+		matchScores?: [number | null, number | null];
+		players?: ExpectedPlayer[];
+		/** index of the yellow POV-arrow row in `players`; null = no arrow */
+		povIndex?: number | null;
+		/**
+		 * Death: killer's weapon id and kind (ids are unique per kind).
+		 * ScoreboardOwn: the player's own main weapon (weaponType unused).
+		 * weaponLabel is informational for the human corrector.
+		 */
+		weaponLabel?: string;
+		weaponId?: number | null;
+		weaponType?: "MAIN" | "SUB" | "SPECIAL";
+		/** Death + ScoreboardOwn: 3 gear rows of [main, sub, sub, sub] ability ids */
+		abilities?: AbilityWithUnknown[][];
+		/** Death only: killer's splash-tag name */
+		name?: string;
+		/** Objective only: match-timer seconds ("3:35" = 215); null = unreadable */
+		time?: number | null;
+		/** Objective only: displayed counter per team, [alpha, bravo] */
+		score?: [number | null, number | null];
+		/** Objective only: penalty pill value per team; null = no pill */
+		penalty?: [number | null, number | null];
+		/** Objective only: which team currently holds the objective */
+		control?: [boolean, boolean];
+		/** Minimap only: casted 8-player spectator map screen (not parsed yet) */
+		spectator?: boolean;
+		/** Minimap only: own-team callout cards in slot order */
+		teammates?: ExpectedMinimapTeammate[];
+		/** Minimap only: enemy panel rows, top to bottom */
+		enemies?: ExpectedMinimapEnemy[];
+	};
+	options?: {
+		/** glob-ish field paths to skip, e.g. "players.*.name", "scores" */
+		skipFields?: string[];
+		/** free-form context for humans (why fields are skipped, capture quirks) */
+		notes?: string;
+	};
+}
+
+export interface Fixture {
+	name: string;
+	dir: string;
+	framePath: string;
+	expected: ExpectedScoreboard;
+}
+
+export function loadFixtures(detector: string): Fixture[] {
+	const root = join(FIXTURES_DIR, detector);
+	if (!existsSync(root)) return [];
+	return readdirSync(root, { withFileTypes: true })
+		.filter((e) => e.isDirectory())
+		.map((e) => {
+			const dir = join(root, e.name);
+			const framePath = ["frame.png", "frame.jpg", "frame.jpeg"]
+				.map((f) => join(dir, f))
+				.find(existsSync);
+			if (!framePath) throw new Error(`fixture ${e.name}: no frame.png/jpg`);
+			const expected = JSON.parse(
+				readFileSync(join(dir, "expected.json"), "utf8"),
+			) as ExpectedScoreboard;
+			return { name: e.name, dir, framePath, expected };
+		})
+		.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+export function isFieldSkipped(fixture: Fixture, field: string): boolean {
+	const skips = fixture.expected.options?.skipFields ?? [];
+	return skips.some((pattern) => {
+		const re = new RegExp(
+			`^${pattern
+				.split("*")
+				.map((s) => s.replace(/[.+?^${}()|[\]\\]/g, "\\$&"))
+				.join("[^.]*")}$`,
+		);
+		return re.test(field);
+	});
+}
+
+export interface FixtureRun<TData = ScoreboardData> {
+	gate: GateResult;
+	events: DetectedEvent<TData>[];
+}
+
+/** Run gate+parse the way the live pipeline would. Caller must have loaded OpenCV. */
+export async function runDetectorOnFixture<TData = ScoreboardData>(
+	detector: Detector<TData>,
+	fixture: Fixture,
+): Promise<FixtureRun<TData>> {
+	const src = toMat(await readImage(fixture.framePath));
+	const frame = normalizeFrame(src);
+	src.delete();
+	const gate = detector.gate(frame);
+	const events = gate.pass ? detector.parse(frame, 0, gate) : [];
+	frame.delete();
+	return { gate, events };
+}
diff --git a/app/features/scanner/node/image-io.ts b/app/features/scanner/node/image-io.ts
new file mode 100644
index 000000000..9ebb6d260
--- /dev/null
+++ b/app/features/scanner/node/image-io.ts
@@ -0,0 +1,43 @@
+/**
+ * Node-only image decode/encode (@napi-rs/canvas). Never imported from src/core.
+ *
+ * Decoding goes through a canvas, whose backing store is alpha-premultiplied;
+ * RGB at partial-alpha pixels can shift by ±1. Everything we read is either
+ * fully opaque (frames, atlases) or consumed premultiplied anyway (weapon
+ * icons are composited over a background), so this is lossless in practice.
+ */
+import { readFileSync, writeFileSync } from "node:fs";
+import { createCanvas, Image, ImageData } from "@napi-rs/canvas";
+import sharp from "sharp";
+import type { FrameData } from "../core/image";
+
+export async function readImage(path: string): Promise<FrameData> {
+	// @napi-rs/canvas mis-decodes AVIF at partial-alpha pixels (white-matte
+	// leak); sharp returns clean straight-alpha RGBA for those
+	if (path.endsWith(".avif")) {
+		const { data, info } = await sharp(path)
+			.ensureAlpha()
+			.raw()
+			.toBuffer({ resolveWithObject: true });
+		return {
+			width: info.width,
+			height: info.height,
+			data: new Uint8ClampedArray(data),
+		};
+	}
+	const img = new Image();
+	img.src = readFileSync(path);
+	await img.decode();
+	const canvas = createCanvas(img.width, img.height);
+	const ctx = canvas.getContext("2d");
+	ctx.drawImage(img, 0, 0);
+	const { width, height, data } = ctx.getImageData(0, 0, img.width, img.height);
+	return { width, height, data };
+}
+
+export function writePng(path: string, frame: FrameData): void {
+	const canvas = createCanvas(frame.width, frame.height);
+	const ctx = canvas.getContext("2d");
+	ctx.putImageData(new ImageData(frame.data, frame.width, frame.height), 0, 0);
+	writeFileSync(path, canvas.toBuffer("image/png"));
+}
diff --git a/app/features/scanner/node/resources.ts b/app/features/scanner/node/resources.ts
new file mode 100644
index 000000000..b13cfe1e2
--- /dev/null
+++ b/app/features/scanner/node/resources.ts
@@ -0,0 +1,51 @@
+/**
+ * Node IO for ScoreboardResources: reads the scanner asset sets from the local
+ * sendou-ink/assets checkout (tests and atlas builders never touch the
+ * CDN). Game icons come from the checkout's shared `img/**` tree, the
+ * scanner-specific atlases from `scanner/v1/**`. What the bundle contains — every
+ * key, template option set, and atlas name — lives in core/resources.ts,
+ * shared with the worker's HTTP loader.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import {
+	loadPlannerStages,
+	type PlannerManifest,
+	type PlannerStage,
+} from "../core/detectors/minimap/stage";
+import type { ScoreboardResources } from "../core/detectors/scoreboard/index";
+import { type AtlasMeta, type GlyphSet, loadGlyphSet } from "../core/glyphs";
+import { assembleScoreboardResources } from "../core/resources";
+import { SCANNER_ASSETS_DIR as ASSETS_DIR, GAME_IMG_DIR } from "./assets-dir";
+import { readImage } from "./image-io";
+
+/** Decode eagerly, defer the (CPU-heavy) glyph slicing to first access. */
+async function loadAtlasLazy(name: string): Promise<() => GlyphSet | null> {
+	const png = join(ASSETS_DIR, "glyphs", `${name}.png`);
+	const json = join(ASSETS_DIR, "glyphs", `${name}.json`);
+	if (!existsSync(png) || !existsSync(json)) return () => null;
+	const meta = JSON.parse(readFileSync(json, "utf8")) as AtlasMeta;
+	const image = await readImage(png);
+	let set: GlyphSet | null = null;
+	return () => (set ??= loadGlyphSet(image, meta));
+}
+
+/** Planner stage signatures; the (CPU) tile slicing runs on first access. */
+async function loadPlannerStagesLazy(): Promise<() => PlannerStage[] | null> {
+	const png = join(ASSETS_DIR, "planner", "signatures.png");
+	const json = join(ASSETS_DIR, "planner", "manifest.json");
+	if (!existsSync(png) || !existsSync(json)) return () => null;
+	const manifest = JSON.parse(readFileSync(json, "utf8")) as PlannerManifest;
+	const atlas = await readImage(png);
+	let stages: PlannerStage[] | null = null;
+	return () => (stages ??= loadPlannerStages(atlas, manifest));
+}
+
+/** Requires loadOpenCV() to have resolved. */
+export function loadScoreboardResources(): Promise<ScoreboardResources> {
+	return assembleScoreboardResources({
+		readIcon: (dir, id) => readImage(join(GAME_IMG_DIR, dir, `${id}.avif`)),
+		loadAtlas: loadAtlasLazy,
+		loadPlannerStages: loadPlannerStagesLazy,
+	});
+}
diff --git a/app/features/scanner/routes/scanner.tsx b/app/features/scanner/routes/scanner.tsx
new file mode 100644
index 000000000..92f88cb3f
--- /dev/null
+++ b/app/features/scanner/routes/scanner.tsx
@@ -0,0 +1,45 @@
+import { lazy } from "react";
+import type { MetaFunction } from "react-router";
+import { Main } from "~/components/Main";
+import { Placeholder } from "~/components/Placeholder";
+import { Redirect } from "~/components/Redirect";
+import { Config } from "~/config";
+import { useHydrated } from "~/hooks/useHydrated";
+import { useHasRole } from "~/modules/permissions/hooks";
+import { metaTags } from "~/utils/remix";
+import type { SendouRouteHandle } from "~/utils/remix.server";
+
+// `builds` powers the empty/UNKNOWN ability label in <Ability />; the weapon
+// and game-misc namespaces the scanner cards rely on are always loaded.
+export const handle: SendouRouteHandle = {
+	i18n: ["builds"],
+};
+
+export const meta: MetaFunction = (args) => {
+	return metaTags({
+		title: "Scanner",
+		description:
+			"Detect Splatoon 3 match events (scoreboards, deaths, map screens) from live OBS footage, VoDs, and screenshots",
+		location: args.location,
+	});
+};
+
+// Everything below the shell assumes a browser: the OpenCV.js worker,
+// IndexedDB, WebCodecs, getUserMedia. Nothing from core/worker/capture/store
+// may be imported at route-module top level — only from inside this lazily
+// imported client component tree, after hydration.
+const ScannerApp = lazy(() =>
+	import("~/features/scanner/components/App").then((m) => ({ default: m.App })),
+);
+
+export default function ScannerPage() {
+	const isHydrated = useHydrated();
+	const isAdmin = useHasRole("ADMIN");
+	const isDev = useHasRole("DEV");
+
+	if (!Config.scannerEnabled && !isAdmin && !isDev) {
+		return <Redirect to="/" />;
+	}
+
+	return <Main bigger>{isHydrated ? <ScannerApp /> : <Placeholder />}</Main>;
+}
diff --git a/app/features/scanner/scanner-schemas.ts b/app/features/scanner/scanner-schemas.ts
new file mode 100644
index 000000000..575bdcf01
--- /dev/null
+++ b/app/features/scanner/scanner-schemas.ts
@@ -0,0 +1,121 @@
+/**
+ * Zod schemas for the scanner domain — the single source of truth shared by
+ * the producer (the scanner match builder/UI in this feature) and the
+ * validator (features/scanner-ingest). Every domain field is a sendou.ink id
+ * type; the compile-time asserts at the bottom pin each schema to the
+ * corresponding core interface so producer and validator cannot drift.
+ *
+ * The core/worker modules consume only the *types* (type-only imports point
+ * the other way), so zod never enters the worker bundle; runtime validation
+ * happens at the boundaries (ingest action, prefill loader).
+ */
+import { z } from "zod";
+import { abilities } from "~/modules/in-game-lists/abilities";
+import { modesShort } from "~/modules/in-game-lists/modes";
+import { stageIds } from "~/modules/in-game-lists/stage-ids";
+import type { Ability } from "~/modules/in-game-lists/types";
+import { mainWeaponIds } from "~/modules/in-game-lists/weapon-ids";
+import type {
+	ScannerMatch,
+	ScannerMatchObjective,
+	ScannerMatchPlayer,
+	ScannerMatchTeam,
+} from "./core/scanner-match";
+import { SCANNER_LOBBIES } from "./scanner-types";
+
+const detectionText = z.string().max(500);
+
+const scannerLobbySchema = z.enum(SCANNER_LOBBIES);
+export const modeShortSchema = z.enum(modesShort);
+export const stageIdSchema = z.literal(stageIds);
+export const mainWeaponIdSchema = z.literal(mainWeaponIds);
+
+const abilityNames = abilities.map((ability) => ability.name) as Ability[];
+/** a sendou ability id, or the detectors' explicit unrecognized marker */
+const scannerAbilitySchema = z.union([
+	z.literal(abilityNames),
+	z.literal("UNKNOWN"),
+]);
+
+const scannerMatchPlayerSchema = z.object({
+	name: detectionText.nullable(),
+	weaponId: mainWeaponIdSchema.nullable(),
+	paint: z.number().nullable(),
+	ka: z.number().nullable(),
+	d: z.number().nullable(),
+	s: z.number().nullable(),
+	/** [head, clothes, shoes] ability rows harvested from death screens */
+	abilities: z.array(z.array(scannerAbilitySchema).max(4)).max(3).optional(),
+});
+
+const scannerMatchTeamSchema = z.object({
+	players: z.array(scannerMatchPlayerSchema).max(4),
+});
+
+const teamIndexSchema = z.union([z.literal(0), z.literal(1)]);
+
+/** counters change at most 1/s, so a match yields a few hundred samples */
+const MAX_OBJECTIVE_SAMPLES = 1000;
+
+const scannerMatchObjectiveSampleSchema = z.object({
+	t: z.number().int().min(0),
+	time: z.number().int().min(0).nullable(),
+	score: z.tuple([z.number().nullable(), z.number().nullable()]),
+	penalty: z.tuple([z.number().nullable(), z.number().nullable()]),
+	control: z.tuple([z.boolean(), z.boolean()]),
+});
+
+const scannerMatchObjectiveSchema = z.object({
+	mode: z.literal("SZ"),
+	samples: z
+		.array(scannerMatchObjectiveSampleSchema)
+		.max(MAX_OBJECTIVE_SAMPLES),
+});
+
+export const scannerMatchSchema = z.object({
+	startsAt: z.number().int().min(0).nullable(),
+	endsAt: z.number().int().min(0).nullable(),
+	/** wall-clock ms the game was played */
+	playedAt: z.number().int().positive().nullable(),
+	lobby: scannerLobbySchema.nullable(),
+	mode: modeShortSchema.nullable(),
+	stage: stageIdSchema.nullable(),
+	matchScores: z
+		.tuple([z.number().nullable(), z.number().nullable()])
+		.nullable(),
+	replayCode: detectionText.nullable(),
+	cast: z.boolean(),
+	objective: scannerMatchObjectiveSchema.nullable(),
+	teams: z.tuple([scannerMatchTeamSchema, scannerMatchTeamSchema]),
+	winner: teamIndexSchema.nullable(),
+	pov: z
+		.object({ team: teamIndexSchema, index: z.number().int().min(0).max(3) })
+		.nullable(),
+});
+
+// ---- compile-time drift protection: schema output <-> core interface ----
+
+type MutuallyAssignable<A, B> = [A] extends [B]
+	? [B] extends [A]
+		? true
+		: never
+	: never;
+
+// `true satisfies …` fails to compile the moment a schema and its core
+// interface disagree in either direction.
+true satisfies MutuallyAssignable<
+	z.infer<typeof scannerMatchPlayerSchema>,
+	ScannerMatchPlayer
+>;
+true satisfies MutuallyAssignable<
+	z.infer<typeof scannerMatchTeamSchema>,
+	ScannerMatchTeam
+>;
+true satisfies MutuallyAssignable<
+	z.infer<typeof scannerMatchObjectiveSchema>,
+	ScannerMatchObjective
+>;
+true satisfies MutuallyAssignable<
+	z.infer<typeof scannerMatchSchema>,
+	ScannerMatch
+>;
diff --git a/app/features/scanner/scanner-search-params.test.ts b/app/features/scanner/scanner-search-params.test.ts
new file mode 100644
index 000000000..56af67ec4
--- /dev/null
+++ b/app/features/scanner/scanner-search-params.test.ts
@@ -0,0 +1,19 @@
+import { describe, it } from "vitest";
+import {
+	assertDecodesToDefault,
+	assertRoundTrips,
+} from "~/modules/search-params/search-params-test-utils";
+import { scannerSearchParams } from "./scanner-search-params";
+
+describe("scannerSearchParams", () => {
+	it("round-trips", () => {
+		assertRoundTrips(scannerSearchParams, {
+			tab: ["live", "screenshot", "vod"],
+			inspect: ["1723456789012-abc123", null],
+		});
+	});
+
+	it("malformed values decode to defaults", () => {
+		assertDecodesToDefault(scannerSearchParams, "tab", [["garbage"], ["LIVE"]]);
+	});
+});
diff --git a/app/features/scanner/scanner-search-params.ts b/app/features/scanner/scanner-search-params.ts
new file mode 100644
index 000000000..fcb4a8b0e
--- /dev/null
+++ b/app/features/scanner/scanner-search-params.ts
@@ -0,0 +1,13 @@
+import { z } from "zod";
+import * as SearchParams from "~/modules/search-params/search-params";
+import { SP } from "~/modules/search-params/search-params";
+
+export const SCANNER_TABS = ["live", "screenshot", "vod"] as const;
+
+export type ScannerTab = (typeof SCANNER_TABS)[number];
+
+export const scannerSearchParams = SearchParams.define({
+	tab: SP.param(z.enum(SCANNER_TABS), { default: "live", loader: false }),
+	/** Inspect handoff key: the screenshot tab claims this frame on load */
+	inspect: SP.param(z.string().max(100).nullable(), { loader: false }),
+});
diff --git a/app/features/scanner/scanner-types.ts b/app/features/scanner/scanner-types.ts
new file mode 100644
index 000000000..c127dc6b7
--- /dev/null
+++ b/app/features/scanner/scanner-types.ts
@@ -0,0 +1,36 @@
+/**
+ * Shared domain vocabulary for the scanner feature: events, snap tables, and
+ * constants speak sendou.ink's id types (ModeShort, StageId, weapon ids,
+ * Ability) — canonical English strings live only inside the OCR snap
+ * layer and never leave a detector.
+ */
+import { abilities } from "~/modules/in-game-lists/abilities";
+import type {
+	Ability,
+	AbilityWithUnknown,
+	MainWeaponId,
+} from "~/modules/in-game-lists/types";
+import { mainWeaponIds } from "~/modules/in-game-lists/weapon-ids";
+
+/** The scoreboard header's lobby tag. PRIVATE marks tournament games. */
+export const SCANNER_LOBBIES = ["X", "SERIES", "OPEN", "PRIVATE"] as const;
+export type ScannerLobby = (typeof SCANNER_LOBBIES)[number];
+
+const MAIN_WEAPON_ID_SET: ReadonlySet<number> = new Set(mainWeaponIds);
+const ABILITY_SET: ReadonlySet<string> = new Set(abilities.map((a) => a.name));
+
+/** Narrow a template/manifest id to a MainWeaponId; null when unknown. */
+export function toMainWeaponId(id: number | string): MainWeaponId | null {
+	const n = Number(id);
+	return MAIN_WEAPON_ID_SET.has(n) ? (n as MainWeaponId) : null;
+}
+
+/**
+ * Narrow an ability-template id to an AbilityWithUnknown; null when the id is
+ * not a known template. Note "UNKNOWN" is a template of its own (the badge was
+ * read but not recognized) and is distinct from null.
+ */
+export function toAbilityWithUnknown(id: string): AbilityWithUnknown | null {
+	if (id === "UNKNOWN") return id;
+	return ABILITY_SET.has(id) ? (id as Ability) : null;
+}
diff --git a/app/features/scanner/store/db.ts b/app/features/scanner/store/db.ts
new file mode 100644
index 000000000..f3a00f360
--- /dev/null
+++ b/app/features/scanner/store/db.ts
@@ -0,0 +1,93 @@
+/**
+ * Shared IndexedDB handle for the app's stores:
+ *  - `events`: live-tab detections, keyed by auto id (see events.ts)
+ *  - `frames`: the live events' full-res analyzed PNGs, keyed by event id —
+ *    kept out of `events` so listing the feed never deserializes them
+ *  - `vods`: one summary record per fully scanned VoD, keyed by file name
+ *  - `vod-events`: the detections of each saved VoD, indexed by VoD name
+ *  - `vod-frames`: the vod-events' PNGs, keyed by vod-event id
+ *  - `inspect-frames`: one-shot Inspect handoffs into a new screenshot tab,
+ *    keyed by handoff key (see inspect.ts)
+ */
+const DB_NAME = "scanner";
+const DB_VERSION = 1;
+
+export const EVENTS_STORE = "events";
+export const FRAMES_STORE = "frames";
+export const VODS_STORE = "vods";
+export const VOD_EVENTS_STORE = "vod-events";
+export const VOD_FRAMES_STORE = "vod-frames";
+export const INSPECT_FRAMES_STORE = "inspect-frames";
+
+/**
+ * Recreates the schema from scratch, dropping any stores already there, so a
+ * DB_VERSION bump is always a clean slate at the cost of wiping scanner data.
+ */
+function createStores(database: IDBDatabase): void {
+	for (const name of Array.from(database.objectStoreNames)) {
+		database.deleteObjectStore(name);
+	}
+
+	const events = database.createObjectStore(EVENTS_STORE, {
+		keyPath: "id",
+		autoIncrement: true,
+	});
+	events.createIndex("t", "t");
+	events.createIndex("detectedAt", "detectedAt");
+
+	database.createObjectStore(VODS_STORE, { keyPath: "name" });
+
+	const vodEvents = database.createObjectStore(VOD_EVENTS_STORE, {
+		keyPath: "id",
+		autoIncrement: true,
+	});
+	vodEvents.createIndex("vod", "vod");
+
+	database.createObjectStore(FRAMES_STORE);
+	database.createObjectStore(VOD_FRAMES_STORE);
+	database.createObjectStore(INSPECT_FRAMES_STORE);
+}
+
+function openDb(): Promise<IDBDatabase> {
+	return new Promise((resolve, reject) => {
+		const req = indexedDB.open(DB_NAME, DB_VERSION);
+		req.onupgradeneeded = () => createStores(req.result);
+		req.onblocked = () => {
+			// biome-ignore lint/suspicious/noConsole: the only diagnostic channel for a hang caused by other tabs
+			console.warn(
+				"scanner database upgrade is blocked — close or reload other sendou.ink tabs",
+			);
+		};
+		req.onsuccess = () => resolve(req.result);
+		req.onerror = () => reject(req.error);
+	});
+}
+
+let dbPromise: Promise<IDBDatabase> | null = null;
+export function db(): Promise<IDBDatabase> {
+	dbPromise ??= openDb().then((database) => {
+		// when another tab needs to upgrade, release the connection instead of
+		// blocking that tab forever; the next call here reconnects fresh
+		database.onversionchange = () => {
+			database.close();
+			dbPromise = null;
+		};
+		return database;
+	});
+	return dbPromise;
+}
+
+/** Single-request convenience wrapper over one object store. */
+export async function tx<T>(
+	storeName: string,
+	mode: IDBTransactionMode,
+	run: (store: IDBObjectStore) => IDBRequest<T>,
+): Promise<T> {
+	const database = await db();
+	return new Promise<T>((resolve, reject) => {
+		const transaction = database.transaction(storeName, mode);
+		const req = run(transaction.objectStore(storeName));
+		req.onsuccess = () => resolve(req.result);
+		req.onerror = () => reject(req.error);
+	});
+}
diff --git a/app/features/scanner/store/events.ts b/app/features/scanner/store/events.ts
new file mode 100644
index 000000000..4928736a7
--- /dev/null
+++ b/app/features/scanner/store/events.ts
@@ -0,0 +1,180 @@
+/**
+ * IndexedDB event store: one `events` object store, keyed by auto id,
+ * indexed by timestamp. A small thumbnail of the detection frame is kept
+ * per event for the feed; the full-res analyzed PNG lives in the separate
+ * `frames` store under the same id (loaded on demand via loadEventFrame),
+ * so listing the feed never deserializes megabytes of blobs. The store is
+ * capped: saving past MAX_EVENTS evicts the oldest events and their frames.
+ */
+import type { IngestedMatchLink } from "~/features/scanner-ingest/scanner-ingest-schemas";
+import type { DetectedEvent } from "../core/detectors/types";
+import { db, EVENTS_STORE, FRAMES_STORE, tx } from "./db";
+
+/** Oldest events (and their frames) are evicted past this count. */
+const MAX_EVENTS = 1000;
+
+/** Where an event stands with sendou.ink /ingest; absent = never attempted. */
+export interface SendStatus {
+	/**
+	 * "unlinked": sendou.ink stored the match but its game is not reported
+	 * yet, so it has no scoreboard to attach to — resent on a backoff.
+	 */
+	state: "queued" | "sending" | "sent" | "unlinked" | "failed";
+	/** wall-clock time of the last state change */
+	at: number;
+	/** failure detail, set when state is "failed" */
+	error?: string;
+	/** the sendou.ink match /ingest linked the sent match to, when it reported one */
+	link?: IngestedMatchLink;
+	/** how many times the match came back unlinked, set while state is "unlinked" */
+	attempts?: number;
+}
+
+export interface StoredEvent {
+	id?: number;
+	type: string;
+	t: number;
+	/** wall-clock time of detection */
+	detectedAt: number;
+	confidence: number;
+	data: unknown;
+	/** small JPEG data URL of the source frame */
+	thumbnail?: string;
+	/** whether a full-res frame exists in the `frames` store under this id */
+	hasFrame?: boolean;
+	send?: SendStatus;
+}
+
+/**
+ * Persist a detection; resolves to its store id. `reuseId` overwrites that
+ * existing row (and its frame) instead of adding a new one, so an event a
+ * better read replaces keeps a stable id.
+ */
+export async function saveEvent(
+	event: DetectedEvent,
+	thumbnail?: string,
+	frame?: Blob,
+	reuseId?: number,
+): Promise<number> {
+	const record: StoredEvent = {
+		...(reuseId !== undefined ? { id: reuseId } : null),
+		type: event.type,
+		t: event.t,
+		detectedAt: Date.now(),
+		confidence: event.confidence,
+		data: event.data,
+		thumbnail,
+		hasFrame: frame !== undefined,
+	};
+	const database = await db();
+	return new Promise<number>((resolve, reject) => {
+		const transaction = database.transaction(
+			[EVENTS_STORE, FRAMES_STORE],
+			"readwrite",
+		);
+		const events = transaction.objectStore(EVENTS_STORE);
+		const frames = transaction.objectStore(FRAMES_STORE);
+		let id: number;
+		const add = events.put(record) as IDBRequest<number>;
+		add.onsuccess = () => {
+			id = add.result;
+			if (frame) frames.put(frame, id);
+			else if (reuseId !== undefined) frames.delete(id);
+			evictOldest(events, frames);
+		};
+		transaction.oncomplete = () => resolve(id);
+		transaction.onerror = () => reject(transaction.error);
+	});
+}
+
+/** Delete records (and frames) beyond MAX_EVENTS, oldest ids first. */
+function evictOldest(events: IDBObjectStore, frames: IDBObjectStore): void {
+	const count = events.count();
+	count.onsuccess = () => {
+		let excess = count.result - MAX_EVENTS;
+		if (excess <= 0) return;
+		const cursor = events.openCursor(); // ascending id = oldest first
+		cursor.onsuccess = () => {
+			const c = cursor.result;
+			if (!c || excess <= 0) return;
+			frames.delete(c.primaryKey);
+			c.delete();
+			excess--;
+			if (excess > 0) c.continue();
+		};
+	};
+}
+
+/** Sets (or clears) the send status of the given events in one transaction. */
+export async function updateEventsSend(
+	ids: number[],
+	send: SendStatus | undefined,
+): Promise<void> {
+	const database = await db();
+	return new Promise<void>((resolve, reject) => {
+		const transaction = database.transaction(EVENTS_STORE, "readwrite");
+		const events = transaction.objectStore(EVENTS_STORE);
+		for (const id of ids) {
+			const get = events.get(id) as IDBRequest<StoredEvent | undefined>;
+			get.onsuccess = () => {
+				const record = get.result;
+				if (!record) return; // evicted meanwhile
+				if (send) record.send = send;
+				else delete record.send;
+				events.put(record);
+			};
+		}
+		transaction.oncomplete = () => resolve();
+		transaction.onerror = () => reject(transaction.error);
+	});
+}
+
+/** Deletes the given events and their frames in one transaction. */
+export async function deleteEvents(ids: number[]): Promise<void> {
+	const database = await db();
+	return new Promise<void>((resolve, reject) => {
+		const transaction = database.transaction(
+			[EVENTS_STORE, FRAMES_STORE],
+			"readwrite",
+		);
+		const events = transaction.objectStore(EVENTS_STORE);
+		const frames = transaction.objectStore(FRAMES_STORE);
+		for (const id of ids) {
+			events.delete(id);
+			frames.delete(id);
+		}
+		transaction.oncomplete = () => resolve();
+		transaction.onerror = () => reject(transaction.error);
+	});
+}
+
+export function listEvents(): Promise<StoredEvent[]> {
+	return tx(
+		EVENTS_STORE,
+		"readonly",
+		(store) => store.getAll() as IDBRequest<StoredEvent[]>,
+	);
+}
+
+/** The event's full-res analyzed PNG, or undefined when none was stored. */
+export function loadEventFrame(id: number): Promise<Blob | undefined> {
+	return tx(
+		FRAMES_STORE,
+		"readonly",
+		(store) => store.get(id) as IDBRequest<Blob | undefined>,
+	);
+}
+
+export async function clearEvents(): Promise<void> {
+	const database = await db();
+	return new Promise<void>((resolve, reject) => {
+		const transaction = database.transaction(
+			[EVENTS_STORE, FRAMES_STORE],
+			"readwrite",
+		);
+		transaction.objectStore(EVENTS_STORE).clear();
+		transaction.objectStore(FRAMES_STORE).clear();
+		transaction.oncomplete = () => resolve();
+		transaction.onerror = () => reject(transaction.error);
+	});
+}
diff --git a/app/features/scanner/store/inspect.ts b/app/features/scanner/store/inspect.ts
new file mode 100644
index 000000000..cda8d7c9b
--- /dev/null
+++ b/app/features/scanner/store/inspect.ts
@@ -0,0 +1,48 @@
+/**
+ * Cross-tab frame handoff for the Inspect action: the source tab stashes the
+ * frame under a fresh key and opens the screenshot page in a new browser tab
+ * with ?inspect=<key>. The write races the new tab's load, so claiming polls
+ * briefly before giving up. Claimed records are deleted; unclaimed leftovers
+ * (blocked popup, tab closed mid-load) are swept by key age on the next
+ * handoff.
+ */
+
+import { INSPECT_FRAMES_STORE, tx } from "./db";
+
+const CLAIM_ATTEMPTS = 20;
+const CLAIM_RETRY_MS = 150;
+const STALE_AFTER_MS = 24 * 60 * 60 * 1000;
+
+/** Fresh handoff key; the fixed-width timestamp prefix keys the stale sweep. */
+export function newInspectKey(): string {
+	return `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+
+/** Stash a frame for the tab that was opened with this key. */
+export async function putInspectFrame(key: string, frame: Blob): Promise<void> {
+	await tx(INSPECT_FRAMES_STORE, "readwrite", (store) =>
+		store.delete(IDBKeyRange.upperBound(String(Date.now() - STALE_AFTER_MS))),
+	);
+	await tx(INSPECT_FRAMES_STORE, "readwrite", (store) => store.put(frame, key));
+}
+
+/** Take (and delete) the frame stashed under this key, polling the write race. */
+export async function claimInspectFrame(key: string): Promise<Blob | null> {
+	for (let attempt = 0; attempt < CLAIM_ATTEMPTS; attempt++) {
+		if (attempt > 0) await delay(CLAIM_RETRY_MS);
+		const frame = await tx<Blob | undefined>(
+			INSPECT_FRAMES_STORE,
+			"readonly",
+			(store) => store.get(key),
+		);
+		if (frame) {
+			await tx(INSPECT_FRAMES_STORE, "readwrite", (store) => store.delete(key));
+			return frame;
+		}
+	}
+	return null;
+}
+
+function delay(ms: number): Promise<void> {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
diff --git a/app/features/scanner/store/vods.browser.test.ts b/app/features/scanner/store/vods.browser.test.ts
new file mode 100644
index 000000000..7e36625b2
--- /dev/null
+++ b/app/features/scanner/store/vods.browser.test.ts
@@ -0,0 +1,56 @@
+import { beforeEach, describe, expect, test } from "vitest";
+import { deleteVod, listVods, saveVod, saveVodResultsSend } from "./vods";
+
+const VOD_NAME = "results-send.mkv";
+
+async function saveTestVod() {
+	await saveVod({ name: VOD_NAME, savedAt: 1_000, duration: 60 }, [
+		{ type: "scoreboard", t: 10, confidence: 0.9, data: {} },
+	]);
+}
+
+async function storedVod() {
+	return (await listVods()).find((vod) => vod.name === VOD_NAME);
+}
+
+describe("saveVodResultsSend()", () => {
+	beforeEach(async () => {
+		await deleteVod(VOD_NAME);
+	});
+
+	test("a saved scan has no send outcome", async () => {
+		await saveTestVod();
+
+		expect((await storedVod())?.resultsSend).toBeUndefined();
+	});
+
+	test("remembers the send outcome of a scan", async () => {
+		await saveTestVod();
+		await saveVodResultsSend(VOD_NAME, {
+			sent: 2,
+			total: 3,
+			error: null,
+			at: 5_000,
+		});
+
+		expect((await storedVod())?.resultsSend).toEqual({
+			sent: 2,
+			total: 3,
+			error: null,
+			at: 5_000,
+		});
+	});
+
+	test("re-scanning the file forgets the send outcome", async () => {
+		await saveTestVod();
+		await saveVodResultsSend(VOD_NAME, {
+			sent: 3,
+			total: 3,
+			error: null,
+			at: 5_000,
+		});
+		await saveTestVod();
+
+		expect((await storedVod())?.resultsSend).toBeUndefined();
+	});
+});
diff --git a/app/features/scanner/store/vods.ts b/app/features/scanner/store/vods.ts
new file mode 100644
index 000000000..b995624f5
--- /dev/null
+++ b/app/features/scanner/store/vods.ts
@@ -0,0 +1,177 @@
+/**
+ * Persistence for completed VoD scans, keyed by the VoD's file name so a
+ * scanned video can be reinspected later without re-decoding it. The
+ * summary lives in `vods`; the detections live in `vod-events` under a
+ * `vod` index, and their full-res analyzed PNGs in `vod-frames` under the
+ * event id (loaded on demand via loadVodEventFrame), so listing VoDs and
+ * their events stays cheap. Re-scanning the same file name overwrites the
+ * previous save.
+ */
+import type { IngestedMatchLink } from "~/features/scanner-ingest/scanner-ingest-schemas";
+import { db, tx, VOD_EVENTS_STORE, VOD_FRAMES_STORE, VODS_STORE } from "./db";
+
+/** How a VoD's last "Send results" went; absent = never attempted. */
+export interface VodResultsSend {
+	/** matches sendou.ink /ingest accepted */
+	sent: number;
+	total: number;
+	/** failure detail, null when the send went through */
+	error: string | null;
+	/** wall-clock time the send finished */
+	at: number;
+	/** links /ingest reported, keyed by index into the scan's ingestable matches */
+	links?: Array<{ matchIndex: number; link: IngestedMatchLink }>;
+}
+
+export interface VodSummary {
+	/** VoD file name — primary key */
+	name: string;
+	/** wall-clock time the scan finished */
+	savedAt: number;
+	/** video duration in seconds */
+	duration: number;
+	eventCount: number;
+	resultsSend?: VodResultsSend;
+}
+
+export interface StoredVodEvent {
+	id?: number;
+	/** owning VoD name (indexed) */
+	vod: string;
+	type: string;
+	t: number;
+	confidence: number;
+	data: unknown;
+	/** small JPEG data URL of the source frame */
+	thumbnail?: string;
+	/** whether a full-res frame exists in `vod-frames` under this id */
+	hasFrame?: boolean;
+}
+
+/** A vod-event to persist, with its (separately stored) frame attached. */
+export type VodEventToSave = Omit<StoredVodEvent, "id" | "vod" | "hasFrame"> & {
+	frame?: Blob;
+};
+
+/** Delete every vod-event (and frame) of `name` via the index, then run `next`. */
+function clearVodEvents(
+	events: IDBObjectStore,
+	frames: IDBObjectStore,
+	name: string,
+	next: () => void,
+): void {
+	const req = events.index("vod").openCursor(IDBKeyRange.only(name));
+	req.onsuccess = () => {
+		const cursor = req.result;
+		if (cursor) {
+			frames.delete(cursor.primaryKey);
+			cursor.delete();
+			cursor.continue();
+		} else {
+			next();
+		}
+	};
+}
+
+export async function saveVod(
+	meta: Omit<VodSummary, "eventCount">,
+	events: VodEventToSave[],
+): Promise<void> {
+	const database = await db();
+	return new Promise((resolve, reject) => {
+		const transaction = database.transaction(
+			[VODS_STORE, VOD_EVENTS_STORE, VOD_FRAMES_STORE],
+			"readwrite",
+		);
+		const eventStore = transaction.objectStore(VOD_EVENTS_STORE);
+		const frameStore = transaction.objectStore(VOD_FRAMES_STORE);
+		clearVodEvents(eventStore, frameStore, meta.name, () => {
+			for (const { frame, ...event } of events) {
+				const add = eventStore.add({
+					...event,
+					vod: meta.name,
+					hasFrame: frame !== undefined,
+				}) as IDBRequest<number>;
+				if (frame) add.onsuccess = () => frameStore.put(frame, add.result);
+			}
+			transaction
+				.objectStore(VODS_STORE)
+				.put({ ...meta, eventCount: events.length });
+		});
+		transaction.oncomplete = () => resolve();
+		transaction.onerror = () => reject(transaction.error);
+	});
+}
+
+/**
+ * Records how a VoD's "Send results" went, so reopening the scan reports
+ * what was sent instead of showing every match as never sent. Re-scanning
+ * the file starts over: `saveVod` writes a summary without one.
+ */
+export async function saveVodResultsSend(
+	name: string,
+	resultsSend: VodResultsSend,
+): Promise<void> {
+	const database = await db();
+	return new Promise((resolve, reject) => {
+		const transaction = database.transaction(VODS_STORE, "readwrite");
+		const vods = transaction.objectStore(VODS_STORE);
+		const get = vods.get(name) as IDBRequest<VodSummary | undefined>;
+		get.onsuccess = () => {
+			const summary = get.result;
+			if (!summary) return; // deleted meanwhile
+			vods.put({ ...summary, resultsSend });
+		};
+		transaction.oncomplete = () => resolve();
+		transaction.onerror = () => reject(transaction.error);
+	});
+}
+
+export async function listVods(): Promise<VodSummary[]> {
+	const vods = await tx(
+		VODS_STORE,
+		"readonly",
+		(store) => store.getAll() as IDBRequest<VodSummary[]>,
+	);
+	return vods.sort((a, b) => b.savedAt - a.savedAt);
+}
+
+export async function loadVodEvents(name: string): Promise<StoredVodEvent[]> {
+	const events = await tx(
+		VOD_EVENTS_STORE,
+		"readonly",
+		(store) =>
+			store.index("vod").getAll(IDBKeyRange.only(name)) as IDBRequest<
+				StoredVodEvent[]
+			>,
+	);
+	return events.sort((a, b) => a.t - b.t);
+}
+
+/** The vod-event's full-res analyzed PNG, or undefined when none was stored. */
+export function loadVodEventFrame(id: number): Promise<Blob | undefined> {
+	return tx(
+		VOD_FRAMES_STORE,
+		"readonly",
+		(store) => store.get(id) as IDBRequest<Blob | undefined>,
+	);
+}
+
+export async function deleteVod(name: string): Promise<void> {
+	const database = await db();
+	return new Promise((resolve, reject) => {
+		const transaction = database.transaction(
+			[VODS_STORE, VOD_EVENTS_STORE, VOD_FRAMES_STORE],
+			"readwrite",
+		);
+		transaction.objectStore(VODS_STORE).delete(name);
+		clearVodEvents(
+			transaction.objectStore(VOD_EVENTS_STORE),
+			transaction.objectStore(VOD_FRAMES_STORE),
+			name,
+			() => {},
+		);
+		transaction.oncomplete = () => resolve();
+		transaction.onerror = () => reject(transaction.error);
+	});
+}
diff --git a/app/features/scanner/tests/ability-harvest.test.ts b/app/features/scanner/tests/ability-harvest.test.ts
new file mode 100644
index 000000000..c758e5fd8
--- /dev/null
+++ b/app/features/scanner/tests/ability-harvest.test.ts
@@ -0,0 +1,133 @@
+/**
+ * Unit tests for connectAbilities: deaths are attributed to the next
+ * scoreboard event and matched to a player row by name/weapon, with
+ * ambiguous matches (two players on the same weapon, misread name)
+ * left unattributed.
+ */
+
+import assert from "node:assert/strict";
+import type {
+	AbilityWithUnknown,
+	MainWeaponId,
+} from "~/modules/in-game-lists/types";
+import { connectAbilities } from "../core/ability-harvest";
+import {
+	DEATH_EVENT_TYPE,
+	type DeathData,
+} from "../core/detectors/death/index";
+import { SCOREBOARD_EVENT_TYPE } from "../core/detectors/scoreboard/index";
+import type { DetectedEvent } from "../core/detectors/types";
+import test from "./node-test-compat";
+
+const GRID_A: AbilityWithUnknown[][] = [
+	["ISM", "ISM", "ISM", "ISM"],
+	["RSU", "RSU", "RSU", "RSU"],
+	["SSU", "SSU", "SSU", "SSU"],
+];
+const GRID_B: AbilityWithUnknown[][] = [
+	["QR", "QR", "QR", "QR"],
+	["QSJ", "QSJ", "QSJ", "QSJ"],
+	["IRU", "IRU", "IRU", "IRU"],
+];
+
+function player(name: string, weaponId: MainWeaponId) {
+	return { name, weaponId, paint: null, ka: null, d: null, s: null };
+}
+
+function death(
+	t: number,
+	name: string | null,
+	weaponId: MainWeaponId | null,
+	abilities: AbilityWithUnknown[][] = GRID_A,
+): DetectedEvent<DeathData> {
+	return {
+		type: DEATH_EVENT_TYPE,
+		t,
+		confidence: 0.9,
+		data: {
+			weaponId,
+			weaponType: weaponId !== null ? "MAIN" : null,
+			abilities,
+			name,
+		},
+	};
+}
+
+function scoreboard(
+	t: number,
+	players: ReturnType<typeof player>[],
+): DetectedEvent {
+	return {
+		type: SCOREBOARD_EVENT_TYPE,
+		t,
+		confidence: 0.9,
+		data: {
+			lobby: null,
+			mode: null,
+			stage: null,
+			scores: [null, null],
+			players,
+		},
+	};
+}
+
+const PLAYERS = [
+	player("Alpha", 40),
+	player("Bravo", 50),
+	player("Charlie", 60),
+	player("Delta", 50),
+	player("Echo", 70),
+	player("Foxtrot", 80),
+	player("Golf", 90),
+	player("Hotel", 100),
+];
+
+test("matches by name+weapon, unique name, and unique weapon", () => {
+	const board = scoreboard(100, PLAYERS);
+	const map = connectAbilities([
+		death(10, "Bravo", 50), // name+weapon → index 1, not the other 50 at index 3
+		death(20, "charlie ", null, GRID_B), // unique name alone (case/space-insensitive) → 2
+		death(30, "garbled", 70), // unique weapon despite misread name → 4
+		board,
+	]);
+	const abilities = map.get(board);
+	assert.ok(abilities);
+	assert.deepEqual(abilities.get(1), GRID_A);
+	assert.deepEqual(abilities.get(2), GRID_B);
+	assert.deepEqual(abilities.get(4), GRID_A);
+	assert.equal(abilities.size, 3);
+});
+
+test("ambiguous weapon with unknown name stays unattributed", () => {
+	const board = scoreboard(100, PLAYERS);
+	const map = connectAbilities([death(10, "garbled", 50), board]);
+	assert.equal(map.get(board), undefined);
+});
+
+test("deaths only attach to the next scoreboard", () => {
+	const board1 = scoreboard(100, PLAYERS);
+	const board2 = scoreboard(400, PLAYERS);
+	const map = connectAbilities([
+		death(10, "Alpha", 40),
+		board1,
+		death(200, "Echo", 70, GRID_B),
+		board2,
+	]);
+	assert.deepEqual(map.get(board1)?.get(0), GRID_A);
+	assert.equal(map.get(board1)?.get(4), undefined);
+	assert.deepEqual(map.get(board2)?.get(4), GRID_B);
+	assert.equal(map.get(board2)?.get(0), undefined);
+});
+
+test("unsorted input is handled and trailing deaths are dropped", () => {
+	const board = scoreboard(100, PLAYERS);
+	const map = connectAbilities([
+		death(150, "Alpha", 40), // after the scoreboard — belongs to a match never finished
+		board,
+		death(10, "Hotel", 100, GRID_B),
+	]);
+	const abilities = map.get(board);
+	assert.ok(abilities);
+	assert.deepEqual(abilities.get(7), GRID_B);
+	assert.equal(abilities.size, 1);
+});
diff --git a/app/features/scanner/tests/banner.test.ts b/app/features/scanner/tests/banner.test.ts
new file mode 100644
index 000000000..ebb922f69
--- /dev/null
+++ b/app/features/scanner/tests/banner.test.ts
@@ -0,0 +1,73 @@
+/**
+ * resolveMatchScores is pure — the parse side of banner.ts is covered by
+ * the scoreboard fixture suite, this pins the winner/loser resolution.
+ */
+
+import assert from "node:assert/strict";
+import {
+	type BannerScoreRead,
+	resolveMatchScores,
+} from "../core/detectors/scoreboard/banner";
+import test from "./node-test-compat";
+
+function read(value: number | null, confidence = 0.9): BannerScoreRead {
+	return {
+		value,
+		confidence,
+		digits: value === null ? 0 : String(value).length,
+		reading: value === null ? "" : String(value),
+	};
+}
+
+test("both sides read: higher value is the winner's, either way around", () => {
+	assert.deepEqual(
+		resolveMatchScores({ left: read(71), right: read(88), knockout: false }),
+		[88, 71],
+	);
+	assert.deepEqual(
+		resolveMatchScores({ left: read(88), right: read(71), knockout: false }),
+		[88, 71],
+	);
+});
+
+test("a knockout reports the full count over anything read off the burst", () => {
+	// burst letters surviving the floor read as a junk low-confidence value
+	assert.deepEqual(
+		resolveMatchScores({
+			left: read(0, 0.88),
+			right: read(7, 0.62),
+			knockout: true,
+		}),
+		[100, 0],
+	);
+});
+
+test("a knockout's loser is the side that read", () => {
+	assert.deepEqual(
+		resolveMatchScores({ left: read(null), right: read(0), knockout: true }),
+		[100, 0],
+	);
+	assert.deepEqual(
+		resolveMatchScores({ left: read(0), right: read(null), knockout: true }),
+		[100, 0],
+	);
+	assert.deepEqual(
+		resolveMatchScores({ left: read(null), right: read(null), knockout: true }),
+		[100, null],
+	);
+});
+
+test("one unreadable side without a knockout reports nothing", () => {
+	assert.deepEqual(
+		resolveMatchScores({ left: read(71), right: read(null), knockout: false }),
+		[null, null],
+	);
+	assert.deepEqual(
+		resolveMatchScores({
+			left: read(null),
+			right: read(null),
+			knockout: false,
+		}),
+		[null, null],
+	);
+});
diff --git a/app/features/scanner/tests/death.1.test.ts b/app/features/scanner/tests/death.1.test.ts
new file mode 100644
index 000000000..dd1cc77a8
--- /dev/null
+++ b/app/features/scanner/tests/death.1.test.ts
@@ -0,0 +1,4 @@
+/** Shard 1/3 of the death suite — see tests/suites/death.ts. */
+import { runDeathSuite } from "./suites/death";
+
+await runDeathSuite(0, 3);
diff --git a/app/features/scanner/tests/death.2.test.ts b/app/features/scanner/tests/death.2.test.ts
new file mode 100644
index 000000000..910b0d987
--- /dev/null
+++ b/app/features/scanner/tests/death.2.test.ts
@@ -0,0 +1,4 @@
+/** Shard 2/3 of the death suite — see tests/suites/death.ts. */
+import { runDeathSuite } from "./suites/death";
+
+await runDeathSuite(1, 3);
diff --git a/app/features/scanner/tests/death.3.test.ts b/app/features/scanner/tests/death.3.test.ts
new file mode 100644
index 000000000..e5724e1f8
--- /dev/null
+++ b/app/features/scanner/tests/death.3.test.ts
@@ -0,0 +1,4 @@
+/** Shard 3/3 of the death suite — see tests/suites/death.ts. */
+import { runDeathSuite } from "./suites/death";
+
+await runDeathSuite(2, 3);
diff --git a/app/features/scanner/tests/dedupe-events.test.ts b/app/features/scanner/tests/dedupe-events.test.ts
new file mode 100644
index 000000000..2d1baa665
--- /dev/null
+++ b/app/features/scanner/tests/dedupe-events.test.ts
@@ -0,0 +1,93 @@
+import assert from "node:assert/strict";
+import type {
+	AbilityWithUnknown,
+	MainWeaponId,
+	StageId,
+} from "~/modules/in-game-lists/types";
+import { withoutRepeatEvents } from "../components/dedupe-events";
+import type { DeathData } from "../core/detectors/death/index";
+import type {
+	MinimapData,
+	MinimapEnemy,
+	MinimapTeammate,
+} from "../core/detectors/minimap/index";
+import { SPECTATOR_SLOTS } from "../core/detectors/minimap/rois";
+import type { DetectedEvent } from "../core/detectors/types";
+import test from "./node-test-compat";
+
+const ALPHA: MainWeaponId[] = [40, 1001, 2010, 3030];
+const BRAVO: MainWeaponId[] = [50, 210, 4010, 8000];
+
+function teammate(
+	weaponId: MainWeaponId | null,
+	i: number,
+	{
+		name = null as string | null,
+		abilities = [] as (AbilityWithUnknown | null)[],
+	} = {},
+): MinimapTeammate {
+	return { slot: SPECTATOR_SLOTS[i]!, name, weaponId, abilities };
+}
+
+function enemy(
+	weaponId: MainWeaponId | null,
+	{ name = null as string | null } = {},
+): MinimapEnemy {
+	return { name, weaponId, abilities: [] };
+}
+
+function minimap(
+	t: number,
+	{
+		stage = 0 as StageId | null,
+		teammates = ALPHA.map((id, i) => teammate(id, i)),
+		enemies = BRAVO.map((id) => enemy(id)),
+	} = {},
+): DetectedEvent {
+	const data: MinimapData = { stage, spectator: true, teammates, enemies };
+	return { type: "Minimap", t, confidence: 0.8, data };
+}
+
+function death(t: number): DetectedEvent {
+	const data: DeathData = {
+		weaponId: null,
+		weaponType: "MAIN",
+		abilities: [],
+		name: null,
+	};
+	return { type: "Death", t, confidence: 0.9, data };
+}
+
+test("collapses a repeated minimap into the first occurrence", () => {
+	const kept = withoutRepeatEvents([minimap(70), minimap(73), minimap(76)]);
+	assert.equal(kept.length, 1);
+	assert.equal(kept[0]!.t, 70);
+});
+
+test("a name-only difference is still a repeat (OCR wobble)", () => {
+	const kept = withoutRepeatEvents([
+		minimap(70, { enemies: BRAVO.map((id) => enemy(id, { name: "クレー" })) }),
+		minimap(73, { enemies: BRAVO.map((id) => enemy(id, { name: "グレー" })) }),
+	]);
+	assert.equal(kept.length, 1);
+});
+
+test("a changed ability read keeps both minimaps", () => {
+	const kept = withoutRepeatEvents([
+		minimap(70),
+		minimap(73, {
+			teammates: ALPHA.map((id, i) =>
+				teammate(id, i, { abilities: i === 0 ? ["ISM"] : [] }),
+			),
+		}),
+	]);
+	assert.equal(kept.length, 2);
+});
+
+test("dedupes across interleaved events of other types, dropping none of them", () => {
+	const kept = withoutRepeatEvents([minimap(70), death(72), minimap(74)]);
+	assert.deepEqual(
+		kept.map((e) => e.type),
+		["Minimap", "Death"],
+	);
+});
diff --git a/app/features/scanner/tests/fixtures/death/classic-squiffer-jp/expected.json b/app/features/scanner/tests/fixtures/death/classic-squiffer-jp/expected.json
new file mode 100644
index 000000000..dc19d74dc
--- /dev/null
+++ b/app/features/scanner/tests/fixtures/death/classic-squiffer-jp/expected.json
@@ -0,0 +1,32 @@
+{
+  "event": "Death",
+  "data": {
+    "weaponId": 2000,
+    "weaponType": "MAIN",
+    "abilities": [
+      [
+        "SSU",
+        "SSU",
+        "SRU",
+        "ISS"
+      ],
+      [
+        "BRU",
+        "ISS",
+        "UNKNOWN",
+        "UNKNOWN"
+      ],
+      [
+        "SCU",
+        "SS",
+        "SCU",
+        "SSU"
+      ]
+    ],
+    "name": "ごあんぜんに",
+    "weaponLabel": "Classic Squiffer"
+  },
+  "options": {
+    "notes": "Japanese-language capture (message 'スクイックリンα で / やられた!', weapon on line 1, read via the death-weapon-ja atlas). Streamer webcam bottom-left pixelated for privacy (clear of every parsed ROI). The all-kana tag name needs the dakuten headroom in TAG_NAME_INNER (ご/ぜ) and the harvested に crop (its bar stroke reads as a near-perfect l otherwise)."
+  }
+}
diff --git a/app/features/scanner/tests/fixtures/death/classic-squiffer-jp/frame.png b/app/features/scanner/tests/fixtures/death/classic-squiffer-jp/frame.png
new file mode 100644
index 000000000..123db53aa
Binary files /dev/null and b/app/features/scanner/tests/fixtures/death/classic-squiffer-jp/frame.png differ
diff --git a/app/features/scanner/tests/fixtures/death/colorful-splashtag/expected.json b/app/features/scanner/tests/fixtures/death/colorful-splashtag/expected.json
new file mode 100644
index 000000000..2c3ea339e
--- /dev/null
+++ b/app/features/scanner/tests/fixtures/death/colorful-splashtag/expected.json
@@ -0,0 +1,29 @@
+{
+  "event": "Death",
+  "data": {
+    "weaponId": 40,
+    "weaponType": "MAIN",
+    "abilities": [
+      [
+        "LDE",
+        "RSU",
+        "ISS",
+        "ISS"
+      ],
+      [
+        "SSU",
+        "SSU",
+        "QR",
+        "SS"
+      ],
+      [
+        "SJ",
+        "SSU",
+        "QR",
+        "QSJ"
+      ]
+    ],
+    "name": "Aviators",
+    "weaponLabel": "Splattershot"
+  }
+}
diff --git a/app/features/scanner/tests/fixtures/death/colorful-splashtag/frame.png b/app/features/scanner/tests/fixtures/death/colorful-splashtag/frame.png
new file mode 100644
index 000000000..e444b92a0
Binary files /dev/null and b/app/features/scanner/tests/fixtures/death/colorful-splashtag/frame.png differ
diff --git a/app/features/scanner/tests/fixtures/death/e-liter-4k-jp-720p/expected.json b/app/features/scanner/tests/fixtures/death/e-liter-4k-jp-720p/expected.json
new file mode 100644
index 000000000..79977e78c
--- /dev/null
+++ b/app/features/scanner/tests/fixtures/death/e-liter-4k-jp-720p/expected.json
@@ -0,0 +1,32 @@
+{
+  "event": "Death",
+  "data": {
+    "weaponId": 2030,
+    "weaponType": "MAIN",
+    "abilities": [
+      [
+        "QSJ",
+        "SSU",
+        "ISS",
+        "UNKNOWN"
+      ],
+      [
+        "ISM",
+        "SSU",
+        "UNKNOWN",
+        "UNKNOWN"
+      ],
+      [
+        "ISS",
+        "SRU",
+        "SPU",
+        "SRU"
+      ]
+    ],
+    "name": "JINGIのヒト",
+    "weaponLabel": "E-liter 4K"
+  },
+  "options": {
+    "notes": "720p VoD capture (upscaled to canonical at ingest), JP death message 'リッター4K で / やられた！'. The read garbles below both the plain-snap threshold and the lattice margin ('4K' is unreadable); the weapon resolves only via burst-icon corroboration — icon top-1 (E-liter 4K) agrees with the plain text ranking's top. Streamer webcam bottom-left pixelated for privacy (region sits left of every parsed ROI)."
+  }
+}
diff --git a/app/features/scanner/tests/fixtures/death/e-liter-4k-jp-720p/frame.png b/app/features/scanner/tests/fixtures/death/e-liter-4k-jp-720p/frame.png
new file mode 100644
index 000000000..bc5974703
Binary files /dev/null and b/app/features/scanner/tests/fixtures/death/e-liter-4k-jp-720p/frame.png differ
diff --git a/app/features/scanner/tests/fixtures/death/fxg-supaatan-slosher/expected.json b/app/features/scanner/tests/fixtures/death/fxg-supaatan-slosher/expected.json
new file mode 100644
index 000000000..e60f48415
--- /dev/null
+++ b/app/features/scanner/tests/fixtures/death/fxg-supaatan-slosher/expected.json
@@ -0,0 +1,29 @@
+{
+  "event": "Death",
+  "data": {
+    "weaponId": 3000,
+    "weaponType": "MAIN",
+    "abilities": [
+      [
+        "CB",
+        "SS",
+        "SSU",
+        "ISS"
+      ],
+      [
+        "QR",
+        "QR",
+        "QR",
+        "QSJ"
+      ],
+      [
+        "QR",
+        "QR",
+        "RES",
+        "SRU"
+      ]
+    ],
+    "name": "FxG スパータン",
+    "weaponLabel": "Slosher"
+  }
+}
diff --git a/app/features/scanner/tests/fixtures/death/fxg-supaatan-slosher/frame.png b/app/features/scanner/tests/fixtures/death/fxg-supaatan-slosher/frame.png
new file mode 100644
index 000000000..08f52aa6a
Binary files /dev/null and b/app/features/scanner/tests/fixtures/death/fxg-supaatan-slosher/frame.png differ
diff --git a/app/features/scanner/tests/fixtures/death/german-booyah-bomb/expected.json b/app/features/scanner/tests/fixtures/death/german-booyah-bomb/expected.json
new file mode 100644
index 000000000..826d73203
--- /dev/null
+++ b/app/features/scanner/tests/fixtures/death/german-booyah-bomb/expected.json
@@ -0,0 +1,29 @@
+{
+  "event": "Death",
+  "data": {
+    "weaponId": 6,
+    "weaponType": "SPECIAL",
+    "abilities": [
+      [
+        "CB",
+        "ISM",
+        "ISM",
+        "SS"
+      ],
+      [
+        "SSU",
+        "SCU",
+        "SCU",
+        "QSJ"
+      ],
+      [
+        "SJ",
+        "SRU",
+        "QSJ",
+        "RES"
+      ]
+    ],
+    "name": "aruka",
+    "weaponLabel": "Booyah Bomb"
+  }
+}
diff --git a/app/features/scanner/tests/fixtures/death/german-booyah-bomb/frame.png b/app/features/scanner/tests/fixtures/death/german-booyah-bomb/frame.png
new file mode 100644
index 000000000..5697b2e3c
Binary files /dev/null and b/app/features/scanner/tests/fixtures/death/german-booyah-bomb/frame.png differ
diff --git a/app/features/scanner/tests/fixtures/death/headphones/expected.json b/app/features/scanner/tests/fixtures/death/headphones/expected.json
new file mode 100644
index 000000000..d50708b85
--- /dev/null
+++ b/app/features/scanner/tests/fixtures/death/headphones/expected.json
@@ -0,0 +1,29 @@
+{
+  "event": "Death",
+  "data": {
+    "weaponId": 10,
+    "weaponType": "MAIN",
+    "abilities": [
+      [
+        "CB",
+        "BRU",
+        "ISS",
+        "ISS"
+      ],
+      [
+        "ISS",
+        "BRU",
+        "QSJ",
+        "BRU"
+      ],
+      [
+        "SJ",
+        "SSU",
+        "QSJ",
+        "SRU"
+      ]
+    ],
+    "name": "Headphones",
+    "weaponLabel": "Splattershot Jr."
+  }
+}
diff --git a/app/features/scanner/tests/fixtures/death/headphones/frame.png b/app/features/scanner/tests/fixtures/death/headphones/frame.png
new file mode 100644
index 000000000..8ec099eb0
Binary files /dev/null and b/app/features/scanner/tests/fixtures/death/headphones/frame.png differ
diff --git a/app/features/scanner/tests/fixtures/death/pink-text-special/expected.json b/app/features/scanner/tests/fixtures/death/pink-text-special/expected.json
new file mode 100644
index 000000000..d9e4930de
--- /dev/null
+++ b/app/features/scanner/tests/fixtures/death/pink-text-special/expected.json
@@ -0,0 +1,29 @@
+{
+  "event": "Death",
+  "data": {
+    "weaponId": 18,
+    "weaponType": "SPECIAL",
+    "abilities": [
+      [
+        "RSU",
+        "SPU",
+        "SPU",
+        "RSU"
+      ],
+      [
+        "RSU",
+        "RSU",
+        "SSU",
+        "RES"
+      ],
+      [
+        "SJ",
+        "SSU",
+        "SSU",
+        "QSJ"
+      ]
+    ],
+    "name": "Jrod_14",
+    "weaponLabel": "Triple Splashdown"
+  }
+}
diff --git a/app/features/scanner/tests/fixtures/death/pink-text-special/frame.png b/app/features/scanner/tests/fixtures/death/pink-text-special/frame.png
new file mode 100644
index 000000000..61f7a359c
Binary files /dev/null and b/app/features/scanner/tests/fixtures/death/pink-text-special/frame.png differ
diff --git a/app/features/scanner/tests/fixtures/death/rapid-blaster-deco-heavy-kez/expected.json b/app/features/scanner/tests/fixtures/death/rapid-blaster-deco-heavy-kez/expected.json
new file mode 100644
index 000000000..d383bd637
--- /dev/null
+++ b/app/features/scanner/tests/fixtures/death/rapid-blaster-deco-heavy-kez/expected.json
@@ -0,0 +1,29 @@
+{
+  "event": "Death",
+  "data": {
+    "weaponId": 241,
+    "weaponType": "MAIN",
+    "abilities": [
+      [
+        "CB",
+        "QR",
+        "BRU",
+        "QR"
+      ],
+      [
+        "QR",
+        "QR",
+        "QR",
+        "QR"
+      ],
+      [
+        "SJ",
+        "RES",
+        "ISM",
+        "ISM"
+      ]
+    ],
+    "name": "heavy kez",
+    "weaponLabel": "Rapid Blaster Deco"
+  }
+}
diff --git a/app/features/scanner/tests/fixtures/death/rapid-blaster-deco-heavy-kez/frame.jpg b/app/features/scanner/tests/fixtures/death/rapid-blaster-deco-heavy-kez/frame.jpg
new file mode 100644
index 000000000..6150feb26
Binary files /dev/null and b/app/features/scanner/tests/fixtures/death/rapid-blaster-deco-heavy-kez/frame.jpg differ
diff --git a/app/features/scanner/tests/fixtures/death/splattershot-tezuka/expected.json b/app/features/scanner/tests/fixtures/death/splattershot-tezuka/expected.json
new file mode 100644
index 000000000..7228d8433
--- /dev/null
+++ b/app/features/scanner/tests/fixtures/death/splattershot-tezuka/expected.json
@@ -0,0 +1,29 @@
+{
+  "event": "Death",
+  "data": {
+    "weaponId": 40,
+    "weaponType": "MAIN",
+    "abilities": [
+      [
+        "CB",
+        "SCU",
+        "SCU",
+        "SS"
+      ],
+      [
+        "SSU",
+        "IA",
+        "IA",
+        "RES"
+      ],
+      [
+        "SJ",
+        "RES",
+        "SRU",
+        "QSJ"
+      ]
+    ],
+    "name": "てづか",
+    "weaponLabel": "Splattershot"
+  }
+}
diff --git a/app/features/scanner/tests/fixtures/death/splattershot-tezuka/frame.jpg b/app/features/scanner/tests/fixtures/death/splattershot-tezuka/frame.jpg
new file mode 100644
index 000000000..92f9500d4
Binary files /dev/null and b/app/features/scanner/tests/fixtures/death/splattershot-tezuka/frame.jpg differ
diff --git a/app/features/scanner/tests/fixtures/death/ultra-stamp-jp-720p/expected.json b/app/features/scanner/tests/fixtures/death/ultra-stamp-jp-720p/expected.json
new file mode 100644
index 000000000..bb8d572a5
--- /dev/null
+++ b/app/features/scanner/tests/fixtures/death/ultra-stamp-jp-720p/expected.json
@@ -0,0 +1,30 @@
+{
+  "event": "Death",
+  "data": {
+    "weaponId": 11,
+    "weaponType": "SPECIAL",
+    "abilities": [
+      [
+        "IRU",
+        "QR",
+        "SPU"
+      ],
+      [
+        "AD",
+        "SPU",
+        "RES",
+        "UNKNOWN"
+      ],
+      [
+        "SPU",
+        "SS",
+        "QSJ"
+      ]
+    ],
+    "name": "gori_1",
+    "weaponLabel": "Ultra Stamp"
+  },
+  "options": {
+    "notes": "720p VoD capture (upscaled to canonical at ingest), JP death message 'ウルトラハンコ で / やられた！'. The garbled low-fidelity read only resolves through the candidate-lattice re-rank (weapon is a SPECIAL, so the burst-icon paths can't help). The name band is a two-hue split banner (yellow/green diagonal), read via the split-background candidate in the tag parse. Streamer webcam bottom-left pixelated for privacy (region sits left of every parsed ROI)."
+  }
+}
diff --git a/app/features/scanner/tests/fixtures/death/ultra-stamp-jp-720p/frame.png b/app/features/scanner/tests/fixtures/death/ultra-stamp-jp-720p/frame.png
new file mode 100644
index 000000000..da83dee19
Binary files /dev/null and b/app/features/scanner/tests/fixtures/death/ultra-stamp-jp-720p/frame.png differ
diff --git a/app/features/scanner/tests/fixtures/death/wipeout-52-gal/expected.json b/app/features/scanner/tests/fixtures/death/wipeout-52-gal/expected.json
new file mode 100644
index 000000000..dfb518b8f
--- /dev/null
+++ b/app/features/scanner/tests/fixtures/death/wipeout-52-gal/expected.json
@@ -0,0 +1,32 @@
+{
+  "event": "Death",
+  "data": {
+    "weaponId": 50,
+    "weaponType": "MAIN",
+    "abilities": [
+      [
+        "OG",
+        "SSU",
+        "SSU",
+        "QSJ"
+      ],
+      [
+        "SSU",
+        "IA",
+        "IA",
+        "IA"
+      ],
+      [
+        "SJ",
+        "SSU",
+        "RES",
+        "SRU"
+      ]
+    ],
+    "name": "さんだいめドパかげ",
+    "weaponLabel": ".52 Gal"
+  },
+  "options": {
+    "notes": "WIPEOUT banner covers the weapon name line; the weapon resolves via the burst icon fallback. The kana name needs the dakuten headroom in TAG_NAME_INNER (げ), the widened merge gap cap (い's strokes sit 16px apart), and the harvested crops."
+  }
+}
diff --git a/app/features/scanner/tests/fixtures/death/wipeout-52-gal/frame.png b/app/features/scanner/tests/fixtures/death/wipeout-52-gal/frame.png
new file mode 100644
index 000000000..450c55ca5
Binary files /dev/null and b/app/features/scanner/tests/fixtures/death/wipeout-52-gal/frame.png differ
diff --git a/app/features/scanner/tests/fixtures/death/z-f-splatterscope-vod/expected.json b/app/features/scanner/tests/fixtures/death/z-f-splatterscope-vod/expected.json
new file mode 100644
index 000000000..f3bdf3a68
--- /dev/null
+++ b/app/features/scanner/tests/fixtures/death/z-f-splatterscope-vod/expected.json
@@ -0,0 +1,32 @@
+{
+  "event": "Death",
+  "data": {
+    "weaponId": 2021,
+    "weaponType": "MAIN",
+    "abilities": [
+      [
+        "SSU",
+        "RSU",
+        "RSU",
+        "SSU"
+      ],
+      [
+        "RP",
+        "SS",
+        "SS",
+        "RSU"
+      ],
+      [
+        "OS",
+        "ISM",
+        "ISM",
+        "ISM"
+      ]
+    ],
+    "name": "おもちっち",
+    "weaponLabel": "Z+F Splatterscope"
+  },
+  "options": {
+    "notes": "Compressed VoD capture. The Respawn Punisher main (middle row) is gray-dark at the circle center, which the old grayscale gate icon probe failed on — the probe reads per-pixel max RGB channel now."
+  }
+}
diff --git a/app/features/scanner/tests/fixtures/death/z-f-splatterscope-vod/frame.png b/app/features/scanner/tests/fixtures/death/z-f-splatterscope-vod/frame.png
new file mode 100644
index 000000000..b3bc0595c
Binary files /dev/null and b/app/features/scanner/tests/fixtures/death/z-f-splatterscope-vod/frame.png differ
diff --git a/app/features/scanner/tests/fixtures/map-start/german-splat-zones-robo-rom-en/expected.json b/app/features/scanner/tests/fixtures/map-start/german-splat-zones-robo-rom-en/expected.json
new file mode 100644
index 000000000..dc47a92f5
--- /dev/null
+++ b/app/features/scanner/tests/fixtures/map-start/german-splat-zones-robo-rom-en/expected.json
@@ -0,0 +1,8 @@
+{
+  "event": "MapStart",
+  "data": {
+    "mode": "SZ",
+    "stage": 21,
+    "stageLabel": "Robo ROM-en"
+  }
+}
diff --git a/app/features/scanner/tests/fixtures/map-start/german-splat-zones-robo-rom-en/frame.png b/app/features/scanner/tests/fixtures/map-start/german-splat-zones-robo-rom-en/frame.png
new file mode 100644
index 000000000..90cc06a55
Binary files /dev/null and b/app/features/scanner/tests/fixtures/map-start/german-splat-zones-robo-rom-en/frame.png differ
diff --git a/app/features/scanner/tests/fixtures/map-start/splat-zones-mahi/expected.json b/app/features/scanner/tests/fixtures/map-start/splat-zones-mahi/expected.json
new file mode 100644
index 000000000..cec8c6655
--- /dev/null
+++ b/app/features/scanner/tests/fixtures/map-start/splat-zones-mahi/expected.json
@@ -0,0 +1,8 @@
+{
+  "event": "MapStart",
+  "data": {
+    "mode": "SZ",
+    "stage": 7,
+    "stageLabel": "Mahi-Mahi Resort"
+  }
+}
diff --git a/app/features/scanner/tests/fixtures/map-start/splat-zones-mahi/frame.png b/app/features/scanner/tests/fixtures/map-start/splat-zones-mahi/frame.png
new file mode 100644
index 000000000..7063f531f
Binary files /dev/null and b/app/features/scanner/tests/fixtures/map-start/splat-zones-mahi/frame.png differ
diff --git a/app/features/scanner/tests/fixtures/map-start/splat-zones-undertow-spillway/expected.json b/app/features/scanner/tests/fixtures/map-start/splat-zones-undertow-spillway/expected.json
new file mode 100644
index 000000000..e49258f16
--- /dev/null
+++ b/app/features/scanner/tests/fixtures/map-start/splat-zones-undertow-spillway/expected.json
@@ -0,0 +1,8 @@
+{
+  "event": "MapStart",
+  "data": {
+    "mode": "SZ",
+    "stage": 3,
+    "stageLabel": "Undertow Spillway"
+  }
+}
diff --git a/app/features/scanner/tests/fixtures/map-start/splat-zones-undertow-spillway/frame.png b/app/features/scanner/tests/fixtures/map-start/splat-zones-undertow-spillway/frame.png
new file mode 100644
index 000000000..71c630ebb
Binary files /dev/null and b/app/features/scanner/tests/fixtures/map-start/splat-zones-undertow-spillway/frame.png differ
diff --git a/app/features/scanner/tests/fixtures/minimap/snix-special-ready/expected.json b/app/features/scanner/tests/fixtures/minimap/snix-special-ready/expected.json
new file mode 100644
index 000000000..94c987e72
--- /dev/null
+++ b/app/features/scanner/tests/fixtures/minimap/snix-special-ready/expected.json
@@ -0,0 +1,97 @@
+{
+  "event": "Minimap",
+  "data": {
+    "stage": 3,
+    "teammates": [
+      {
+        "slot": "up",
+        "name": "こむぎこをこねたユウ",
+        "abilities": [
+          "CB",
+          "ISS",
+          "SJ"
+        ],
+        "weaponLabel": "Splattershot",
+        "weaponId": 40
+      },
+      {
+        "slot": "left",
+        "name": "Snix",
+        "abilities": [
+          "CB",
+          "SSU",
+          "SJ"
+        ],
+        "weaponLabel": "Splatana Stamper",
+        "weaponId": 8000
+      },
+      {
+        "slot": "right",
+        "name": "スライムLv.13",
+        "abilities": [
+          "ISS",
+          "ISS",
+          "ISS"
+        ],
+        "weaponLabel": "Splattershot Jr.",
+        "weaponId": 10
+      },
+      {
+        "slot": "self",
+        "name": "Sendou",
+        "abilities": [
+          "CB",
+          "QR",
+          "SJ"
+        ],
+        "weaponLabel": "Custom Blaster",
+        "weaponId": 211
+      }
+    ],
+    "enemies": [
+      {
+        "abilities": [
+          "CB",
+          "QR",
+          "SJ"
+        ],
+        "weaponLabel": "Inkbrush Nouveau",
+        "weaponId": 1101
+      },
+      {
+        "abilities": [
+          "OG",
+          "SSU",
+          "SJ"
+        ],
+        "weaponLabel": ".52 Gal",
+        "weaponId": 50
+      },
+      {
+        "abilities": [
+          "ISM",
+          "SSU",
+          "SCU"
+        ],
+        "weaponLabel": "Big Swig Roller",
+        "weaponId": 1040
+      },
+      {
+        "abilities": [
+          "SSU",
+          "NS",
+          "SSU"
+        ],
+        "weaponLabel": "Luna Blaster Neo",
+        "weaponId": 201
+      }
+    ],
+    "stageLabel": "Undertow Spillway"
+  },
+  "options": {
+    "skipFields": [
+      "teammates.0.name"
+    ],
+    "notes": "Tower Control frame with three special-ready camo surfaces: the left card (Splatana Stamper — dark art whose padded-square icon renders bigger than the 54px weapon box, unmatchable before the art-cropped templates) and enemy rows 0 (Inkbrush Nouveau) and 2 (Big Swig Roller). Self card is a Custom Blaster on a warm translucent background (kit tiles: Point Sensor + Triple Splashdown). teammates.0.name skipped: the up card reads こむきこをこねたユウ — the ぎ dakuten is below atlas resolution at 29px. Control values are the deterministic estimator output."
+  }
+}
diff --git a/app/features/scanner/tests/fixtures/minimap/snix-special-ready/frame.png b/app/features/scanner/tests/fixtures/minimap/snix-special-ready/frame.png
new file mode 100644
index 000000000..bf98e80db
Binary files /dev/null and b/app/features/scanner/tests/fixtures/minimap/snix-special-ready/frame.png differ
diff --git a/app/features/scanner/tests/fixtures/minimap/spectator-area-cup-round1/expected.json b/app/features/scanner/tests/fixtures/minimap/spectator-area-cup-round1/expected.json
new file mode 100644
index 000000000..130827b3f
--- /dev/null
+++ b/app/features/scanner/tests/fixtures/minimap/spectator-area-cup-round1/expected.json
@@ -0,0 +1,102 @@
+{
+  "event": "Minimap",
+  "data": {
+    "stage": 14,
+    "spectator": true,
+    "teammates": [
+      {
+        "slot": "up",
+        "name": "リビア",
+        "abilities": [
+          "SSU",
+          "SCU",
+          "SJ"
+        ],
+        "weaponLabel": "Splash-o-matic",
+        "weaponId": 20
+      },
+      {
+        "slot": "right",
+        "name": "がらっこ",
+        "abilities": [
+          "LDE",
+          "SPU",
+          "SJ"
+        ],
+        "weaponLabel": "Dread Wringer",
+        "weaponId": 3050
+      },
+      {
+        "slot": "down",
+        "name": "ーロたべる",
+        "abilities": [
+          "OG",
+          "SSU",
+          "SJ"
+        ],
+        "weaponLabel": "Custom Blaster",
+        "weaponId": 211
+      },
+      {
+        "slot": "left",
+        "name": "ももドラグーン",
+        "abilities": [
+          "LDE",
+          "SCU",
+          "ISM"
+        ],
+        "weaponLabel": "Snipewriter 5H",
+        "weaponId": 2070
+      }
+    ],
+    "enemies": [
+      {
+        "name": "ウルボー",
+        "abilities": [
+          "LDE",
+          "SPU",
+          "SJ"
+        ],
+        "weaponLabel": "Snipewriter 5H",
+        "weaponId": 2070
+      },
+      {
+        "name": "ねこすき",
+        "abilities": [
+          "OG",
+          "QR",
+          "SJ"
+        ],
+        "weaponLabel": "S-BLAST '91",
+        "weaponId": 261
+      },
+      {
+        "name": "そっぴ",
+        "abilities": [
+          "RSU",
+          "RSU",
+          "SJ"
+        ],
+        "weaponLabel": "Zink Mini Splatling",
+        "weaponId": 4001
+      },
+      {
+        "name": "しゅーた",
+        "abilities": [
+          "OG",
+          "SSU",
+          "SJ"
+        ],
+        "weaponLabel": ".52 Gal",
+        "weaponId": 50
+      }
+    ],
+    "stageLabel": "Manta Maria"
+  },
+  "options": {
+    "skipFields": [
+      "enemies.0.name"
+    ],
+    "notes": "8-player spectator map screen from the AREA CUP stream (Round 1), pre-match — teams at spawn, so the control estimate sits near zero (spawn markers only). Formerly negative/map-screen-2; relabeled when the spectator variant became gated off the X jump-button disc. enemies.0.name skipped: ウルボー reads ウルホー — the ボ dakuten is below atlas resolution at this size (same limit as snix-special-ready's ぎ). teammates.2.name ーロたべる is the pixel reading; if the real name uses kanji (一口たべる) it is unrecoverable — 一/ー and 口/ロ are pixel-identical and the atlas carries no kanji."
+  }
+}
diff --git a/app/features/scanner/tests/fixtures/minimap/spectator-area-cup-round1/frame.jpg b/app/features/scanner/tests/fixtures/minimap/spectator-area-cup-round1/frame.jpg
new file mode 100644
index 000000000..4d3bb35a0
Binary files /dev/null and b/app/features/scanner/tests/fixtures/minimap/spectator-area-cup-round1/frame.jpg differ
diff --git a/app/features/scanner/tests/fixtures/minimap/spectator-area-cup-winners-qf/expected.json b/app/features/scanner/tests/fixtures/minimap/spectator-area-cup-winners-qf/expected.json
new file mode 100644
index 000000000..fd171e31a
--- /dev/null
+++ b/app/features/scanner/tests/fixtures/minimap/spectator-area-cup-winners-qf/expected.json
@@ -0,0 +1,99 @@
+{
+  "event": "Minimap",
+  "data": {
+    "stage": 4,
+    "spectator": true,
+    "teammates": [
+      {
+        "slot": "up",
+        "name": "ももドラグーン",
+        "abilities": [
+          "LDE",
+          "SCU",
+          "ISM"
+        ],
+        "weaponLabel": "Snipewriter 5H",
+        "weaponId": 2070
+      },
+      {
+        "slot": "right",
+        "name": "れいまるがんばれや!",
+        "abilities": [
+          "SCU",
+          "SSU",
+          "SSU"
+        ],
+        "weaponLabel": "Splash-o-matic",
+        "weaponId": 20
+      },
+      {
+        "slot": "down",
+        "name": "ひまじん",
+        "abilities": [
+          "OG",
+          "SSU",
+          "SJ"
+        ],
+        "weaponLabel": "Custom Blaster",
+        "weaponId": 211
+      },
+      {
+        "slot": "left",
+        "name": "!のりしお!",
+        "abilities": [
+          "CB",
+          "SSU",
+          "SJ"
+        ],
+        "weaponLabel": "Splatana Stamper",
+        "weaponId": 8000
+      }
+    ],
+    "enemies": [
+      {
+        "name": "とど",
+        "abilities": [
+          "CB",
+          "H",
+          "SJ"
+        ],
+        "weaponLabel": "Mint Decavitator",
+        "weaponId": 8020
+      },
+      {
+        "name": "たなは",
+        "abilities": [
+          "RSU",
+          "SSU",
+          "SCU"
+        ],
+        "weaponLabel": "Splat Brella",
+        "weaponId": 6000
+      },
+      {
+        "name": "いなてんきんぐ",
+        "abilities": [
+          "LDE",
+          "RSU",
+          "RSU"
+        ],
+        "weaponLabel": "Zink Mini Splatling",
+        "weaponId": 4001
+      },
+      {
+        "name": "そふ",
+        "abilities": [
+          "RSU",
+          "RSU",
+          "RES"
+        ],
+        "weaponLabel": "Heavy Splatling",
+        "weaponId": 4010
+      }
+    ],
+    "stageLabel": "Mincemeat Metalworks"
+  },
+  "options": {
+    "notes": "8-player spectator map screen (AREA CUP, Winners Quarterfinals), the frame that motivated the spectator gate: the stream chrome covers both overlay gate anchors (close disc behind the branding top-left, spawn-pill area behind the bottom name bar). ももドラグーン also appears in spectator-area-cup-round1 with the identical loadout — a cross-fixture consistency anchor. れいまるがんばれや! ties 29px vs 30px name reads at equal confidence; the 29px read (correct がんばれ) wins as first-tried."
+  }
+}
diff --git a/app/features/scanner/tests/fixtures/minimap/spectator-area-cup-winners-qf/frame.png b/app/features/scanner/tests/fixtures/minimap/spectator-area-cup-winners-qf/frame.png
new file mode 100644
index 000000000..87bde40d9
Binary files /dev/null and b/app/features/scanner/tests/fixtures/minimap/spectator-area-cup-winners-qf/frame.png differ
diff --git a/app/features/scanner/tests/fixtures/minimap/spectator-pxg/expected.json b/app/features/scanner/tests/fixtures/minimap/spectator-pxg/expected.json
new file mode 100644
index 000000000..8add5bbcd
--- /dev/null
+++ b/app/features/scanner/tests/fixtures/minimap/spectator-pxg/expected.json
@@ -0,0 +1,102 @@
+{
+  "event": "Minimap",
+  "data": {
+    "stage": 18,
+    "spectator": true,
+    "teammates": [
+      {
+        "slot": "up",
+        "name": "kyutpie<3",
+        "abilities": [
+          "SSU",
+          "SSU",
+          "SJ"
+        ],
+        "weaponLabel": ".96 Gal",
+        "weaponId": 80
+      },
+      {
+        "slot": "right",
+        "name": "Grey",
+        "abilities": [
+          "LDE",
+          "SCU",
+          "ISM"
+        ],
+        "weaponLabel": "Flingza Roller",
+        "weaponId": 1030
+      },
+      {
+        "slot": "down",
+        "name": "JORDANYAGI",
+        "abilities": [
+          "CB",
+          "QR",
+          "SJ"
+        ],
+        "weaponLabel": "Order Slosher Replica",
+        "weaponId": 3005
+      },
+      {
+        "slot": "left",
+        "name": "f(x)= x²-8",
+        "abilities": [
+          "OG",
+          "SCU",
+          "ISM"
+        ],
+        "weaponLabel": "Rapid Blaster Pro WNT-R",
+        "weaponId": 252
+      }
+    ],
+    "enemies": [
+      {
+        "name": "Nala fan",
+        "abilities": [
+          "CB",
+          "SSU",
+          "SJ"
+        ],
+        "weaponLabel": "S-BLAST '91",
+        "weaponId": 261
+      },
+      {
+        "name": "バッラスト",
+        "abilities": [
+          "LDE",
+          "SPU",
+          "ISM"
+        ],
+        "weaponLabel": "Snipewriter 5H",
+        "weaponId": 2070
+      },
+      {
+        "name": "Jared",
+        "abilities": [
+          "CB",
+          "QR",
+          "SJ"
+        ],
+        "weaponLabel": "Twinklez Splat Dualies",
+        "weaponId": 5012
+      },
+      {
+        "name": "Reiyu C:3",
+        "abilities": [
+          "SSU",
+          "SSU",
+          "SJ"
+        ],
+        "weaponLabel": "Splash-o-matic",
+        "weaponId": 20
+      }
+    ],
+    "stageLabel": "Crableg Capital"
+  },
+  "options": {
+    "skipFields": [
+      "teammates.3.name"
+    ],
+    "notes": "8-player spectator map screen from a different stream layout (PXG score bug top-left) — attests the card grid and the X jump-button disc land on the same ROIs across layouts. Latin names anchor the 29-30px glyph-height calibration. teammates.3.name skipped: the superscript two in f(x)= x²-8 is not a charset glyph (reads ´ or ·)."
+  }
+}
diff --git a/app/features/scanner/tests/fixtures/minimap/spectator-pxg/frame.png b/app/features/scanner/tests/fixtures/minimap/spectator-pxg/frame.png
new file mode 100644
index 000000000..3eee50f6e
Binary files /dev/null and b/app/features/scanner/tests/fixtures/minimap/spectator-pxg/frame.png differ
diff --git a/app/features/scanner/tests/fixtures/minimap/stonks-cross-both-teams/expected.json b/app/features/scanner/tests/fixtures/minimap/stonks-cross-both-teams/expected.json
new file mode 100644
index 000000000..2b7ff4744
--- /dev/null
+++ b/app/features/scanner/tests/fixtures/minimap/stonks-cross-both-teams/expected.json
@@ -0,0 +1,82 @@
+{
+  "event": "Minimap",
+  "data": {
+    "stage": 6,
+    "teammates": [
+      {
+        "slot": "up",
+        "name": "STONKS",
+        "abilities": [
+          "IRU",
+          "RP",
+          "SJ"
+        ],
+        "weaponLabel": "Tri-Stringer",
+        "weaponId": 7010
+      },
+      {
+        "slot": "left",
+        "name": "Player",
+        "abilities": [
+          "IRU",
+          "QR",
+          "SS"
+        ],
+        "weaponLabel": "Splattershot Jr.",
+        "weaponId": 10
+      },
+      {
+        "slot": "right",
+        "name": null,
+        "abilities": [],
+        "weaponLabel": null,
+        "weaponId": null
+      },
+      {
+        "slot": "self",
+        "name": "Edd",
+        "abilities": [
+          "IRU",
+          "QR",
+          "SS"
+        ],
+        "weaponLabel": "Ballpoint Splatling",
+        "weaponId": 4030
+      }
+    ],
+    "enemies": [
+      {
+        "abilities": [
+          "BRU",
+          "SS",
+          "IRU"
+        ],
+        "weaponLabel": "Slosher",
+        "weaponId": 3000
+      },
+      {
+        "abilities": [],
+        "weaponLabel": "Splat Roller",
+        "weaponId": 1010
+      },
+      {
+        "abilities": [],
+        "weaponLabel": "Dualie Squelchers",
+        "weaponId": 5030
+      },
+      {
+        "abilities": [
+          "IRU",
+          "QR",
+          "SS"
+        ],
+        "weaponLabel": "Splattershot",
+        "weaponId": 40
+      }
+    ],
+    "stageLabel": "Museum d'Alfonsino"
+  },
+  "options": {
+    "notes": "One respawning card per team plus a struck-out special-ready (camo) enemy row. Enemy row 1's label was corrected from Flingza Roller to Splat Roller when the art-cropped templates landed (white roll, blue L-frame, yellow-striped grip — matches the 1010 icon exactly). Enemy row 2 is both struck out and special-ready: the red dualie art reads through the X, but the Custom-vs-plain Dualie Squelchers tag is hidden behind a stroke, so the icon matcher near-ties the twins (5031 0.600 vs 5030 0.597); the row's sub tile (Splat Bomb silhouette, readable despite the stroke clipping it) breaks the tie to plain Dualie Squelchers (subResolved). Control values are the deterministic estimator output (share of visible map surface, not in-game turf %)."
+  }
+}
diff --git a/app/features/scanner/tests/fixtures/minimap/stonks-cross-both-teams/frame.jpg b/app/features/scanner/tests/fixtures/minimap/stonks-cross-both-teams/frame.jpg
new file mode 100644
index 000000000..2a684cf42
Binary files /dev/null and b/app/features/scanner/tests/fixtures/minimap/stonks-cross-both-teams/frame.jpg differ
diff --git a/app/features/scanner/tests/fixtures/objective/splat-zones-barnacle-dime-bright-plate/expected.json b/app/features/scanner/tests/fixtures/objective/splat-zones-barnacle-dime-bright-plate/expected.json
new file mode 100644
index 000000000..13f808c0b
--- /dev/null
+++ b/app/features/scanner/tests/fixtures/objective/splat-zones-barnacle-dime-bright-plate/expected.json
@@ -0,0 +1,13 @@
+{
+	"event": "Objective",
+	"data": {
+		"mode": "SZ",
+		"time": 277,
+		"score": [97, 100],
+		"penalty": [null, null],
+		"control": [true, false]
+	},
+	"options": {
+		"notes": "Alpha (bright yellow-green ink) in control: their plate keeps the bright team-color fill (POV frame shows the We're in control! banner). Bravo still at the three-digit 100."
+	}
+}
diff --git a/app/features/scanner/tests/fixtures/objective/splat-zones-barnacle-dime-bright-plate/frame.png b/app/features/scanner/tests/fixtures/objective/splat-zones-barnacle-dime-bright-plate/frame.png
new file mode 100644
index 000000000..437d187e9
Binary files /dev/null and b/app/features/scanner/tests/fixtures/objective/splat-zones-barnacle-dime-bright-plate/frame.png differ
diff --git a/app/features/scanner/tests/fixtures/objective/splat-zones-barnacle-dime-double-penalty/expected.json b/app/features/scanner/tests/fixtures/objective/splat-zones-barnacle-dime-double-penalty/expected.json
new file mode 100644
index 000000000..34628f9e3
--- /dev/null
+++ b/app/features/scanner/tests/fixtures/objective/splat-zones-barnacle-dime-double-penalty/expected.json
@@ -0,0 +1,13 @@
+{
+	"event": "Objective",
+	"data": {
+		"mode": "SZ",
+		"time": 157,
+		"score": [2, 15],
+		"penalty": [64, 65],
+		"control": [true, false]
+	},
+	"options": {
+		"notes": "Penalty pills under both plates at once; alpha (bright green fill) in control."
+	}
+}
diff --git a/app/features/scanner/tests/fixtures/objective/splat-zones-barnacle-dime-double-penalty/frame.png b/app/features/scanner/tests/fixtures/objective/splat-zones-barnacle-dime-double-penalty/frame.png
new file mode 100644
index 000000000..f3a1959ee
Binary files /dev/null and b/app/features/scanner/tests/fixtures/objective/splat-zones-barnacle-dime-double-penalty/frame.png differ
diff --git a/app/features/scanner/tests/fixtures/objective/splat-zones-barnacle-dime-penalty/expected.json b/app/features/scanner/tests/fixtures/objective/splat-zones-barnacle-dime-penalty/expected.json
new file mode 100644
index 000000000..8c517bef6
--- /dev/null
+++ b/app/features/scanner/tests/fixtures/objective/splat-zones-barnacle-dime-penalty/expected.json
@@ -0,0 +1,13 @@
+{
+	"event": "Objective",
+	"data": {
+		"mode": "SZ",
+		"time": 209,
+		"score": [2, 84],
+		"penalty": [75, null],
+		"control": [false, true]
+	},
+	"options": {
+		"notes": "Single-digit count with a large penalty on alpha; bravo (purple) in control with the team-color fill."
+	}
+}
diff --git a/app/features/scanner/tests/fixtures/objective/splat-zones-barnacle-dime-penalty/frame.png b/app/features/scanner/tests/fixtures/objective/splat-zones-barnacle-dime-penalty/frame.png
new file mode 100644
index 000000000..f874fd46d
Binary files /dev/null and b/app/features/scanner/tests/fixtures/objective/splat-zones-barnacle-dime-penalty/frame.png differ
diff --git a/app/features/scanner/tests/fixtures/objective/splat-zones-barnacle-dime-start/expected.json b/app/features/scanner/tests/fixtures/objective/splat-zones-barnacle-dime-start/expected.json
new file mode 100644
index 000000000..28dba9670
--- /dev/null
+++ b/app/features/scanner/tests/fixtures/objective/splat-zones-barnacle-dime-start/expected.json
@@ -0,0 +1,13 @@
+{
+	"event": "Objective",
+	"data": {
+		"mode": "SZ",
+		"time": 299,
+		"score": [100, 100],
+		"penalty": [null, null],
+		"control": [false, false]
+	},
+	"options": {
+		"notes": "Match start: zone neutral, both plates near-black with three-digit 100s (green/pink digits)."
+	}
+}
diff --git a/app/features/scanner/tests/fixtures/objective/splat-zones-barnacle-dime-start/frame.png b/app/features/scanner/tests/fixtures/objective/splat-zones-barnacle-dime-start/frame.png
new file mode 100644
index 000000000..7970b25ae
Binary files /dev/null and b/app/features/scanner/tests/fixtures/objective/splat-zones-barnacle-dime-start/frame.png differ
diff --git a/app/features/scanner/tests/fixtures/objective/splat-zones-mako-mart/expected.json b/app/features/scanner/tests/fixtures/objective/splat-zones-mako-mart/expected.json
new file mode 100644
index 000000000..2edfe054c
--- /dev/null
+++ b/app/features/scanner/tests/fixtures/objective/splat-zones-mako-mart/expected.json
@@ -0,0 +1,10 @@
+{
+	"event": "Objective",
+	"data": {
+		"mode": "SZ",
+		"time": 215,
+		"score": [95, 53],
+		"penalty": [4, null],
+		"control": [false, true]
+	}
+}
diff --git a/app/features/scanner/tests/fixtures/objective/splat-zones-mako-mart/frame.png b/app/features/scanner/tests/fixtures/objective/splat-zones-mako-mart/frame.png
new file mode 100644
index 000000000..25d2a304c
Binary files /dev/null and b/app/features/scanner/tests/fixtures/objective/splat-zones-mako-mart/frame.png differ
diff --git a/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/anarchy-open-rainmaker-knockout-museum/expected.json b/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/anarchy-open-rainmaker-knockout-museum/expected.json
new file mode 100644
index 000000000..8a18629e4
--- /dev/null
+++ b/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/anarchy-open-rainmaker-knockout-museum/expected.json
@@ -0,0 +1,82 @@
+{
+  "event": "ScoreboardBattleLogReplay",
+  "data": {
+    "lobby": "OPEN",
+    "mode": "RM",
+    "stage": 6,
+    "timestamp": "6/7/2026 19:04",
+    "replayCode": "RWYQ-4X37-M1EL-EGGQ",
+    "matchScores": [
+      100,
+      0
+    ],
+    "povIndex": 0,
+    "players": [
+      {
+        "name": "8♪cloudy",
+        "paint": 849,
+        "ka": 10,
+        "d": 6,
+        "s": 4,
+        "weaponId": 82
+      },
+      {
+        "name": "8♪Lightboy",
+        "paint": 765,
+        "ka": 9,
+        "d": 4,
+        "s": 1,
+        "weaponId": 80
+      },
+      {
+        "name": "8♪Clubs◇",
+        "paint": 550,
+        "ka": 6,
+        "d": 6,
+        "s": 0,
+        "weaponId": 81
+      },
+      {
+        "name": "8♪Rose",
+        "paint": 536,
+        "ka": 4,
+        "d": 7,
+        "s": 1,
+        "weaponId": 6030
+      },
+      {
+        "name": "Léholienne",
+        "paint": 789,
+        "ka": 11,
+        "d": 4,
+        "s": 3,
+        "weaponId": 1022
+      },
+      {
+        "name": "Chill out",
+        "paint": 869,
+        "ka": 11,
+        "d": 5,
+        "s": 2,
+        "weaponId": 3012
+      },
+      {
+        "name": "KXR_SOL",
+        "paint": 724,
+        "ka": 6,
+        "d": 4,
+        "s": 1,
+        "weaponId": 1015
+      },
+      {
+        "name": "とまったゆづき",
+        "paint": 463,
+        "ka": 4,
+        "d": 4,
+        "s": 1,
+        "weaponId": 8010
+      }
+    ],
+    "stageLabel": "Museum d'Alfonsino"
+  }
+}
diff --git a/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/anarchy-open-rainmaker-knockout-museum/frame.png b/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/anarchy-open-rainmaker-knockout-museum/frame.png
new file mode 100644
index 000000000..8ea4fc49e
Binary files /dev/null and b/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/anarchy-open-rainmaker-knockout-museum/frame.png differ
diff --git a/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/low-res-2/expected.json b/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/low-res-2/expected.json
new file mode 100644
index 000000000..768fd361e
--- /dev/null
+++ b/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/low-res-2/expected.json
@@ -0,0 +1,81 @@
+{
+  "event": "ScoreboardBattleLogReplay",
+  "data": {
+    "lobby": "PRIVATE",
+    "mode": "SZ",
+    "stage": 17,
+    "timestamp": "3/7/2026 21:22",
+    "replayCode": "R0M1-UCVK-F5AK-VUL2",
+    "matchScores": [
+      100,
+      0
+    ],
+    "players": [
+      {
+        "name": "★Bønk★•PE•",
+        "weaponId": 1010,
+        "paint": 1210,
+        "ka": 19,
+        "d": 6,
+        "s": 5
+      },
+      {
+        "name": "Enamel",
+        "weaponId": 2070,
+        "paint": 1596,
+        "ka": 14,
+        "d": 3,
+        "s": 6
+      },
+      {
+        "name": "Sen★u",
+        "weaponId": 10,
+        "paint": 1534,
+        "ka": 13,
+        "d": 10,
+        "s": 6
+      },
+      {
+        "name": "Rιppιn←H",
+        "weaponId": 8001,
+        "paint": 1248,
+        "ka": 10,
+        "d": 11,
+        "s": 5
+      },
+      {
+        "name": "nwrm",
+        "weaponId": 50,
+        "paint": 1018,
+        "ka": 14,
+        "d": 12,
+        "s": 3
+      },
+      {
+        "name": "slord",
+        "weaponId": 20,
+        "paint": 1807,
+        "ka": 8,
+        "d": 4,
+        "s": 6
+      },
+      {
+        "name": "Olise",
+        "weaponId": 2070,
+        "paint": 1535,
+        "ka": 10,
+        "d": 3,
+        "s": 6
+      },
+      {
+        "name": "AHOOLduιUuU",
+        "weaponId": 1015,
+        "paint": 870,
+        "ka": 12,
+        "d": 14,
+        "s": 3
+      }
+    ],
+    "stageLabel": "Barnacle & Dime"
+  }
+}
diff --git a/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/low-res-2/frame.png b/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/low-res-2/frame.png
new file mode 100644
index 000000000..e1787ce7a
Binary files /dev/null and b/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/low-res-2/frame.png differ
diff --git a/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/low-res/expected.json b/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/low-res/expected.json
new file mode 100644
index 000000000..094b0e3c8
--- /dev/null
+++ b/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/low-res/expected.json
@@ -0,0 +1,80 @@
+{
+  "event": "ScoreboardBattleLogReplay",
+  "data": {
+    "lobby": "PRIVATE",
+    "mode": "SZ",
+    "stage": 2,
+    "replayCode": "RVRM-XXEL-0573-Q45U",
+    "matchScores": [
+      100,
+      0
+    ],
+    "players": [
+      {
+        "name": "nwrm",
+        "weaponId": 50,
+        "paint": 381,
+        "ka": 8,
+        "d": 2,
+        "s": 0
+      },
+      {
+        "name": "slord",
+        "weaponId": 20,
+        "paint": 613,
+        "ka": 4,
+        "d": 1,
+        "s": 2
+      },
+      {
+        "name": "Olise",
+        "weaponId": 2070,
+        "paint": 456,
+        "ka": 3,
+        "d": 1,
+        "s": 2
+      },
+      {
+        "name": "AHOOLddduuU",
+        "weaponId": 1015,
+        "paint": 287,
+        "ka": 1,
+        "d": 2,
+        "s": 1
+      },
+      {
+        "name": "★Bønk★•PE•",
+        "weaponId": 1002,
+        "paint": 327,
+        "ka": 3,
+        "d": 3,
+        "s": 1
+      },
+      {
+        "name": "Enamel",
+        "weaponId": 2070,
+        "paint": 408,
+        "ka": 1,
+        "d": 1,
+        "s": 2
+      },
+      {
+        "name": "Rιppιn←H",
+        "weaponId": 8001,
+        "paint": 270,
+        "ka": 3,
+        "d": 3,
+        "s": 1
+      },
+      {
+        "name": "Sen★u",
+        "weaponId": 10,
+        "paint": 354,
+        "ka": 0,
+        "d": 3,
+        "s": 1
+      }
+    ],
+    "stageLabel": "Hagglefish Market"
+  }
+}
diff --git a/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/low-res/frame.png b/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/low-res/frame.png
new file mode 100644
index 000000000..c056a08e7
Binary files /dev/null and b/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/low-res/frame.png differ
diff --git a/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/private-battle-crableg-capital/expected.json b/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/private-battle-crableg-capital/expected.json
new file mode 100644
index 000000000..8e8929cf7
--- /dev/null
+++ b/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/private-battle-crableg-capital/expected.json
@@ -0,0 +1,73 @@
+{
+  "event": "ScoreboardBattleLogReplay",
+  "data": {
+    "lobby": "PRIVATE",
+    "mode": "SZ",
+    "stage": 18,
+    "timestamp": "9/7/2026 18:13",
+    "replayCode": "R1V4-PAHW-GGM2-PD9S",
+    "matchScores": [
+      100,
+      0
+    ],
+    "players": [
+      {
+        "name": "bobong",
+        "weaponId": 201,
+        "paint": 248,
+        "ka": 4,
+        "d": 1,
+        "s": 0
+      },
+      {
+        "name": "8♪cloudy",
+        "weaponId": 7022,
+        "paint": 392,
+        "ka": 2,
+        "d": 1,
+        "s": 2
+      },
+      {
+        "name": "あさごはん",
+        "weaponId": 2030,
+        "paint": 206,
+        "ka": 1,
+        "d": 0,
+        "s": 0
+      },
+      {
+        "name": "CPT-Eevee☆",
+        "weaponId": 8000,
+        "paint": 209,
+        "ka": 2,
+        "d": 2,
+        "s": 0
+      },
+      {
+        "name": "かなめ",
+        "weaponId": 4000,
+        "paint": 524,
+        "ka": 4,
+        "d": 3,
+        "s": 3
+      },
+      {
+        "name": "maomaoく3",
+        "weaponId": 2030,
+        "paint": 263,
+        "ka": 0,
+        "d": 2,
+        "s": 0
+      },
+      {
+        "name": "Ccaramel",
+        "weaponId": 8010,
+        "paint": 233,
+        "ka": 0,
+        "d": 4,
+        "s": 0
+      }
+    ],
+    "stageLabel": "Crableg Capital"
+  }
+}
diff --git a/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/private-battle-crableg-capital/frame.png b/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/private-battle-crableg-capital/frame.png
new file mode 100644
index 000000000..e99d944a2
Binary files /dev/null and b/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/private-battle-crableg-capital/frame.png differ
diff --git a/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/private-battle-splat-zones-hagglefish/expected.json b/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/private-battle-splat-zones-hagglefish/expected.json
new file mode 100644
index 000000000..635bd3056
--- /dev/null
+++ b/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/private-battle-splat-zones-hagglefish/expected.json
@@ -0,0 +1,82 @@
+{
+  "event": "ScoreboardBattleLogReplay",
+  "data": {
+    "lobby": "PRIVATE",
+    "mode": "SZ",
+    "stage": 2,
+    "timestamp": "3/7/2026 22:28",
+    "replayCode": "R6KE-D064-3CXD-XVKL",
+    "matchScores": [
+      88,
+      77
+    ],
+    "povIndex": 1,
+    "players": [
+      {
+        "name": "Jasmeanie",
+        "paint": 1049,
+        "ka": 23,
+        "d": 9,
+        "s": 4,
+        "weaponId": 211
+      },
+      {
+        "name": "Sendou",
+        "paint": 1907,
+        "ka": 8,
+        "d": 5,
+        "s": 8,
+        "weaponId": 10
+      },
+      {
+        "name": "Enamel",
+        "paint": 1694,
+        "ka": 10,
+        "d": 3,
+        "s": 7,
+        "weaponId": 2070
+      },
+      {
+        "name": "★Bønk★•PE•",
+        "paint": 1745,
+        "ka": 4,
+        "d": 4,
+        "s": 9,
+        "weaponId": 1040
+      },
+      {
+        "name": "gameing",
+        "paint": 1099,
+        "ka": 13,
+        "d": 10,
+        "s": 5,
+        "weaponId": 201
+      },
+      {
+        "name": "Comrade",
+        "paint": 1969,
+        "ka": 9,
+        "d": 3,
+        "s": 8,
+        "weaponId": 2070
+      },
+      {
+        "name": "Hawianakin",
+        "paint": 1667,
+        "ka": 8,
+        "d": 6,
+        "s": 7,
+        "weaponId": 7012
+      },
+      {
+        "name": "term",
+        "paint": 1426,
+        "ka": 6,
+        "d": 11,
+        "s": 8,
+        "weaponId": 6001
+      }
+    ],
+    "stageLabel": "Hagglefish Market"
+  }
+}
diff --git a/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/private-battle-splat-zones-hagglefish/frame.jpeg b/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/private-battle-splat-zones-hagglefish/frame.jpeg
new file mode 100644
index 000000000..f5674e6f2
Binary files /dev/null and b/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/private-battle-splat-zones-hagglefish/frame.jpeg differ
diff --git a/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/private-battle-splat-zones-marlin/expected.json b/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/private-battle-splat-zones-marlin/expected.json
new file mode 100644
index 000000000..cd201a48c
--- /dev/null
+++ b/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/private-battle-splat-zones-marlin/expected.json
@@ -0,0 +1,76 @@
+{
+  "event": "ScoreboardBattleLogReplay",
+  "data": {
+    "lobby": "PRIVATE",
+    "mode": "SZ",
+    "stage": 22,
+    "timestamp": "9/7/2026 18:17",
+    "matchScores": [
+      100,
+      0
+    ],
+    "players": [
+      {
+        "name": "CPT-Eevee☆",
+        "weaponId": 8000,
+        "paint": 466,
+        "ka": 7,
+        "d": 2,
+        "s": 1
+      },
+      {
+        "name": "8♪cloudy",
+        "weaponId": 7022,
+        "paint": 607,
+        "ka": 4,
+        "d": 1,
+        "s": 2
+      },
+      {
+        "name": "あさごはん",
+        "weaponId": 2070,
+        "paint": 472,
+        "ka": 5,
+        "d": 1,
+        "s": 1
+      },
+      {
+        "name": "bobong",
+        "weaponId": 201,
+        "paint": 159,
+        "ka": 1,
+        "d": 1,
+        "s": 0
+      },
+      {
+        "name": "maomaoく3",
+        "weaponId": 2060,
+        "paint": 405,
+        "ka": 3,
+        "d": 3,
+        "s": 1
+      },
+      {
+        "name": "かなめ",
+        "weaponId": 4000,
+        "paint": 753,
+        "ka": 1,
+        "d": 3,
+        "s": 3
+      },
+      {
+        "name": "Ccaramel",
+        "weaponId": 8010,
+        "paint": 381,
+        "ka": 1,
+        "d": 4,
+        "s": 0
+      }
+    ],
+    "replayCode": "R24X-YWMH-K2S6-TK9G",
+    "stageLabel": "Marlin Airport"
+  },
+  "options": {
+    "notes": "Twitch-stream capture. 7-player match: the 8th pill is empty and must not be emitted. Replay code hand-verified from the zoomed frame (old parser returned no code; a later one misread T as 7)."
+  }
+}
diff --git a/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/private-battle-splat-zones-marlin/frame.png b/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/private-battle-splat-zones-marlin/frame.png
new file mode 100644
index 000000000..791580b77
Binary files /dev/null and b/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/private-battle-splat-zones-marlin/frame.png differ
diff --git a/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/x-battle-rainmaker-brinewater-1404/expected.json b/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/x-battle-rainmaker-brinewater-1404/expected.json
new file mode 100644
index 000000000..b72cab8f9
--- /dev/null
+++ b/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/x-battle-rainmaker-brinewater-1404/expected.json
@@ -0,0 +1,84 @@
+{
+  "event": "ScoreboardBattleLogReplay",
+  "data": {
+    "lobby": "X",
+    "mode": "RM",
+    "stage": 13,
+    "timestamp": "9/7/2026 14:04",
+    "replayCode": "R80B-00DL-WF4X-V3CA",
+    "matchScores": [
+      100,
+      0
+    ],
+    "players": [
+      {
+        "name": "D4C",
+        "weaponId": 80,
+        "paint": 691,
+        "ka": 8,
+        "d": 3,
+        "s": 3
+      },
+      {
+        "name": "ちからこそパワー",
+        "weaponId": 5000,
+        "paint": 562,
+        "ka": 7,
+        "d": 3,
+        "s": 2
+      },
+      {
+        "name": "8♪cloudy",
+        "weaponId": 7030,
+        "paint": 787,
+        "ka": 8,
+        "d": 3,
+        "s": 2
+      },
+      {
+        "name": "このゲームたのしいl",
+        "weaponId": 80,
+        "paint": 568,
+        "ka": 8,
+        "d": 3,
+        "s": 3
+      },
+      {
+        "name": "Rami",
+        "weaponId": 5000,
+        "paint": 431,
+        "ka": 9,
+        "d": 6,
+        "s": 2
+      },
+      {
+        "name": "ぐ",
+        "weaponId": 80,
+        "paint": 514,
+        "ka": 3,
+        "d": 3,
+        "s": 1
+      },
+      {
+        "name": "ミルクリスピー",
+        "weaponId": 90,
+        "paint": 494,
+        "ka": 6,
+        "d": 4,
+        "s": 1
+      },
+      {
+        "name": "だれやそれあけみ",
+        "weaponId": 80,
+        "paint": 455,
+        "ka": 5,
+        "d": 3,
+        "s": 1
+      }
+    ],
+    "stageLabel": "Brinewater Springs"
+  },
+  "options": {
+    "notes": "Heavily compressed stream capture. Replay code hand-verified from the zoomed frame; a prior parse misread 8>6, B>D/A, F>E, A>I."
+  }
+}
diff --git a/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/x-battle-rainmaker-brinewater-1404/frame.png b/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/x-battle-rainmaker-brinewater-1404/frame.png
new file mode 100644
index 000000000..975823fbb
Binary files /dev/null and b/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/x-battle-rainmaker-brinewater-1404/frame.png differ
diff --git a/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/x-battle-rainmaker-brinewater-1411/expected.json b/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/x-battle-rainmaker-brinewater-1411/expected.json
new file mode 100644
index 000000000..bb6f95059
--- /dev/null
+++ b/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/x-battle-rainmaker-brinewater-1411/expected.json
@@ -0,0 +1,89 @@
+{
+  "event": "ScoreboardBattleLogReplay",
+  "data": {
+    "lobby": "X",
+    "mode": "RM",
+    "replayCode": "R17L-PFKK-C1Q2-143L",
+    "matchScores": [
+      53,
+      27
+    ],
+    "players": [
+      {
+        "name": "ちからこそパワー",
+        "weaponId": 5000,
+        "paint": 1167,
+        "ka": 18,
+        "d": 11,
+        "s": 4
+      },
+      {
+        "name": "めがねがし",
+        "weaponId": 70,
+        "paint": 1067,
+        "ka": 17,
+        "d": 6,
+        "s": 4
+      },
+      {
+        "name": "コーヒーゼリー",
+        "weaponId": 60,
+        "paint": 1653,
+        "ka": 14,
+        "d": 6,
+        "s": 6
+      },
+      {
+        "name": "しゅーたようつべ",
+        "weaponId": 7011,
+        "paint": 1374,
+        "ka": 12,
+        "d": 7,
+        "s": 4
+      },
+      {
+        "name": "むぎ",
+        "weaponId": 5000,
+        "paint": 843,
+        "ka": 12,
+        "d": 14,
+        "s": 2
+      },
+      {
+        "name": "8♪cloudy",
+        "weaponId": 7030,
+        "paint": 1837,
+        "ka": 9,
+        "d": 6,
+        "s": 4
+      },
+      {
+        "name": "キャンディ",
+        "weaponId": 0,
+        "paint": 1442,
+        "ka": 9,
+        "d": 8,
+        "s": 7
+      },
+      {
+        "name": "コジャケサラダ つべ",
+        "weaponId": 7021,
+        "paint": 1267,
+        "ka": 9,
+        "d": 10,
+        "s": 1
+      }
+    ],
+    "stage": 13,
+    "timestamp": "9/7/2026 14:11",
+    "stageLabel": "Brinewater Springs"
+  },
+  "options": {
+    "skipFields": [
+      "players.1.name",
+      "players.4.name",
+      "players.7.name"
+    ],
+    "notes": "Same stream as the 1404 case. The old export carried the anonymized-view nicknames; names here are the on-screen ones. Skipped names read without dakuten (めがねがし>めかねかし, むぎ>むき, コジャケサラダ>コジャケサラタ) - names atlas lacks templates for those glyphs. Code hand-verified (F>E misread)."
+  }
+}
diff --git a/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/x-battle-rainmaker-brinewater-1411/frame.png b/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/x-battle-rainmaker-brinewater-1411/frame.png
new file mode 100644
index 000000000..212c39af4
Binary files /dev/null and b/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/x-battle-rainmaker-brinewater-1411/frame.png differ
diff --git a/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/x-battle-rainmaker-brinewater-1416/expected.json b/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/x-battle-rainmaker-brinewater-1416/expected.json
new file mode 100644
index 000000000..36e4ae59b
--- /dev/null
+++ b/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/x-battle-rainmaker-brinewater-1416/expected.json
@@ -0,0 +1,88 @@
+{
+  "event": "ScoreboardBattleLogReplay",
+  "data": {
+    "lobby": "X",
+    "mode": "RM",
+    "stage": 13,
+    "timestamp": "9/7/2026 14:16",
+    "replayCode": "RUH3-3NEF-F5FY-PAJL",
+    "matchScores": [
+      100,
+      null
+    ],
+    "players": [
+      {
+        "name": "G,~,K",
+        "weaponId": 2051,
+        "paint": 1077,
+        "ka": 8,
+        "d": 3,
+        "s": 3
+      },
+      {
+        "name": "RADWIMPS",
+        "weaponId": 1015,
+        "paint": 690,
+        "ka": 7,
+        "d": 4,
+        "s": 2
+      },
+      {
+        "name": "けいた",
+        "weaponId": 8000,
+        "paint": 853,
+        "ka": 7,
+        "d": 5,
+        "s": 2
+      },
+      {
+        "name": "RD777",
+        "weaponId": 50,
+        "paint": 696,
+        "ka": 6,
+        "d": 7,
+        "s": 2
+      },
+      {
+        "name": "モンターニュ",
+        "weaponId": 50,
+        "paint": 771,
+        "ka": 9,
+        "d": 6,
+        "s": 1
+      },
+      {
+        "name": "8♪cloudy",
+        "weaponId": 7030,
+        "paint": 1150,
+        "ka": 5,
+        "d": 4,
+        "s": 2
+      },
+      {
+        "name": "めがねがし",
+        "weaponId": 70,
+        "paint": 559,
+        "ka": 7,
+        "d": 3,
+        "s": 1
+      },
+      {
+        "name": "むぎ",
+        "weaponId": 5000,
+        "paint": 546,
+        "ka": 4,
+        "d": 9,
+        "s": 1
+      }
+    ],
+    "stageLabel": "Brinewater Springs"
+  },
+  "options": {
+    "skipFields": [
+      "players.6.name",
+      "players.7.name"
+    ],
+    "notes": "Heavily compressed stream capture. Code hand-verified from the zoomed frame; a prior parse misread U>D, N>H, F>E, 5>6. Skipped names read without dakuten (see the 1411 case)."
+  }
+}
diff --git a/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/x-battle-rainmaker-brinewater-1416/frame.png b/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/x-battle-rainmaker-brinewater-1416/frame.png
new file mode 100644
index 000000000..f6ffbe672
Binary files /dev/null and b/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/x-battle-rainmaker-brinewater-1416/frame.png differ
diff --git a/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/x-battle-rainmaker-brinewater-1422/expected.json b/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/x-battle-rainmaker-brinewater-1422/expected.json
new file mode 100644
index 000000000..6065877e9
--- /dev/null
+++ b/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/x-battle-rainmaker-brinewater-1422/expected.json
@@ -0,0 +1,87 @@
+{
+  "event": "ScoreboardBattleLogReplay",
+  "data": {
+    "lobby": "X",
+    "mode": "RM",
+    "stage": 13,
+    "timestamp": "9/7/2026 14:22",
+    "replayCode": "RGX0-QWEM-E3VS-AVG6",
+    "matchScores": [
+      100,
+      0
+    ],
+    "players": [
+      {
+        "name": "ひきたてやくB",
+        "weaponId": 261,
+        "paint": 1040,
+        "ka": 16,
+        "d": 6,
+        "s": 5
+      },
+      {
+        "name": "ホコまこうどんホコ",
+        "weaponId": 7030,
+        "paint": 1210,
+        "ka": 8,
+        "d": 3,
+        "s": 7
+      },
+      {
+        "name": "S",
+        "weaponId": 3030,
+        "paint": 1838,
+        "ka": 5,
+        "d": 1,
+        "s": 6
+      },
+      {
+        "name": "8♪cloudy",
+        "weaponId": 7030,
+        "paint": 1522,
+        "ka": 9,
+        "d": 3,
+        "s": 6
+      },
+      {
+        "name": "モンターニュ",
+        "weaponId": 50,
+        "paint": 1238,
+        "ka": 6,
+        "d": 4,
+        "s": 4
+      },
+      {
+        "name": "ブラスターアレルギー",
+        "weaponId": 7030,
+        "paint": 1489,
+        "ka": 5,
+        "d": 7,
+        "s": 2
+      },
+      {
+        "name": "0",
+        "weaponId": 7012,
+        "paint": 1257,
+        "ka": 3,
+        "d": 3,
+        "s": 2
+      },
+      {
+        "name": "スリュー",
+        "weaponId": 5030,
+        "paint": 965,
+        "ka": 3,
+        "d": 8,
+        "s": 2
+      }
+    ],
+    "stageLabel": "Brinewater Springs"
+  },
+  "options": {
+    "skipFields": [
+      "players.5.name"
+    ],
+    "notes": "Same stream as the 1404 case; parses correctly today - regression guard. The old export carried anonymized-view nicknames; names here are the on-screen ones ('S' and '0' are real one-char names). players.5 truth is ブラスターアレルギー but reads with アレィLギ garbled mid-name."
+  }
+}
diff --git a/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/x-battle-rainmaker-brinewater-1422/frame.png b/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/x-battle-rainmaker-brinewater-1422/frame.png
new file mode 100644
index 000000000..738c48b96
Binary files /dev/null and b/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/x-battle-rainmaker-brinewater-1422/frame.png differ
diff --git a/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/x-battle-rainmaker-urchin-1434/expected.json b/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/x-battle-rainmaker-urchin-1434/expected.json
new file mode 100644
index 000000000..465b71b78
--- /dev/null
+++ b/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/x-battle-rainmaker-urchin-1434/expected.json
@@ -0,0 +1,84 @@
+{
+  "event": "ScoreboardBattleLogReplay",
+  "data": {
+    "lobby": "X",
+    "mode": "RM",
+    "stage": 24,
+    "timestamp": "9/7/2026 14:34",
+    "replayCode": "RUCT-5HNH-XWDC-J51U",
+    "matchScores": [
+      32,
+      7
+    ],
+    "players": [
+      {
+        "name": "Mesh Cap",
+        "weaponId": 0,
+        "paint": 1365,
+        "ka": 16,
+        "d": 7,
+        "s": 4
+      },
+      {
+        "name": "Braid",
+        "weaponId": 2030,
+        "paint": 1230,
+        "ka": 11,
+        "d": 3,
+        "s": 2
+      },
+      {
+        "name": "Sneaky",
+        "weaponId": 7030,
+        "paint": 1345,
+        "ka": 9,
+        "d": 9,
+        "s": 5
+      },
+      {
+        "name": "Wave",
+        "weaponId": 20,
+        "paint": 923,
+        "ka": 11,
+        "d": 9,
+        "s": 2
+      },
+      {
+        "name": "Splashy",
+        "weaponId": 50,
+        "paint": 1288,
+        "ka": 18,
+        "d": 7,
+        "s": 4
+      },
+      {
+        "name": "Capped",
+        "weaponId": 0,
+        "paint": 1321,
+        "ka": 7,
+        "d": 11,
+        "s": 8
+      },
+      {
+        "name": "Slugger",
+        "weaponId": 2031,
+        "paint": 894,
+        "ka": 6,
+        "d": 7,
+        "s": 2
+      },
+      {
+        "name": "Sunshield",
+        "weaponId": 7030,
+        "paint": 1320,
+        "ka": 4,
+        "d": 9,
+        "s": 7
+      }
+    ],
+    "stageLabel": "Urchin Underpass"
+  },
+  "options": {
+    "notes": "Heavily compressed stream capture, anonymized-view names. Code hand-verified from the zoomed frame; a prior parse misread U>D, T>7, 5>6, N>H, U>L."
+  }
+}
diff --git a/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/x-battle-rainmaker-urchin-1434/frame.png b/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/x-battle-rainmaker-urchin-1434/frame.png
new file mode 100644
index 000000000..d4494a7e2
Binary files /dev/null and b/app/features/scanner/tests/fixtures/scoreboard-battle-log-replay/x-battle-rainmaker-urchin-1434/frame.png differ
diff --git a/app/features/scanner/tests/fixtures/scoreboard-battle-log/private-battle-rainmaker-lemuria-hub/expected.json b/app/features/scanner/tests/fixtures/scoreboard-battle-log/private-battle-rainmaker-lemuria-hub/expected.json
new file mode 100644
index 000000000..20aa68272
--- /dev/null
+++ b/app/features/scanner/tests/fixtures/scoreboard-battle-log/private-battle-rainmaker-lemuria-hub/expected.json
@@ -0,0 +1,80 @@
+{
+  "event": "ScoreboardBattleLog",
+  "data": {
+    "lobby": "X",
+    "mode": "RM",
+    "stage": 23,
+    "stageLabel": "Lemuria Hub",
+    "timestamp": "5/8/2026 18:16",
+    "matchScores": [
+      96,
+      86
+    ],
+    "players": [
+      {
+        "name": "Now or Never Seven",
+        "weaponId": 60,
+        "paint": 1216,
+        "ka": 12,
+        "d": 11,
+        "s": 4
+      },
+      {
+        "name": "lnvisifloats",
+        "weaponId": 40,
+        "paint": 1233,
+        "ka": 20,
+        "d": 8,
+        "s": 4
+      },
+      {
+        "name": "3D",
+        "weaponId": 7010,
+        "paint": 1694,
+        "ka": 12,
+        "d": 6,
+        "s": 6
+      },
+      {
+        "name": "Beanie",
+        "weaponId": 252,
+        "paint": 1088,
+        "ka": 10,
+        "d": 11,
+        "s": 3
+      },
+      {
+        "name": "BluFocals",
+        "weaponId": 5001,
+        "paint": 1575,
+        "ka": 14,
+        "d": 11,
+        "s": 3
+      },
+      {
+        "name": "Headphones",
+        "weaponId": 2021,
+        "paint": 879,
+        "ka": 7,
+        "d": 8,
+        "s": 3
+      },
+      {
+        "name": "Slugger",
+        "weaponId": 1020,
+        "paint": 1618,
+        "ka": 10,
+        "d": 8,
+        "s": 5
+      },
+      {
+        "name": "Mesh Cap",
+        "weaponId": 50,
+        "paint": 1264,
+        "ka": 12,
+        "d": 9,
+        "s": 4
+      }
+    ]
+  }
+}
diff --git a/app/features/scanner/tests/fixtures/scoreboard-battle-log/private-battle-rainmaker-lemuria-hub/frame.png b/app/features/scanner/tests/fixtures/scoreboard-battle-log/private-battle-rainmaker-lemuria-hub/frame.png
new file mode 100644
index 000000000..7543ab5f2
Binary files /dev/null and b/app/features/scanner/tests/fixtures/scoreboard-battle-log/private-battle-rainmaker-lemuria-hub/frame.png differ
diff --git a/app/features/scanner/tests/fixtures/scoreboard-battle-log/private-battle-splat-zones-makomart/expected.json b/app/features/scanner/tests/fixtures/scoreboard-battle-log/private-battle-splat-zones-makomart/expected.json
new file mode 100644
index 000000000..84220f518
--- /dev/null
+++ b/app/features/scanner/tests/fixtures/scoreboard-battle-log/private-battle-splat-zones-makomart/expected.json
@@ -0,0 +1,88 @@
+{
+  "event": "ScoreboardBattleLog",
+  "data": {
+    "lobby": "PRIVATE",
+    "mode": "SZ",
+    "stage": 10,
+    "timestamp": "5/8/2026 19:16",
+    "matchScores": [
+      100,
+      0
+    ],
+    "povIndex": 3,
+    "players": [
+      {
+        "name": "BDAYBOY",
+        "paint": 1955,
+        "ka": 13,
+        "d": 5,
+        "s": 8,
+        "weaponId": 60
+      },
+      {
+        "name": "∴Columbina",
+        "paint": 1430,
+        "ka": 8,
+        "d": 7,
+        "s": 6,
+        "weaponId": 3020
+      },
+      {
+        "name": "xtsy",
+        "paint": 956,
+        "ka": 9,
+        "d": 4,
+        "s": 4,
+        "weaponId": 50
+      },
+      {
+        "name": "Sendou",
+        "paint": 917,
+        "ka": 6,
+        "d": 9,
+        "s": 3,
+        "weaponId": 211
+      },
+      {
+        "name": "Bronx Thug",
+        "paint": 1512,
+        "ka": 13,
+        "d": 7,
+        "s": 7,
+        "weaponId": 3011
+      },
+      {
+        "name": "mr 2how",
+        "paint": 1380,
+        "ka": 11,
+        "d": 9,
+        "s": 7,
+        "weaponId": 8002
+      },
+      {
+        "name": "Katfesh",
+        "paint": 1473,
+        "ka": 3,
+        "d": 3,
+        "s": 7,
+        "weaponId": 2071
+      },
+      {
+        "name": "-Artemis->",
+        "paint": 1031,
+        "ka": 10,
+        "d": 8,
+        "s": 5,
+        "weaponId": 1002
+      }
+    ],
+    "stageLabel": "MakoMart"
+  },
+  "options": {
+    "skipFields": [
+      "players.0.name",
+      "players.1.name"
+    ],
+    "notes": "720p stream capture with horizontal banding. players.0.name (BDAYBOY) reads BOAuBOY and players.1.name (∴Columbina) reads ∴Columhina — the banding cuts glyph cores at this size. Weapons row order: N-ZAP '85, Sloshing Machine, .52 Gal, Custom Blaster, Tri-Slosher Nouveau, Stickerz Splatana Stamper, Snipewriter 5B, Carbon Roller ANG-L."
+  }
+}
diff --git a/app/features/scanner/tests/fixtures/scoreboard-battle-log/private-battle-splat-zones-makomart/frame.png b/app/features/scanner/tests/fixtures/scoreboard-battle-log/private-battle-splat-zones-makomart/frame.png
new file mode 100644
index 000000000..ac8abb94b
Binary files /dev/null and b/app/features/scanner/tests/fixtures/scoreboard-battle-log/private-battle-splat-zones-makomart/frame.png differ
diff --git a/app/features/scanner/tests/fixtures/scoreboard-battle-log/private-battle-splat-zones-robo-rom-en/expected.json b/app/features/scanner/tests/fixtures/scoreboard-battle-log/private-battle-splat-zones-robo-rom-en/expected.json
new file mode 100644
index 000000000..d1ce633d5
--- /dev/null
+++ b/app/features/scanner/tests/fixtures/scoreboard-battle-log/private-battle-splat-zones-robo-rom-en/expected.json
@@ -0,0 +1,79 @@
+{
+  "event": "ScoreboardBattleLog",
+  "data": {
+    "lobby": "PRIVATE",
+    "mode": "SZ",
+    "stage": 21,
+    "timestamp": "5/8/2026 19:30",
+    "matchScores": [
+      100,
+      0
+    ],
+    "players": [
+      {
+        "name": "xtsy",
+        "weaponId": 8000,
+        "paint": 591,
+        "ka": 6,
+        "d": 0,
+        "s": 2
+      },
+      {
+        "name": "BDAYBOY",
+        "weaponId": 60,
+        "paint": 741,
+        "ka": 4,
+        "d": 0,
+        "s": 2
+      },
+      {
+        "name": "Sendou",
+        "weaponId": 211,
+        "paint": 296,
+        "ka": 4,
+        "d": 3,
+        "s": 1
+      },
+      {
+        "name": "∴Columhina",
+        "weaponId": 3020,
+        "paint": 529,
+        "ka": 3,
+        "d": 0,
+        "s": 1
+      },
+      {
+        "name": "mr 2how",
+        "weaponId": 8002,
+        "paint": 503,
+        "ka": 2,
+        "d": 4,
+        "s": 2
+      },
+      {
+        "name": "Bronx Thug",
+        "weaponId": 41,
+        "paint": 482,
+        "ka": 1,
+        "d": 3,
+        "s": 1
+      },
+      {
+        "name": "-Hrtemis->",
+        "weaponId": 1001,
+        "paint": 310,
+        "ka": 1,
+        "d": 3,
+        "s": 1
+      },
+      {
+        "name": "Katfesh",
+        "weaponId": 2070,
+        "paint": 562,
+        "ka": 0,
+        "d": 0,
+        "s": 2
+      }
+    ]
+  }
+}
diff --git a/app/features/scanner/tests/fixtures/scoreboard-battle-log/private-battle-splat-zones-robo-rom-en/frame.png b/app/features/scanner/tests/fixtures/scoreboard-battle-log/private-battle-splat-zones-robo-rom-en/frame.png
new file mode 100644
index 000000000..39a669acf
Binary files /dev/null and b/app/features/scanner/tests/fixtures/scoreboard-battle-log/private-battle-splat-zones-robo-rom-en/frame.png differ
diff --git a/app/features/scanner/tests/fixtures/scoreboard-battle-log/x-battle-clam-blitz-lemuria/expected.json b/app/features/scanner/tests/fixtures/scoreboard-battle-log/x-battle-clam-blitz-lemuria/expected.json
new file mode 100644
index 000000000..6fdfbe2a0
--- /dev/null
+++ b/app/features/scanner/tests/fixtures/scoreboard-battle-log/x-battle-clam-blitz-lemuria/expected.json
@@ -0,0 +1,87 @@
+{
+  "event": "ScoreboardBattleLog",
+  "data": {
+    "lobby": "X",
+    "mode": "CB",
+    "stage": 23,
+    "timestamp": "3/8/2026 18:11",
+    "matchScores": [
+      30,
+      23
+    ],
+    "povIndex": 5,
+    "players": [
+      {
+        "name": "Pony",
+        "paint": 1680,
+        "ka": 11,
+        "d": 6,
+        "s": 7,
+        "weaponId": 60
+      },
+      {
+        "name": "Charms",
+        "paint": 1367,
+        "ka": 9,
+        "d": 10,
+        "s": 6,
+        "weaponId": 0
+      },
+      {
+        "name": "Mesh Cap",
+        "paint": 857,
+        "ka": 4,
+        "d": 6,
+        "s": 2,
+        "weaponId": 2030
+      },
+      {
+        "name": "Retro",
+        "paint": 1034,
+        "ka": 9,
+        "d": 8,
+        "s": 4,
+        "weaponId": 251
+      },
+      {
+        "name": "Invisifloats",
+        "paint": 1762,
+        "ka": 14,
+        "d": 6,
+        "s": 5,
+        "weaponId": 60
+      },
+      {
+        "name": "Beanie",
+        "paint": 1194,
+        "ka": 11,
+        "d": 8,
+        "s": 2,
+        "weaponId": 252
+      },
+      {
+        "name": "Headphones",
+        "paint": 859,
+        "ka": 4,
+        "d": 5,
+        "s": 1,
+        "weaponId": 2030
+      },
+      {
+        "name": "Slugger",
+        "paint": 1023,
+        "ka": 11,
+        "d": 6,
+        "s": 3,
+        "weaponId": 1010
+      }
+    ],
+    "stageLabel": "Lemuria Hub"
+  },
+  "options": {
+    "skipFields": [
+      "players.4.name"
+    ],
+    "notes": "players.4.name (Invisifloats) reads lnvisifloats — I and l are pixel-identical bars in this face. Weapons row order: N-ZAP '85, Sploosh-o-matic, E-liter 4K, Rapid Blaster Pro Deco, N-ZAP '85, Rapid Blaster Pro WNT-R, E-liter 4K, Splat Roller (Big Bubbler special confirms the near-tied Flingza off)."
+  }
+}
diff --git a/app/features/scanner/tests/fixtures/scoreboard-battle-log/x-battle-clam-blitz-lemuria/frame.png b/app/features/scanner/tests/fixtures/scoreboard-battle-log/x-battle-clam-blitz-lemuria/frame.png
new file mode 100644
index 000000000..6c9cbf45c
Binary files /dev/null and b/app/features/scanner/tests/fixtures/scoreboard-battle-log/x-battle-clam-blitz-lemuria/frame.png differ
diff --git a/app/features/scanner/tests/fixtures/scoreboard-own/order-slosher-replica/expected.json b/app/features/scanner/tests/fixtures/scoreboard-own/order-slosher-replica/expected.json
new file mode 100644
index 000000000..f8164985e
--- /dev/null
+++ b/app/features/scanner/tests/fixtures/scoreboard-own/order-slosher-replica/expected.json
@@ -0,0 +1,31 @@
+{
+  "event": "ScoreboardOwn",
+  "data": {
+    "lobby": "PRIVATE",
+    "mode": "SZ",
+    "stage": 7,
+    "weaponId": 3005,
+    "abilities": [
+      [
+        "CB",
+        "QSJ",
+        "SS",
+        "RES"
+      ],
+      [
+        "SSU",
+        "QSJ",
+        "SS",
+        "SRU"
+      ],
+      [
+        "SJ",
+        "ISS",
+        "SS",
+        "QSJ"
+      ]
+    ],
+    "stageLabel": "Mahi-Mahi Resort",
+    "weaponLabel": "Order Slosher Replica"
+  }
+}
diff --git a/app/features/scanner/tests/fixtures/scoreboard-own/order-slosher-replica/frame.png b/app/features/scanner/tests/fixtures/scoreboard-own/order-slosher-replica/frame.png
new file mode 100644
index 000000000..c6068a242
Binary files /dev/null and b/app/features/scanner/tests/fixtures/scoreboard-own/order-slosher-replica/frame.png differ
diff --git a/app/features/scanner/tests/fixtures/scoreboard-own/private-battle-splat-zones-museum/expected.json b/app/features/scanner/tests/fixtures/scoreboard-own/private-battle-splat-zones-museum/expected.json
new file mode 100644
index 000000000..c72709d90
--- /dev/null
+++ b/app/features/scanner/tests/fixtures/scoreboard-own/private-battle-splat-zones-museum/expected.json
@@ -0,0 +1,31 @@
+{
+  "event": "ScoreboardOwn",
+  "data": {
+    "lobby": "PRIVATE",
+    "mode": "SZ",
+    "stage": 6,
+    "weaponId": 50,
+    "abilities": [
+      [
+        "OG",
+        "SSU",
+        "RES",
+        "SSU"
+      ],
+      [
+        "SSU",
+        "SRU",
+        "SSU",
+        "SSU"
+      ],
+      [
+        "SJ",
+        "IA",
+        "QSJ",
+        "IA"
+      ]
+    ],
+    "stageLabel": "Museum d'Alfonsino",
+    "weaponLabel": ".52 Gal"
+  }
+}
diff --git a/app/features/scanner/tests/fixtures/scoreboard-own/private-battle-splat-zones-museum/frame.png b/app/features/scanner/tests/fixtures/scoreboard-own/private-battle-splat-zones-museum/frame.png
new file mode 100644
index 000000000..9412e376a
Binary files /dev/null and b/app/features/scanner/tests/fixtures/scoreboard-own/private-battle-splat-zones-museum/frame.png differ
diff --git a/app/features/scanner/tests/fixtures/scoreboard/german-private-battle-clam-blitz/expected.json b/app/features/scanner/tests/fixtures/scoreboard/german-private-battle-clam-blitz/expected.json
new file mode 100644
index 000000000..2aa63ea22
--- /dev/null
+++ b/app/features/scanner/tests/fixtures/scoreboard/german-private-battle-clam-blitz/expected.json
@@ -0,0 +1,87 @@
+{
+  "event": "Scoreboard",
+  "data": {
+    "lobby": "PRIVATE",
+    "mode": "CB",
+    "stage": 0,
+    "matchScores": [
+      96,
+      74
+    ],
+    "povIndex": 0,
+    "players": [
+      {
+        "name": "くらうに ★～",
+        "weaponId": 2070,
+        "paint": 1565,
+        "ka": 22,
+        "d": 4,
+        "s": 6
+      },
+      {
+        "name": "a",
+        "weaponId": 210,
+        "paint": 938,
+        "ka": 19,
+        "d": 15,
+        "s": 3
+      },
+      {
+        "name": "24K",
+        "weaponId": 80,
+        "paint": 1540,
+        "ka": 16,
+        "d": 7,
+        "s": 6
+      },
+      {
+        "name": "Ù Ballóòn",
+        "weaponId": 3000,
+        "paint": 1321,
+        "ka": 16,
+        "d": 12,
+        "s": 3
+      },
+      {
+        "name": "Eier",
+        "weaponId": 3011,
+        "paint": 1406,
+        "ka": 18,
+        "d": 13,
+        "s": 5
+      },
+      {
+        "name": "aruka",
+        "weaponId": 8001,
+        "paint": 1523,
+        "ka": 17,
+        "d": 9,
+        "s": 6
+      },
+      {
+        "name": "リッター4K",
+        "weaponId": 2021,
+        "paint": 1219,
+        "ka": 6,
+        "d": 10,
+        "s": 2
+      },
+      {
+        "name": "Florescent",
+        "weaponId": 50,
+        "paint": 1133,
+        "ka": 14,
+        "d": 13,
+        "s": 3
+      }
+    ],
+    "stageLabel": "Scorch Gorge"
+  },
+  "options": {
+    "skipFields": [
+      "players.0.name",
+      "players.3.name",
+      "players.6.name"
+    ]
+  }
+}
diff --git a/app/features/scanner/tests/fixtures/scoreboard/german-private-battle-clam-blitz/frame.png b/app/features/scanner/tests/fixtures/scoreboard/german-private-battle-clam-blitz/frame.png
new file mode 100644
index 000000000..c952748e1
Binary files /dev/null and b/app/features/scanner/tests/fixtures/scoreboard/german-private-battle-clam-blitz/frame.png differ
diff --git a/app/features/scanner/tests/fixtures/scoreboard/private-battle-splat-zones-ko-hagglefish/expected.json b/app/features/scanner/tests/fixtures/scoreboard/private-battle-splat-zones-ko-hagglefish/expected.json
new file mode 100644
index 000000000..a6de364a8
--- /dev/null
+++ b/app/features/scanner/tests/fixtures/scoreboard/private-battle-splat-zones-ko-hagglefish/expected.json
@@ -0,0 +1,86 @@
+{
+  "event": "Scoreboard",
+  "options": {
+    "skipFields": [
+      "players.3.name"
+    ],
+    "notes": "KNOCKOUT! burst on the RIGHT banner side (loser's Score: 0 on the left) - regression guard for the burst reading as a 7-0 score. players.3 truth is AHOOUUUUUU but reads AHOOLUUUUU (U misread as L). players.6 name uses dotless i (as parsed) - verify against source if it ever fails."
+  },
+  "data": {
+    "lobby": "PRIVATE",
+    "mode": "SZ",
+    "stage": 2,
+    "stageLabel": "Hagglefish Market",
+    "matchScores": [
+      100,
+      0
+    ],
+    "povIndex": 7,
+    "players": [
+      {
+        "name": "nwrm",
+        "weaponId": 50,
+        "paint": 381,
+        "ka": 8,
+        "d": 2,
+        "s": 0
+      },
+      {
+        "name": "slord",
+        "weaponId": 20,
+        "paint": 613,
+        "ka": 4,
+        "d": 1,
+        "s": 2
+      },
+      {
+        "name": "Olise",
+        "weaponId": 2070,
+        "paint": 456,
+        "ka": 3,
+        "d": 1,
+        "s": 2
+      },
+      {
+        "name": "AHOOUUUUUU",
+        "weaponId": 1015,
+        "paint": 287,
+        "ka": 1,
+        "d": 2,
+        "s": 1
+      },
+      {
+        "name": "★Bønk★•PE•",
+        "weaponId": 1001,
+        "paint": 327,
+        "ka": 3,
+        "d": 3,
+        "s": 1
+      },
+      {
+        "name": "Enamel",
+        "weaponId": 2070,
+        "paint": 408,
+        "ka": 1,
+        "d": 1,
+        "s": 2
+      },
+      {
+        "name": "Rιppιng_H",
+        "weaponId": 8001,
+        "paint": 270,
+        "ka": 3,
+        "d": 3,
+        "s": 1
+      },
+      {
+        "name": "Sendou",
+        "weaponId": 10,
+        "paint": 354,
+        "ka": 0,
+        "d": 3,
+        "s": 1
+      }
+    ]
+  }
+}
diff --git a/app/features/scanner/tests/fixtures/scoreboard/private-battle-splat-zones-ko-hagglefish/frame.png b/app/features/scanner/tests/fixtures/scoreboard/private-battle-splat-zones-ko-hagglefish/frame.png
new file mode 100644
index 000000000..0b1d0b137
Binary files /dev/null and b/app/features/scanner/tests/fixtures/scoreboard/private-battle-splat-zones-ko-hagglefish/frame.png differ
diff --git a/app/features/scanner/tests/fixtures/scoreboard/private-battle-splat-zones-ko-kera-2/expected.json b/app/features/scanner/tests/fixtures/scoreboard/private-battle-splat-zones-ko-kera-2/expected.json
new file mode 100644
index 000000000..106383957
--- /dev/null
+++ b/app/features/scanner/tests/fixtures/scoreboard/private-battle-splat-zones-ko-kera-2/expected.json
@@ -0,0 +1,80 @@
+{
+  "event": "Scoreboard",
+  "data": {
+    "lobby": "PRIVATE",
+    "mode": "SZ",
+    "stage": 3,
+    "matchScores": [
+      85,
+      82
+    ],
+    "povIndex": 3,
+    "players": [
+      {
+        "name": "Mongering",
+        "weaponId": 261,
+        "paint": 1312,
+        "ka": 23,
+        "d": 8,
+        "s": 6
+      },
+      {
+        "name": "y0s",
+        "weaponId": 4050,
+        "paint": 1460,
+        "ka": 18,
+        "d": 6,
+        "s": 5
+      },
+      {
+        "name": "fuzzy",
+        "weaponId": 20,
+        "paint": 1525,
+        "ka": 13,
+        "d": 10,
+        "s": 5
+      },
+      {
+        "name": "kera",
+        "weaponId": 400,
+        "paint": 953,
+        "ka": 15,
+        "d": 8,
+        "s": 2
+      },
+      {
+        "name": "Cucumber",
+        "weaponId": 5015,
+        "paint": 1284,
+        "ka": 21,
+        "d": 10,
+        "s": 5
+      },
+      {
+        "name": "Reefslider",
+        "weaponId": 3050,
+        "paint": 1584,
+        "ka": 16,
+        "d": 10,
+        "s": 6
+      },
+      {
+        "name": "sigma",
+        "weaponId": 4050,
+        "paint": 1336,
+        "ka": 12,
+        "d": 9,
+        "s": 6
+      },
+      {
+        "name": "tomato",
+        "weaponId": 8020,
+        "paint": 1051,
+        "ka": 11,
+        "d": 12,
+        "s": 3
+      }
+    ],
+    "stageLabel": "Undertow Spillway"
+  }
+}
diff --git a/app/features/scanner/tests/fixtures/scoreboard/private-battle-splat-zones-ko-kera-2/frame.png b/app/features/scanner/tests/fixtures/scoreboard/private-battle-splat-zones-ko-kera-2/frame.png
new file mode 100644
index 000000000..0fec694e1
Binary files /dev/null and b/app/features/scanner/tests/fixtures/scoreboard/private-battle-splat-zones-ko-kera-2/frame.png differ
diff --git a/app/features/scanner/tests/fixtures/scoreboard/private-battle-splat-zones-ko-kera/expected.json b/app/features/scanner/tests/fixtures/scoreboard/private-battle-splat-zones-ko-kera/expected.json
new file mode 100644
index 000000000..78d8b557a
--- /dev/null
+++ b/app/features/scanner/tests/fixtures/scoreboard/private-battle-splat-zones-ko-kera/expected.json
@@ -0,0 +1,80 @@
+{
+  "event": "Scoreboard",
+  "data": {
+    "lobby": "PRIVATE",
+    "mode": "SZ",
+    "stage": 6,
+    "matchScores": [
+      100,
+      0
+    ],
+    "povIndex": 3,
+    "players": [
+      {
+        "name": "Mongering",
+        "weaponId": 261,
+        "paint": 503,
+        "ka": 11,
+        "d": 1,
+        "s": 2
+      },
+      {
+        "name": "y0s",
+        "weaponId": 2070,
+        "paint": 766,
+        "ka": 8,
+        "d": 0,
+        "s": 3
+      },
+      {
+        "name": "fuzzy",
+        "weaponId": 20,
+        "paint": 624,
+        "ka": 5,
+        "d": 2,
+        "s": 2
+      },
+      {
+        "name": "kera",
+        "weaponId": 400,
+        "paint": 323,
+        "ka": 5,
+        "d": 3,
+        "s": 0
+      },
+      {
+        "name": "sigma",
+        "weaponId": 2070,
+        "paint": 500,
+        "ka": 4,
+        "d": 3,
+        "s": 2
+      },
+      {
+        "name": "Reefslider",
+        "weaponId": 3050,
+        "paint": 503,
+        "ka": 3,
+        "d": 6,
+        "s": 1
+      },
+      {
+        "name": "Cucumber",
+        "weaponId": 5015,
+        "paint": 427,
+        "ka": 2,
+        "d": 5,
+        "s": 2
+      },
+      {
+        "name": "tomato",
+        "weaponId": 8020,
+        "paint": 414,
+        "ka": 1,
+        "d": 6,
+        "s": 1
+      }
+    ],
+    "stageLabel": "Museum d'Alfonsino"
+  }
+}
diff --git a/app/features/scanner/tests/fixtures/scoreboard/private-battle-splat-zones-ko-kera/frame.png b/app/features/scanner/tests/fixtures/scoreboard/private-battle-splat-zones-ko-kera/frame.png
new file mode 100644
index 000000000..c00f845f8
Binary files /dev/null and b/app/features/scanner/tests/fixtures/scoreboard/private-battle-splat-zones-ko-kera/frame.png differ
diff --git a/app/features/scanner/tests/fixtures/scoreboard/private-battle-splat-zones-umami/expected.json b/app/features/scanner/tests/fixtures/scoreboard/private-battle-splat-zones-umami/expected.json
new file mode 100644
index 000000000..2fffa0c1c
--- /dev/null
+++ b/app/features/scanner/tests/fixtures/scoreboard/private-battle-splat-zones-umami/expected.json
@@ -0,0 +1,79 @@
+{
+  "event": "Scoreboard",
+  "data": {
+    "lobby": "PRIVATE",
+    "mode": "SZ",
+    "stage": 15,
+    "stageLabel": "Um'ami Ruins",
+    "matchScores": [
+      93,
+      69
+    ],
+    "players": [
+      {
+        "name": "sDpp",
+        "weaponId": 50,
+        "paint": 1037,
+        "ka": 18,
+        "d": 10,
+        "s": 3
+      },
+      {
+        "name": "Mathis♪・“",
+        "weaponId": 2070,
+        "paint": 1566,
+        "ka": 14,
+        "d": 5,
+        "s": 6
+      },
+      {
+        "name": "あ",
+        "weaponId": 2000,
+        "paint": 1254,
+        "ka": 15,
+        "d": 5,
+        "s": 5
+      },
+      {
+        "name": "YuNI",
+        "weaponId": 3005,
+        "paint": 1294,
+        "ka": 13,
+        "d": 11,
+        "s": 4
+      },
+      {
+        "name": "★Bønk★•PE•",
+        "weaponId": 1101,
+        "paint": 1428,
+        "ka": 19,
+        "d": 10,
+        "s": 6
+      },
+      {
+        "name": "Rιppιng_H",
+        "weaponId": 8020,
+        "paint": 1315,
+        "ka": 9,
+        "d": 13,
+        "s": 5
+      },
+      {
+        "name": "Sendou",
+        "weaponId": 6010,
+        "paint": 1028,
+        "ka": 7,
+        "d": 7,
+        "s": 4
+      },
+      {
+        "name": "Enamel",
+        "weaponId": 2070,
+        "paint": 1356,
+        "ka": 8,
+        "d": 6,
+        "s": 5
+      }
+    ]
+  }
+}
diff --git a/app/features/scanner/tests/fixtures/scoreboard/private-battle-splat-zones-umami/frame.png b/app/features/scanner/tests/fixtures/scoreboard/private-battle-splat-zones-umami/frame.png
new file mode 100644
index 000000000..8797d8168
Binary files /dev/null and b/app/features/scanner/tests/fixtures/scoreboard/private-battle-splat-zones-umami/frame.png differ
diff --git a/app/features/scanner/tests/fixtures/scoreboard/private-battle-triton-cup-154-sendou/expected.json b/app/features/scanner/tests/fixtures/scoreboard/private-battle-triton-cup-154-sendou/expected.json
new file mode 100644
index 000000000..d2fed7b91
--- /dev/null
+++ b/app/features/scanner/tests/fixtures/scoreboard/private-battle-triton-cup-154-sendou/expected.json
@@ -0,0 +1,80 @@
+{
+  "event": "Scoreboard",
+  "data": {
+    "lobby": "PRIVATE",
+    "mode": "SZ",
+    "stage": 17,
+    "matchScores": [
+      100,
+      0
+    ],
+    "povIndex": 2,
+    "players": [
+      {
+        "name": "★Bønk★•PE•",
+        "weaponId": 1010,
+        "paint": 1210,
+        "ka": 19,
+        "d": 6,
+        "s": 5
+      },
+      {
+        "name": "Enamel",
+        "weaponId": 2070,
+        "paint": 1596,
+        "ka": 14,
+        "d": 3,
+        "s": 6
+      },
+      {
+        "name": "Sendou",
+        "weaponId": 10,
+        "paint": 1534,
+        "ka": 13,
+        "d": 10,
+        "s": 6
+      },
+      {
+        "name": "Rιppιng_H",
+        "weaponId": 8001,
+        "paint": 1248,
+        "ka": 10,
+        "d": 11,
+        "s": 5
+      },
+      {
+        "name": "nwrm",
+        "weaponId": 50,
+        "paint": 1018,
+        "ka": 14,
+        "d": 12,
+        "s": 3
+      },
+      {
+        "name": "slord",
+        "weaponId": 20,
+        "paint": 1807,
+        "ka": 8,
+        "d": 4,
+        "s": 6
+      },
+      {
+        "name": "Olise",
+        "weaponId": 2070,
+        "paint": 1535,
+        "ka": 10,
+        "d": 3,
+        "s": 6
+      },
+      {
+        "name": "AHOOUUUUUU",
+        "weaponId": 1015,
+        "paint": 870,
+        "ka": 12,
+        "d": 14,
+        "s": 3
+      }
+    ],
+    "stageLabel": "Barnacle & Dime"
+  }
+}
diff --git a/app/features/scanner/tests/fixtures/scoreboard/private-battle-triton-cup-154-sendou/frame.png b/app/features/scanner/tests/fixtures/scoreboard/private-battle-triton-cup-154-sendou/frame.png
new file mode 100644
index 000000000..b935d4d0d
Binary files /dev/null and b/app/features/scanner/tests/fixtures/scoreboard/private-battle-triton-cup-154-sendou/frame.png differ
diff --git a/app/features/scanner/tests/fixtures/scoreboard/robot/expected.json b/app/features/scanner/tests/fixtures/scoreboard/robot/expected.json
new file mode 100644
index 000000000..98c6a9589
--- /dev/null
+++ b/app/features/scanner/tests/fixtures/scoreboard/robot/expected.json
@@ -0,0 +1,79 @@
+{
+  "event": "Scoreboard",
+  "data": {
+    "lobby": "PRIVATE",
+    "mode": "SZ",
+    "stage": 4,
+    "matchScores": [
+      100,
+      0
+    ],
+    "players": [
+      {
+        "name": "R.O.B.O.T",
+        "weaponId": 211,
+        "paint": 686,
+        "ka": 13,
+        "d": 5,
+        "s": 3
+      },
+      {
+        "name": "でんさく",
+        "weaponId": 60,
+        "paint": 1207,
+        "ka": 11,
+        "d": 2,
+        "s": 5
+      },
+      {
+        "name": "いちごシロップ",
+        "weaponId": 2030,
+        "paint": 707,
+        "ka": 7,
+        "d": 2,
+        "s": 3
+      },
+      {
+        "name": "てんさく",
+        "weaponId": 3000,
+        "paint": 818,
+        "ka": 5,
+        "d": 5,
+        "s": 2
+      },
+      {
+        "name": "Mathis",
+        "weaponId": 2070,
+        "paint": 1013,
+        "ka": 10,
+        "d": 3,
+        "s": 5
+      },
+      {
+        "name": "Rαι×ι..・",
+        "weaponId": 8000,
+        "paint": 868,
+        "ka": 6,
+        "d": 6,
+        "s": 4
+      },
+      {
+        "name": "YuNI",
+        "weaponId": 3005,
+        "paint": 908,
+        "ka": 5,
+        "d": 6,
+        "s": 2
+      },
+      {
+        "name": "eileen",
+        "weaponId": 50,
+        "paint": 629,
+        "ka": 4,
+        "d": 9,
+        "s": 2
+      }
+    ],
+    "stageLabel": "Mincemeat Metalworks"
+  }
+}
diff --git a/app/features/scanner/tests/fixtures/scoreboard/robot/frame.png b/app/features/scanner/tests/fixtures/scoreboard/robot/frame.png
new file mode 100644
index 000000000..c806ec936
Binary files /dev/null and b/app/features/scanner/tests/fixtures/scoreboard/robot/frame.png differ
diff --git a/app/features/scanner/tests/fixtures/scoreboard/special-symbols/expected.json b/app/features/scanner/tests/fixtures/scoreboard/special-symbols/expected.json
new file mode 100644
index 000000000..00707e68e
--- /dev/null
+++ b/app/features/scanner/tests/fixtures/scoreboard/special-symbols/expected.json
@@ -0,0 +1,79 @@
+{
+  "event": "Scoreboard",
+  "data": {
+    "lobby": "SERIES",
+    "mode": "SZ",
+    "stage": 8,
+    "matchScores": [
+      100,
+      0
+    ],
+    "players": [
+      {
+        "name": "Sendou",
+        "weaponId": 220,
+        "paint": 437,
+        "ka": 6,
+        "d": 2,
+        "s": 1
+      },
+      {
+        "name": "◇Dαrz™",
+        "weaponId": 4010,
+        "paint": 635,
+        "ka": 3,
+        "d": 0,
+        "s": 2
+      },
+      {
+        "name": "Love★Star",
+        "weaponId": 7015,
+        "paint": 467,
+        "ka": 4,
+        "d": 1,
+        "s": 2
+      },
+      {
+        "name": "m",
+        "weaponId": 5000,
+        "paint": 498,
+        "ka": 5,
+        "d": 2,
+        "s": 2
+      },
+      {
+        "name": "Super★star",
+        "weaponId": 2070,
+        "paint": 683,
+        "ka": 3,
+        "d": 1,
+        "s": 2
+      },
+      {
+        "name": "Kelo",
+        "weaponId": 5002,
+        "paint": 453,
+        "ka": 1,
+        "d": 3,
+        "s": 3
+      },
+      {
+        "name": "<sein>",
+        "weaponId": 47,
+        "paint": 488,
+        "ka": 0,
+        "d": 4,
+        "s": 2
+      },
+      {
+        "name": "ウサギ「usagi」",
+        "weaponId": 3011,
+        "paint": 312,
+        "ka": 1,
+        "d": 4,
+        "s": 1
+      }
+    ],
+    "stageLabel": "Inkblot Art Academy"
+  }
+}
diff --git a/app/features/scanner/tests/fixtures/scoreboard/special-symbols/frame.png b/app/features/scanner/tests/fixtures/scoreboard/special-symbols/frame.png
new file mode 100644
index 000000000..ac82a3af5
Binary files /dev/null and b/app/features/scanner/tests/fixtures/scoreboard/special-symbols/frame.png differ
diff --git a/app/features/scanner/tests/fixtures/scoreboard/splash-sploosh/expected.json b/app/features/scanner/tests/fixtures/scoreboard/splash-sploosh/expected.json
new file mode 100644
index 000000000..3960bd54e
--- /dev/null
+++ b/app/features/scanner/tests/fixtures/scoreboard/splash-sploosh/expected.json
@@ -0,0 +1,85 @@
+{
+  "event": "Scoreboard",
+  "options": {
+    "skipFields": [
+      "players.2.name"
+    ]
+  },
+  "data": {
+    "lobby": "PRIVATE",
+    "mode": "SZ",
+    "stage": 13,
+    "matchScores": [
+      100,
+      0
+    ],
+    "povIndex": 1,
+    "players": [
+      {
+        "name": "Bocchi",
+        "weaponId": 60,
+        "paint": 1422,
+        "ka": 15,
+        "d": 10,
+        "s": 6
+      },
+      {
+        "name": "have faith",
+        "weaponId": 3005,
+        "paint": 1161,
+        "ka": 13,
+        "d": 6,
+        "s": 4
+      },
+      {
+        "name": "くらうに ★～",
+        "weaponId": 2030,
+        "paint": 993,
+        "ka": 6,
+        "d": 2,
+        "s": 5
+      },
+      {
+        "name": "Florescent",
+        "weaponId": 211,
+        "paint": 1046,
+        "ka": 13,
+        "d": 6,
+        "s": 5
+      },
+      {
+        "name": "Elis",
+        "weaponId": 60,
+        "paint": 1662,
+        "ka": 15,
+        "d": 2,
+        "s": 6
+      },
+      {
+        "name": "Jrod_14",
+        "weaponId": 4041,
+        "paint": 1105,
+        "ka": 10,
+        "d": 10,
+        "s": 3
+      },
+      {
+        "name": "GOLD SHIP",
+        "weaponId": 2030,
+        "paint": 799,
+        "ka": 2,
+        "d": 2,
+        "s": 4
+      },
+      {
+        "name": "merocï¬・~",
+        "weaponId": 0,
+        "paint": 1155,
+        "ka": 8,
+        "d": 12,
+        "s": 6
+      }
+    ],
+    "stageLabel": "Brinewater Springs"
+  }
+}
diff --git a/app/features/scanner/tests/fixtures/scoreboard/splash-sploosh/frame.png b/app/features/scanner/tests/fixtures/scoreboard/splash-sploosh/frame.png
new file mode 100644
index 000000000..95afe859a
Binary files /dev/null and b/app/features/scanner/tests/fixtures/scoreboard/splash-sploosh/frame.png differ
diff --git a/app/features/scanner/tests/fixtures/scoreboard/xbattle-splat-zones-ko-capture/expected.json b/app/features/scanner/tests/fixtures/scoreboard/xbattle-splat-zones-ko-capture/expected.json
new file mode 100644
index 000000000..bbe61405a
--- /dev/null
+++ b/app/features/scanner/tests/fixtures/scoreboard/xbattle-splat-zones-ko-capture/expected.json
@@ -0,0 +1,80 @@
+{
+  "event": "Scoreboard",
+  "data": {
+    "lobby": "X",
+    "mode": "SZ",
+    "stage": 0,
+    "matchScores": [
+      100,
+      0
+    ],
+    "povIndex": 0,
+    "players": [
+      {
+        "name": "Pinhole",
+        "weaponId": 211,
+        "paint": 842,
+        "ka": 12,
+        "d": 7,
+        "s": 2
+      },
+      {
+        "name": "Sunshield",
+        "weaponId": 20,
+        "paint": 1217,
+        "ka": 7,
+        "d": 6,
+        "s": 3
+      },
+      {
+        "name": "Headphones",
+        "weaponId": 3030,
+        "paint": 1768,
+        "ka": 4,
+        "d": 4,
+        "s": 5
+      },
+      {
+        "name": "Now or Never Seven",
+        "weaponId": 2030,
+        "paint": 693,
+        "ka": 4,
+        "d": 4,
+        "s": 2
+      },
+      {
+        "name": "Charms",
+        "weaponId": 60,
+        "paint": 1422,
+        "ka": 9,
+        "d": 6,
+        "s": 5
+      },
+      {
+        "name": "Teddy",
+        "weaponId": 3010,
+        "paint": 980,
+        "ka": 7,
+        "d": 7,
+        "s": 5
+      },
+      {
+        "name": "Circle",
+        "weaponId": 8002,
+        "paint": 1204,
+        "ka": 8,
+        "d": 6,
+        "s": 3
+      },
+      {
+        "name": "Fleece",
+        "weaponId": 2030,
+        "paint": 1053,
+        "ka": 5,
+        "d": 2,
+        "s": 4
+      }
+    ],
+    "stageLabel": "Scorch Gorge"
+  }
+}
diff --git a/app/features/scanner/tests/fixtures/scoreboard/xbattle-splat-zones-ko-capture/frame.png b/app/features/scanner/tests/fixtures/scoreboard/xbattle-splat-zones-ko-capture/frame.png
new file mode 100644
index 000000000..97e0fb848
Binary files /dev/null and b/app/features/scanner/tests/fixtures/scoreboard/xbattle-splat-zones-ko-capture/frame.png differ
diff --git a/app/features/scanner/tests/fixtures/scoreboard/xbattle-splat-zones-ko/expected.json b/app/features/scanner/tests/fixtures/scoreboard/xbattle-splat-zones-ko/expected.json
new file mode 100644
index 000000000..bbe61405a
--- /dev/null
+++ b/app/features/scanner/tests/fixtures/scoreboard/xbattle-splat-zones-ko/expected.json
@@ -0,0 +1,80 @@
+{
+  "event": "Scoreboard",
+  "data": {
+    "lobby": "X",
+    "mode": "SZ",
+    "stage": 0,
+    "matchScores": [
+      100,
+      0
+    ],
+    "povIndex": 0,
+    "players": [
+      {
+        "name": "Pinhole",
+        "weaponId": 211,
+        "paint": 842,
+        "ka": 12,
+        "d": 7,
+        "s": 2
+      },
+      {
+        "name": "Sunshield",
+        "weaponId": 20,
+        "paint": 1217,
+        "ka": 7,
+        "d": 6,
+        "s": 3
+      },
+      {
+        "name": "Headphones",
+        "weaponId": 3030,
+        "paint": 1768,
+        "ka": 4,
+        "d": 4,
+        "s": 5
+      },
+      {
+        "name": "Now or Never Seven",
+        "weaponId": 2030,
+        "paint": 693,
+        "ka": 4,
+        "d": 4,
+        "s": 2
+      },
+      {
+        "name": "Charms",
+        "weaponId": 60,
+        "paint": 1422,
+        "ka": 9,
+        "d": 6,
+        "s": 5
+      },
+      {
+        "name": "Teddy",
+        "weaponId": 3010,
+        "paint": 980,
+        "ka": 7,
+        "d": 7,
+        "s": 5
+      },
+      {
+        "name": "Circle",
+        "weaponId": 8002,
+        "paint": 1204,
+        "ka": 8,
+        "d": 6,
+        "s": 3
+      },
+      {
+        "name": "Fleece",
+        "weaponId": 2030,
+        "paint": 1053,
+        "ka": 5,
+        "d": 2,
+        "s": 4
+      }
+    ],
+    "stageLabel": "Scorch Gorge"
+  }
+}
diff --git a/app/features/scanner/tests/fixtures/scoreboard/xbattle-splat-zones-ko/frame.jpg b/app/features/scanner/tests/fixtures/scoreboard/xbattle-splat-zones-ko/frame.jpg
new file mode 100644
index 000000000..79009f79d
Binary files /dev/null and b/app/features/scanner/tests/fixtures/scoreboard/xbattle-splat-zones-ko/frame.jpg differ
diff --git a/app/features/scanner/tests/map-start.test.ts b/app/features/scanner/tests/map-start.test.ts
new file mode 100644
index 000000000..3361f5053
--- /dev/null
+++ b/app/features/scanner/tests/map-start.test.ts
@@ -0,0 +1,151 @@
+/**
+ * Golden-file tests for the MapStartDetector over every fixture in
+ * map-start/, mirroring tests/suites/death.ts, plus cross-negative sweeps in
+ * both directions: the map-start gate must stay quiet on every scoreboard,
+ * replay, and death positive, and their gates must stay quiet on the
+ * map-start fixtures.
+ */
+
+import assert from "node:assert/strict";
+import { loadOpenCV } from "../core/cv";
+import { createDeathDetector } from "../core/detectors/death/index";
+import {
+	createMapStartDetector,
+	type MapStartData,
+} from "../core/detectors/map-start/index";
+import { createScoreboardDetector } from "../core/detectors/scoreboard/index";
+import { createScoreboardBattleLogReplayDetector } from "../core/detectors/scoreboard-battle-log-replay/index";
+import {
+	type Fixture,
+	isFieldSkipped,
+	loadFixtures,
+	runDetectorOnFixture,
+} from "../node/fixtures";
+import { loadScoreboardResources } from "../node/resources";
+import test from "./node-test-compat";
+
+await loadOpenCV();
+const resources = await loadScoreboardResources();
+const detector = createMapStartDetector(resources);
+const fixtures = loadFixtures("map-start");
+
+test("map-start fixtures exist", () => {
+	assert.ok(fixtures.length > 0, "no fixtures found under map-start/");
+});
+
+for (const fixture of fixtures) {
+	test(`map-start/${fixture.name}`, async (t) => {
+		const { gate, events } = await runDetectorOnFixture<MapStartData>(
+			detector,
+			fixture,
+		);
+		const expectPositive = fixture.expected.event === "MapStart";
+
+		await t.test("gate", () => {
+			assert.equal(
+				gate.pass,
+				expectPositive,
+				`gate ${gate.pass ? "fired" : "did not fire"} (score=${gate.score.toFixed(3)}), expected ${expectPositive ? "fire" : "no fire"}`,
+			);
+		});
+
+		if (!expectPositive) return;
+		const event = events[0];
+		assert.ok(
+			event,
+			gate.pass
+				? "gate passed but parse emitted no event (label confirmation failed?)"
+				: "no event (gate did not fire)",
+		);
+		const expected = fixture.expected.data ?? {};
+
+		await t.test(
+			"mode",
+			{ skip: expected.mode === undefined || skip(fixture, "mode") },
+			() => {
+				assert.equal(
+					event.data.mode,
+					expected.mode,
+					`mode mismatch (raw: "${event.debug?.modeReading}", score=${Number(event.debug?.modeScore ?? 0).toFixed(3)})`,
+				);
+			},
+		);
+
+		await t.test(
+			"stage",
+			{ skip: expected.stage === undefined || skip(fixture, "stage") },
+			() => {
+				assert.equal(
+					event.data.stage,
+					expected.stage,
+					`stage mismatch (raw: "${event.debug?.stageReading}", score=${Number(event.debug?.stageScore ?? 0).toFixed(3)})`,
+				);
+			},
+		);
+	});
+}
+
+// The intro splash overlays live gameplay while the other screens replace
+// or overlay it differently; none of the four gates may fire on another
+// detector's positives.
+const otherPositives = [
+	...loadFixtures("scoreboard").filter(
+		(f) => f.expected.event === "Scoreboard",
+	),
+	...loadFixtures("scoreboard-battle-log-replay").filter(
+		(f) => f.expected.event === "ScoreboardBattleLogReplay",
+	),
+	...loadFixtures("death").filter((f) => f.expected.event === "Death"),
+];
+for (const fixture of otherPositives) {
+	test(`map-start gate stays quiet on ${fixture.dir.split("/").slice(-2).join("/")}`, async () => {
+		const { gate } = await runDetectorOnFixture(detector, fixture);
+		assert.equal(
+			gate.pass,
+			false,
+			`map-start gate fired (score=${gate.score.toFixed(3)})`,
+		);
+	});
+}
+
+// Shared negatives (tests/fixtures/negative/): frames no detector may fire on.
+for (const fixture of loadFixtures("negative")) {
+	test(`map-start gate stays quiet on negative/${fixture.name}`, async () => {
+		const { gate } = await runDetectorOnFixture(detector, fixture);
+		assert.equal(
+			gate.pass,
+			false,
+			`map-start gate fired (score=${gate.score.toFixed(3)})`,
+		);
+	});
+}
+
+const scoreboardDetector = createScoreboardDetector(resources);
+const replayDetector = createScoreboardBattleLogReplayDetector(resources);
+const deathDetector = createDeathDetector(resources);
+for (const fixture of fixtures.filter((f) => f.expected.event === "MapStart")) {
+	test(`other gates stay quiet on map-start/${fixture.name}`, async () => {
+		const live = await runDetectorOnFixture(scoreboardDetector, fixture);
+		assert.equal(
+			live.gate.pass,
+			false,
+			`scoreboard gate fired (score=${live.gate.score.toFixed(3)})`,
+		);
+		const replay = await runDetectorOnFixture(replayDetector, fixture);
+		assert.equal(
+			replay.gate.pass,
+			false,
+			`replay gate fired (score=${replay.gate.score.toFixed(3)})`,
+		);
+		const death = await runDetectorOnFixture(deathDetector, fixture);
+		assert.equal(
+			death.gate.pass,
+			false,
+			`death gate fired (score=${death.gate.score.toFixed(3)})`,
+		);
+	});
+}
+
+function skip(fixture: Fixture, field: string): boolean | string {
+	return isFieldSkipped(fixture, field) ? "skipFields" : false;
+}
diff --git a/app/features/scanner/tests/match-builder.test.ts b/app/features/scanner/tests/match-builder.test.ts
new file mode 100644
index 000000000..e72973bcb
--- /dev/null
+++ b/app/features/scanner/tests/match-builder.test.ts
@@ -0,0 +1,657 @@
+import assert from "node:assert/strict";
+import type {
+	AbilityWithUnknown,
+	MainWeaponId,
+	ModeShort,
+	StageId,
+} from "~/modules/in-game-lists/types";
+import type { DeathData } from "../core/detectors/death/index";
+import type {
+	MinimapData,
+	MinimapEnemy,
+	MinimapTeammate,
+} from "../core/detectors/minimap/index";
+import { SPECTATOR_SLOTS } from "../core/detectors/minimap/rois";
+import type { ObjectiveData } from "../core/detectors/objective/index";
+import type { ScoreboardData } from "../core/detectors/scoreboard/index";
+import type { ScoreboardBattleLogData } from "../core/detectors/scoreboard-battle-log/index";
+import type { ScoreboardBattleLogReplayData } from "../core/detectors/scoreboard-battle-log-replay/index";
+import type { DetectedEvent } from "../core/detectors/types";
+import {
+	buildScannerMatches,
+	ingestSkipReasons,
+	invalidObjectiveEvents,
+} from "../core/match-builder";
+import type { ScannerLobby } from "../scanner-types";
+import test from "./node-test-compat";
+
+const NAMES = ["w1", "w2", "w3", "w4", "l1", "l2", "l3", "l4"];
+const ALPHA: MainWeaponId[] = [40, 1001, 2010, 3030];
+const BRAVO: MainWeaponId[] = [50, 210, 4010, 8000];
+const ALL = [...ALPHA, ...BRAVO];
+
+function mapStart(
+	t: number,
+	{ mode = "SZ" as ModeShort | null, stage = 0 as StageId | null } = {},
+): DetectedEvent {
+	return { type: "MapStart", t, confidence: 0.9, data: { mode, stage } };
+}
+
+function death(
+	t: number,
+	name: string,
+	abilities: AbilityWithUnknown[][] = [["ISM", "ISS", "ISS", "ISS"]],
+): DetectedEvent {
+	const data: DeathData = {
+		weaponId: null,
+		weaponType: "MAIN",
+		abilities,
+		name,
+	};
+	return { type: "Death", t, confidence: 0.9, data };
+}
+
+function objective(
+	t: number,
+	{
+		time = 215 as number | null,
+		score = [95, 53] as [number | null, number | null],
+		penalty = [null, null] as [number | null, number | null],
+		control = [true, false] as [boolean, boolean],
+	} = {},
+): DetectedEvent {
+	const data: ObjectiveData = { mode: "SZ", time, score, penalty, control };
+	return { type: "Objective", t, confidence: 0.9, data };
+}
+
+function scoreboard(
+	t: number,
+	{
+		lobby = "PRIVATE" as ScannerLobby | null,
+		mode = "SZ" as ModeShort | null,
+		stage = 0 as StageId | null,
+		weapons = ALL as (MainWeaponId | null)[],
+		povIndex = 0 as number | null,
+		matchScores = [100, 47] as [number | null, number | null],
+	} = {},
+): DetectedEvent {
+	const data: ScoreboardData = {
+		lobby,
+		mode,
+		stage,
+		matchScores,
+		players: weapons.map((weaponId, i) => ({
+			name: NAMES[i] ?? `p${i}`,
+			weaponId,
+			paint: 1000,
+			ka: 10,
+			d: 5,
+			s: 2,
+		})),
+		povIndex,
+	};
+	return { type: "Scoreboard", t, confidence: 0.9, data };
+}
+
+function replayScoreboard(
+	t: number,
+	{
+		timestamp = null as string | null,
+		replayCode = "RABC-DEFG-HIJK-LMNO" as string | null,
+	} = {},
+): DetectedEvent & { detectedAt?: number } {
+	const base = scoreboard(t).data as ScoreboardData;
+	const data: ScoreboardBattleLogReplayData = {
+		...base,
+		timestamp,
+		replayCode,
+		matchScores: [88, 71],
+	};
+	return { type: "ScoreboardBattleLogReplay", t, confidence: 0.9, data };
+}
+
+function battleLogScoreboard(
+	t: number,
+	{ timestamp = null as string | null } = {},
+): DetectedEvent & { detectedAt?: number } {
+	const base = scoreboard(t).data as ScoreboardData;
+	const data: ScoreboardBattleLogData = {
+		...base,
+		timestamp,
+		matchScores: [100, 0],
+	};
+	return { type: "ScoreboardBattleLog", t, confidence: 0.9, data };
+}
+
+function teammate(weaponId: MainWeaponId | null, i: number): MinimapTeammate {
+	return {
+		slot: SPECTATOR_SLOTS[i]!,
+		name: null,
+		weaponId,
+		abilities: [],
+	};
+}
+
+function enemy(weaponId: MainWeaponId | null): MinimapEnemy {
+	return {
+		name: null,
+		weaponId,
+		abilities: [],
+	};
+}
+
+function minimap(
+	t: number,
+	{
+		stage = 0 as StageId | null,
+		alpha = ALPHA as (MainWeaponId | null)[],
+		bravo = BRAVO as (MainWeaponId | null)[],
+		spectator = true,
+	} = {},
+): DetectedEvent {
+	const data: MinimapData = {
+		stage,
+		spectator,
+		teammates: alpha.map(teammate),
+		enemies: bravo.map(enemy),
+	};
+	return { type: "Minimap", t, confidence: 0.8, data };
+}
+
+function weapons(match: {
+	teams: [
+		{ players: { weaponId: MainWeaponId | null }[] },
+		{ players: { weaponId: MainWeaponId | null }[] },
+	];
+}): (MainWeaponId | null)[] {
+	return match.teams.flatMap((team) =>
+		team.players.map((player) => player.weaponId),
+	);
+}
+
+test("groups map start, deaths and scoreboard into one match", () => {
+	const events = [
+		mapStart(0),
+		death(60, "l2"),
+		death(120, "l3"),
+		scoreboard(300),
+	];
+	const built = buildScannerMatches(events);
+	assert.equal(built.length, 1);
+	assert.deepEqual(
+		built[0]!.sources.map((e) => e.type),
+		["MapStart", "Death", "Death", "Scoreboard"],
+	);
+	// sources are the exact input objects
+	assert.equal(built[0]!.sources[0], events[0]);
+});
+
+test("scoreboard fields land on the match", () => {
+	const built = buildScannerMatches([mapStart(0), scoreboard(300)]);
+	const match = built[0]!.match;
+	assert.equal(match.startsAt, 0);
+	assert.equal(match.endsAt, 300);
+	assert.equal(match.lobby, "PRIVATE");
+	assert.equal(match.mode, "SZ");
+	assert.equal(match.stage, 0);
+	assert.equal(match.winner, 0);
+	assert.deepEqual(match.pov, { team: 0, index: 0 });
+	assert.deepEqual(match.matchScores, [100, 47]);
+	assert.deepEqual(
+		match.teams.map((team) => team.players.map((p) => p.name)),
+		[
+			["w1", "w2", "w3", "w4"],
+			["l1", "l2", "l3", "l4"],
+		],
+	);
+	assert.deepEqual(weapons(match), ALL);
+	assert.equal(match.cast, false);
+	assert.equal(match.replayCode, null);
+	assert.equal(match.objective, null);
+});
+
+test("a losing-side pov index maps to the second team", () => {
+	const built = buildScannerMatches([scoreboard(300, { povIndex: 6 })]);
+	assert.deepEqual(built[0]!.match.pov, { team: 1, index: 2 });
+});
+
+test("objective reads become teams-order samples on the match", () => {
+	const built = buildScannerMatches([
+		mapStart(0),
+		objective(120.4, { time: 215, penalty: [4, null] }),
+		objective(180, { time: 155, score: [80, 53] }),
+		scoreboard(300),
+	]);
+	assert.deepEqual(built[0]!.match.objective, {
+		mode: "SZ",
+		samples: [
+			{
+				t: 120,
+				time: 215,
+				score: [95, 53],
+				penalty: [4, null],
+				control: [true, false],
+			},
+			{
+				t: 180,
+				time: 155,
+				score: [80, 53],
+				penalty: [null, null],
+				control: [true, false],
+			},
+		],
+	});
+});
+
+test("a losing-side pov swaps objective samples into teams order", () => {
+	const built = buildScannerMatches([
+		objective(120, { penalty: [4, null] }),
+		scoreboard(300, { povIndex: 6 }),
+	]);
+	assert.deepEqual(built[0]!.match.objective!.samples[0], {
+		t: 120,
+		time: 215,
+		score: [53, 95],
+		penalty: [null, 4],
+		control: [false, true],
+	});
+});
+
+test("a known non-SZ match drops its objective reads", () => {
+	const events = [
+		mapStart(0, { mode: "CB" }),
+		objective(60),
+		objective(120),
+		scoreboard(300, { mode: "CB" }),
+	];
+	const built = buildScannerMatches(events);
+	assert.equal(built[0]!.match.objective, null);
+	assert.deepEqual(invalidObjectiveEvents(built), [events[1], events[2]]);
+});
+
+test("an unknown-mode match keeps its objective reads", () => {
+	const built = buildScannerMatches([
+		mapStart(0, { mode: null }),
+		objective(60),
+		scoreboard(300, { mode: null }),
+	]);
+	assert.equal(built[0]!.match.objective!.samples.length, 1);
+	assert.deepEqual(invalidObjectiveEvents(built), []);
+});
+
+test("without a pov the side whose count got lower is the winner side", () => {
+	const built = buildScannerMatches([
+		mapStart(0),
+		objective(60, { score: [95, 53] }),
+		objective(200, { score: [60, 20] }),
+		scoreboard(300, { povIndex: null }),
+	]);
+	assert.deepEqual(
+		built[0]!.match.objective!.samples.map((sample) => sample.score),
+		[
+			[53, 95],
+			[20, 60],
+		],
+	);
+});
+
+test("enriches players with abilities from the match's deaths", () => {
+	const build: AbilityWithUnknown[][] = [
+		["ISM", "ISS", "ISS", "ISS"],
+		["QR", "QSJ", "QSJ", "QSJ"],
+		["SSU", "RSU", "RSU", "RSU"],
+	];
+	const built = buildScannerMatches([
+		mapStart(0),
+		death(60, "l2", build),
+		scoreboard(300),
+	]);
+	const teams = built[0]!.match.teams;
+	assert.deepEqual(teams[1].players[1]!.abilities, build);
+	assert.equal(teams[0].players[0]!.abilities, undefined);
+});
+
+test("deaths from an earlier match do not leak into the next match", () => {
+	const built = buildScannerMatches([
+		mapStart(0),
+		death(60, "l2"),
+		scoreboard(300),
+		mapStart(400),
+		scoreboard(700),
+	]);
+	assert.equal(built.length, 2);
+	assert.equal(built[1]!.match.teams[1].players[1]!.abilities, undefined);
+});
+
+test("a scoreboard without a preceding map start claims the last 8 minutes of deaths", () => {
+	const built = buildScannerMatches([death(60, "l2"), scoreboard(300)]);
+	assert.equal(built.length, 1);
+	assert.deepEqual(
+		built[0]!.sources.map((e) => e.type),
+		["Death", "Scoreboard"],
+	);
+	assert.notEqual(built[0]!.match.teams[1].players[1]!.abilities, undefined);
+});
+
+test("deaths older than 8 minutes do not join a map-start-less match", () => {
+	const built = buildScannerMatches([
+		death(60, "l2"),
+		death(700, "l3"),
+		scoreboard(1000),
+	]);
+	assert.equal(built.length, 1);
+	assert.deepEqual(
+		built[0]!.sources.map((e) => e.t),
+		[700, 1000],
+	);
+});
+
+test("every event belongs to at most one match", () => {
+	const events = [
+		death(10, "l2"), // orphan invalidated by the map start
+		mapStart(30),
+		death(60, "l3"),
+		minimap(90),
+		scoreboard(300),
+		death(320, "l4"), // orphan claimed by the next scoreboard
+		scoreboard(700),
+		minimap(800),
+		minimap(1200), // gap-splits into its own match
+		scoreboard(1300),
+	];
+	const built = buildScannerMatches(events);
+	assert.equal(built.length, 4);
+
+	const seen = new Set<DetectedEvent>();
+	for (const b of built) {
+		for (const source of b.sources) {
+			assert.equal(seen.has(source), false);
+			seen.add(source);
+		}
+	}
+});
+
+test("the fallback window does not reach past the previous scoreboard", () => {
+	const built = buildScannerMatches([
+		mapStart(0),
+		death(60, "l2"),
+		scoreboard(300),
+		death(400, "l3"),
+		scoreboard(700),
+	]);
+	assert.equal(built.length, 2);
+	assert.deepEqual(
+		built[1]!.sources.map((e) => e.t),
+		[400, 700],
+	);
+});
+
+test("non-private lobbies are recorded and skipped on ingest", () => {
+	const built = buildScannerMatches([
+		mapStart(0),
+		scoreboard(300, { lobby: "X" }),
+		mapStart(400),
+		scoreboard(700),
+	]);
+	const skipped = ingestSkipReasons(built);
+	assert.equal(built.length, 2);
+	assert.equal(built[0]!.match.lobby, "X");
+	assert.equal(skipped.get(built[0]!), "lobby");
+	assert.equal(skipped.get(built[1]!), undefined);
+});
+
+test("a scoreless match whose counters had no time to run out is a disconnect", () => {
+	const built = buildScannerMatches([
+		mapStart(0),
+		objective(140, { time: 183, score: [10, 43], penalty: [69, 0] }),
+		scoreboard(155, { matchScores: [null, null] }),
+	]);
+	assert.equal(built.length, 1);
+	assert.equal(ingestSkipReasons(built).get(built[0]!), "disconnect");
+});
+
+test("a scoreless match a knockout could have ended is kept", () => {
+	const built = buildScannerMatches([
+		mapStart(0),
+		objective(140, { time: 30, score: [5, 90], penalty: [0, 0] }),
+		scoreboard(200, { matchScores: [null, null] }),
+	]);
+	assert.equal(built.length, 1);
+	assert.equal(ingestSkipReasons(built).size, 0);
+});
+
+test("a scoreless match replayed on the same map is a disconnect", () => {
+	const built = buildScannerMatches([
+		mapStart(0),
+		scoreboard(300, { matchScores: [null, null] }),
+		mapStart(400),
+		scoreboard(700),
+	]);
+	const skipped = ingestSkipReasons(built);
+	assert.equal(built.length, 2);
+	assert.equal(skipped.get(built[0]!), "disconnect");
+	assert.equal(skipped.get(built[1]!), undefined);
+});
+
+test("a scoreless match the next map moves on from is kept", () => {
+	const built = buildScannerMatches([
+		mapStart(0),
+		scoreboard(300, { matchScores: [null, null] }),
+		mapStart(400, { stage: 1 }),
+		scoreboard(700, { stage: 1 }),
+	]);
+	assert.equal(built.length, 2);
+	assert.equal(ingestSkipReasons(built).size, 0);
+});
+
+test("an unreadable lobby is ingestable", () => {
+	const built = buildScannerMatches([scoreboard(300, { lobby: null })]);
+	assert.equal(built.length, 1);
+	assert.equal(ingestSkipReasons(built).size, 0);
+});
+
+test("a match whose scoreboard was missed is dropped on the next map start", () => {
+	const built = buildScannerMatches([
+		mapStart(0),
+		death(60, "l2"),
+		mapStart(400),
+		death(460, "l3"),
+		scoreboard(700),
+	]);
+	assert.equal(built.length, 1);
+	assert.deepEqual(
+		built[0]!.sources.map((e) => e.t),
+		[400, 460, 700],
+	);
+});
+
+test("a trailing map start with deaths but no scoreboard identifies no match", () => {
+	assert.deepEqual(buildScannerMatches([mapStart(0), death(60, "l2")]), []);
+});
+
+test("event types that identify no match are ignored", () => {
+	const own: DetectedEvent = {
+		type: "ScoreboardOwn",
+		t: 310,
+		confidence: 0.9,
+		data: {
+			lobby: "PRIVATE",
+			mode: null,
+			stage: null,
+			weaponId: null,
+			abilities: [],
+		},
+	};
+	const built = buildScannerMatches([mapStart(0), own, scoreboard(300), own]);
+	assert.equal(built.length, 1);
+	assert.deepEqual(
+		built[0]!.sources.map((e) => e.type),
+		["MapStart", "Scoreboard"],
+	);
+});
+
+test("a replay scoreboard supplies replay code, set score and recording time", () => {
+	const event = replayScoreboard(300, { timestamp: "25.12.2025 21:30" });
+	event.detectedAt = Date.UTC(2025, 11, 26, 12, 0);
+	const built = buildScannerMatches([event]);
+	const match = built[0]!.match;
+	assert.equal(match.replayCode, "RABC-DEFG-HIJK-LMNO");
+	assert.deepEqual(match.matchScores, [88, 71]);
+	assert.equal(match.playedAt, new Date(2025, 11, 25, 21, 30).getTime());
+});
+
+test("a battle log scoreboard closes a match and supplies the recording time without a replay code", () => {
+	const event = battleLogScoreboard(300, { timestamp: "25.12.2025 21:30" });
+	event.detectedAt = Date.UTC(2025, 11, 26, 12, 0);
+	const built = buildScannerMatches([event]);
+	const match = built[0]!.match;
+	assert.equal(match.replayCode, null);
+	assert.deepEqual(match.matchScores, [100, 0]);
+	assert.equal(match.playedAt, new Date(2025, 11, 25, 21, 30).getTime());
+});
+
+test("without a replay timestamp, playedAt falls back to the scoreboard's detection time", () => {
+	const event = scoreboard(300) as DetectedEvent & { detectedAt?: number };
+	event.detectedAt = 1_700_000_000_000;
+	const built = buildScannerMatches([event]);
+	assert.equal(built[0]!.match.playedAt, 1_700_000_000_000);
+});
+
+test("a minimap-only match has no playedAt and no winner", () => {
+	const built = buildScannerMatches([minimap(70), minimap(120)]);
+	const match = built[0]!.match;
+	assert.equal(match.playedAt, null);
+	assert.equal(match.winner, null);
+	assert.equal(match.pov, null);
+	assert.equal(match.matchScores, null);
+});
+
+test("a spectator map's minimaps become one cast match: weapons + stage from the minimap, mode unread", () => {
+	const built = buildScannerMatches([minimap(70), minimap(120)]);
+	assert.equal(built.length, 1);
+	const match = built[0]!.match;
+	assert.equal(match.startsAt, 70);
+	assert.equal(match.endsAt, 120);
+	assert.equal(match.mode, null);
+	assert.equal(match.stage, 0);
+	assert.equal(match.cast, true);
+	assert.deepEqual(weapons(match), ALL);
+});
+
+test("a pov overlay minimap is not flagged as cast", () => {
+	const built = buildScannerMatches([minimap(70, { spectator: false })]);
+	assert.equal(built[0]!.match.cast, false);
+});
+
+test("a lone misread stage neither splits the match nor poisons its stage", () => {
+	const built = buildScannerMatches([
+		minimap(70, { stage: 0 }),
+		minimap(90, { stage: 1 }),
+		minimap(110, { stage: 0 }),
+		minimap(130, { stage: 0 }),
+	]);
+	assert.equal(built.length, 1);
+	assert.equal(built[0]!.match.stage, 0);
+});
+
+test("a confirmed stage change splits even when the misread-looking frame is mid-stream", () => {
+	const built = buildScannerMatches([
+		minimap(70, { stage: 0 }),
+		minimap(90, { stage: 1 }),
+		minimap(110, { stage: 1 }),
+	]);
+	assert.equal(built.length, 2);
+	assert.deepEqual(
+		built.map((b) => b.match.stage),
+		[0, 1],
+	);
+	assert.deepEqual(
+		built.map((b) => b.match.startsAt),
+		[70, 90],
+	);
+});
+
+// KNOWN LIMITATION (documented, not desired): two consecutive games on the
+// SAME stage with a between-games break shorter than MATCH_GAP_SECONDS merge
+// into one match — no native UI delimits them on casted footage and the
+// simplified minimap carries no signal to split on. Real mode/game detection
+// should replace this.
+test("same-stage rematch within the gap window merges into one match (known limitation)", () => {
+	const game1 = [minimap(70), minimap(150)];
+	const game2 = [minimap(380), minimap(460)];
+	assert.equal(buildScannerMatches([...game1, ...game2]).length, 1);
+});
+
+test("a stage change splits minimaps into separate per-map matches", () => {
+	const built = buildScannerMatches([
+		minimap(70, { stage: 0 }),
+		minimap(120, { stage: 0 }),
+		minimap(400, { stage: 1 }),
+	]);
+	assert.equal(built.length, 2);
+	assert.deepEqual(
+		built.map((b) => b.match.stage),
+		[0, 1],
+	);
+	assert.deepEqual(
+		built.map((b) => b.match.startsAt),
+		[70, 400],
+	);
+});
+
+test("a large time gap splits even same-stage minimaps (different games)", () => {
+	const built = buildScannerMatches([minimap(70), minimap(90), minimap(600)]);
+	assert.equal(built.length, 2);
+	assert.deepEqual(
+		built.map((b) => b.match.startsAt),
+		[70, 600],
+	);
+});
+
+test("minimaps of one game (close in time, same stage) stay one match", () => {
+	const built = buildScannerMatches([minimap(70), minimap(90), minimap(250)]);
+	assert.equal(built.length, 1);
+	assert.equal(built[0]!.match.startsAt, 70);
+});
+
+test("weapon slots are merged across a match's minimap frames", () => {
+	const frame1 = minimap(70, { alpha: [null, 1001, null, 3030] });
+	const frame2 = minimap(90, { alpha: [40, null, 2010, 3030] });
+	const built = buildScannerMatches([frame1, frame2]);
+	assert.deepEqual(weapons(built[0]!.match), ALL);
+});
+
+test("a slot no frame read stays null for consumers to skip on", () => {
+	const built = buildScannerMatches([
+		minimap(70, { alpha: [40, 1001, 2010, null] }),
+	]);
+	assert.deepEqual(weapons(built[0]!.match), [40, 1001, 2010, null, ...BRAVO]);
+});
+
+test("a MapStart supplies the real mode and opens a match", () => {
+	const built = buildScannerMatches([
+		mapStart(30, { mode: "RM", stage: 6 }),
+		minimap(70, { stage: 6 }),
+	]);
+	assert.equal(built.length, 1);
+	assert.equal(built[0]!.match.mode, "RM");
+	assert.equal(built[0]!.match.startsAt, 30);
+});
+
+test("a scoreboard is the preferred weapon/mode source and closes a match", () => {
+	const boardWeapons: (MainWeaponId | null)[] = [
+		10, 10, 10, 10, 20, 20, 20, 20,
+	];
+	const built = buildScannerMatches([
+		minimap(70),
+		scoreboard(330, { mode: "TC", weapons: boardWeapons }),
+	]);
+	assert.equal(built.length, 1);
+	assert.equal(built[0]!.match.mode, "TC");
+	assert.deepEqual(weapons(built[0]!.match), boardWeapons);
+	assert.equal(built[0]!.match.startsAt, 70);
+});
+
+test("no minimaps and no scoreboard means no match", () => {
+	assert.deepEqual(buildScannerMatches([mapStart(30), mapStart(400)]), []);
+});
diff --git a/app/features/scanner/tests/match-sets.test.ts b/app/features/scanner/tests/match-sets.test.ts
new file mode 100644
index 000000000..ded9a29fe
--- /dev/null
+++ b/app/features/scanner/tests/match-sets.test.ts
@@ -0,0 +1,138 @@
+import assert from "node:assert/strict";
+import { assignMatchSets } from "../core/match-sets";
+import type { ScannerMatch, ScannerMatchPlayer } from "../core/scanner-match";
+import test from "./node-test-compat";
+
+const TEAM_A = ["Sendou", "Kiver", "Brian", "Zed"];
+const TEAM_B = ["Gos", "Noah", "Alice", "Bob"];
+const TEAM_C = ["Totoro", "Miso", "Ramen", "Udon"];
+const TEAM_D = ["Pearl", "Marina", "Callie", "Marie"];
+
+function player(name: string | null): ScannerMatchPlayer {
+	return { name, weaponId: null, paint: null, ka: null, d: null, s: null };
+}
+
+function match(
+	alpha: (string | null)[],
+	bravo: (string | null)[],
+): ScannerMatch {
+	return {
+		startsAt: null,
+		endsAt: null,
+		playedAt: null,
+		lobby: null,
+		mode: null,
+		stage: null,
+		matchScores: null,
+		replayCode: null,
+		cast: false,
+		objective: null,
+		teams: [{ players: alpha.map(player) }, { players: bravo.map(player) }],
+		winner: null,
+		pov: null,
+	};
+}
+
+test("assignMatchSets", async (t) => {
+	await t.test("empty input", () => {
+		assert.deepEqual(assignMatchSets([]), []);
+	});
+
+	await t.test("same eight players stay in one set", () => {
+		const games = [
+			match(TEAM_A, TEAM_B),
+			match(TEAM_A, TEAM_B),
+			match(TEAM_A, TEAM_B),
+		];
+		assert.deepEqual(assignMatchSets(games), [1, 1, 1]);
+	});
+
+	await t.test("team sides swapping keeps the set together", () => {
+		const games = [match(TEAM_A, TEAM_B), match(TEAM_B, TEAM_A)];
+		assert.deepEqual(assignMatchSets(games), [1, 1]);
+	});
+
+	await t.test("a fully different lobby opens a new set", () => {
+		const games = [
+			match(TEAM_A, TEAM_B),
+			match(TEAM_A, TEAM_B),
+			match(TEAM_C, TEAM_D),
+			match(TEAM_C, TEAM_D),
+		];
+		assert.deepEqual(assignMatchSets(games), [1, 1, 2, 2]);
+	});
+
+	await t.test("OCR stutter on a couple of names is tolerated", () => {
+		const games = [
+			match(TEAM_A, TEAM_B),
+			match(
+				["Send0u", "Kiver", "Brian", "Zed"],
+				["Gos", "N0ah", "Alice", "Bob"],
+			),
+		];
+		assert.deepEqual(assignMatchSets(games), [1, 1]);
+	});
+
+	await t.test("tail damage on short CJK names is not a roster change", () => {
+		const games = [
+			match(
+				["まどろみ", "ほった", "きのちゃんねる !", "くてんちゃんねる"],
+				["かなえる", "たん", "ロット", "れた"],
+			),
+			match(
+				["まどろみ", "ほっ′`", "きのちゃんねる !", "くてんちゃんねる"],
+				["かなえる", "たん", "ロット", "れ"],
+			),
+		];
+		assert.deepEqual(assignMatchSets(games), [1, 1]);
+	});
+
+	await t.test("one sub is tolerated, two are a new set", () => {
+		const oneSub = [
+			match(TEAM_A, TEAM_B),
+			match(["Sendou", "Kiver", "Brian", "NewGuy"], TEAM_B),
+		];
+		assert.deepEqual(assignMatchSets(oneSub), [1, 1]);
+
+		const twoSubs = [
+			match(TEAM_A, TEAM_B),
+			match(["Sendou", "Kiver", "Sub1", "Sub2"], TEAM_B),
+		];
+		assert.deepEqual(assignMatchSets(twoSubs), [1, 2]);
+	});
+
+	await t.test("a nameless match never breaks the chain", () => {
+		const games = [
+			match(TEAM_A, TEAM_B),
+			match([null, null, null, null], [null, null, null, null]),
+			match(TEAM_A, TEAM_B),
+		];
+		assert.deepEqual(assignMatchSets(games), [1, 1, 1]);
+	});
+
+	await t.test("a partial roster read chains on what both saw", () => {
+		const games = [
+			match(TEAM_A, TEAM_B),
+			match(["Sendou", "Kiver", null, null], [null, null, null, null]),
+			match(TEAM_A, TEAM_B),
+		];
+		assert.deepEqual(assignMatchSets(games), [1, 1, 1]);
+	});
+
+	await t.test("a partial read of different players opens a new set", () => {
+		const games = [
+			match(TEAM_A, TEAM_B),
+			match(["Totoro", "Miso", "Ramen", null], [null, null, null, null]),
+		];
+		assert.deepEqual(assignMatchSets(games), [1, 2]);
+	});
+
+	await t.test("comparison follows the latest roster, not the first", () => {
+		const games = [
+			match(TEAM_A, TEAM_B),
+			match(["Sendou", "Kiver", "Brian", "SubA"], TEAM_B),
+			match(["Sendou", "Kiver", "Brian", "SubB"], TEAM_B),
+		];
+		assert.deepEqual(assignMatchSets(games), [1, 1, 1]);
+	});
+});
diff --git a/app/features/scanner/tests/minimap.test.ts b/app/features/scanner/tests/minimap.test.ts
new file mode 100644
index 000000000..ec6e49697
--- /dev/null
+++ b/app/features/scanner/tests/minimap.test.ts
@@ -0,0 +1,245 @@
+/**
+ * Golden-file tests for the MinimapDetector over every fixture in minimap/,
+ * plus cross-negative sweeps in both directions: the minimap gate must stay
+ * quiet on every other detector's positives (and the shared negatives), and
+ * every other gate must stay quiet on the minimap fixtures.
+ */
+
+import assert from "node:assert/strict";
+import { loadOpenCV } from "../core/cv";
+import { createDeathDetector } from "../core/detectors/death/index";
+import { createMapStartDetector } from "../core/detectors/map-start/index";
+import {
+	createMinimapDetector,
+	type MinimapData,
+} from "../core/detectors/minimap/index";
+import { createScoreboardDetector } from "../core/detectors/scoreboard/index";
+import { createScoreboardBattleLogReplayDetector } from "../core/detectors/scoreboard-battle-log-replay/index";
+import { createScoreboardOwnDetector } from "../core/detectors/scoreboard-own/index";
+import type { Detector } from "../core/detectors/types";
+import {
+	type Fixture,
+	isFieldSkipped,
+	loadFixtures,
+	runDetectorOnFixture,
+} from "../node/fixtures";
+import { loadScoreboardResources } from "../node/resources";
+import test from "./node-test-compat";
+
+await loadOpenCV();
+const resources = await loadScoreboardResources();
+const detector = createMinimapDetector(resources);
+const fixtures = loadFixtures("minimap");
+
+test("minimap fixtures exist", () => {
+	assert.ok(fixtures.length > 0, "no fixtures found under minimap/");
+});
+
+for (const fixture of fixtures) {
+	test(`minimap/${fixture.name}`, async (t) => {
+		const { gate, events } = await runDetectorOnFixture<MinimapData>(
+			detector,
+			fixture,
+		);
+		const expectPositive = fixture.expected.event === "Minimap";
+
+		await t.test("gate", () => {
+			assert.equal(
+				gate.pass,
+				expectPositive,
+				`gate ${gate.pass ? "fired" : "did not fire"} (score=${gate.score.toFixed(3)}), expected ${expectPositive ? "fire" : "no fire"}`,
+			);
+		});
+
+		if (!expectPositive) return;
+		const event = events[0];
+		assert.ok(event, "gate passed but no event parsed");
+		const expected = fixture.expected.data ?? {};
+
+		await t.test(
+			"spectator",
+			{ skip: expected.spectator === undefined },
+			() => {
+				assert.equal(event.data.spectator, expected.spectator);
+			},
+		);
+
+		await t.test(
+			"stage",
+			{ skip: expected.stage === undefined || skip(fixture, "stage") },
+			() => {
+				assert.equal(
+					event.data.stage,
+					expected.stage,
+					`stage mismatch (debug: ${JSON.stringify(event.debug?.stage)})`,
+				);
+			},
+		);
+
+		// an expected array also pins the count, so a spectator stub (or a
+		// misaligned parse) can't smuggle in phantom cards or rows
+		await t.test(
+			"teammate count",
+			{ skip: expected.teammates === undefined },
+			() => {
+				assert.equal(event.data.teammates.length, expected.teammates?.length);
+			},
+		);
+		await t.test(
+			"enemy count",
+			{ skip: expected.enemies === undefined },
+			() => {
+				assert.equal(event.data.enemies.length, expected.enemies?.length);
+			},
+		);
+
+		for (const [i, want] of (expected.teammates ?? []).entries()) {
+			await t.test(
+				`teammate ${i} (${want.slot ?? "?"})`,
+				{ skip: skip(fixture, `teammates.${i}`) },
+				() => {
+					const got = event.data.teammates[i];
+					assert.ok(
+						got,
+						`teammate ${i} missing (got ${event.data.teammates.length})`,
+					);
+					const cardDebug = JSON.stringify(
+						(event.debug?.cards as unknown[])?.[i],
+					);
+					if (want.slot !== undefined) assert.equal(got.slot, want.slot);
+					if (
+						want.name !== undefined &&
+						!isFieldSkipped(fixture, `teammates.${i}.name`)
+					) {
+						assert.equal(got.name, want.name, `name (debug: ${cardDebug})`);
+					}
+					if (
+						want.weaponId !== undefined &&
+						!isFieldSkipped(fixture, `teammates.${i}.weapon`)
+					) {
+						assert.equal(
+							got.weaponId,
+							want.weaponId,
+							`weapon (debug: ${cardDebug})`,
+						);
+					}
+					if (
+						want.abilities !== undefined &&
+						!isFieldSkipped(fixture, `teammates.${i}.abilities`)
+					) {
+						assert.deepEqual(
+							got.abilities,
+							want.abilities,
+							`abilities (debug: ${cardDebug})`,
+						);
+					}
+				},
+			);
+		}
+
+		for (const [i, want] of (expected.enemies ?? []).entries()) {
+			await t.test(
+				`enemy ${i}`,
+				{ skip: skip(fixture, `enemies.${i}`) },
+				() => {
+					const got = event.data.enemies[i];
+					assert.ok(
+						got,
+						`enemy row ${i} missing (got ${event.data.enemies.length})`,
+					);
+					const rowDebug = JSON.stringify(
+						(event.debug?.enemies as unknown[])?.[i],
+					);
+					if (
+						want.name !== undefined &&
+						!isFieldSkipped(fixture, `enemies.${i}.name`)
+					) {
+						assert.equal(got.name, want.name, `name (debug: ${rowDebug})`);
+					}
+					if (
+						want.weaponId !== undefined &&
+						!isFieldSkipped(fixture, `enemies.${i}.weapon`)
+					) {
+						assert.equal(
+							got.weaponId,
+							want.weaponId,
+							`weapon (debug: ${rowDebug})`,
+						);
+					}
+					if (
+						want.abilities !== undefined &&
+						!isFieldSkipped(fixture, `enemies.${i}.abilities`)
+					) {
+						assert.deepEqual(
+							got.abilities,
+							want.abilities,
+							`abilities (debug: ${rowDebug})`,
+						);
+					}
+				},
+			);
+		}
+	});
+}
+
+// The map overlay replaces everything else on screen; its gate may not fire
+// on any other detector's positives, nor theirs on the minimap fixtures.
+const otherPositives = [
+	...loadFixtures("scoreboard").filter(
+		(f) => f.expected.event === "Scoreboard",
+	),
+	...loadFixtures("scoreboard-battle-log-replay").filter(
+		(f) => f.expected.event === "ScoreboardBattleLogReplay",
+	),
+	...loadFixtures("scoreboard-own").filter(
+		(f) => f.expected.event === "ScoreboardOwn",
+	),
+	...loadFixtures("death").filter((f) => f.expected.event === "Death"),
+	...loadFixtures("map-start").filter((f) => f.expected.event === "MapStart"),
+];
+for (const fixture of otherPositives) {
+	test(`minimap gate stays quiet on ${fixture.dir.split("/").slice(-2).join("/")}`, async () => {
+		const { gate } = await runDetectorOnFixture(detector, fixture);
+		assert.equal(
+			gate.pass,
+			false,
+			`minimap gate fired (score=${gate.score.toFixed(3)})`,
+		);
+	});
+}
+
+// Shared negatives (tests/fixtures/negative/): frames no detector may fire on.
+for (const fixture of loadFixtures("negative")) {
+	test(`minimap gate stays quiet on negative/${fixture.name}`, async () => {
+		const { gate } = await runDetectorOnFixture(detector, fixture);
+		assert.equal(
+			gate.pass,
+			false,
+			`minimap gate fired (score=${gate.score.toFixed(3)})`,
+		);
+	});
+}
+
+const otherDetectors: Detector<unknown>[] = [
+	createScoreboardDetector(resources) as Detector<unknown>,
+	createScoreboardBattleLogReplayDetector(resources) as Detector<unknown>,
+	createScoreboardOwnDetector(resources) as Detector<unknown>,
+	createDeathDetector(resources) as Detector<unknown>,
+	createMapStartDetector(resources) as Detector<unknown>,
+];
+for (const fixture of fixtures.filter((f) => f.expected.event === "Minimap")) {
+	test(`other gates stay quiet on minimap/${fixture.name}`, async () => {
+		for (const other of otherDetectors) {
+			const { gate } = await runDetectorOnFixture(other, fixture);
+			assert.equal(
+				gate.pass,
+				false,
+				`${other.id} gate fired (score=${gate.score.toFixed(3)})`,
+			);
+		}
+	});
+}
+
+function skip(fixture: Fixture, field: string): boolean | string {
+	return isFieldSkipped(fixture, field) ? "skipFields" : false;
+}
diff --git a/app/features/scanner/tests/node-test-compat.ts b/app/features/scanner/tests/node-test-compat.ts
new file mode 100644
index 000000000..01ca591bd
--- /dev/null
+++ b/app/features/scanner/tests/node-test-compat.ts
@@ -0,0 +1,66 @@
+/**
+ * node:test-shaped `test` on top of Vitest, so the golden-file suites keep
+ * their original shape (dynamic per-fixture tests with nested `t.test`
+ * subtests and `{ skip }` options — a pattern Vitest has no native
+ * equivalent for). Subtests run inline; every failure is collected and the
+ * parent test reports them all at once, preserving node:test's
+ * "one field mismatch doesn't hide the next" behavior.
+ */
+import { test as vitestTest } from "vitest";
+
+type SubtestBody = () => void | Promise<void>;
+
+export interface CompatTestContext {
+	test(name: string, fn: SubtestBody): Promise<void>;
+	test(
+		name: string,
+		opts: { skip?: boolean | string },
+		fn: SubtestBody,
+	): Promise<void>;
+}
+
+export default function test(
+	name: string,
+	fn: (t: CompatTestContext) => void | Promise<void>,
+): void {
+	vitestTest(name, async () => {
+		const failures: { name: string; error: unknown }[] = [];
+		const subtest = async (
+			subName: string,
+			optsOrFn: { skip?: boolean | string } | SubtestBody,
+			maybeFn?: SubtestBody,
+		): Promise<void> => {
+			const opts = typeof optsOrFn === "function" ? {} : optsOrFn;
+			const body = typeof optsOrFn === "function" ? optsOrFn : maybeFn;
+			if (opts.skip || !body) return;
+			try {
+				await body();
+			} catch (error) {
+				failures.push({ name: subName, error });
+			}
+		};
+		const t: CompatTestContext = { test: subtest };
+		await fn(t);
+		if (failures.length === 0) return;
+		if (failures.length === 1 && failures[0]) {
+			const { name: subName, error } = failures[0];
+			if (error instanceof Error) {
+				error.message = `[${subName}] ${error.message}`;
+				throw error;
+			}
+			throw new Error(`[${subName}] ${String(error)}`);
+		}
+		const summary = failures
+			.map(
+				({ name: subName, error }) =>
+					`[${subName}] ${error instanceof Error ? error.message : String(error)}`,
+			)
+			.join("\n");
+		const aggregate = new Error(
+			`${failures.length} subtests failed:\n${summary}`,
+		);
+		const first = failures[0]?.error;
+		if (first instanceof Error && first.stack) aggregate.stack = first.stack;
+		throw aggregate;
+	});
+}
diff --git a/app/features/scanner/tests/objective.test.ts b/app/features/scanner/tests/objective.test.ts
new file mode 100644
index 000000000..22a3491f5
--- /dev/null
+++ b/app/features/scanner/tests/objective.test.ts
@@ -0,0 +1,205 @@
+/**
+ * Golden-file tests for the ObjectiveDetector over every fixture in
+ * objective/, mirroring map-start.test.ts, plus cross-negative sweeps in
+ * both directions: the objective gate must stay quiet on every other
+ * detector's positives (and the shared negatives), and their gates must
+ * stay quiet on the objective fixtures.
+ */
+
+import assert from "node:assert/strict";
+import { loadOpenCV } from "../core/cv";
+import { createDeathDetector } from "../core/detectors/death/index";
+import { createMapStartDetector } from "../core/detectors/map-start/index";
+import { createMinimapDetector } from "../core/detectors/minimap/index";
+import {
+	createObjectiveDetector,
+	type ObjectiveData,
+} from "../core/detectors/objective/index";
+import { createScoreboardDetector } from "../core/detectors/scoreboard/index";
+import { createScoreboardBattleLogReplayDetector } from "../core/detectors/scoreboard-battle-log-replay/index";
+import { createScoreboardOwnDetector } from "../core/detectors/scoreboard-own/index";
+import type { Detector } from "../core/detectors/types";
+import {
+	type Fixture,
+	isFieldSkipped,
+	loadFixtures,
+	runDetectorOnFixture,
+} from "../node/fixtures";
+import { loadScoreboardResources } from "../node/resources";
+import test from "./node-test-compat";
+
+await loadOpenCV();
+const resources = await loadScoreboardResources();
+const detector = createObjectiveDetector(resources);
+const fixtures = loadFixtures("objective");
+
+test("objective fixtures exist", () => {
+	assert.ok(fixtures.length > 0, "no fixtures found under objective/");
+});
+
+for (const fixture of fixtures) {
+	test(`objective/${fixture.name}`, async (t) => {
+		const { gate, events } = await runDetectorOnFixture<ObjectiveData>(
+			detector,
+			fixture,
+		);
+		const expectPositive = fixture.expected.event === "Objective";
+
+		await t.test("gate", () => {
+			assert.equal(
+				gate.pass,
+				expectPositive,
+				`gate ${gate.pass ? "fired" : "did not fire"} (score=${gate.score.toFixed(3)}), expected ${expectPositive ? "fire" : "no fire"}`,
+			);
+		});
+
+		if (!expectPositive) return;
+		const event = events[0];
+		assert.ok(
+			event,
+			gate.pass
+				? "gate passed but parse emitted no event (no readable count?)"
+				: "no event (gate did not fire)",
+		);
+		const expected = fixture.expected.data ?? {};
+		const debug = () => JSON.stringify(event.debug);
+
+		await t.test(
+			"mode",
+			{ skip: expected.mode === undefined || skip(fixture, "mode") },
+			() => {
+				assert.equal(event.data.mode, expected.mode);
+			},
+		);
+
+		await t.test(
+			"time",
+			{ skip: expected.time === undefined || skip(fixture, "time") },
+			() => {
+				assert.equal(
+					event.data.time,
+					expected.time,
+					`time mismatch (${debug()})`,
+				);
+			},
+		);
+
+		for (const side of [0, 1] as const) {
+			await t.test(
+				`score[${side}]`,
+				{
+					skip: expected.score === undefined || skip(fixture, `score.${side}`),
+				},
+				() => {
+					assert.equal(
+						event.data.score[side],
+						expected.score![side],
+						`score[${side}] mismatch (${debug()})`,
+					);
+				},
+			);
+			await t.test(
+				`penalty[${side}]`,
+				{
+					skip:
+						expected.penalty === undefined || skip(fixture, `penalty.${side}`),
+				},
+				() => {
+					assert.equal(
+						event.data.penalty[side],
+						expected.penalty![side],
+						`penalty[${side}] mismatch (${debug()})`,
+					);
+				},
+			);
+			await t.test(
+				`control[${side}]`,
+				{
+					skip:
+						expected.control === undefined || skip(fixture, `control.${side}`),
+				},
+				() => {
+					assert.equal(
+						event.data.control[side],
+						expected.control![side],
+						`control[${side}] mismatch (${debug()})`,
+					);
+				},
+			);
+		}
+	});
+}
+
+// Screens that replace gameplay can never show the counters — the gate must
+// stay quiet on their positives.
+const otherPositiveSets = [
+	["scoreboard", "Scoreboard"],
+	["scoreboard-battle-log-replay", "ScoreboardBattleLogReplay"],
+	["scoreboard-own", "ScoreboardOwn"],
+	["map-start", "MapStart"],
+	["minimap", "Minimap"],
+] as const;
+for (const [dir, eventType] of otherPositiveSets) {
+	for (const fixture of loadFixtures(dir).filter(
+		(f) => f.expected.event === eventType,
+	)) {
+		test(`objective gate stays quiet on ${dir}/${fixture.name}`, async () => {
+			const { gate } = await runDetectorOnFixture(detector, fixture);
+			assert.equal(
+				gate.pass,
+				false,
+				`objective gate fired (score=${gate.score.toFixed(3)})`,
+			);
+		});
+	}
+}
+
+// No sweep over death positives: the death overlay rides live gameplay
+// whose counter HUD stays visible (several death fixtures show full,
+// correctly-readable plates), so neither gate- nor parse-level quiet can be
+// promised there. Death frames with counters make fine objective fixtures.
+
+// Shared negatives (tests/fixtures/negative/): frames no detector may fire on.
+for (const fixture of loadFixtures("negative")) {
+	test(`objective gate stays quiet on negative/${fixture.name}`, async () => {
+		const { gate } = await runDetectorOnFixture(detector, fixture);
+		assert.equal(
+			gate.pass,
+			false,
+			`objective gate fired (score=${gate.score.toFixed(3)})`,
+		);
+	});
+}
+
+const otherDetectors: readonly [string, Detector<unknown>][] = [
+	["scoreboard", createScoreboardDetector(resources) as Detector<unknown>],
+	[
+		"scoreboard-battle-log-replay",
+		createScoreboardBattleLogReplayDetector(resources) as Detector<unknown>,
+	],
+	[
+		"scoreboard-own",
+		createScoreboardOwnDetector(resources) as Detector<unknown>,
+	],
+	["death", createDeathDetector(resources) as Detector<unknown>],
+	["map-start", createMapStartDetector(resources) as Detector<unknown>],
+	["minimap", createMinimapDetector(resources) as Detector<unknown>],
+];
+for (const fixture of fixtures.filter(
+	(f) => f.expected.event === "Objective",
+)) {
+	test(`other gates stay quiet on objective/${fixture.name}`, async () => {
+		for (const [name, other] of otherDetectors) {
+			const { gate } = await runDetectorOnFixture(other, fixture);
+			assert.equal(
+				gate.pass,
+				false,
+				`${name} gate fired (score=${gate.score.toFixed(3)})`,
+			);
+		}
+	});
+}
+
+function skip(fixture: Fixture, field: string): boolean | string {
+	return isFieldSkipped(fixture, field) ? "skipFields" : false;
+}
diff --git a/app/features/scanner/tests/opencv-smoke.test.ts b/app/features/scanner/tests/opencv-smoke.test.ts
new file mode 100644
index 000000000..2c2308263
--- /dev/null
+++ b/app/features/scanner/tests/opencv-smoke.test.ts
@@ -0,0 +1,29 @@
+import assert from "node:assert/strict";
+import { loadOpenCV, minMaxLoc } from "../core/cv";
+import test from "./node-test-compat";
+
+test("opencv.js loads in Node and matchTemplate works", async () => {
+	const cv = await loadOpenCV();
+
+	// 20x20 gray canvas with a 5x5 white square at (10, 7)
+	const scene = new cv.Mat(20, 20, cv.CV_8UC1, new cv.Scalar(64));
+	const white = scene.roi(new cv.Rect(10, 7, 5, 5));
+	white.setTo(new cv.Scalar(255));
+	white.delete();
+
+	// Template must have variance for TM_CCOEFF_NORMED: white square + gray border
+	const patch = scene.roi(new cv.Rect(9, 6, 7, 7));
+	const template = patch.clone();
+	patch.delete();
+	const result = new cv.Mat();
+	cv.matchTemplate(scene, template, result, cv.TM_CCOEFF_NORMED);
+	const { maxLoc, maxVal } = minMaxLoc(result);
+
+	assert.equal(maxLoc.x, 9);
+	assert.equal(maxLoc.y, 6);
+	assert.ok(maxVal > 0.99, `expected strong peak, got ${maxVal}`);
+
+	scene.delete();
+	template.delete();
+	result.delete();
+});
diff --git a/app/features/scanner/tests/replay-time.test.ts b/app/features/scanner/tests/replay-time.test.ts
new file mode 100644
index 000000000..cc332094a
--- /dev/null
+++ b/app/features/scanner/tests/replay-time.test.ts
@@ -0,0 +1,142 @@
+import assert from "node:assert/strict";
+import { parseReplayTimestamp } from "../core/replay-time";
+import test from "./node-test-compat";
+
+/** Expected epoch for a local wall time — timezone-independent comparison. */
+function local(
+	year: number,
+	month: number,
+	day: number,
+	h: number,
+	min: number,
+): number {
+	return new Date(year, month - 1, day, h, min).getTime();
+}
+
+test("day-first locale reads D/M/Y", () => {
+	assert.equal(
+		parseReplayTimestamp("3/7/2026 22:28", {
+			locale: "fi-FI",
+			now: local(2026, 7, 4, 10, 0),
+		}),
+		local(2026, 7, 3, 22, 28),
+	);
+});
+
+test("a 24h hour implies day-first even under a month-first browser locale", () => {
+	// the real misread: Finnish console, en-US browser — 21:15 proves a 24h
+	// clock (12h consoles render AM/PM), and 24h locales are day-first
+	assert.equal(
+		parseReplayTimestamp("3.7.2026 21:15", {
+			locale: "en-US",
+			now: local(2026, 7, 5, 12, 0),
+		}),
+		local(2026, 7, 3, 21, 15),
+	);
+	// midnight hours only exist on a 24h clock too
+	assert.equal(
+		parseReplayTimestamp("3/7/2026 0:45", {
+			locale: "en-US",
+			now: local(2026, 7, 4, 10, 0),
+		}),
+		local(2026, 7, 3, 0, 45),
+	);
+});
+
+test("month-first locale reads M/D/Y when the hour is clock-ambiguous", () => {
+	// 9:15 could be either clock, and now is far from both readings — the
+	// browser locale is the only remaining signal
+	assert.equal(
+		parseReplayTimestamp("3/7/2026 9:15", {
+			locale: "en-US",
+			now: local(2026, 5, 10, 12, 0),
+		}),
+		local(2026, 3, 7, 9, 15),
+	);
+});
+
+test("recency flips a locale misread whose swap lands near now", () => {
+	// Finnish console with an en-US browser and no 24h evidence: the locale
+	// says March 7, but that's months away while July 3 is yesterday
+	assert.equal(
+		parseReplayTimestamp("3/7/2026 9:15", {
+			locale: "en-US",
+			now: local(2026, 7, 4, 12, 0),
+		}),
+		local(2026, 7, 3, 9, 15),
+	);
+});
+
+test("recency leaves a recent locale reading alone", () => {
+	assert.equal(
+		parseReplayTimestamp("3/7/2026 9:15", {
+			locale: "en-US",
+			now: local(2026, 3, 8, 12, 0),
+		}),
+		local(2026, 3, 7, 9, 15),
+	);
+});
+
+test("an old replay keeps the locale order when neither reading is recent", () => {
+	assert.equal(
+		parseReplayTimestamp("5.1.2026 9:15", {
+			locale: "fi-FI",
+			now: local(2026, 7, 15, 12, 0),
+		}),
+		local(2026, 1, 5, 9, 15),
+	);
+});
+
+test("a segment above 12 overrides every order signal", () => {
+	assert.equal(
+		parseReplayTimestamp("25/7/2026 9:05", { locale: "en-US" }),
+		local(2026, 7, 25, 9, 5),
+	);
+	assert.equal(
+		parseReplayTimestamp("7/25/2026 9:05", { locale: "fi-FI" }),
+		local(2026, 7, 25, 9, 5),
+	);
+});
+
+test("dot and dash separators parse", () => {
+	const now = local(2026, 3, 8, 12, 0);
+	assert.equal(
+		parseReplayTimestamp("7.3.2026 22:28", { locale: "de-DE", now }),
+		local(2026, 3, 7, 22, 28),
+	);
+	assert.equal(
+		parseReplayTimestamp("7-3-2026 22:28", { locale: "de-DE", now }),
+		local(2026, 3, 7, 22, 28),
+	);
+});
+
+test("year-first format is month-first, regardless of clock or recency", () => {
+	assert.equal(
+		parseReplayTimestamp("2026/3/7 22:28", {
+			locale: "ja-JP",
+			now: local(2026, 7, 4, 12, 0),
+		}),
+		local(2026, 3, 7, 22, 28),
+	);
+});
+
+test("two-digit year lands in the 2000s", () => {
+	assert.equal(
+		parseReplayTimestamp("3/7/26 22:28", {
+			locale: "fi-FI",
+			now: local(2026, 7, 4, 10, 0),
+		}),
+		local(2026, 7, 3, 22, 28),
+	);
+});
+
+test("invalid dates and times are rejected", () => {
+	assert.equal(
+		parseReplayTimestamp("31/2/2026 10:00", { locale: "fi-FI" }),
+		null,
+	);
+	assert.equal(parseReplayTimestamp("13/13/2026 10:00"), null);
+	assert.equal(parseReplayTimestamp("3/7/2026 25:00"), null);
+	assert.equal(parseReplayTimestamp("3/7/2026 10:60"), null);
+	assert.equal(parseReplayTimestamp("not a timestamp"), null);
+});
diff --git a/app/features/scanner/tests/scheduler.test.ts b/app/features/scanner/tests/scheduler.test.ts
new file mode 100644
index 000000000..ec9044738
--- /dev/null
+++ b/app/features/scanner/tests/scheduler.test.ts
@@ -0,0 +1,281 @@
+/**
+ * Unit tests for DetectorScheduler: search/refine check cadence,
+ * steady-frame suppression (stagnation and sufficient-confidence early
+ * stop), the rearm cooldown, checkIntervalS compatibility, and the calm
+ * signal that drives VoD skim mode.
+ */
+
+import assert from "node:assert/strict";
+import {
+	DetectorScheduler,
+	type SchedulingInfo,
+} from "../core/detectors/scheduler";
+import test from "./node-test-compat";
+
+const OPTS = {
+	refineIntervalS: 0.1,
+	searchIntervalS: 0.1,
+	maxStagnantParses: 3,
+	stagnantAfterS: 0.25,
+	minImprovement: 0.001,
+	quietAfterS: 10,
+	matchOpenMaxS: 60,
+	matchOpeningTypes: ["MapStart"],
+	matchClosingTypes: ["Scoreboard"],
+};
+
+function make(detector: Partial<SchedulingInfo>, options = {}) {
+	return new DetectorScheduler([{ id: "d", ...detector }], {
+		...OPTS,
+		...options,
+	});
+}
+
+function feed(
+	s: DetectorScheduler,
+	t: number,
+	options: {
+		pass: boolean;
+		confidence?: number;
+		type?: string;
+		signature?: number[];
+	},
+): "skipped" | "gated" | "parsed" {
+	if (!s.dueDetectors(t).includes("d")) return "skipped";
+	s.recordGate("d", t, options.pass, options.signature);
+	if (!options.pass || !s.shouldParse("d", t)) return "gated";
+	s.recordParse(
+		"d",
+		t,
+		options.confidence === undefined
+			? []
+			: [{ type: options.type ?? "Event", confidence: options.confidence }],
+	);
+	return "parsed";
+}
+
+test("a failing gate is only re-checked at the search cadence", () => {
+	const s = make({ searchIntervalS: 1 });
+	assert.equal(feed(s, 0, { pass: false }), "gated");
+	assert.equal(feed(s, 0.5, { pass: false }), "skipped");
+	assert.equal(feed(s, 0.99, { pass: false }), "skipped");
+	assert.equal(feed(s, 1, { pass: false }), "gated");
+});
+
+test("a passing gate drops to the dense refine cadence", () => {
+	const s = make({ searchIntervalS: 1 });
+	assert.equal(feed(s, 0, { pass: true, confidence: 0.7 }), "parsed");
+	assert.equal(feed(s, 0.05, { pass: true, confidence: 0.7 }), "skipped");
+	assert.equal(feed(s, 0.1, { pass: true, confidence: 0.7 }), "parsed");
+	assert.equal(feed(s, 0.2, { pass: true, confidence: 0.7 }), "parsed");
+});
+
+test("a per-detector refine interval overrides the dense default", () => {
+	const s = make({ refineIntervalS: 0.5 });
+	assert.equal(feed(s, 0, { pass: true, confidence: 0.7 }), "parsed");
+	assert.equal(feed(s, 0.1, { pass: true, confidence: 0.7 }), "skipped");
+	assert.equal(feed(s, 0.4, { pass: true, confidence: 0.7 }), "skipped");
+	assert.equal(feed(s, 0.5, { pass: true, confidence: 0.7 }), "parsed");
+});
+
+test("a per-detector stagnation budget suppresses sooner", () => {
+	const s = make({ maxStagnantParses: 2 }, { stagnantAfterS: 0.1 });
+	assert.equal(feed(s, 0.0, { pass: true, confidence: 0.9 }), "parsed");
+	assert.equal(feed(s, 0.1, { pass: true, confidence: 0.9 }), "parsed");
+	assert.equal(feed(s, 0.2, { pass: true, confidence: 0.9 }), "parsed");
+	assert.equal(feed(s, 0.3, { pass: true, confidence: 0.9 }), "gated");
+});
+
+test("suppresses after stagnant parses on a static screen", () => {
+	const s = make({});
+	assert.equal(feed(s, 0.0, { pass: true, confidence: 0.9 }), "parsed");
+	assert.equal(feed(s, 0.1, { pass: true, confidence: 0.9 }), "parsed");
+	assert.equal(feed(s, 0.2, { pass: true, confidence: 0.9 }), "parsed");
+	assert.equal(feed(s, 0.3, { pass: true, confidence: 0.9 }), "parsed");
+	assert.equal(feed(s, 0.4, { pass: true, confidence: 0.9 }), "gated");
+	assert.equal(feed(s, 0.5, { pass: true, confidence: 0.9 }), "gated");
+});
+
+test("an improving read resets the stagnation counter", () => {
+	const s = make({});
+	feed(s, 0.0, { pass: true, confidence: 0.7 });
+	feed(s, 0.1, { pass: true, confidence: 0.7 });
+	feed(s, 0.2, { pass: true, confidence: 0.7 });
+	assert.equal(feed(s, 0.3, { pass: true, confidence: 0.85 }), "parsed");
+	assert.equal(feed(s, 0.4, { pass: true, confidence: 0.85 }), "parsed");
+	assert.equal(feed(s, 0.5, { pass: true, confidence: 0.85 }), "parsed");
+	assert.equal(feed(s, 0.6, { pass: true, confidence: 0.85 }), "parsed");
+	assert.equal(feed(s, 0.7, { pass: true, confidence: 0.85 }), "gated");
+});
+
+test("a gate drop ends the streak and re-enables parsing", () => {
+	const s = make({});
+	for (let i = 0; i < 5; i++) feed(s, i * 0.1, { pass: true, confidence: 0.9 });
+	assert.equal(feed(s, 0.5, { pass: true, confidence: 0.9 }), "gated");
+	assert.equal(feed(s, 0.6, { pass: false }), "gated");
+	assert.equal(feed(s, 0.7, { pass: true, confidence: 0.9 }), "parsed");
+});
+
+test("gate firing without events stagnates too", () => {
+	const s = make({});
+	for (let i = 0; i < 4; i++) {
+		assert.equal(feed(s, i * 0.1, { pass: true }), "parsed");
+	}
+	assert.equal(feed(s, 0.4, { pass: true }), "gated");
+});
+
+test("dense no-read parses during an entry animation respect the time floor", () => {
+	const s = make({}, { stagnantAfterS: 3 });
+	// the gate fires from t=0 while the screen is still animating in and
+	// parses read nothing — a parse count alone must not suppress here
+	for (let i = 0; i < 8; i++) {
+		assert.equal(feed(s, i * 0.15, { pass: true }), "parsed");
+	}
+	// the screen becomes readable and the read still lands
+	assert.equal(feed(s, 1.35, { pass: true, confidence: 0.88 }), "parsed");
+	// once truly static past the time floor, suppression still kicks in
+	for (let i = 0; i < 25; i++) {
+		feed(s, 1.5 + i * 0.15, { pass: true, confidence: 0.88 });
+	}
+	assert.equal(feed(s, 5.4, { pass: true, confidence: 0.88 }), "gated");
+});
+
+test("a sufficient read suppresses immediately", () => {
+	const s = make({ sufficientConfidence: 0.95 });
+	assert.equal(feed(s, 0.0, { pass: true, confidence: 0.96 }), "parsed");
+	assert.equal(feed(s, 0.1, { pass: true, confidence: 0.99 }), "gated");
+	// gate drop = screen changed = fresh streak parses again
+	feed(s, 0.2, { pass: false });
+	assert.equal(feed(s, 0.3, { pass: true, confidence: 0.7 }), "parsed");
+});
+
+test("a changed gate signature re-arms a suppressed streak", () => {
+	const s = make({ sufficientConfidence: 0.8 });
+	const entryA = [20, 200];
+	const entryB = [200, 20];
+	assert.equal(
+		feed(s, 0, { pass: true, confidence: 0.9, signature: entryA }),
+		"parsed",
+	);
+	assert.equal(
+		feed(s, 0.1, { pass: true, confidence: 0.9, signature: entryA }),
+		"gated",
+	);
+	// codec noise within tolerance is still the same screen
+	assert.equal(
+		feed(s, 0.2, { pass: true, confidence: 0.9, signature: [22, 198] }),
+		"gated",
+	);
+	// the next browsed entry keeps the gate passing but moves the content
+	assert.equal(
+		feed(s, 0.3, { pass: true, confidence: 0.9, signature: entryB }),
+		"parsed",
+	);
+	assert.equal(
+		feed(s, 0.4, { pass: true, confidence: 0.9, signature: entryB }),
+		"gated",
+	);
+});
+
+test("a signature change mid-streak starts a fresh best", () => {
+	const s = make({});
+	feed(s, 0.0, { pass: true, confidence: 0.9, signature: [0] });
+	feed(s, 0.1, { pass: true, confidence: 0.9, signature: [0] });
+	// the next entry reads worse than the old best — with the old streak's
+	// best carried over these would count stagnant and suppress at t=0.4
+	feed(s, 0.2, { pass: true, confidence: 0.7, signature: [255] });
+	feed(s, 0.3, { pass: true, confidence: 0.7, signature: [255] });
+	assert.equal(
+		feed(s, 0.4, { pass: true, confidence: 0.7, signature: [255] }),
+		"parsed",
+	);
+});
+
+test("rearm cooldown skips parses across gate flicker", () => {
+	const s = make({ sufficientConfidence: 0.95, rearmCooldownS: 4 });
+	assert.equal(feed(s, 1.0, { pass: true, confidence: 0.96 }), "parsed");
+	feed(s, 1.5, { pass: false });
+	assert.equal(feed(s, 2.0, { pass: true, confidence: 0.9 }), "gated");
+	assert.equal(feed(s, 4.9, { pass: true, confidence: 0.9 }), "gated");
+	assert.equal(feed(s, 5.1, { pass: true, confidence: 0.9 }), "parsed");
+});
+
+test("checkIntervalS caps both phases and exempts from suppression", () => {
+	const s = make({ checkIntervalS: 1 });
+	assert.equal(feed(s, 0.0, { pass: true, confidence: 0.9 }), "parsed");
+	assert.equal(feed(s, 0.5, { pass: true, confidence: 0.9 }), "skipped");
+	for (let t = 1; t < 10; t++) {
+		assert.equal(feed(s, t, { pass: true, confidence: 0.9 }), "parsed");
+	}
+});
+
+test("suppressSteadyFrames=false checks and parses every frame", () => {
+	const s = make(
+		{ searchIntervalS: 1, sufficientConfidence: 0.5 },
+		{ suppressSteadyFrames: false },
+	);
+	for (let i = 0; i < 10; i++) {
+		assert.equal(feed(s, 0, { pass: true, confidence: 0.9 }), "parsed");
+	}
+	assert.equal(s.calm(1000), false);
+});
+
+test("calm needs a quiet period and no open match", () => {
+	const s = make({});
+	assert.equal(feed(s, 0, { pass: false }), "gated");
+	assert.equal(s.calm(5), false);
+	assert.equal(s.calm(10), true);
+	// a gate pass resets the quiet clock
+	feed(s, 10, { pass: true, confidence: 0.9 });
+	assert.equal(s.calm(15), false);
+	assert.equal(s.calm(20), true);
+	// a confident map-start keeps the scan active for matchOpenMaxS
+	feed(s, 21, { pass: true, confidence: 0.9, type: "MapStart" });
+	assert.equal(s.calm(50), false);
+	assert.equal(s.calm(21 + 60), true);
+});
+
+test("a scoreboard closes the match early", () => {
+	const s = make({});
+	feed(s, 0, { pass: true, confidence: 0.9, type: "MapStart" });
+	assert.equal(s.calm(30), false);
+	feed(s, 31, { pass: true, confidence: 0.9, type: "Scoreboard" });
+	// quiet period still applies after the closing read
+	assert.equal(s.calm(35), false);
+	assert.equal(s.calm(41), true);
+});
+
+test("a t jumping backwards resets the session", () => {
+	const s = make({ searchIntervalS: 1 });
+	feed(s, 100, { pass: false });
+	assert.equal(feed(s, 100.5, { pass: false }), "skipped");
+	// a rescan starts earlier than anything seen — fresh state, due again
+	assert.equal(feed(s, 0, { pass: false }), "gated");
+});
+
+test("detectors are tracked independently", () => {
+	const s = new DetectorScheduler(
+		[{ id: "a" }, { id: "b", searchIntervalS: 1 }],
+		OPTS,
+	);
+	assert.deepEqual(s.dueDetectors(0), ["a", "b"]);
+	s.recordGate("a", 0, true);
+	s.recordGate("b", 0, false);
+	assert.deepEqual(s.dueDetectors(0.5), ["a"]);
+	assert.deepEqual(s.dueDetectors(1), ["a", "b"]);
+});
+
+test("nextDueT lets frames skip analysis entirely", () => {
+	const s = new DetectorScheduler(
+		[
+			{ id: "a", searchIntervalS: 0.5 },
+			{ id: "b", searchIntervalS: 1 },
+		],
+		OPTS,
+	);
+	assert.equal(s.nextDueT(), Number.NEGATIVE_INFINITY);
+	s.dueDetectors(0);
+	s.recordGate("a", 0, false);
+	s.recordGate("b", 0, false);
+	assert.equal(s.nextDueT(), 0.5);
+});
diff --git a/app/features/scanner/tests/scoreboard-battle-log-replay.1.test.ts b/app/features/scanner/tests/scoreboard-battle-log-replay.1.test.ts
new file mode 100644
index 000000000..d9a57d91c
--- /dev/null
+++ b/app/features/scanner/tests/scoreboard-battle-log-replay.1.test.ts
@@ -0,0 +1,7 @@
+/**
+ * Shard 1/2 of the replay suite — see
+ * tests/suites/scoreboard-battle-log-replay.ts.
+ */
+import { runScoreboardBattleLogReplaySuite } from "./suites/scoreboard-battle-log-replay";
+
+await runScoreboardBattleLogReplaySuite(0, 2);
diff --git a/app/features/scanner/tests/scoreboard-battle-log-replay.2.test.ts b/app/features/scanner/tests/scoreboard-battle-log-replay.2.test.ts
new file mode 100644
index 000000000..15e174970
--- /dev/null
+++ b/app/features/scanner/tests/scoreboard-battle-log-replay.2.test.ts
@@ -0,0 +1,7 @@
+/**
+ * Shard 2/2 of the replay suite — see
+ * tests/suites/scoreboard-battle-log-replay.ts.
+ */
+import { runScoreboardBattleLogReplaySuite } from "./suites/scoreboard-battle-log-replay";
+
+await runScoreboardBattleLogReplaySuite(1, 2);
diff --git a/app/features/scanner/tests/scoreboard-battle-log.test.ts b/app/features/scanner/tests/scoreboard-battle-log.test.ts
new file mode 100644
index 000000000..49bc3867b
--- /dev/null
+++ b/app/features/scanner/tests/scoreboard-battle-log.test.ts
@@ -0,0 +1,238 @@
+/**
+ * Golden-file suite for the ScoreboardBattleLogDetector over every fixture in
+ * scoreboard-battle-log/, mirroring
+ * tests/suites/scoreboard-battle-log-replay.ts (the battle log shows the same
+ * data sans the replay code), plus cross-negative sweeps: the battle log gate
+ * must stay quiet on both lookalike results screens.
+ */
+
+import assert from "node:assert/strict";
+import { loadOpenCV } from "../core/cv";
+import type {
+	ScoreboardPlayer,
+	ScoreboardRowDebug,
+} from "../core/detectors/scoreboard/index";
+import {
+	createScoreboardBattleLogDetector,
+	SCOREBOARD_BATTLE_LOG_EVENT_TYPE,
+} from "../core/detectors/scoreboard-battle-log/index";
+import {
+	type Fixture,
+	isFieldSkipped,
+	loadFixtures,
+	runDetectorOnFixture,
+} from "../node/fixtures";
+import { loadScoreboardResources } from "../node/resources";
+import test from "./node-test-compat";
+
+await loadOpenCV();
+const detector = createScoreboardBattleLogDetector(
+	await loadScoreboardResources(),
+);
+const fixtures = loadFixtures("scoreboard-battle-log");
+
+test("scoreboard-battle-log fixtures exist", () => {
+	assert.ok(
+		fixtures.length > 0,
+		"no fixtures found under scoreboard-battle-log/",
+	);
+});
+
+for (const fixture of fixtures) {
+	test(`scoreboard-battle-log/${fixture.name}`, async (t) => {
+		const { gate, events } = await runDetectorOnFixture(detector, fixture);
+		const expectPositive =
+			fixture.expected.event === SCOREBOARD_BATTLE_LOG_EVENT_TYPE;
+
+		await t.test("gate", () => {
+			assert.equal(
+				gate.pass,
+				expectPositive,
+				`gate ${gate.pass ? "fired" : "did not fire"} (score=${gate.score.toFixed(3)}), expected ${expectPositive ? "fire" : "no fire"}`,
+			);
+		});
+
+		if (!expectPositive) return;
+		const event = events[0];
+		assert.ok(event, "gate passed but no event parsed");
+		const rows = (event.debug?.rows ?? []) as ScoreboardRowDebug[];
+		const expected = fixture.expected.data ?? {};
+
+		await t.test("matchScores", { skip: skip(fixture, "matchScores") }, () => {
+			const dbg = event.debug?.matchScore as
+				| { left?: { reading?: string }; right?: { reading?: string } }
+				| undefined;
+			assert.deepEqual(
+				event.data.matchScores,
+				expected.matchScores,
+				`matchScores mismatch (readings: "${dbg?.left?.reading}" / "${dbg?.right?.reading}")`,
+			);
+		});
+
+		await t.test(
+			"header",
+			{ skip: expected.mode === undefined || skip(fixture, "header") },
+			() => {
+				const dbg = event.debug?.header as
+					| { topReading?: string; bottomReading?: string }
+					| undefined;
+				assert.deepEqual(
+					{
+						lobby: event.data.lobby,
+						mode: event.data.mode,
+						stage: event.data.stage,
+					},
+					{
+						lobby: expected.lobby ?? null,
+						mode: expected.mode ?? null,
+						stage: expected.stage ?? null,
+					},
+					`header mismatch (readings: "${dbg?.topReading}" / "${dbg?.bottomReading}")`,
+				);
+			},
+		);
+
+		await t.test(
+			"timestamp",
+			{
+				skip: expected.timestamp === undefined || skip(fixture, "timestamp"),
+			},
+			() => {
+				const dbg = event.debug?.header as { topReading?: string } | undefined;
+				assert.equal(
+					event.data.timestamp,
+					expected.timestamp,
+					`timestamp mismatch (reading: "${dbg?.topReading}")`,
+				);
+			},
+		);
+
+		await t.test(
+			"povIndex",
+			{ skip: expected.povIndex === undefined || skip(fixture, "povIndex") },
+			() => {
+				const fractions = rows.map((r) => r.povFraction.toFixed(3)).join(",");
+				assert.equal(
+					event.data.povIndex,
+					expected.povIndex,
+					`povIndex mismatch (yellow fractions=${fractions})`,
+				);
+			},
+		);
+
+		const players = expected.players ?? [];
+
+		await t.test(
+			"player count",
+			{ skip: expected.players === undefined || skip(fixture, "players") },
+			() => {
+				assert.equal(event.data.players.length, players.length);
+			},
+		);
+
+		for (const [i, want] of players.entries()) {
+			const got: ScoreboardPlayer | undefined = event.data.players[i];
+			const dbg = rows[i];
+			assert.ok(got, `row ${i} missing from parse`);
+
+			await t.test(
+				`row ${i} weapon`,
+				{
+					skip:
+						want.weaponId === undefined ||
+						skip(fixture, `players.${i}.weaponId`),
+				},
+				() => {
+					const top = dbg?.weapon?.top
+						.map((c) => `${c.id}:${c.score.toFixed(3)}`)
+						.join(" ");
+					assert.equal(
+						got.weaponId,
+						want.weaponId,
+						`weapon mismatch (candidates: ${top})`,
+					);
+				},
+			);
+
+			await t.test(
+				`row ${i} name`,
+				{
+					skip: want.name === undefined || skip(fixture, `players.${i}.name`),
+				},
+				() => {
+					assert.equal(
+						got.name,
+						want.name,
+						`name mismatch (min glyph score=${dbg?.nameScore.toFixed(3)})`,
+					);
+				},
+			);
+
+			await t.test(
+				`row ${i} paint`,
+				{
+					skip: want.paint === undefined || skip(fixture, `players.${i}.paint`),
+				},
+				() => {
+					assert.equal(
+						got.paint,
+						want.paint,
+						`paint mismatch (score=${dbg?.paintScore.toFixed(3)})`,
+					);
+				},
+			);
+
+			await t.test(
+				`row ${i} stats`,
+				{
+					skip: want.ka === undefined || skip(fixture, `players.${i}.stats`),
+				},
+				() => {
+					const scores = dbg?.statScores.map((s) => s.toFixed(3)).join(",");
+					assert.deepEqual(
+						{ ka: got.ka, d: got.d, s: got.s },
+						{ ka: want.ka, d: want.d ?? null, s: want.s ?? null },
+						`stat mismatch (scores=${scores})`,
+					);
+				},
+			);
+		}
+	});
+}
+
+// The three scoreboard-shaped screens must not trigger each other's
+// detectors; the mirror sweeps live in scoreboard.test.ts and
+// suites/scoreboard-battle-log-replay.ts.
+for (const fixture of [
+	...loadFixtures("scoreboard").filter(
+		(f) => f.expected.event === "Scoreboard",
+	),
+	...loadFixtures("scoreboard-battle-log-replay").filter(
+		(f) => f.expected.event === "ScoreboardBattleLogReplay",
+	),
+]) {
+	test(`scoreboard-battle-log gate stays quiet on ${fixture.name}`, async () => {
+		const { gate } = await runDetectorOnFixture(detector, fixture);
+		assert.equal(
+			gate.pass,
+			false,
+			`scoreboard-battle-log gate fired (score=${gate.score.toFixed(3)})`,
+		);
+	});
+}
+
+// Shared negatives (tests/fixtures/negative/): frames no detector may fire on.
+for (const fixture of loadFixtures("negative")) {
+	test(`scoreboard-battle-log gate stays quiet on negative/${fixture.name}`, async () => {
+		const { gate } = await runDetectorOnFixture(detector, fixture);
+		assert.equal(
+			gate.pass,
+			false,
+			`scoreboard-battle-log gate fired (score=${gate.score.toFixed(3)})`,
+		);
+	});
+}
+
+function skip(fixture: Fixture, field: string): boolean | string {
+	return isFieldSkipped(fixture, field) ? "skipFields" : false;
+}
diff --git a/app/features/scanner/tests/scoreboard-own.test.ts b/app/features/scanner/tests/scoreboard-own.test.ts
new file mode 100644
index 000000000..abc59edd7
--- /dev/null
+++ b/app/features/scanner/tests/scoreboard-own.test.ts
@@ -0,0 +1,158 @@
+/**
+ * Golden-file tests for the ScoreboardOwnDetector over every fixture in
+ * scoreboard-own/, plus cross-negative sweeps in both directions: the own
+ * gate must stay quiet on every other detector's positives (and the shared
+ * negatives), and every other gate must stay quiet on the own fixtures.
+ */
+
+import assert from "node:assert/strict";
+import { loadOpenCV } from "../core/cv";
+import { createDeathDetector } from "../core/detectors/death/index";
+import { createMapStartDetector } from "../core/detectors/map-start/index";
+import { createScoreboardDetector } from "../core/detectors/scoreboard/index";
+import { createScoreboardBattleLogReplayDetector } from "../core/detectors/scoreboard-battle-log-replay/index";
+import {
+	createScoreboardOwnDetector,
+	type ScoreboardOwnData,
+} from "../core/detectors/scoreboard-own/index";
+import type { Detector } from "../core/detectors/types";
+import {
+	type Fixture,
+	isFieldSkipped,
+	loadFixtures,
+	runDetectorOnFixture,
+} from "../node/fixtures";
+import { loadScoreboardResources } from "../node/resources";
+import test from "./node-test-compat";
+
+await loadOpenCV();
+const resources = await loadScoreboardResources();
+const detector = createScoreboardOwnDetector(resources);
+const fixtures = loadFixtures("scoreboard-own");
+
+test("scoreboard-own fixtures exist", () => {
+	assert.ok(fixtures.length > 0, "no fixtures found under scoreboard-own/");
+});
+
+for (const fixture of fixtures) {
+	test(`scoreboard-own/${fixture.name}`, async (t) => {
+		const { gate, events } = await runDetectorOnFixture<ScoreboardOwnData>(
+			detector,
+			fixture,
+		);
+		const expectPositive = fixture.expected.event === "ScoreboardOwn";
+
+		await t.test("gate", () => {
+			assert.equal(
+				gate.pass,
+				expectPositive,
+				`gate ${gate.pass ? "fired" : "did not fire"} (score=${gate.score.toFixed(3)}), expected ${expectPositive ? "fire" : "no fire"}`,
+			);
+		});
+
+		if (!expectPositive) return;
+		const event = events[0];
+		assert.ok(event, "gate passed but no event parsed");
+		const expected = fixture.expected.data ?? {};
+
+		for (const field of ["lobby", "mode", "stage"] as const) {
+			await t.test(
+				field,
+				{ skip: expected[field] === undefined || skip(fixture, field) },
+				() => {
+					assert.equal(
+						event.data[field],
+						expected[field],
+						`${field} mismatch (header debug: ${JSON.stringify(event.debug?.header)})`,
+					);
+				},
+			);
+		}
+
+		await t.test(
+			"weapon",
+			{ skip: expected.weaponId === undefined || skip(fixture, "weapon") },
+			() => {
+				assert.equal(
+					event.data.weaponId,
+					expected.weaponId,
+					`weapon mismatch (read: "${event.debug?.weaponName}", raw: "${event.debug?.weaponReading}", score=${Number(event.debug?.weaponScore ?? 0).toFixed(3)})`,
+				);
+			},
+		);
+
+		for (const [row, wantRow] of (expected.abilities ?? []).entries()) {
+			await t.test(
+				`abilities row ${row}`,
+				{ skip: skip(fixture, `abilities.${row}`) },
+				() => {
+					assert.deepEqual(
+						event.data.abilities[row],
+						wantRow,
+						`ability row mismatch (debug: ${JSON.stringify((event.debug?.abilityRows as unknown[])?.[row])})`,
+					);
+				},
+			);
+		}
+	});
+}
+
+// The own-results screen replaces everything else on screen; its gate may
+// not fire on any other detector's positives, nor theirs on its fixtures.
+const otherPositives = [
+	...loadFixtures("scoreboard").filter(
+		(f) => f.expected.event === "Scoreboard",
+	),
+	...loadFixtures("scoreboard-battle-log-replay").filter(
+		(f) => f.expected.event === "ScoreboardBattleLogReplay",
+	),
+	...loadFixtures("death").filter((f) => f.expected.event === "Death"),
+	...loadFixtures("map-start").filter((f) => f.expected.event === "MapStart"),
+];
+for (const fixture of otherPositives) {
+	test(`scoreboard-own gate stays quiet on ${fixture.dir.split("/").slice(-2).join("/")}`, async () => {
+		const { gate } = await runDetectorOnFixture(detector, fixture);
+		assert.equal(
+			gate.pass,
+			false,
+			`scoreboard-own gate fired (score=${gate.score.toFixed(3)})`,
+		);
+	});
+}
+
+// Shared negatives (tests/fixtures/negative/): frames no detector may fire on.
+for (const fixture of loadFixtures("negative")) {
+	test(`scoreboard-own gate stays quiet on negative/${fixture.name}`, async () => {
+		const { gate } = await runDetectorOnFixture(detector, fixture);
+		assert.equal(
+			gate.pass,
+			false,
+			`scoreboard-own gate fired (score=${gate.score.toFixed(3)})`,
+		);
+	});
+}
+
+const otherDetectors: Detector<unknown>[] = [
+	createScoreboardDetector(resources) as Detector<unknown>,
+	createScoreboardBattleLogReplayDetector(resources) as Detector<unknown>,
+	createDeathDetector(resources) as Detector<unknown>,
+	createMapStartDetector(resources) as Detector<unknown>,
+];
+for (const fixture of fixtures.filter(
+	(f) => f.expected.event === "ScoreboardOwn",
+)) {
+	test(`other gates stay quiet on scoreboard-own/${fixture.name}`, async () => {
+		for (const other of otherDetectors) {
+			const { gate } = await runDetectorOnFixture(other, fixture);
+			assert.equal(
+				gate.pass,
+				false,
+				`${other.id} gate fired (score=${gate.score.toFixed(3)})`,
+			);
+		}
+	});
+}
+
+function skip(fixture: Fixture, field: string): boolean | string {
+	return isFieldSkipped(fixture, field) ? "skipFields" : false;
+}
diff --git a/app/features/scanner/tests/scoreboard.test.ts b/app/features/scanner/tests/scoreboard.test.ts
new file mode 100644
index 000000000..45d143384
--- /dev/null
+++ b/app/features/scanner/tests/scoreboard.test.ts
@@ -0,0 +1,202 @@
+/**
+ * Golden-file tests: run the ScoreboardDetector over every fixture and
+ * compare per field, so a failure names the exact field and row with the
+ * raw match score (threshold problems must look different from ROI problems).
+ *
+ * Target one case: node --test --test-name-pattern="xbattle" 'tests/**'
+ */
+
+import assert from "node:assert/strict";
+import { loadOpenCV } from "../core/cv";
+import {
+	createScoreboardDetector,
+	type ScoreboardPlayer,
+	type ScoreboardRowDebug,
+} from "../core/detectors/scoreboard/index";
+import {
+	type Fixture,
+	isFieldSkipped,
+	loadFixtures,
+	runDetectorOnFixture,
+} from "../node/fixtures";
+import { loadScoreboardResources } from "../node/resources";
+import test from "./node-test-compat";
+
+await loadOpenCV();
+const detector = createScoreboardDetector(await loadScoreboardResources());
+const fixtures = loadFixtures("scoreboard");
+
+test("fixtures exist", () => {
+	assert.ok(fixtures.length > 0, "no fixtures found under scoreboard/");
+});
+
+for (const fixture of fixtures) {
+	test(`scoreboard/${fixture.name}`, async (t) => {
+		const { gate, events } = await runDetectorOnFixture(detector, fixture);
+		const expectPositive = fixture.expected.event === "Scoreboard";
+
+		await t.test("gate", () => {
+			assert.equal(
+				gate.pass,
+				expectPositive,
+				`gate ${gate.pass ? "fired" : "did not fire"} (score=${gate.score.toFixed(3)}), expected ${expectPositive ? "fire" : "no fire"}`,
+			);
+		});
+
+		if (!expectPositive) return;
+		const event = events[0];
+		assert.ok(event, "gate passed but no event parsed");
+		const rows = (event.debug?.rows ?? []) as ScoreboardRowDebug[];
+		const expected = fixture.expected.data ?? {};
+
+		await t.test("matchScores", { skip: skip(fixture, "matchScores") }, () => {
+			const dbg = event.debug?.matchScore as
+				| { left?: { reading?: string }; right?: { reading?: string } }
+				| undefined;
+			assert.deepEqual(
+				event.data.matchScores,
+				expected.matchScores,
+				`matchScores mismatch (readings: "${dbg?.left?.reading}" / "${dbg?.right?.reading}")`,
+			);
+		});
+
+		await t.test(
+			"header",
+			{ skip: expected.mode === undefined || skip(fixture, "header") },
+			() => {
+				const dbg = event.debug?.header as
+					| { lobbyReading?: string; lineReading?: string }
+					| undefined;
+				assert.deepEqual(
+					{
+						lobby: event.data.lobby,
+						mode: event.data.mode,
+						stage: event.data.stage,
+					},
+					{
+						lobby: expected.lobby ?? null,
+						mode: expected.mode ?? null,
+						stage: expected.stage ?? null,
+					},
+					`header mismatch (readings: "${dbg?.lobbyReading}" / "${dbg?.lineReading}")`,
+				);
+			},
+		);
+
+		await t.test(
+			"povIndex",
+			{ skip: expected.povIndex === undefined || skip(fixture, "povIndex") },
+			() => {
+				const fractions = rows.map((r) => r.povFraction.toFixed(3)).join(",");
+				assert.equal(
+					event.data.povIndex,
+					expected.povIndex,
+					`povIndex mismatch (yellow fractions=${fractions})`,
+				);
+			},
+		);
+
+		const players = expected.players ?? [];
+		for (const [i, want] of players.entries()) {
+			const got: ScoreboardPlayer | undefined = event.data.players[i];
+			const dbg = rows[i];
+			assert.ok(got, `row ${i} missing from parse`);
+
+			await t.test(
+				`row ${i} weapon`,
+				{
+					skip:
+						want.weaponId === undefined ||
+						skip(fixture, `players.${i}.weaponId`),
+				},
+				() => {
+					const top = dbg?.weapon?.top
+						.map((c) => `${c.id}:${c.score.toFixed(3)}`)
+						.join(" ");
+					assert.equal(
+						got.weaponId,
+						want.weaponId,
+						`weapon mismatch (candidates: ${top})`,
+					);
+				},
+			);
+
+			await t.test(
+				`row ${i} name`,
+				{ skip: want.name === undefined || skip(fixture, `players.${i}.name`) },
+				() => {
+					assert.equal(
+						got.name,
+						want.name,
+						`name mismatch (min glyph score=${dbg?.nameScore.toFixed(3)})`,
+					);
+				},
+			);
+
+			await t.test(
+				`row ${i} paint`,
+				{
+					skip: want.paint === undefined || skip(fixture, `players.${i}.paint`),
+				},
+				() => {
+					assert.equal(
+						got.paint,
+						want.paint,
+						`paint mismatch (score=${dbg?.paintScore.toFixed(3)})`,
+					);
+				},
+			);
+
+			await t.test(
+				`row ${i} stats`,
+				{ skip: want.ka === undefined || skip(fixture, `players.${i}.stats`) },
+				() => {
+					const scores = dbg?.statScores.map((s) => s.toFixed(3)).join(",");
+					assert.deepEqual(
+						{ ka: got.ka, d: got.d, s: got.s },
+						{ ka: want.ka, d: want.d ?? null, s: want.s ?? null },
+						`stat mismatch (scores=${scores})`,
+					);
+				},
+			);
+		}
+	});
+}
+
+// Mirror of the cross-negative sweeps in
+// suites/scoreboard-battle-log-replay.ts and scoreboard-battle-log.test.ts:
+// the live gate must stay quiet on every replay-browser and battle log
+// positive.
+for (const fixture of [
+	...loadFixtures("scoreboard-battle-log-replay").filter(
+		(f) => f.expected.event === "ScoreboardBattleLogReplay",
+	),
+	...loadFixtures("scoreboard-battle-log").filter(
+		(f) => f.expected.event === "ScoreboardBattleLog",
+	),
+]) {
+	test(`scoreboard gate stays quiet on ${fixture.name}`, async () => {
+		const { gate } = await runDetectorOnFixture(detector, fixture);
+		assert.equal(
+			gate.pass,
+			false,
+			`scoreboard gate fired (score=${gate.score.toFixed(3)})`,
+		);
+	});
+}
+
+// Shared negatives (tests/fixtures/negative/): frames no detector may fire on.
+for (const fixture of loadFixtures("negative")) {
+	test(`scoreboard gate stays quiet on negative/${fixture.name}`, async () => {
+		const { gate } = await runDetectorOnFixture(detector, fixture);
+		assert.equal(
+			gate.pass,
+			false,
+			`scoreboard gate fired (score=${gate.score.toFixed(3)})`,
+		);
+	});
+}
+
+function skip(fixture: Fixture, field: string): boolean | string {
+	return isFieldSkipped(fixture, field) ? "skipFields" : false;
+}
diff --git a/app/features/scanner/tests/sendou-upload.test.ts b/app/features/scanner/tests/sendou-upload.test.ts
new file mode 100644
index 000000000..3585cbb50
--- /dev/null
+++ b/app/features/scanner/tests/sendou-upload.test.ts
@@ -0,0 +1,71 @@
+import assert from "node:assert/strict";
+import { vodsNewSearchParams } from "~/features/vods/vods-search-params";
+import type { MainWeaponId } from "~/modules/in-game-lists/types";
+import { sendouUpload } from "../components/sendou-upload";
+import type { MinimapData } from "../core/detectors/minimap/index";
+import type { ScoreboardData } from "../core/detectors/scoreboard/index";
+import type { DetectedEvent } from "../core/detectors/types";
+import test from "./node-test-compat";
+
+const ALPHA: MainWeaponId[] = [40, 1001, 2010, 3030];
+const BRAVO: MainWeaponId[] = [50, 210, 4010, 8000];
+
+function scoreboard(t: number, povIndex: number | null): DetectedEvent {
+	const data: ScoreboardData = {
+		lobby: "PRIVATE",
+		mode: "SZ",
+		stage: 0,
+		matchScores: [100, 47],
+		players: [...ALPHA, ...BRAVO].map((weaponId, i) => ({
+			name: `p${i}`,
+			weaponId,
+			paint: 1000,
+			ka: 10,
+			d: 5,
+			s: 2,
+		})),
+		povIndex,
+	};
+	return { type: "Scoreboard", t, confidence: 0.9, data };
+}
+
+function prefilledMatches(events: DetectedEvent[]) {
+	const { url } = sendouUpload(events);
+	assert.ok(url);
+	const { ingest } = vodsNewSearchParams.parse(
+		new URL(url, "https://sendou.ink"),
+	);
+	assert.ok(ingest);
+	return ingest.matches;
+}
+
+test("the pov seat's weapon is sent as the prefilled pov weapon", () => {
+	const matches = prefilledMatches([scoreboard(300, 6)]);
+
+	assert.equal(matches[0]!.povWeapon, BRAVO[2]);
+});
+
+test("no pov weapon is sent when no scoreboard identified the seat", () => {
+	const matches = prefilledMatches([scoreboard(300, null)]);
+
+	assert.equal(matches[0]!.povWeapon, undefined);
+});
+
+test("weapons are padded to 4 slots per team so uneven rosters keep the team split", () => {
+	const data: MinimapData = {
+		stage: 0,
+		spectator: true,
+		teammates: (["up", "left", "right"] as const).map((slot, i) => ({
+			slot,
+			name: null,
+			weaponId: ALPHA[i]!,
+			abilities: [],
+		})),
+		enemies: BRAVO.map((weaponId) => ({ name: null, weaponId, abilities: [] })),
+	};
+	const matches = prefilledMatches([
+		{ type: "Minimap", t: 300, confidence: 0.9, data },
+	]);
+
+	assert.deepEqual(matches[0]!.weapons, [...ALPHA.slice(0, 3), null, ...BRAVO]);
+});
diff --git a/app/features/scanner/tests/suites/death.ts b/app/features/scanner/tests/suites/death.ts
new file mode 100644
index 000000000..4cc2cf421
--- /dev/null
+++ b/app/features/scanner/tests/suites/death.ts
@@ -0,0 +1,170 @@
+/**
+ * Golden-file suite for the DeathDetector over every fixture in death/,
+ * mirroring tests/scoreboard.test.ts, plus cross-negative sweeps in both
+ * directions: the death gate must stay quiet on every scoreboard and
+ * replay positive, and their gates must stay quiet on the death fixtures.
+ *
+ * Death parses are the most expensive in the repo (four burst-line reads
+ * plus up to six splash-tag name passes each), so the suite is sharded
+ * across processes: tests/death.<n>.test.ts each run one shard. Every
+ * fixture group is dealt round-robin, so `node --test tests/death.*.test.ts`
+ * still covers exactly what the old single file did.
+ */
+
+import assert from "node:assert/strict";
+import { loadOpenCV } from "../../core/cv";
+import {
+	createDeathDetector,
+	type DeathData,
+} from "../../core/detectors/death/index";
+import { createScoreboardDetector } from "../../core/detectors/scoreboard/index";
+import { createScoreboardBattleLogReplayDetector } from "../../core/detectors/scoreboard-battle-log-replay/index";
+import {
+	type Fixture,
+	isFieldSkipped,
+	loadFixtures,
+	runDetectorOnFixture,
+} from "../../node/fixtures";
+import { loadScoreboardResources } from "../../node/resources";
+import test from "../node-test-compat";
+
+export async function runDeathSuite(
+	shard: number,
+	shardCount: number,
+): Promise<void> {
+	await loadOpenCV();
+	const resources = await loadScoreboardResources();
+	const detector = createDeathDetector(resources);
+	const fixtures = loadFixtures("death");
+	const mine = <T>(items: T[]): T[] =>
+		items.filter((_, i) => i % shardCount === shard);
+
+	if (shard === 0) {
+		test("death fixtures exist", () => {
+			assert.ok(fixtures.length > 0, "no fixtures found under death/");
+		});
+	}
+
+	for (const fixture of mine(fixtures)) {
+		test(`death/${fixture.name}`, async (t) => {
+			const { gate, events } = await runDetectorOnFixture<DeathData>(
+				detector,
+				fixture,
+			);
+			const expectPositive = fixture.expected.event === "Death";
+
+			await t.test("gate", () => {
+				assert.equal(
+					gate.pass,
+					expectPositive,
+					`gate ${gate.pass ? "fired" : "did not fire"} (score=${gate.score.toFixed(3)}), expected ${expectPositive ? "fire" : "no fire"}`,
+				);
+			});
+
+			if (!expectPositive) return;
+			const event = events[0];
+			assert.ok(event, "gate passed but no event parsed");
+			const expected = fixture.expected.data ?? {};
+
+			await t.test(
+				"weapon",
+				{ skip: expected.weaponId === undefined || skip(fixture, "weapon") },
+				() => {
+					assert.equal(
+						event.data.weaponId,
+						expected.weaponId,
+						`weapon mismatch (read: "${event.debug?.weaponName}", raw: "${event.debug?.weaponRaw}", score=${Number(event.debug?.weaponScore ?? 0).toFixed(3)})`,
+					);
+					if (expected.weaponType !== undefined) {
+						assert.equal(event.data.weaponType, expected.weaponType);
+					}
+				},
+			);
+
+			for (const [row, wantRow] of (expected.abilities ?? []).entries()) {
+				await t.test(
+					`abilities row ${row}`,
+					{ skip: skip(fixture, `abilities.${row}`) },
+					() => {
+						assert.deepEqual(
+							event.data.abilities[row],
+							wantRow,
+							`ability row mismatch (debug: ${JSON.stringify((event.debug?.abilityRows as unknown[])?.[row])})`,
+						);
+					},
+				);
+			}
+
+			await t.test(
+				"name",
+				{ skip: expected.name === undefined || skip(fixture, "name") },
+				() => {
+					assert.equal(
+						event.data.name,
+						expected.name,
+						`name mismatch (raw: "${event.debug?.nameRaw}", score=${Number(event.debug?.nameScore ?? 0).toFixed(3)})`,
+					);
+				},
+			);
+		});
+	}
+
+	// The death overlay sits on live gameplay while the scoreboards replace it;
+	// none of the three gates may fire on another detector's positives.
+	const scoreboardPositives = loadFixtures("scoreboard").filter(
+		(f) => f.expected.event === "Scoreboard",
+	);
+	const replayPositives = loadFixtures("scoreboard-battle-log-replay").filter(
+		(f) => f.expected.event === "ScoreboardBattleLogReplay",
+	);
+	for (const fixture of mine([...scoreboardPositives, ...replayPositives])) {
+		test(`death gate stays quiet on ${fixture.dir.split("/").slice(-2).join("/")}`, async () => {
+			const { gate } = await runDetectorOnFixture(detector, fixture);
+			assert.equal(
+				gate.pass,
+				false,
+				`death gate fired (score=${gate.score.toFixed(3)})`,
+			);
+		});
+	}
+
+	// Shared negatives (tests/fixtures/negative/): frames no detector may fire on.
+	for (const fixture of mine(loadFixtures("negative"))) {
+		test(`death gate stays quiet on negative/${fixture.name}`, async () => {
+			const { gate } = await runDetectorOnFixture(detector, fixture);
+			assert.equal(
+				gate.pass,
+				false,
+				`death gate fired (score=${gate.score.toFixed(3)})`,
+			);
+		});
+	}
+
+	const crossFixtures = mine(
+		fixtures.filter((f) => f.expected.event === "Death"),
+	);
+	if (crossFixtures.length > 0) {
+		const scoreboardDetector = createScoreboardDetector(resources);
+		const replayDetector = createScoreboardBattleLogReplayDetector(resources);
+		for (const fixture of crossFixtures) {
+			test(`scoreboard gates stay quiet on death/${fixture.name}`, async () => {
+				const live = await runDetectorOnFixture(scoreboardDetector, fixture);
+				assert.equal(
+					live.gate.pass,
+					false,
+					`scoreboard gate fired (score=${live.gate.score.toFixed(3)})`,
+				);
+				const replay = await runDetectorOnFixture(replayDetector, fixture);
+				assert.equal(
+					replay.gate.pass,
+					false,
+					`replay gate fired (score=${replay.gate.score.toFixed(3)})`,
+				);
+			});
+		}
+	}
+}
+
+function skip(fixture: Fixture, field: string): boolean | string {
+	return isFieldSkipped(fixture, field) ? "skipFields" : false;
+}
diff --git a/app/features/scanner/tests/suites/scoreboard-battle-log-replay.ts b/app/features/scanner/tests/suites/scoreboard-battle-log-replay.ts
new file mode 100644
index 000000000..c23fed4ca
--- /dev/null
+++ b/app/features/scanner/tests/suites/scoreboard-battle-log-replay.ts
@@ -0,0 +1,267 @@
+/**
+ * Golden-file suite for the ScoreboardBattleLogReplayDetector over every
+ * fixture in scoreboard-battle-log-replay/, mirroring tests/scoreboard.test.ts,
+ * plus the replay extras (timestamp, replay code, match scores) and a
+ * cross-negative sweep: the replay gate must stay quiet on every
+ * live-scoreboard positive.
+ *
+ * Replay parses are expensive (eight 68px weapon rows plus the Rowdy-face
+ * code line), so the suite is sharded across processes:
+ * tests/scoreboard-battle-log-replay.<n>.test.ts each run one shard. Every
+ * fixture group is dealt round-robin, so
+ * `node --test tests/scoreboard-battle-log-replay.*.test.ts` still covers
+ * exactly what the old single file did.
+ */
+
+import assert from "node:assert/strict";
+import { loadOpenCV } from "../../core/cv";
+import type {
+	ScoreboardPlayer,
+	ScoreboardRowDebug,
+} from "../../core/detectors/scoreboard/index";
+import { createScoreboardBattleLogReplayDetector } from "../../core/detectors/scoreboard-battle-log-replay/index";
+import {
+	type Fixture,
+	isFieldSkipped,
+	loadFixtures,
+	runDetectorOnFixture,
+} from "../../node/fixtures";
+import { loadScoreboardResources } from "../../node/resources";
+import test from "../node-test-compat";
+
+export async function runScoreboardBattleLogReplaySuite(
+	shard: number,
+	shardCount: number,
+): Promise<void> {
+	await loadOpenCV();
+	const detector = createScoreboardBattleLogReplayDetector(
+		await loadScoreboardResources(),
+	);
+	const fixtures = loadFixtures("scoreboard-battle-log-replay");
+	const mine = <T>(items: T[]): T[] =>
+		items.filter((_, i) => i % shardCount === shard);
+
+	if (shard === 0) {
+		test("replay fixtures exist", () => {
+			assert.ok(
+				fixtures.length > 0,
+				"no fixtures found under scoreboard-battle-log-replay/",
+			);
+		});
+	}
+
+	for (const fixture of mine(fixtures)) {
+		test(`scoreboard-battle-log-replay/${fixture.name}`, async (t) => {
+			const { gate, events } = await runDetectorOnFixture(detector, fixture);
+			const expectPositive =
+				fixture.expected.event === "ScoreboardBattleLogReplay";
+
+			await t.test("gate", () => {
+				assert.equal(
+					gate.pass,
+					expectPositive,
+					`gate ${gate.pass ? "fired" : "did not fire"} (score=${gate.score.toFixed(3)}), expected ${expectPositive ? "fire" : "no fire"}`,
+				);
+			});
+
+			if (!expectPositive) return;
+			const event = events[0];
+			assert.ok(event, "gate passed but no event parsed");
+			const rows = (event.debug?.rows ?? []) as ScoreboardRowDebug[];
+			const expected = fixture.expected.data ?? {};
+
+			await t.test(
+				"matchScores",
+				{ skip: skip(fixture, "matchScores") },
+				() => {
+					assert.deepEqual(event.data.matchScores, expected.matchScores);
+				},
+			);
+
+			await t.test(
+				"header",
+				{ skip: expected.mode === undefined || skip(fixture, "header") },
+				() => {
+					const dbg = event.debug?.header as
+						| { topReading?: string; bottomReading?: string }
+						| undefined;
+					assert.deepEqual(
+						{
+							lobby: event.data.lobby,
+							mode: event.data.mode,
+							stage: event.data.stage,
+						},
+						{
+							lobby: expected.lobby ?? null,
+							mode: expected.mode ?? null,
+							stage: expected.stage ?? null,
+						},
+						`header mismatch (readings: "${dbg?.topReading}" / "${dbg?.bottomReading}")`,
+					);
+				},
+			);
+
+			await t.test(
+				"timestamp",
+				{
+					skip: expected.timestamp === undefined || skip(fixture, "timestamp"),
+				},
+				() => {
+					const dbg = event.debug?.header as
+						| { topReading?: string }
+						| undefined;
+					assert.equal(
+						event.data.timestamp,
+						expected.timestamp,
+						`timestamp mismatch (reading: "${dbg?.topReading}")`,
+					);
+				},
+			);
+
+			await t.test(
+				"replayCode",
+				{
+					skip:
+						expected.replayCode === undefined || skip(fixture, "replayCode"),
+				},
+				() => {
+					assert.equal(
+						event.data.replayCode,
+						expected.replayCode,
+						`replay code mismatch (raw: "${event.debug?.codeRaw}")`,
+					);
+				},
+			);
+
+			await t.test(
+				"povIndex",
+				{ skip: expected.povIndex === undefined || skip(fixture, "povIndex") },
+				() => {
+					const fractions = rows.map((r) => r.povFraction.toFixed(3)).join(",");
+					assert.equal(
+						event.data.povIndex,
+						expected.povIndex,
+						`povIndex mismatch (yellow fractions=${fractions})`,
+					);
+				},
+			);
+
+			const players = expected.players ?? [];
+
+			// Fixtures list the complete roster; empty pills (short teams) must be
+			// skipped by the parser, not emitted as phantom players.
+			await t.test(
+				"player count",
+				{ skip: expected.players === undefined || skip(fixture, "players") },
+				() => {
+					assert.equal(event.data.players.length, players.length);
+				},
+			);
+
+			for (const [i, want] of players.entries()) {
+				const got: ScoreboardPlayer | undefined = event.data.players[i];
+				const dbg = rows[i];
+				assert.ok(got, `row ${i} missing from parse`);
+
+				await t.test(
+					`row ${i} weapon`,
+					{
+						skip:
+							want.weaponId === undefined ||
+							skip(fixture, `players.${i}.weaponId`),
+					},
+					() => {
+						const top = dbg?.weapon?.top
+							.map((c) => `${c.id}:${c.score.toFixed(3)}`)
+							.join(" ");
+						assert.equal(
+							got.weaponId,
+							want.weaponId,
+							`weapon mismatch (candidates: ${top})`,
+						);
+					},
+				);
+
+				await t.test(
+					`row ${i} name`,
+					{
+						skip: want.name === undefined || skip(fixture, `players.${i}.name`),
+					},
+					() => {
+						assert.equal(
+							got.name,
+							want.name,
+							`name mismatch (min glyph score=${dbg?.nameScore.toFixed(3)})`,
+						);
+					},
+				);
+
+				await t.test(
+					`row ${i} paint`,
+					{
+						skip:
+							want.paint === undefined || skip(fixture, `players.${i}.paint`),
+					},
+					() => {
+						assert.equal(
+							got.paint,
+							want.paint,
+							`paint mismatch (score=${dbg?.paintScore.toFixed(3)})`,
+						);
+					},
+				);
+
+				await t.test(
+					`row ${i} stats`,
+					{
+						skip: want.ka === undefined || skip(fixture, `players.${i}.stats`),
+					},
+					() => {
+						const scores = dbg?.statScores.map((s) => s.toFixed(3)).join(",");
+						assert.deepEqual(
+							{ ka: got.ka, d: got.d, s: got.s },
+							{ ka: want.ka, d: want.d ?? null, s: want.s ?? null },
+							`stat mismatch (scores=${scores})`,
+						);
+					},
+				);
+			}
+		});
+	}
+
+	// The scoreboard-shaped screens must not trigger each other's detectors;
+	// the mirror sweeps live in scoreboard.test.ts and scoreboard-battle-log.test.ts.
+	for (const fixture of mine([
+		...loadFixtures("scoreboard").filter(
+			(f) => f.expected.event === "Scoreboard",
+		),
+		...loadFixtures("scoreboard-battle-log").filter(
+			(f) => f.expected.event === "ScoreboardBattleLog",
+		),
+	])) {
+		test(`replay gate stays quiet on ${fixture.name}`, async () => {
+			const { gate } = await runDetectorOnFixture(detector, fixture);
+			assert.equal(
+				gate.pass,
+				false,
+				`replay gate fired (score=${gate.score.toFixed(3)})`,
+			);
+		});
+	}
+
+	// Shared negatives (tests/fixtures/negative/): frames no detector may fire on.
+	for (const fixture of mine(loadFixtures("negative"))) {
+		test(`replay gate stays quiet on negative/${fixture.name}`, async () => {
+			const { gate } = await runDetectorOnFixture(detector, fixture);
+			assert.equal(
+				gate.pass,
+				false,
+				`replay gate fired (score=${gate.score.toFixed(3)})`,
+			);
+		});
+	}
+}
+
+function skip(fixture: Fixture, field: string): boolean | string {
+	return isFieldSkipped(fixture, field) ? "skipFields" : false;
+}
diff --git a/app/features/scanner/tests/timeline.test.ts b/app/features/scanner/tests/timeline.test.ts
new file mode 100644
index 000000000..e1ae4da0f
--- /dev/null
+++ b/app/features/scanner/tests/timeline.test.ts
@@ -0,0 +1,177 @@
+import assert from "node:assert/strict";
+import type { ScoreboardData } from "../core/detectors/scoreboard/index";
+import type { DetectedEvent } from "../core/detectors/types";
+import { TimelineBuilder } from "../core/timeline/index";
+import test from "./node-test-compat";
+
+function event(
+	t: number,
+	confidence: number,
+	type = "Scoreboard",
+): DetectedEvent {
+	return { type, t, confidence, data: { t } };
+}
+
+/** A ScoreboardBattleLogReplay event with just the identity-relevant data fields. */
+function replay(
+	t: number,
+	confidence: number,
+	data: Partial<ScoreboardData> & {
+		timestamp?: string | null;
+		replayCode?: string | null;
+	},
+): DetectedEvent {
+	return {
+		type: "ScoreboardBattleLogReplay",
+		t,
+		confidence,
+		data: {
+			lobby: null,
+			mode: null,
+			stage: null,
+			timestamp: null,
+			replayCode: null,
+			scores: [null, null],
+			players: [],
+			povIndex: null,
+			...data,
+		},
+	};
+}
+
+function players(paints: (number | null)[]): ScoreboardData["players"] {
+	return paints.map((paint, i) => ({
+		name: `p${i}`,
+		weaponId: null,
+		paint,
+		ka: null,
+		d: null,
+		s: null,
+	}));
+}
+
+test("timeline drops low-confidence events", () => {
+	const tl = new TimelineBuilder({ minConfidence: 0.6 });
+	assert.equal(tl.push(event(0, 0.5)).action, "dropped");
+	assert.equal(tl.events.length, 0);
+});
+
+test("timeline merges same-type events inside the window", () => {
+	const tl = new TimelineBuilder({ mergeWindow: 30, minConfidence: 0 });
+	assert.equal(tl.push(event(100, 0.8)).action, "added");
+	assert.equal(tl.push(event(110, 0.7)).action, "merged");
+	assert.equal(tl.events.length, 1);
+	assert.equal(tl.events[0]!.confidence, 0.8);
+});
+
+test("timeline keeps the highest-confidence version", () => {
+	const tl = new TimelineBuilder({ mergeWindow: 30, minConfidence: 0 });
+	tl.push(event(100, 0.7));
+	const result = tl.push(event(105, 0.9));
+	assert.equal(result.action, "replaced");
+	assert.equal(tl.events[0]!.confidence, 0.9);
+});
+
+test("timeline keeps separate events outside the window", () => {
+	const tl = new TimelineBuilder({ mergeWindow: 30, minConfidence: 0 });
+	tl.push(event(100, 0.8));
+	assert.equal(tl.push(event(200, 0.8)).action, "added");
+	assert.equal(tl.events.length, 2);
+});
+
+test("different event types never merge", () => {
+	const tl = new TimelineBuilder({ mergeWindow: 30, minConfidence: 0 });
+	tl.push(event(100, 0.8, "Scoreboard"));
+	assert.equal(tl.push(event(105, 0.8, "Death")).action, "added");
+	assert.equal(tl.events.length, 2);
+});
+
+test("scoreboards with different stages stay separate inside the window", () => {
+	const tl = new TimelineBuilder({ minConfidence: 0 });
+	assert.equal(tl.push(replay(100, 0.8, { stage: 21 })).action, "added");
+	assert.equal(tl.push(replay(104, 0.8, { stage: 2 })).action, "added");
+	assert.equal(tl.push(replay(108, 0.8, { stage: 17 })).action, "added");
+	// revisiting the first replay merges back into its event, skipping the
+	// incompatible ones in between
+	assert.equal(tl.push(replay(112, 0.7, { stage: 21 })).action, "merged");
+	assert.equal(tl.events.length, 3);
+});
+
+test("a null stage read never splits", () => {
+	const tl = new TimelineBuilder({ minConfidence: 0 });
+	tl.push(replay(100, 0.8, { stage: 21 }));
+	assert.equal(tl.push(replay(104, 0.7, { stage: null })).action, "merged");
+});
+
+test("different recording timestamps split, equal ones merge", () => {
+	const tl = new TimelineBuilder({ minConfidence: 0 });
+	tl.push(replay(100, 0.8, { timestamp: "3/7/2026 21:15" }));
+	assert.equal(
+		tl.push(replay(104, 0.8, { timestamp: "3/7/2026 21:22" })).action,
+		"added",
+	);
+	assert.equal(
+		tl.push(replay(108, 0.7, { timestamp: "3/7/2026 21:15" })).action,
+		"merged",
+	);
+});
+
+test("replay codes tolerate misread glyphs but split on real differences", () => {
+	const tl = new TimelineBuilder({ minConfidence: 0 });
+	tl.push(replay(100, 0.8, { replayCode: "R797-V51Y-945W-C4JJ" }));
+	// same replay, three glyphs misread on a low-fidelity capture
+	assert.equal(
+		tl.push(replay(104, 0.7, { replayCode: "R797-U51Y-945W-G4JL" })).action,
+		"merged",
+	);
+	assert.equal(
+		tl.push(replay(108, 0.8, { replayCode: "RVRM-XXEL-0573-Q4SV" })).action,
+		"added",
+	);
+});
+
+test("disjoint paint totals split when stage and code are unreadable", () => {
+	const tl = new TimelineBuilder({ minConfidence: 0 });
+	tl.push(
+		replay(100, 0.8, {
+			players: players([327, 408, 270, 354, 381, 613, 456, 287]),
+		}),
+	);
+	const other = replay(104, 0.8, {
+		players: players([733, 946, 1020, 878, 666, 1068, 1050, 631]),
+	});
+	assert.equal(tl.push(other).action, "added");
+	// same board re-read with jitter: a couple of rows misread or null
+	const jittered = replay(108, 0.7, {
+		players: players([733, 946, 1020, null, 666, 1068, 1050, 613]),
+	});
+	assert.equal(tl.push(jittered).action, "merged");
+	assert.equal(tl.events.length, 2);
+});
+
+test("too few readable paints never split", () => {
+	const tl = new TimelineBuilder({ minConfidence: 0 });
+	tl.push(
+		replay(100, 0.8, {
+			players: players([327, 408, 270, null, null, null, null, null]),
+		}),
+	);
+	const other = replay(104, 0.7, {
+		players: players([733, 946, 1020, null, null, null, null, null]),
+	});
+	assert.equal(tl.push(other).action, "merged");
+});
+
+test("per-type merge window: repeat death frames merge, consecutive deaths do not", () => {
+	const tl = new TimelineBuilder({ minConfidence: 0 });
+	assert.equal(tl.push(event(100, 0.8, "Death")).action, "added");
+	// same death, sampled again 3s later
+	assert.equal(tl.push(event(103, 0.7, "Death")).action, "merged");
+	// next death after respawn + travel: outside the 8s Death window but
+	// well inside the default 30s
+	assert.equal(tl.push(event(112, 0.8, "Death")).action, "added");
+	assert.equal(tl.events.length, 2);
+	// scoreboards keep the wide default window
+	tl.push(event(200, 0.8, "Scoreboard"));
+	assert.equal(tl.push(event(212, 0.7, "Scoreboard")).action, "merged");
+});
diff --git a/app/features/scanner/worker/analyzer.worker.ts b/app/features/scanner/worker/analyzer.worker.ts
new file mode 100644
index 000000000..e0a1aaef7
--- /dev/null
+++ b/app/features/scanner/worker/analyzer.worker.ts
@@ -0,0 +1,303 @@
+/**
+ * AnalyzerWorker: owns OpenCV.js (WASM), the detector registry and a
+ * DetectorScheduler. Two entry points: "frame" — the main thread posts one
+ * ImageBitmap/VideoFrame at a time (live capture, screenshot harness, VoD
+ * seek fallback); results come back per detector, then a "done" carrying the
+ * scheduler's calm signal and telemetry. "scanChunk" — a VoD time slice is
+ * demuxed/decoded entirely in the worker with mediabunny: the worker owns a
+ * contiguous slice so scheduling is exact, undue frames skip canvas
+ * readback, and calm stretches skim by keyframe hops instead of decoding
+ * every frame — the big VoD speedup, since sequential decode bounds scan
+ * wall-clock time.
+ */
+import {
+	ALL_FORMATS,
+	BlobSource,
+	EncodedPacketSink,
+	Input,
+	type VideoSample,
+	VideoSampleSink,
+} from "mediabunny";
+import { loadOpenCV } from "../core/cv";
+import { MAP_START_EVENT_TYPE } from "../core/detectors/map-start/index";
+import {
+	createAllDetectors,
+	SCOREBOARD_EVENT_TYPES,
+} from "../core/detectors/registry";
+import { DetectorScheduler } from "../core/detectors/scheduler";
+import {
+	createScanTelemetry,
+	detectorTelemetry,
+} from "../core/detectors/telemetry";
+import type { Detector } from "../core/detectors/types";
+import { normalizeFrame, toMat } from "../core/image";
+import type {
+	AnalyzeRequest,
+	InitRequest,
+	ScanChunkRequest,
+	WorkerRequest,
+	WorkerResponse,
+} from "./protocol";
+import { fetchScoreboardResources } from "./resources";
+
+/**
+ * Widest skim hop: calm footage is sampled at the keyframe cadence, capped
+ * here so long-GOP recordings still cannot slip a results screen (~10s) or
+ * a match intro (~7s) between two samples.
+ */
+const MAX_SKIM_STRIDE_S = 2.5;
+const PROGRESS_POST_INTERVAL_MS = 400;
+const PREVIEW_POST_INTERVAL_MS = 600;
+const PREVIEW_WIDTH = 480;
+const PREVIEW_HEIGHT = 270;
+
+let detectors: Detector<unknown>[] = [];
+let scheduler: DetectorScheduler | null = null;
+let telemetry = createScanTelemetry();
+let chunkAborted = false;
+/** last per-frame t, to reset telemetry when a new session rewinds the clock */
+let lastFrameT = Number.NEGATIVE_INFINITY;
+
+function post(message: WorkerResponse, transfer: Transferable[] = []): void {
+	self.postMessage(message, { transfer });
+}
+
+async function init({
+	assetsBaseUrl,
+	suppressSteadyFrames = true,
+}: InitRequest): Promise<void> {
+	try {
+		await loadOpenCV();
+		const resources = await fetchScoreboardResources(assetsBaseUrl);
+		detectors = createAllDetectors(resources);
+		scheduler = new DetectorScheduler(detectors, {
+			suppressSteadyFrames,
+			matchOpeningTypes: [MAP_START_EVENT_TYPE],
+			matchClosingTypes: SCOREBOARD_EVENT_TYPES,
+		});
+		telemetry = createScanTelemetry();
+		post({ kind: "ready" });
+	} catch (error) {
+		post({ kind: "error", message: `init failed: ${String(error)}` });
+	}
+}
+
+/**
+ * Run the due detectors over one frame; closes `bitmap`. When the scheduler
+ * has no detector due, the canvas readback and normalize are skipped too.
+ */
+async function analyzeFrame(
+	bitmap: ImageBitmap | VideoFrame,
+	t: number,
+): Promise<void> {
+	const due = scheduler!.dueDetectors(t);
+	if (due.length === 0) {
+		bitmap.close();
+		return;
+	}
+	const width = "displayWidth" in bitmap ? bitmap.displayWidth : bitmap.width;
+	const height =
+		"displayHeight" in bitmap ? bitmap.displayHeight : bitmap.height;
+	const canvas = new OffscreenCanvas(width, height);
+	const ctx = canvas.getContext("2d", { willReadFrequently: true })!;
+	ctx.drawImage(bitmap, 0, 0);
+	bitmap.close();
+	const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
+
+	const src = toMat({
+		width: imageData.width,
+		height: imageData.height,
+		data: imageData.data,
+	});
+	let frame: ReturnType<typeof normalizeFrame>;
+	try {
+		frame = normalizeFrame(src);
+	} finally {
+		src.delete();
+	}
+	telemetry.analyzedFrames++;
+
+	// On detection, ship back the exact analyzed pixels (lossless, at capture
+	// resolution) so the UI never has to re-grab a later frame — encoded at
+	// most once per frame, however many detectors fire on it.
+	let encoded: Promise<Blob> | null = null;
+	const frameBlob = () =>
+		(encoded ??= canvas.convertToBlob({ type: "image/png" }));
+
+	try {
+		for (const detector of detectors) {
+			if (!due.includes(detector.id)) continue;
+			const counters = detectorTelemetry(telemetry, detector.id);
+			counters.checks++;
+			const gateStart = performance.now();
+			const gate = detector.gate(frame);
+			counters.gateMs += performance.now() - gateStart;
+			scheduler!.recordGate(detector.id, t, gate.pass, gate.signature);
+			if (gate.pass) counters.gatePasses++;
+			const runParse = gate.pass && scheduler!.shouldParse(detector.id, t);
+			if (gate.pass && !runParse) counters.suppressedParses++;
+			let events: ReturnType<typeof detector.parse> = [];
+			if (runParse) {
+				const parseStart = performance.now();
+				events = detector.parse(frame, t, gate);
+				counters.parses++;
+				counters.parseMs += performance.now() - parseStart;
+				scheduler!.recordParse(detector.id, t, events);
+			}
+			const blob =
+				events.length > 0 && detector.attachFrame !== false
+					? await frameBlob()
+					: undefined;
+			post({
+				kind: "result",
+				detector: detector.id,
+				t,
+				gate,
+				events,
+				frame: blob,
+			});
+		}
+	} finally {
+		frame.delete();
+	}
+}
+
+async function analyze({ bitmap, t }: AnalyzeRequest): Promise<void> {
+	if (t + 5 < lastFrameT) telemetry = createScanTelemetry();
+	lastFrameT = t;
+	try {
+		await analyzeFrame(bitmap, t);
+	} catch (error) {
+		post({ kind: "error", message: `analyze failed: ${String(error)}` });
+	}
+	post({ kind: "done", t, calm: scheduler!.calm(t), telemetry });
+}
+
+async function scanChunk({
+	file,
+	chunkIndex,
+	tStart,
+	tEnd,
+}: ScanChunkRequest): Promise<void> {
+	chunkAborted = false;
+	scheduler!.reset(tStart);
+	telemetry = createScanTelemetry();
+	const wallStart = performance.now();
+	let lastProgressAt = 0;
+	let lastPreviewAt = 0;
+	let cursor = tStart;
+	let mode: "active" | "skim" = "active";
+
+	const input = new Input({
+		formats: ALL_FORMATS,
+		source: new BlobSource(file),
+	});
+	try {
+		const track = await input.getPrimaryVideoTrack();
+		if (!track || !(await track.canDecode())) {
+			throw new Error("worker cannot decode this file");
+		}
+		const samples = new VideoSampleSink(track);
+		const packets = new EncodedPacketSink(track);
+
+		const handleSample = async (sample: VideoSample): Promise<void> => {
+			telemetry.decodedFrames++;
+			const t = sample.timestamp;
+			const span = Math.max(0, t - cursor);
+			if (mode === "active") telemetry.activeVideoS += span;
+			else telemetry.skimVideoS += span;
+			cursor = Math.max(cursor, t);
+			const frame = sample.toVideoFrame();
+			sample.close();
+			const now = performance.now();
+			let preview: ImageBitmap | undefined;
+			if (now - lastPreviewAt >= PREVIEW_POST_INTERVAL_MS) {
+				lastPreviewAt = now;
+				preview = await createImageBitmap(frame, {
+					resizeWidth: PREVIEW_WIDTH,
+					resizeHeight: PREVIEW_HEIGHT,
+				});
+			}
+			if (t >= scheduler!.nextDueT()) {
+				await analyzeFrame(frame, t);
+			} else {
+				frame.close();
+			}
+			if (preview || now - lastProgressAt >= PROGRESS_POST_INTERVAL_MS) {
+				lastProgressAt = now;
+				telemetry.wallMs = performance.now() - wallStart;
+				post(
+					{
+						kind: "chunkProgress",
+						chunkIndex,
+						t: cursor,
+						mode,
+						telemetry,
+						preview,
+					},
+					preview ? [preview] : [],
+				);
+			}
+		};
+
+		scan: while (!chunkAborted && cursor < tEnd) {
+			if (mode === "active") {
+				// dense sequential decode: every frame is seen, the scheduler
+				// decides which are worth analyzing
+				for await (const sample of samples.samples(cursor)) {
+					if (!sample) continue;
+					if (chunkAborted || sample.timestamp >= tEnd) {
+						sample.close();
+						break scan;
+					}
+					await handleSample(sample);
+					if (scheduler!.calm(cursor)) {
+						mode = "skim";
+						break;
+					}
+				}
+				if (mode === "active") break; // media ended before tEnd
+			} else {
+				// skim: hop keyframe to keyframe (single-frame decodes) while
+				// calm, capped so long GOPs cannot hide a short screen
+				const key = await packets.getKeyPacket(cursor + MAX_SKIM_STRIDE_S, {
+					verifyKeyPackets: true,
+				});
+				const target =
+					key && key.timestamp > cursor
+						? key.timestamp
+						: cursor + MAX_SKIM_STRIDE_S;
+				if (target >= tEnd) {
+					cursor = tEnd;
+					break;
+				}
+				const sample = await samples.getSample(target);
+				if (!sample) {
+					cursor = target;
+					continue;
+				}
+				await handleSample(sample);
+				cursor = Math.max(cursor, target);
+				if (!scheduler!.calm(cursor)) mode = "active";
+			}
+		}
+
+		telemetry.wallMs = performance.now() - wallStart;
+		post({ kind: "chunkDone", chunkIndex, telemetry });
+	} catch (error) {
+		post({
+			kind: "error",
+			message: `chunk ${chunkIndex} scan failed: ${String(error)}`,
+		});
+	} finally {
+		input.dispose();
+	}
+}
+
+self.onmessage = (e: MessageEvent) => {
+	const msg = e.data as WorkerRequest;
+	if (msg.kind === "init") void init(msg);
+	else if (msg.kind === "frame") void analyze(msg);
+	else if (msg.kind === "scanChunk") void scanChunk(msg);
+	else if (msg.kind === "abortChunk") chunkAborted = true;
+};
diff --git a/app/features/scanner/worker/client.ts b/app/features/scanner/worker/client.ts
new file mode 100644
index 000000000..9b87d378b
--- /dev/null
+++ b/app/features/scanner/worker/client.ts
@@ -0,0 +1,181 @@
+/**
+ * Main-thread wrapper around the AnalyzerWorker: init handshake, then either
+ * one in-flight frame at a time (live capture / screenshot / seek fallback —
+ * each frame yields one result per due detector, then a "done" carrying the
+ * scheduler's calm signal and telemetry) or one in-flight chunk scan (the
+ * worker decodes and analyzes a VoD time slice by itself, streaming results
+ * and progress until "chunkDone").
+ */
+import { Config } from "../../../config";
+import type { ScanTelemetry } from "../core/detectors/telemetry";
+import type { WorkerResponse } from "./protocol";
+
+export type ResultHandler = (
+	result: Extract<WorkerResponse, { kind: "result" }>,
+) => void;
+export type ErrorHandler = (message: string) => void;
+export interface DoneInfo {
+	calm: boolean;
+	telemetry: ScanTelemetry;
+}
+export type DoneHandler = (t: number, info: DoneInfo) => void;
+export type ChunkProgress = Extract<WorkerResponse, { kind: "chunkProgress" }>;
+export type ChunkProgressHandler = (progress: ChunkProgress) => void;
+
+/** each chunk-scanning worker decodes and analyzes on its own; leave a core
+ * for the main thread and one for the browser's media stack */
+export function defaultScanWorkerCount(): number {
+	return Math.min(4, Math.max(1, (navigator.hardwareConcurrency || 4) - 2));
+}
+
+interface PendingChunk {
+	resolve(telemetry: ScanTelemetry): void;
+	reject(error: Error): void;
+	onProgress?: ChunkProgressHandler;
+}
+
+export class AnalyzerClient {
+	#worker: Worker;
+	#ready = false;
+	#busy = false;
+	#onResult: ResultHandler;
+	#onError: ErrorHandler;
+	#onDone: DoneHandler | undefined;
+	#readyPromise: Promise<void>;
+	#rejectReady: ((error: Error) => void) | undefined;
+	#idleWaiters: (() => void)[] = [];
+	#chunk: PendingChunk | null = null;
+
+	constructor(
+		onResult: ResultHandler,
+		// biome-ignore lint/suspicious/noConsole: default sink for worker errors when no handler is passed
+		onError: ErrorHandler = console.error,
+		onDone?: DoneHandler,
+		options: { suppressSteadyFrames?: boolean } = {},
+	) {
+		this.#onResult = onResult;
+		this.#onError = onError;
+		this.#onDone = onDone;
+		this.#worker = new Worker(
+			new URL("./analyzer.worker.ts", import.meta.url),
+			{
+				type: "module",
+			},
+		);
+		let resolveReady!: () => void;
+		this.#readyPromise = new Promise((resolve, reject) => {
+			resolveReady = resolve;
+			this.#rejectReady = reject;
+		});
+		// init failure also surfaces via onError; don't let an un-awaited
+		// whenReady() turn it into an unhandled rejection as well
+		this.#readyPromise.catch(() => {});
+		this.#worker.onmessage = (e: MessageEvent<WorkerResponse>) => {
+			const msg = e.data;
+			if (msg.kind === "ready") {
+				this.#ready = true;
+				resolveReady();
+			} else if (msg.kind === "result") {
+				this.#onResult(msg);
+			} else if (msg.kind === "done") {
+				this.#settle();
+				this.#onDone?.(msg.t, { calm: msg.calm, telemetry: msg.telemetry });
+			} else if (msg.kind === "chunkProgress") {
+				this.#chunk?.onProgress?.(msg);
+			} else if (msg.kind === "chunkDone") {
+				const chunk = this.#chunk;
+				this.#chunk = null;
+				this.#settle();
+				chunk?.resolve(msg.telemetry);
+			} else if (msg.kind === "error") {
+				this.#fail(msg.message);
+			}
+		};
+		// A throw outside the worker's own try/catch posts neither "error" nor
+		// "done"; without these handlers `busy` would stay true forever and the
+		// sampler / VoD scan would silently freeze.
+		this.#worker.onerror = (e: ErrorEvent) => {
+			this.#fail(`worker error: ${e.message || String(e)}`);
+		};
+		this.#worker.onmessageerror = () => {
+			this.#fail("worker message deserialization failed");
+		};
+		this.#worker.postMessage({
+			kind: "init",
+			assetsBaseUrl: Config.staticAssetsUrl,
+			suppressSteadyFrames: options.suppressSteadyFrames ?? true,
+		});
+	}
+
+	whenReady(): Promise<void> {
+		return this.#readyPromise;
+	}
+
+	get busy(): boolean {
+		return this.#busy || !this.#ready;
+	}
+
+	/** Resolves once no frame or chunk scan is in flight. Call whenReady() first. */
+	async whenIdle(): Promise<void> {
+		while (this.#busy) {
+			await new Promise<void>((resolve) => this.#idleWaiters.push(resolve));
+		}
+	}
+
+	/** Returns false (and closes the bitmap) if the worker is still busy. */
+	analyze(bitmap: ImageBitmap | VideoFrame, t: number): boolean {
+		if (this.busy) {
+			bitmap.close();
+			return false;
+		}
+		this.#busy = true;
+		this.#worker.postMessage({ kind: "frame", bitmap, t }, [bitmap]);
+		return true;
+	}
+
+	/**
+	 * Scan [tStart, tEnd) of `file` inside the worker. Results stream to the
+	 * shared result handler; resolves with the chunk's telemetry once done
+	 * (an aborted chunk resolves too — abort is not an error).
+	 */
+	scanChunk(
+		request: { file: File; chunkIndex: number; tStart: number; tEnd: number },
+		onProgress?: ChunkProgressHandler,
+	): Promise<ScanTelemetry> {
+		if (this.busy) {
+			return Promise.reject(new Error("analyzer is busy"));
+		}
+		this.#busy = true;
+		return new Promise((resolve, reject) => {
+			this.#chunk = { resolve, reject, onProgress };
+			this.#worker.postMessage({ kind: "scanChunk", ...request });
+		});
+	}
+
+	/** Ask a running chunk scan to stop; it resolves after the current frame. */
+	abortChunk(): void {
+		if (this.#chunk) this.#worker.postMessage({ kind: "abortChunk" });
+	}
+
+	dispose(): void {
+		this.#worker.terminate();
+	}
+
+	#settle(): void {
+		this.#busy = false;
+		const waiters = this.#idleWaiters;
+		this.#idleWaiters = [];
+		for (const waiter of waiters) waiter();
+	}
+
+	#fail(message: string): void {
+		// an error before "ready" means init failed — reject whenReady() so
+		// callers don't hang on a client that will never become usable
+		if (!this.#ready) this.#rejectReady?.(new Error(message));
+		const chunk = this.#chunk;
+		this.#chunk = null;
+		this.#settle();
+		if (chunk) chunk.reject(new Error(message));
+		else this.#onError(message);
+	}
+}
diff --git a/app/features/scanner/worker/protocol.ts b/app/features/scanner/worker/protocol.ts
new file mode 100644
index 000000000..399ca25a7
--- /dev/null
+++ b/app/features/scanner/worker/protocol.ts
@@ -0,0 +1,86 @@
+import type { ScanTelemetry } from "../core/detectors/telemetry";
+import type { DetectedEvent, GateResult } from "../core/detectors/types";
+
+export interface InitRequest {
+	kind: "init";
+	/**
+	 * static assets CDN root the worker fetches icons and atlases from
+	 * (`Config.staticAssetsUrl`); passed in the init message so the worker
+	 * bundle stays free of the app config graph
+	 */
+	assetsBaseUrl: string;
+	/**
+	 * skip parse() for a detector whose gate keeps firing without confidence
+	 * improving (static screen), and let the scheduler thin out checks;
+	 * default true — one-shot consumers like the screenshot harness turn it
+	 * off to get every detector on every frame
+	 */
+	suppressSteadyFrames?: boolean;
+}
+
+export interface AnalyzeRequest {
+	kind: "frame";
+	/** VideoFrame is what VoD decode produces; transferring it directly skips
+	 * a main-thread ImageBitmap conversion */
+	bitmap: ImageBitmap | VideoFrame;
+	/** seconds into the stream */
+	t: number;
+}
+
+/**
+ * Scan a time slice of a VoD entirely inside the worker: demux + decode with
+ * mediabunny, schedule detectors, post results as they fire. Decoding in the
+ * worker removes the per-frame main-thread hop and lets each worker own a
+ * contiguous slice, so scheduler state (cadence, suppression, calm) is exact
+ * instead of split across a pool.
+ */
+export interface ScanChunkRequest {
+	kind: "scanChunk";
+	file: File;
+	chunkIndex: number;
+	/** seconds; the chunk scans [tStart, tEnd) */
+	tStart: number;
+	tEnd: number;
+}
+
+export interface AbortChunkRequest {
+	kind: "abortChunk";
+}
+
+export type WorkerRequest =
+	| InitRequest
+	| AnalyzeRequest
+	| ScanChunkRequest
+	| AbortChunkRequest;
+
+export type WorkerResponse =
+	| { kind: "ready" }
+	| {
+			kind: "result";
+			detector: string;
+			t: number;
+			gate: GateResult;
+			events: DetectedEvent<unknown>[];
+			/** lossless PNG of the exact frame that was analyzed; present when events fired */
+			frame?: Blob;
+	  }
+	/** all due detectors have reported for frame t (per-frame path only) */
+	| {
+			kind: "done";
+			t: number;
+			/** scheduler sees dead air — the caller may widen its sampling stride */
+			calm: boolean;
+			telemetry: ScanTelemetry;
+	  }
+	| {
+			kind: "chunkProgress";
+			chunkIndex: number;
+			/** seconds of video the chunk scan has reached */
+			t: number;
+			mode: "active" | "skim";
+			telemetry: ScanTelemetry;
+			/** small bitmap of the latest decoded frame, for the preview canvas */
+			preview?: ImageBitmap;
+	  }
+	| { kind: "chunkDone"; chunkIndex: number; telemetry: ScanTelemetry }
+	| { kind: "error"; message: string };
diff --git a/app/features/scanner/worker/resources.ts b/app/features/scanner/worker/resources.ts
new file mode 100644
index 000000000..9b0c338f0
--- /dev/null
+++ b/app/features/scanner/worker/resources.ts
@@ -0,0 +1,91 @@
+/**
+ * Worker/browser IO for ScoreboardResources: fetches over HTTP. Game icons
+ * come from the CDN's shared `img/<dir>/<id>.avif` sets the rest of the app
+ * already uses; the scanner-specific atlases (glyphs, planner signatures) are
+ * served same-origin from this repo's `public/scanner/v1/**`. What the bundle
+ * contains — every key, template option set, and atlas name — lives in
+ * core/resources.ts, shared with the Node loader. The base URL arrives via
+ * the worker init message (see worker/protocol.ts) so this module never
+ * imports the app config.
+ */
+
+import {
+	loadPlannerStages,
+	type PlannerManifest,
+	type PlannerStage,
+} from "../core/detectors/minimap/stage";
+import type { ScoreboardResources } from "../core/detectors/scoreboard/index";
+import { type AtlasMeta, type GlyphSet, loadGlyphSet } from "../core/glyphs";
+import type { FrameData } from "../core/image";
+import { assembleScoreboardResources } from "../core/resources";
+
+/** Scanner parser atlases; the version segment guards against CDN cache skew —
+ * bump it together with breaking atlas format changes (must match the
+ * Node-side SCANNER_ASSETS_DIR default in node/assets-dir.ts).
+ * xxx: temporarily served same-origin from this repo's public/ while the
+ * feature is in development; move to the assets repo CDN
+ * (`${base}/scanner/v1`) later */
+const ATLAS_BASE = "/scanner/v1";
+
+async function fetchImage(url: string): Promise<FrameData> {
+	const res = await fetch(url);
+	if (!res.ok) throw new Error(`fetch ${url}: ${res.status}`);
+	const bitmap = await createImageBitmap(await res.blob());
+	const canvas = new OffscreenCanvas(bitmap.width, bitmap.height);
+	const ctx = canvas.getContext("2d")!;
+	ctx.drawImage(bitmap, 0, 0);
+	bitmap.close();
+	const data = ctx.getImageData(0, 0, canvas.width, canvas.height);
+	return { width: data.width, height: data.height, data: data.data };
+}
+
+function makeFetchAtlas(base: string) {
+	return async function fetchAtlas(
+		name: string,
+	): Promise<() => GlyphSet | null> {
+		try {
+			const [meta, image] = await Promise.all([
+				fetch(`${base}/glyphs/${name}.json`).then((r) => {
+					if (!r.ok) throw new Error(String(r.status));
+					return r.json() as Promise<AtlasMeta>;
+				}),
+				fetchImage(`${base}/glyphs/${name}.png`),
+			]);
+			const set = loadGlyphSet(image, meta);
+			return () => set;
+		} catch {
+			return () => null;
+		}
+	};
+}
+
+function makeFetchPlannerStages(base: string) {
+	return async function fetchPlannerStages(): Promise<
+		() => PlannerStage[] | null
+	> {
+		try {
+			const [manifest, atlas] = await Promise.all([
+				fetch(`${base}/planner/manifest.json`).then((r) => {
+					if (!r.ok) throw new Error(String(r.status));
+					return r.json() as Promise<PlannerManifest>;
+				}),
+				fetchImage(`${base}/planner/signatures.png`),
+			]);
+			const stages = loadPlannerStages(atlas, manifest);
+			return () => stages;
+		} catch {
+			return () => null;
+		}
+	};
+}
+
+/** Requires loadOpenCV() to have resolved. */
+export function fetchScoreboardResources(
+	base: string,
+): Promise<ScoreboardResources> {
+	return assembleScoreboardResources({
+		readIcon: (dir, id) => fetchImage(`${base}/img/${dir}/${id}.avif`),
+		loadAtlas: makeFetchAtlas(ATLAS_BASE),
+		loadPlannerStages: makeFetchPlannerStages(ATLAS_BASE),
+	});
+}
diff --git a/app/features/tournament-match/TournamentMatchRepository.server.ts b/app/features/tournament-match/TournamentMatchRepository.server.ts
index be1251e71..1e1f17840 100644
--- a/app/features/tournament-match/TournamentMatchRepository.server.ts
+++ b/app/features/tournament-match/TournamentMatchRepository.server.ts
@@ -479,7 +479,7 @@ export function findByTournamentTeamId(tournamentTeamId: number) {
 								"otherTeam.id",
 							),
 					)
-					.select((eb) => commonUserSelect(eb))
+					.select((eb) => [...commonUserSelect(eb), "User.country"])
 					.whereRef(
 						"TournamentMatchGameResult.matchId",
 						"=",
diff --git a/app/features/tournament-match/components/TournamentMatchTabs.tsx b/app/features/tournament-match/components/TournamentMatchTabs.tsx
index 0aa16e60a..588cdfb3a 100644
--- a/app/features/tournament-match/components/TournamentMatchTabs.tsx
+++ b/app/features/tournament-match/components/TournamentMatchTabs.tsx
@@ -6,7 +6,10 @@ import type {
 	TimelineMap,
 	TimelinePickBanEvent,
 } from "~/components/match-page/MatchTimeline";
+import type { WeaponPoolWeapon } from "~/components/match-page/WeaponPool";
+import type { ObjectiveTimelineEvent } from "~/components/ObjectiveTimeline";
 import { useUser } from "~/features/auth/core/user";
+import type { IngestedScoreboardData } from "~/features/scanner-ingest/core/Scoreboards";
 import { useTournament } from "~/features/tournament/tournament-context";
 import * as PickBan from "~/features/tournament-bracket/core/PickBan";
 import { matchSchema } from "~/features/tournament-bracket/tournament-bracket-schemas";
@@ -16,10 +19,14 @@ import { databaseTimestampToJavascriptTimestamp } from "~/utils/dates";
 import { tournamentTeamPage } from "~/utils/urls";
 import type { TournamentMatchLoaderData } from "../loaders/to.$id.matches.$mid.server";
 import { type MatchPageTeam, useMatch } from "../match-page-context";
+import { resolveTimelineWeapons } from "../tournament-match-utils";
 import { TournamentMatchActionPickBanTab } from "./TournamentMatchActionPickBanTab";
 import { TournamentMatchActionTab } from "./TournamentMatchActionTab";
 import { TournamentMatchAdminTab } from "./TournamentMatchAdminTab";
 
+/** Ingested scoreboard rows come winning team first, 4 players per side. */
+const SCOREBOARD_PLAYERS_PER_TEAM = 4;
+
 export function TournamentMatchTabs({
 	data,
 }: {
@@ -153,13 +160,28 @@ function resolveTimelineMaps(
 		const alphaRoster = resolveRoster(result.participants, opponentOneId);
 		const bravoRoster = resolveRoster(result.participants, opponentTwoId);
 
+		const ingestedScoreboard = data.ingestedScoreboards.find(
+			(scoreboard) => scoreboard.mapIndex === mapIndex,
+		);
+		const alphaIsWinner = result.winnerTeamId === opponentOneId;
+
 		const weaponFor = (userId: number) =>
 			data.reportedWeapons?.find(
 				(w) => w.mapIndex === mapIndex && w.userId === userId,
 			)?.weaponSplId ?? null;
 
-		const alphaWeapons = alphaRoster.map((u) => weaponFor(u.id));
-		const bravoWeapons = bravoRoster.map((u) => weaponFor(u.id));
+		const weaponsFor = (
+			roster: ReturnType<typeof resolveRoster>,
+			tournamentTeamId: number,
+		): WeaponPoolWeapon[] =>
+			resolveTimelineWeapons({
+				linkedWeapons: roster.map((u) => weaponFor(u.id)),
+				ingestedPlayers: ingestedScoreboard?.data.players ?? [],
+				tournamentTeamId,
+			});
+
+		const alphaWeapons = weaponsFor(alphaRoster, opponentOneId);
+		const bravoWeapons = weaponsFor(bravoRoster, opponentTwoId);
 		const hasAnyWeapon =
 			alphaWeapons.some((w) => w !== null) ||
 			bravoWeapons.some((w) => w !== null);
@@ -168,10 +190,7 @@ function resolveTimelineMaps(
 			stageId: result.stageId,
 			mode: result.mode,
 			timestamp: databaseTimestampToJavascriptTimestamp(result.createdAt),
-			winner:
-				result.winnerTeamId === opponentOneId
-					? ("ALPHA" as const)
-					: ("BRAVO" as const),
+			winner: alphaIsWinner ? ("ALPHA" as const) : ("BRAVO" as const),
 			rosters: {
 				alpha: alphaRoster,
 				bravo: bravoRoster,
@@ -180,10 +199,75 @@ function resolveTimelineMaps(
 				? { alpha: alphaWeapons, bravo: bravoWeapons }
 				: undefined,
 			ko: result.ko != null ? Boolean(result.ko) : undefined,
+			scoreboard: resolveTimelineScoreboard(ingestedScoreboard, alphaIsWinner),
 		};
 	});
 }
 
+function resolveTimelineScoreboard(
+	ingestedScoreboard:
+		| TournamentMatchLoaderData["ingestedScoreboards"][number]
+		| undefined,
+	alphaIsWinner: boolean,
+): TimelineMap["scoreboard"] {
+	if (!ingestedScoreboard) return undefined;
+
+	const toTimelinePlayers = (
+		players: (typeof ingestedScoreboard)["data"]["players"],
+	) =>
+		players.map((player) => ({
+			name: player.name,
+			weaponSplId: player.weaponSplId,
+			ka: player.ka,
+			d: player.d,
+			s: player.s,
+			paint: player.paint,
+			abilities: player.abilities,
+		}));
+
+	const winnerRows = ingestedScoreboard.data.players.slice(
+		0,
+		SCOREBOARD_PLAYERS_PER_TEAM,
+	);
+	const loserRows = ingestedScoreboard.data.players.slice(
+		SCOREBOARD_PLAYERS_PER_TEAM,
+	);
+	const [winnerScore, loserScore] = ingestedScoreboard.data.scores;
+
+	return {
+		scores: alphaIsWinner
+			? ([winnerScore, loserScore] as [number | null, number | null])
+			: ([loserScore, winnerScore] as [number | null, number | null]),
+		alpha: toTimelinePlayers(alphaIsWinner ? winnerRows : loserRows),
+		bravo: toTimelinePlayers(alphaIsWinner ? loserRows : winnerRows),
+		objective: toTimelineObjective(
+			ingestedScoreboard.data.objective,
+			alphaIsWinner,
+		),
+	};
+}
+
+/** Stored counter samples are winner-first; the timeline charts alpha-first. */
+function toTimelineObjective(
+	objective: IngestedScoreboardData["objective"],
+	alphaIsWinner: boolean,
+): ObjectiveTimelineEvent[] | undefined {
+	if (!objective) return undefined;
+
+	const alphaFirst = <T,>(pair: [T, T]): [T, T] =>
+		alphaIsWinner ? pair : [pair[1], pair[0]];
+
+	return objective.samples.map((sample) => ({
+		t: sample.t,
+		data: {
+			time: sample.time,
+			score: alphaFirst(sample.score),
+			penalty: alphaFirst(sample.penalty),
+			control: alphaFirst(sample.control),
+		},
+	}));
+}
+
 function resolveTimelinePickBanData(
 	data: TournamentMatchLoaderData,
 	opponentOneId: number,
diff --git a/app/features/tournament-match/loaders/to.$id.matches.$mid.server.ts b/app/features/tournament-match/loaders/to.$id.matches.$mid.server.ts
index b253814d9..208ba476e 100644
--- a/app/features/tournament-match/loaders/to.$id.matches.$mid.server.ts
+++ b/app/features/tournament-match/loaders/to.$id.matches.$mid.server.ts
@@ -2,6 +2,7 @@ import cachified from "@epic-web/cachified";
 import type { LoaderFunctionArgs } from "react-router";
 import * as ChatSystemMessage from "~/features/chat/ChatSystemMessage.server";
 import { chatAccessible } from "~/features/chat/chat-utils";
+import * as ScannerIngestRepository from "~/features/scanner-ingest/ScannerIngestRepository.server";
 import * as ReportedWeaponRepository from "~/features/sendouq-match/ReportedWeaponRepository.server";
 import * as TournamentRepository from "~/features/tournament/TournamentRepository.server";
 import * as TournamentTeamRepository from "~/features/tournament/TournamentTeamRepository.server";
@@ -68,6 +69,9 @@ export const loader = async ({ params }: LoaderFunctionArgs) => {
 	const reportedWeapons =
 		await ReportedWeaponRepository.findByTournamentMatchId(matchId);
 
+	const ingestedScoreboards =
+		await ScannerIngestRepository.findScoreboardsByTournamentMatchId(matchId);
+
 	const matchIsOver = Boolean(match.winnerSide);
 
 	if (
@@ -247,6 +251,7 @@ export const loader = async ({ params }: LoaderFunctionArgs) => {
 		},
 		results,
 		reportedWeapons,
+		ingestedScoreboards,
 		mapList,
 		teams: [match.opponentOne?.id, match.opponentTwo?.id].flatMap(
 			(tournamentTeamId) => {
diff --git a/app/features/tournament-match/tournament-match-utils.test.ts b/app/features/tournament-match/tournament-match-utils.test.ts
index e884be5ab..00a0ed831 100644
--- a/app/features/tournament-match/tournament-match-utils.test.ts
+++ b/app/features/tournament-match/tournament-match-utils.test.ts
@@ -1,5 +1,10 @@
-import { describe, expect, test } from "vitest";
-import { mapCountPlayedInSetWithCertainty } from "./tournament-match-utils";
+import { describe, expect, it, test } from "vitest";
+import type { IngestedScoreboardPlayer } from "~/features/scanner-ingest/core/Scoreboards";
+import type { MainWeaponId } from "~/modules/in-game-lists/types";
+import {
+	mapCountPlayedInSetWithCertainty,
+	resolveTimelineWeapons,
+} from "./tournament-match-utils";
 
 const mapCountParamsToResult: {
 	bestOf: number;
@@ -26,3 +31,91 @@ describe("mapCountPlayedInSetWithCertainty()", () => {
 		});
 	}
 });
+
+const TEAM_ID = 1;
+const OTHER_TEAM_ID = 2;
+
+function ingestedPlayer(
+	partial: Partial<IngestedScoreboardPlayer>,
+): IngestedScoreboardPlayer {
+	return {
+		name: "player",
+		tournamentTeamId: TEAM_ID,
+		weaponSplId: 10 as MainWeaponId,
+		ka: 10,
+		d: 5,
+		s: 2,
+		paint: 1000,
+		...partial,
+	};
+}
+
+describe("resolveTimelineWeapons()", () => {
+	it("passes reported weapons through and leaves gaps null without ingested rows", () => {
+		expect(
+			resolveTimelineWeapons({
+				linkedWeapons: [10, null, 20, null],
+				ingestedPlayers: [],
+				tournamentTeamId: TEAM_ID,
+			}),
+		).toEqual([10, null, 20, null]);
+	});
+
+	it("fills gaps from unaccounted ingested rows, marked unverified", () => {
+		expect(
+			resolveTimelineWeapons({
+				linkedWeapons: [10, null, null, null],
+				ingestedPlayers: [
+					ingestedPlayer({ weaponSplId: 30 }),
+					ingestedPlayer({ weaponSplId: 40 }),
+				],
+				tournamentTeamId: TEAM_ID,
+			}),
+		).toEqual([
+			10,
+			{ weaponSplId: 30, unverified: true },
+			{ weaponSplId: 40, unverified: true },
+			null,
+		]);
+	});
+
+	it("does not reuse an ingested row whose weapon a roster member already reported", () => {
+		expect(
+			resolveTimelineWeapons({
+				linkedWeapons: [10, null, null, null],
+				ingestedPlayers: [ingestedPlayer({ weaponSplId: 10 })],
+				tournamentTeamId: TEAM_ID,
+			}),
+		).toEqual([10, null, null, null]);
+	});
+
+	it("keeps the extra ingested row of a weapon two players ran when only one reported it", () => {
+		expect(
+			resolveTimelineWeapons({
+				linkedWeapons: [10, null, null, null],
+				ingestedPlayers: [
+					ingestedPlayer({ weaponSplId: 10 }),
+					ingestedPlayer({ weaponSplId: 10 }),
+				],
+				tournamentTeamId: TEAM_ID,
+			}),
+		).toEqual([10, { weaponSplId: 10, unverified: true }, null, null]);
+	});
+
+	it("skips ingested rows already attributed to a user, from the other team or without a weapon", () => {
+		expect(
+			resolveTimelineWeapons({
+				linkedWeapons: [null, null, null, null],
+				ingestedPlayers: [
+					ingestedPlayer({ weaponSplId: 30, userId: 42 }),
+					ingestedPlayer({
+						weaponSplId: 40,
+						tournamentTeamId: OTHER_TEAM_ID,
+					}),
+					ingestedPlayer({ weaponSplId: null }),
+				],
+				tournamentTeamId: TEAM_ID,
+			}),
+		).toEqual([null, null, null, null]);
+	});
+});
diff --git a/app/features/tournament-match/tournament-match-utils.ts b/app/features/tournament-match/tournament-match-utils.ts
index d7ba71bdd..8325e33f0 100644
--- a/app/features/tournament-match/tournament-match-utils.ts
+++ b/app/features/tournament-match/tournament-match-utils.ts
@@ -1,9 +1,15 @@
 import type { TFunction } from "i18next";
 import * as R from "remeda";
+import type { WeaponPoolWeapon } from "~/components/match-page/WeaponPool";
 import type { TournamentRoundMaps } from "~/db/tables-json";
+import type { IngestedScoreboardPlayer } from "~/features/scanner-ingest/core/Scoreboards";
 import type { Tournament } from "~/features/tournament-bracket/core/Tournament";
 import type { TournamentDataTeam } from "~/features/tournament-bracket/core/Tournament.server";
-import type { ModeShort, StageId } from "~/modules/in-game-lists/types";
+import type {
+	MainWeaponId,
+	ModeShort,
+	StageId,
+} from "~/modules/in-game-lists/types";
 import type { TournamentMaplistSource } from "~/modules/tournament-map-list-generator/types";
 import { logger } from "~/utils/logger";
 
@@ -88,6 +94,62 @@ export function pickInfoText({
 	return "";
 }
 
+/**
+ * One team's weapons for a map row: each roster member's reported weapon,
+ * with the gaps filled from the map's ingested scoreboard rows that no
+ * member accounts for. An ingested row without a user is only unaccounted
+ * for if no roster member already reported its weapon, otherwise it is that
+ * member's row and reusing it would show their weapon twice — a multiset
+ * count, so two ingested rows of a weapon survive one report of it.
+ *
+ * @param linkedWeapons per roster member, the weapon they reported for the map (null = none)
+ * @param ingestedPlayers the map's ingested scoreboard rows (empty when none ingested)
+ * @returns index-aligned with `linkedWeapons`; ingested fills are marked unverified
+ */
+export function resolveTimelineWeapons({
+	linkedWeapons,
+	ingestedPlayers,
+	tournamentTeamId,
+}: {
+	linkedWeapons: (MainWeaponId | null)[];
+	ingestedPlayers: IngestedScoreboardPlayer[];
+	tournamentTeamId: number;
+}): WeaponPoolWeapon[] {
+	const accountedForCounts = new Map<MainWeaponId, number>();
+	for (const weapon of linkedWeapons) {
+		if (weapon === null) continue;
+		accountedForCounts.set(weapon, (accountedForCounts.get(weapon) ?? 0) + 1);
+	}
+
+	const unlinkedIngested = ingestedPlayers.flatMap((player) => {
+		if (
+			player.userId !== undefined ||
+			player.weaponSplId === null ||
+			player.tournamentTeamId !== tournamentTeamId
+		) {
+			return [];
+		}
+
+		const accountedFor = accountedForCounts.get(player.weaponSplId) ?? 0;
+		if (accountedFor > 0) {
+			accountedForCounts.set(player.weaponSplId, accountedFor - 1);
+			return [];
+		}
+
+		return [player.weaponSplId];
+	});
+
+	let unlinkedIdx = 0;
+	return linkedWeapons.map((linked) => {
+		if (linked !== null) return linked;
+
+		const ingested = unlinkedIngested[unlinkedIdx++];
+		return ingested !== undefined
+			? { weaponSplId: ingested, unverified: true }
+			: null;
+	});
+}
+
 export function isSetOverByResults({
 	results,
 	count,
diff --git a/app/features/tournament/core/sets.server.ts b/app/features/tournament/core/sets.server.ts
index 3ccf04b77..01f4cae7c 100644
--- a/app/features/tournament/core/sets.server.ts
+++ b/app/features/tournament/core/sets.server.ts
@@ -34,7 +34,12 @@ export interface PlayedSet {
 		roster: Array<
 			Pick<
 				Tables["User"],
-				"id" | "username" | "discordAvatar" | "discordId" | "customUrl"
+				| "id"
+				| "username"
+				| "discordAvatar"
+				| "discordId"
+				| "customUrl"
+				| "country"
 			> & { customAvatarUrl: string | null }
 		>;
 	};
diff --git a/app/features/tournament/loaders/to.$id.teams.$tid.comps.server.ts b/app/features/tournament/loaders/to.$id.teams.$tid.comps.server.ts
new file mode 100644
index 000000000..e9ee5697c
--- /dev/null
+++ b/app/features/tournament/loaders/to.$id.teams.$tid.comps.server.ts
@@ -0,0 +1,105 @@
+import type { LoaderFunctionArgs } from "react-router";
+import { requireUser } from "~/features/auth/core/user.server";
+import * as RunComps from "~/features/img-export/core/RunComps";
+import * as ScannerIngestRepository from "~/features/scanner-ingest/ScannerIngestRepository.server";
+import * as ReportedWeaponRepository from "~/features/sendouq-match/ReportedWeaponRepository.server";
+import { tournamentDataCached } from "~/features/tournament-bracket/core/Tournament.server";
+import { tournamentTeamPageParamsSchema } from "~/features/tournament-bracket/tournament-bracket-schemas";
+import * as TournamentMatchRepository from "~/features/tournament-match/TournamentMatchRepository.server";
+import type { MainWeaponId } from "~/modules/in-game-lists/types";
+import type { SerializeFrom } from "~/utils/remix";
+import { forbidden, parseParams } from "~/utils/remix.server";
+
+export type TournamentTeamCompsLoaderData = SerializeFrom<typeof loader>;
+
+export const loader = async ({ params }: LoaderFunctionArgs) => {
+	const user = requireUser();
+	const { id: tournamentId, tid: tournamentTeamId } = parseParams({
+		params,
+		schema: tournamentTeamPageParamsSchema,
+	});
+
+	const tournament = await tournamentDataCached({ tournamentId });
+	const team = tournament?.ctx.teams.find(
+		(team) => team.id === tournamentTeamId,
+	);
+	if (!tournament || !team) {
+		throw new Response(null, { status: 404 });
+	}
+
+	if (!team.memberUserIds.includes(user.id)) {
+		throw forbidden();
+	}
+
+	const minMembersPerTeam = tournament.ctx.settings.minMembersPerTeam ?? 4;
+
+	const teamIdByUserId = new Map<number, number>();
+	for (const team of tournament.ctx.teams) {
+		for (const userId of team.memberUserIds) {
+			teamIdByUserId.set(userId, team.id);
+		}
+	}
+
+	const sets =
+		await TournamentMatchRepository.findByTournamentTeamId(tournamentTeamId);
+
+	const ownObservations: RunComps.CompObservation[] = [];
+	const opponentComps: Array<{
+		tournamentMatchId: number;
+		comp: MainWeaponId[];
+	}> = [];
+	let mapOrderOffset = 0;
+
+	for (const set of sets) {
+		const reported =
+			(await ReportedWeaponRepository.findByTournamentMatchId(
+				set.tournamentMatchId,
+			)) ?? [];
+		const scoreboards =
+			await ScannerIngestRepository.findScoreboardsByTournamentMatchId(
+				set.tournamentMatchId,
+			);
+
+		const opponentObservations: RunComps.CompObservation[] = [];
+
+		for (let mapIndex = 0; mapIndex < set.matches.length; mapIndex++) {
+			const mapOrder = mapOrderOffset + mapIndex;
+			const ingestedPlayers =
+				scoreboards.find((scoreboard) => scoreboard.mapIndex === mapIndex)?.data
+					.players ?? [];
+			const reportedForMap = reported.filter(
+				(row) => row.mapIndex === mapIndex,
+			);
+
+			const observationsFor = (teamId: number) =>
+				RunComps.mapObservations({
+					mapOrder,
+					reported: reportedForMap.filter(
+						(row) => teamIdByUserId.get(row.userId) === teamId,
+					),
+					ingested: ingestedPlayers.filter(
+						(player) => player.tournamentTeamId === teamId,
+					),
+				});
+
+			ownObservations.push(...observationsFor(tournamentTeamId));
+			opponentObservations.push(...observationsFor(set.otherTeamId));
+		}
+
+		mapOrderOffset += set.matches.length;
+
+		opponentComps.push({
+			tournamentMatchId: set.tournamentMatchId,
+			comp: fullCompOnly(RunComps.buildComp(opponentObservations)),
+		});
+	}
+
+	return {
+		ownComp: fullCompOnly(RunComps.buildComp(ownObservations)),
+		opponentComps,
+	};
+
+	function fullCompOnly(comp: MainWeaponId[]) {
+		return comp.length >= minMembersPerTeam ? comp : [];
+	}
+};
diff --git a/app/features/tournament/loaders/to.$id.teams.$tid.server.ts b/app/features/tournament/loaders/to.$id.teams.$tid.server.ts
index fc843e772..905fcee5d 100644
--- a/app/features/tournament/loaders/to.$id.teams.$tid.server.ts
+++ b/app/features/tournament/loaders/to.$id.teams.$tid.server.ts
@@ -79,6 +79,7 @@ export const loader = async ({ params }: LoaderFunctionArgs) => {
 			),
 		})),
 		winCounts: winCounts(sets),
+		participatedUsersCount: fullTournament.participatedUserIds?.length ?? 0,
 		division:
 			standingsResult.type === "multi"
 				? (standingsResult.standings.find((div) =>
diff --git a/app/features/tournament/routes/to.$id.teams.$tid.comps.ts b/app/features/tournament/routes/to.$id.teams.$tid.comps.ts
new file mode 100644
index 000000000..08f1b97e3
--- /dev/null
+++ b/app/features/tournament/routes/to.$id.teams.$tid.comps.ts
@@ -0,0 +1 @@
+export { loader } from "../loaders/to.$id.teams.$tid.comps.server";
diff --git a/app/features/tournament/routes/to.$id.teams.$tid.tsx b/app/features/tournament/routes/to.$id.teams.$tid.tsx
index 575c6a67f..2891f9c16 100644
--- a/app/features/tournament/routes/to.$id.teams.$tid.tsx
+++ b/app/features/tournament/routes/to.$id.teams.$tid.tsx
@@ -1,12 +1,16 @@
 import clsx from "clsx";
+import { HardDriveDownload } from "lucide-react";
 import { useTranslation } from "react-i18next";
 import type { MetaFunction } from "react-router";
-import { Link, useLoaderData } from "react-router";
+import { Link, useFetcher, useLoaderData } from "react-router";
 import { SendouButton } from "~/components/elements/Button";
 import { SendouPopover } from "~/components/elements/Popover";
 import { ModeImage, StageImage } from "~/components/Image";
 import { Placement } from "~/components/Placement";
 import { UserLink } from "~/components/UserLink";
+import { useUser } from "~/features/auth/core/user";
+import { ImageExportDialog } from "~/features/img-export/components/ImageExportDialog";
+import { TournamentRunGraphic } from "~/features/img-export/components/TournamentRunGraphic";
 import { useTournament } from "~/features/tournament/tournament-context";
 import type { TournamentTeamFull } from "~/features/tournament-bracket/core/Tournament.server";
 import type { TournamentMaplistSource } from "~/modules/tournament-map-list-generator/types";
@@ -14,9 +18,11 @@ import { metaTags } from "~/utils/remix";
 import {
 	teamPage,
 	tournamentMatchPage,
+	tournamentTeamCompsPage,
 	tournamentTeamPage,
 } from "~/utils/urls";
 import { TeamWithRoster } from "../components/TeamWithRoster";
+import type { TournamentTeamCompsLoaderData } from "../loaders/to.$id.teams.$tid.comps.server";
 import {
 	loader,
 	type TournamentTeamLoaderData,
@@ -74,6 +80,7 @@ export default function TournamentTeamPage() {
 					teamsCount={tournament.ctx.teams.length}
 				/>
 			) : null}
+			<RunImageExport />
 			<div className={styles.teamSets}>
 				{data.sets.map((set) => {
 					return <SetInfo key={set.tournamentMatchId} set={set} team={team} />;
@@ -153,6 +160,123 @@ function StatSquares({
 	);
 }
 
+function RunImageExport() {
+	const { t } = useTranslation(["common"]);
+	const user = useUser();
+	const data = useLoaderData<typeof loader>();
+	const tournament = useTournament();
+	const fetcher = useFetcher<TournamentTeamCompsLoaderData>();
+
+	const isOwnTeam = data.team.members.some(
+		(member) => member.userId === user?.id,
+	);
+
+	if (!isOwnTeam || typeof data.placement !== "number") return null;
+
+	const handleOpen = () => {
+		if (fetcher.state === "idle" && !fetcher.data) {
+			fetcher.load(
+				tournamentTeamCompsPage({
+					tournamentId: tournament.ctx.id,
+					tournamentTeamId: data.tournamentTeamId,
+				}),
+			);
+		}
+	};
+
+	const compByMatchId = new Map(
+		fetcher.data?.opponentComps.map((opponentComp) => [
+			opponentComp.tournamentMatchId,
+			opponentComp.comp,
+		]),
+	);
+
+	const activePlayers = data.activePlayers ?? [];
+	const ownPlayers =
+		activePlayers.length > 0
+			? data.team.members.filter((member) =>
+					activePlayers.includes(member.userId),
+				)
+			: data.team.members;
+
+	const graphicTeam = {
+		placement: data.placement,
+		name: data.team.name,
+		logoUrl: data.team.logoUrl ?? undefined,
+		players: ownPlayers.map((player) => ({
+			name: player.username,
+			countryCode: player.country ?? undefined,
+		})),
+		weapons: fetcher.data?.ownComp ?? [],
+	};
+
+	const matches = data.sets.map((set) => {
+		const { bracketName, roundNameWithoutMatchIdentifier } =
+			set.matchContextNames;
+		const opponentTeam = tournament.teamById(set.opponent.id);
+
+		return {
+			opponent: {
+				name: set.opponent.name,
+				logoUrl: opponentTeam?.logoUrl ?? undefined,
+				seed: opponentTeam?.seed,
+				players: set.opponent.roster.map((rosterUser) => ({
+					name: rosterUser.username,
+					countryCode: rosterUser.country ?? undefined,
+				})),
+				weapons: compByMatchId.get(set.tournamentMatchId) ?? [],
+			},
+			ownScore: set.score[0],
+			opponentScore: set.score[1],
+			roundName: roundNameWithoutMatchIdentifier ?? "",
+			bracketName: bracketName ?? "",
+		};
+	});
+
+	return (
+		<ImageExportDialog
+			trigger={
+				<SendouButton
+					size="small"
+					variant="outlined"
+					icon={<HardDriveDownload />}
+					onPress={handleOpen}
+					className="mx-auto"
+				>
+					{t("common:imageExport.export")}
+				</SendouButton>
+			}
+			heading={t("common:imageExport.export")}
+			filename={`tournament-${tournament.ctx.id}-run`}
+		>
+			{fetcher.data ? (
+				// xxx: pass seriesWins so 1st place finishes show the series titles row
+				<TournamentRunGraphic
+					tournamentId={tournament.ctx.id}
+					tournamentTeamId={data.tournamentTeamId}
+					tournamentName={tournament.ctx.name}
+					startTime={tournament.ctx.startsAt}
+					logoUrl={tournament.ctx.logoUrl ?? undefined}
+					tier={tournament.ctx.tier ?? undefined}
+					organization={
+						tournament.ctx.organization
+							? {
+									name: tournament.ctx.organization.name,
+									avatarUrl: tournament.ctx.organization.logoUrl ?? undefined,
+								}
+							: undefined
+					}
+					team={graphicTeam}
+					seed={tournament.teamById(data.tournamentTeamId)?.seed}
+					matches={matches}
+					teamsCount={tournament.ctx.teams.length}
+					playersCount={data.participatedUsersCount}
+				/>
+			) : null}
+		</ImageExportDialog>
+	);
+}
+
 function SetInfo({
 	set,
 	team,
diff --git a/app/features/vods/loaders/vods.new.server.ts b/app/features/vods/loaders/vods.new.server.ts
index adacb6f2c..e728e4be0 100644
--- a/app/features/vods/loaders/vods.new.server.ts
+++ b/app/features/vods/loaders/vods.new.server.ts
@@ -1,17 +1,27 @@
 import type { LoaderFunctionArgs } from "react-router";
 import { requireUser } from "~/features/auth/core/user.server";
+import {
+	type PrefillVodMatch,
+	prefillVodMatches,
+} from "~/features/scanner-ingest/core/VodMatches";
+import type { IngestVodPrefill } from "~/features/scanner-ingest/scanner-ingest-vod-schemas";
 import { notFoundIfNullish } from "~/utils/remix.server";
 import * as VodRepository from "../VodRepository.server";
+import type { videoMatchTypes } from "../vods-constants";
 import { vodsNewSearchParams } from "../vods-search-params";
-import { canEditVideo, vodToVideoBeingAdded } from "../vods-utils";
+import {
+	canEditVideo,
+	secondsToHoursMinutesSecondString,
+	vodToVideoBeingAdded,
+} from "../vods-utils";
 
 export const loader = async ({ url }: LoaderFunctionArgs) => {
 	const user = requireUser();
 
-	const { vod: vodId } = vodsNewSearchParams.parse(url);
+	const { vod: vodId, ingest } = vodsNewSearchParams.parse(url);
 
 	if (vodId === null) {
-		return { vodToEdit: null };
+		return { vodToEdit: null, vodPrefill: vodPrefillFromIngestParam(ingest) };
 	}
 
 	const vod = notFoundIfNullish(await VodRepository.findVodById(vodId));
@@ -25,8 +35,34 @@ export const loader = async ({ url }: LoaderFunctionArgs) => {
 				vodToEdit.pov?.type === "USER" ? vodToEdit.pov.userId : undefined,
 		})
 	) {
-		return { vodToEdit: null };
+		return { vodToEdit: null, vodPrefill: null };
 	}
 
-	return { vodToEdit: { ...vodToEdit, id: vod.id } };
+	return { vodToEdit: { ...vodToEdit, id: vod.id }, vodPrefill: null };
 };
+
+export interface VodPrefill {
+	type: (typeof videoMatchTypes)[number] | null;
+	matches: (Omit<PrefillVodMatch, "startsAt"> & { startsAt: string })[];
+}
+
+/**
+ * Maps the `ingest` search param the scanner VoD tab's "Add VoD" button
+ * fills (an ingestVodPrefillSchema payload, see
+ * ~/features/scanner-ingest/scanner-ingest-vod-schemas) into form-prefill data. Detection
+ * misses stay null for the user to fill; a malformed param has already
+ * decoded to null.
+ */
+function vodPrefillFromIngestParam(
+	ingest: IngestVodPrefill | null,
+): VodPrefill | null {
+	if (!ingest) return null;
+
+	return {
+		type: ingest.type ?? null,
+		matches: prefillVodMatches(ingest.matches).map((match) => ({
+			...match,
+			startsAt: secondsToHoursMinutesSecondString(match.startsAt),
+		})),
+	};
+}
diff --git a/app/features/vods/routes/vods.new.tsx b/app/features/vods/routes/vods.new.tsx
index 12c16197e..ff44c4651 100644
--- a/app/features/vods/routes/vods.new.tsx
+++ b/app/features/vods/routes/vods.new.tsx
@@ -12,7 +12,11 @@ import { YouTubeEmbed } from "~/components/YouTubeEmbed";
 import type { ArrayItemRenderContext, CustomFieldRenderProps } from "~/form";
 import type { WeaponPoolItem } from "~/form/fields/WeaponPoolFormField";
 import type { FormRenderProps } from "~/form/SendouForm";
-import { SendouForm, useFormFieldContext } from "~/form/SendouForm";
+import {
+	SendouForm,
+	useFormValue,
+	useOptionalFormFieldContext,
+} from "~/form/SendouForm";
 import { useIsomorphicLayoutEffect } from "~/hooks/useIsomorphicLayoutEffect";
 import { useRecentlyReportedWeapons } from "~/hooks/useRecentlyReportedWeapons";
 import type { MainWeaponId, StageId } from "~/modules/in-game-lists/types";
@@ -47,21 +51,23 @@ export default function NewVodPage() {
 
 	const defaultValues = data.vodToEdit
 		? vodToEditToFormValues(data.vodToEdit)
-		: {
-				type: "TOURNAMENT" as const,
-				teamSize: "4" as const,
-				pov: { type: "USER" as const },
-				matches: [
-					{
-						mode: "SZ" as const,
-						stageId: 1 as StageId,
-						startsAt: "",
-						weapon: undefined as MainWeaponId | undefined,
-						weaponsTeamOne: [] as WeaponPoolItem[],
-						weaponsTeamTwo: [] as WeaponPoolItem[],
-					},
-				],
-			};
+		: data.vodPrefill
+			? vodPrefillToFormValues(data.vodPrefill)
+			: {
+					type: "TOURNAMENT" as const,
+					teamSize: "4" as const,
+					pov: { type: "USER" as const },
+					matches: [
+						{
+							mode: "SZ" as const,
+							stageId: 1 as StageId,
+							startsAt: "",
+							weapon: undefined as MainWeaponId | undefined,
+							weaponsTeamOne: [] as WeaponPoolItem[],
+							weaponsTeamTwo: [] as WeaponPoolItem[],
+						},
+					],
+				};
 
 	return (
 		<Main halfWidth className={styles.layout}>
@@ -122,14 +128,56 @@ function vodToEditToFormValues(vodToEdit: VodToEdit) {
 	};
 }
 
+type VodPrefill = NonNullable<Awaited<ReturnType<typeof loader>>["vodPrefill"]>;
+
+/**
+ * Prefill from the emberz VoD parser's `ingest` search param (see the loader):
+ * detected matches with anything the detectors missed left at the blank form's
+ * defaults for the user to fill. CAST weapons are the alpha team's four slots
+ * then bravo's; unread slots are dropped so the remaining empty (required)
+ * selects surface them. A non-CAST VoD instead takes the POV player's weapon,
+ * which the scan only knows when a scoreboard identified their seat.
+ */
+function vodPrefillToFormValues(prefill: VodPrefill) {
+	const teamSize = 4;
+	const isCast = prefill.type === "CAST";
+
+	return {
+		type: prefill.type ?? ("TOURNAMENT" as const),
+		teamSize: "4" as const,
+		pov: { type: "USER" as const },
+		matches: prefill.matches.map((match) => ({
+			startsAt: match.startsAt,
+			mode: match.mode ?? ("SZ" as const),
+			stageId: (match.stageId ?? 1) as StageId,
+			weapon: isCast
+				? undefined
+				: ((match.povWeapon ?? undefined) as MainWeaponId | undefined),
+			weaponsTeamOne: isCast
+				? weaponPoolFromPrefill(match.weapons.slice(0, teamSize))
+				: ([] as WeaponPoolItem[]),
+			weaponsTeamTwo: isCast
+				? weaponPoolFromPrefill(match.weapons.slice(teamSize, teamSize * 2))
+				: ([] as WeaponPoolItem[]),
+		})),
+	};
+}
+
+function weaponPoolFromPrefill(
+	weapons: VodPrefill["matches"][number]["weapons"],
+): WeaponPoolItem[] {
+	return weapons
+		.filter((id): id is MainWeaponId => id !== null)
+		.map((id) => ({ id, isFavorite: false }));
+}
+
 function YouTubeEmbedWrapper({
 	onPlayerReady,
 }: {
 	onPlayerReady: (player: YT.Player) => void;
 }) {
-	const { values } = useFormFieldContext();
 	const floatWidth = useFloatingEmbedWidth();
-	const youtubeUrl = values.youtubeUrl as string | undefined;
+	const youtubeUrl = useFormValue("youtubeUrl") as string | undefined;
 
 	if (!youtubeUrl) return null;
 
@@ -197,8 +245,7 @@ function VodFormFields({
 	player: YT.Player | null;
 	FormField: VodFormFieldComponent;
 }) {
-	const { values } = useFormFieldContext();
-	const videoType = values.type as string;
+	const videoType = useFormValue("type") as string;
 
 	return (
 		<>
@@ -219,7 +266,6 @@ function VodFormFields({
 						index={ctx.index}
 						itemName={ctx.itemName}
 						values={ctx.values as unknown as MatchFieldValues}
-						formValues={ctx.formValues}
 						setItemField={
 							ctx.setItemField as <K extends keyof MatchFieldValues>(
 								field: K,
@@ -239,12 +285,12 @@ function VodFormFields({
 }
 
 function TeamSizeField({ FormField }: { FormField: VodFormFieldComponent }) {
-	const { setValueFromPrev } = useFormFieldContext();
+	const context = useOptionalFormFieldContext();
 
 	// The weapon count per match is tied to the team size, so any already picked
 	// weapons would no longer fit the new size.
 	const clearMatchWeapons = () => {
-		setValueFromPrev("matches", (prev) =>
+		context?.setValueFromPrev("matches", (prev) =>
 			((prev ?? []) as Array<Record<string, unknown>>).map((match) => ({
 				...match,
 				weaponsTeamOne: [],
@@ -345,7 +391,6 @@ function MatchFieldsetContent({
 	index,
 	itemName,
 	values: matchValues,
-	formValues,
 	setItemField,
 	canRemove,
 	remove,
@@ -355,6 +400,8 @@ function MatchFieldsetContent({
 }: MatchFieldsetContentProps) {
 	const { t } = useTranslation(["vods", "common"]);
 	const [currentTime, setCurrentTime] = useState<string>("");
+	const previousWeapons = (useFormValue(`matches[${index - 1}]`) ??
+		null) as MatchFieldValues | null;
 
 	useEffect(() => {
 		if (!player) return;
@@ -373,9 +420,6 @@ function MatchFieldsetContent({
 		return () => clearInterval(interval);
 	}, [player]);
 
-	const allMatches = formValues.matches as MatchFieldValues[];
-	const previousWeapons = index > 0 ? allMatches[index - 1] : null;
-
 	return (
 		<>
 			<div className="stack horizontal sm items-center justify-between">
@@ -418,7 +462,6 @@ function MatchFieldsetContent({
 					setItemField={setItemField}
 					videoType={videoType}
 					previousWeapons={previousWeapons}
-					formValues={formValues}
 				/>
 			</div>
 		</>
@@ -431,7 +474,6 @@ function WeaponsField({
 	setItemField,
 	videoType,
 	previousWeapons,
-	formValues,
 }: {
 	index: number;
 	matchValues: MatchFieldValues;
@@ -441,10 +483,9 @@ function WeaponsField({
 	) => void;
 	videoType: string;
 	previousWeapons: MatchFieldValues | null;
-	formValues: Record<string, unknown>;
 }) {
 	const { t } = useTranslation(["vods", "forms"]);
-	const teamSizeValue = formValues.teamSize as string | undefined;
+	const teamSizeValue = useFormValue("teamSize") as string | undefined;
 	const teamSize = teamSizeValue ? Number(teamSizeValue) : 4;
 	const { recentlyReportedWeapons, addRecentlyReportedWeapon } =
 		useRecentlyReportedWeapons();
diff --git a/app/features/vods/vods-search-params.test.ts b/app/features/vods/vods-search-params.test.ts
index bfa1ed311..4a0baea2c 100644
--- a/app/features/vods/vods-search-params.test.ts
+++ b/app/features/vods/vods-search-params.test.ts
@@ -36,9 +36,22 @@ describe("vodsSearchParams", () => {
 });
 
 describe("vodsNewSearchParams", () => {
+	const ingestMatch = {
+		startsAt: 30,
+		mode: "SZ" as const,
+		modeAssumed: true,
+		stage: 0 as const,
+		weapons: [40 as const, null],
+	};
+
 	it("round-trips", () => {
 		assertRoundTrips(vodsNewSearchParams, {
 			vod: [null, 1, 12345],
+			ingest: [
+				null,
+				{ matches: [ingestMatch] },
+				{ type: "CAST", matches: [ingestMatch, ingestMatch] },
+			],
 		});
 	});
 
@@ -49,6 +62,11 @@ describe("vodsNewSearchParams", () => {
 			["1.5"],
 			["abc"],
 		]);
+		assertDecodesToDefault(vodsNewSearchParams, "ingest", [
+			["not json"],
+			['{"matches":[]}'],
+			['{"matches":[{"startsAt":-1}]}'],
+		]);
 	});
 });
 
diff --git a/app/features/vods/vods-search-params.ts b/app/features/vods/vods-search-params.ts
index 9ed458fdd..790a3fcf2 100644
--- a/app/features/vods/vods-search-params.ts
+++ b/app/features/vods/vods-search-params.ts
@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { ingestVodPrefillSchema } from "~/features/scanner-ingest/scanner-ingest-vod-schemas";
 import { stageIds } from "~/modules/in-game-lists/stage-ids";
 import { mainWeaponIds } from "~/modules/in-game-lists/weapon-ids";
 import * as SearchParams from "~/modules/search-params/search-params";
@@ -28,6 +29,10 @@ export const vodsSearchParams = SearchParams.define({
 
 export const vodsNewSearchParams = SearchParams.define({
 	vod: SP.param(z.number().int().positive().nullable(), { loader: true }),
+	ingest: SP.json(ingestVodPrefillSchema.nullable(), {
+		loader: true,
+		compress: true,
+	}),
 });
 
 export const vodsVodSearchParams = SearchParams.define({
diff --git a/app/form/FormField.tsx b/app/form/FormField.tsx
index 1be9f20f4..509fb7bb6 100644
--- a/app/form/FormField.tsx
+++ b/app/form/FormField.tsx
@@ -51,7 +51,7 @@ import {
 
 export type { CustomFieldRenderProps };
 
-const EMPTY_FORM_VALUES: Record<string, unknown> = {};
+const EMPTY_ITEM_VALUES: Record<string, unknown> = {};
 
 interface FormFieldProps {
 	name: string;
@@ -147,19 +147,6 @@ export function FormField({
 		getClientError,
 	);
 
-	// Only object arrays with a custom render receive the whole-form values, so
-	// every other field type subscribes to a constant and skips re-rendering
-	// when unrelated fields change.
-	const needsAllValues =
-		formField.type === "array" && typeof children === "function";
-	const getAllValues = () =>
-		needsAllValues ? store.values : EMPTY_FORM_VALUES;
-	const formValues = React.useSyncExternalStore(
-		store.subscribe,
-		getAllValues,
-		getAllValues,
-	);
-
 	const serverError =
 		context?.serverErrors[name as keyof typeof context.serverErrors];
 	const hasSubmitted = context?.hasSubmitted ?? false;
@@ -471,35 +458,20 @@ export function FormField({
 				renderItem={(idx, itemName) => {
 					if (hasCustomRender && isObjectArray) {
 						const arrayValue = value as Record<string, unknown>[];
-						const itemValues = arrayValue[idx] ?? {};
-
-						const setItemField = (fieldName: string, fieldValue: unknown) => {
-							context?.setValueFromPrev(name, (prev) => {
-								const currentArray = (prev ?? []) as Record<string, unknown>[];
-								const newArray = [...currentArray];
-								newArray[idx] = {
-									...currentArray[idx],
-									[fieldName]: fieldValue,
-								};
-								return newArray;
-							});
-						};
-
-						const remove = () => {
-							handleChange(arrayValue.filter((_, i) => i !== idx));
-						};
 
 						return (
-							children as (props: ArrayItemRenderContext) => React.ReactNode
-						)({
-							index: idx,
-							itemName,
-							values: itemValues,
-							formValues,
-							setItemField,
-							canRemove: arrayValue.length > (formField.min ?? 0),
-							remove,
-						});
+							<ArrayItemCustomRender
+								arrayName={name}
+								index={idx}
+								itemName={itemName}
+								itemValues={arrayValue[idx] ?? EMPTY_ITEM_VALUES}
+								canRemove={arrayValue.length > (formField.min ?? 0)}
+								onArrayChange={handleChange as (v: unknown[]) => void}
+								renderChildren={
+									children as (props: ArrayItemRenderContext) => React.ReactNode
+								}
+							/>
+						);
 					}
 
 					return (
@@ -628,6 +600,68 @@ export function FormField({
 	);
 }
 
+interface ArrayItemCustomRenderProps {
+	arrayName: string;
+	index: number;
+	itemName: string;
+	itemValues: Record<string, unknown>;
+	canRemove: boolean;
+	onArrayChange: (value: unknown[]) => void;
+	renderChildren: (props: ArrayItemRenderContext) => React.ReactNode;
+}
+
+/**
+ * One custom-rendered array item, memoized so that a form edit re-renders only
+ * the item whose slice of the array changed — the array field itself re-renders
+ * on every write to the array. For this to hold, anything the item render reads
+ * from the form outside its own item must be subscribed to via `useFormValue`.
+ * The callbacks read the current array through the store instead of closing
+ * over it so a skipped re-render can never make them act on stale values.
+ */
+const ArrayItemCustomRender = React.memo(function ArrayItemCustomRender({
+	arrayName,
+	index,
+	itemName,
+	itemValues,
+	canRemove,
+	onArrayChange,
+	renderChildren,
+}: ArrayItemCustomRenderProps) {
+	const context = useOptionalFormFieldContext();
+
+	const setItemField = (fieldName: string, fieldValue: unknown) => {
+		context?.setValueFromPrev(arrayName, (prev) => {
+			const currentArray = (prev ?? []) as Record<string, unknown>[];
+			const newArray = [...currentArray];
+			newArray[index] = {
+				...currentArray[index],
+				[fieldName]: fieldValue,
+			};
+			return newArray;
+		});
+	};
+
+	const remove = () => {
+		if (!context) return;
+		const currentArray = (getNestedValue(context.store.values, arrayName) ??
+			[]) as unknown[];
+		onArrayChange(currentArray.filter((_, i) => i !== index));
+	};
+
+	return (
+		<>
+			{renderChildren({
+				index,
+				itemName,
+				values: itemValues,
+				setItemField,
+				canRemove,
+				remove,
+			})}
+		</>
+	);
+});
+
 function isArrayAppend(
 	values: Record<string, unknown>,
 	name: string,
diff --git a/app/form/SendouForm.browser.test.tsx b/app/form/SendouForm.browser.test.tsx
index 58f7e1554..421d31e35 100644
--- a/app/form/SendouForm.browser.test.tsx
+++ b/app/form/SendouForm.browser.test.tsx
@@ -23,6 +23,7 @@ import {
 	userSearch,
 } from "./fields";
 import { SendouForm, useFormFieldContext } from "./SendouForm";
+import type { ArrayItemRenderContext } from "./types";
 
 let mockFetcherData: { fieldErrors?: Record<string, string> } | undefined;
 
@@ -1461,6 +1462,269 @@ describe("SendouForm", () => {
 		});
 	});
 
+	describe("array field with custom-rendered items", () => {
+		const memberSchema = () =>
+			z.object({
+				members: array({
+					label: "labels.members",
+					min: 0,
+					max: 10,
+					field: fieldset({
+						fields: z.object({
+							name: textField({ label: "labels.name", maxLength: 100 }),
+							role: select({
+								label: "labels.staffRole",
+								items: [
+									{ value: "ORGANIZER", label: "options.staffRole.ORGANIZER" },
+									{ value: "STREAMER", label: "options.staffRole.STREAMER" },
+								],
+							}),
+						}),
+					}),
+				}),
+			});
+
+		function renderCustomArrayForm(options?: {
+			defaultValues?: Record<string, unknown>;
+			onApply?: (values: Record<string, unknown>) => void;
+		}) {
+			const router = createMemoryRouter(
+				[
+					{
+						path: "/",
+						element: (
+							<SendouForm
+								schema={memberSchema()}
+								defaultValues={options?.defaultValues}
+								onApply={options?.onApply}
+							>
+								<FormField name="members">
+									{(ctx: ArrayItemRenderContext) => (
+										<div>
+											<div data-testid={`member-${ctx.index}`}>
+												{ctx.values.name as string} /{" "}
+												{ctx.values.role as string}
+											</div>
+											<button
+												type="button"
+												onClick={() =>
+													ctx.setItemField(
+														"name",
+														`${ctx.values.name as string} edited`,
+													)
+												}
+											>
+												Edit member {ctx.index + 1}
+											</button>
+											{ctx.canRemove ? (
+												<button type="button" onClick={() => ctx.remove()}>
+													Remove member {ctx.index + 1}
+												</button>
+											) : null}
+										</div>
+									)}
+								</FormField>
+							</SendouForm>
+						),
+					},
+				],
+				{ initialEntries: ["/"] },
+			);
+
+			return render(<RouterProvider router={router} />);
+		}
+
+		const memberTestIds = (screen: Awaited<ReturnType<typeof render>>) =>
+			screen.container.querySelectorAll('[data-testid^="member-"]');
+
+		test("renders each item through the render function with its values", async () => {
+			const screen = await renderCustomArrayForm({
+				defaultValues: {
+					members: [
+						{ name: "Alice", role: "ORGANIZER" },
+						{ name: "Bob", role: "STREAMER" },
+					],
+				},
+			});
+
+			await expect
+				.element(screen.getByTestId("member-0"))
+				.toHaveTextContent("Alice / ORGANIZER");
+			await expect
+				.element(screen.getByTestId("member-1"))
+				.toHaveTextContent("Bob / STREAMER");
+		});
+
+		test("add button appends a new custom-rendered item", async () => {
+			const screen = await renderCustomArrayForm();
+
+			expect(memberTestIds(screen).length).toBe(1);
+
+			await screen.getByRole("button", { name: "Add" }).click();
+
+			await expect
+				.element(screen.getByTestId("member-1"))
+				.toHaveTextContent("/ ORGANIZER");
+			expect(memberTestIds(screen).length).toBe(2);
+		});
+
+		test("remove removes exactly the clicked item", async () => {
+			const onApply = vi.fn();
+			const screen = await renderCustomArrayForm({
+				defaultValues: {
+					members: [
+						{ name: "Alice", role: "ORGANIZER" },
+						{ name: "Bob", role: "STREAMER" },
+						{ name: "Carol", role: "STREAMER" },
+					],
+				},
+				onApply,
+			});
+
+			await screen.getByRole("button", { name: "Remove member 2" }).click();
+
+			expect(memberTestIds(screen).length).toBe(2);
+			await expect
+				.element(screen.getByTestId("member-0"))
+				.toHaveTextContent("Alice / ORGANIZER");
+			await expect
+				.element(screen.getByTestId("member-1"))
+				.toHaveTextContent("Carol / STREAMER");
+
+			await screen.getByRole("button", { name: "Submit" }).click();
+
+			expect(onApply).toHaveBeenCalledWith({
+				members: [
+					expect.objectContaining({ name: "Alice", role: "ORGANIZER" }),
+					expect.objectContaining({ name: "Carol", role: "STREAMER" }),
+				],
+			});
+		});
+
+		test("remove after add acts on the grown array, not a stale one", async () => {
+			const screen = await renderCustomArrayForm({
+				defaultValues: {
+					members: [
+						{ name: "Alice", role: "ORGANIZER" },
+						{ name: "Bob", role: "STREAMER" },
+					],
+				},
+			});
+
+			await screen.getByRole("button", { name: "Add" }).click();
+			await screen.getByRole("button", { name: "Remove member 1" }).click();
+
+			// A stale remove would have filtered the pre-add two-item array and
+			// dropped the freshly added row along with Alice.
+			expect(memberTestIds(screen).length).toBe(2);
+			await expect
+				.element(screen.getByTestId("member-0"))
+				.toHaveTextContent("Bob / STREAMER");
+		});
+
+		test("remove after editing a different item keeps the edit", async () => {
+			const onApply = vi.fn();
+			const screen = await renderCustomArrayForm({
+				defaultValues: {
+					members: [
+						{ name: "Alice", role: "ORGANIZER" },
+						{ name: "Bob", role: "STREAMER" },
+						{ name: "Carol", role: "STREAMER" },
+					],
+				},
+				onApply,
+			});
+
+			// Editing item 1 does not re-render the memoized item 3, so its remove
+			// callback must read the current array instead of a stale closure.
+			await screen.getByRole("button", { name: "Edit member 1" }).click();
+			await screen.getByRole("button", { name: "Remove member 3" }).click();
+
+			await screen.getByRole("button", { name: "Submit" }).click();
+
+			expect(onApply).toHaveBeenCalledWith({
+				members: [
+					expect.objectContaining({ name: "Alice edited", role: "ORGANIZER" }),
+					expect.objectContaining({ name: "Bob", role: "STREAMER" }),
+				],
+			});
+		});
+
+		test("setItemField updates only the targeted item's field", async () => {
+			const onApply = vi.fn();
+			const screen = await renderCustomArrayForm({
+				defaultValues: {
+					members: [
+						{ name: "Alice", role: "ORGANIZER" },
+						{ name: "Bob", role: "STREAMER" },
+					],
+				},
+				onApply,
+			});
+
+			await screen.getByRole("button", { name: "Edit member 2" }).click();
+
+			await expect
+				.element(screen.getByTestId("member-1"))
+				.toHaveTextContent("Bob edited / STREAMER");
+			await expect
+				.element(screen.getByTestId("member-0"))
+				.toHaveTextContent("Alice / ORGANIZER");
+
+			await screen.getByRole("button", { name: "Submit" }).click();
+
+			expect(onApply).toHaveBeenCalledWith({
+				members: [
+					expect.objectContaining({ name: "Alice", role: "ORGANIZER" }),
+					expect.objectContaining({ name: "Bob edited", role: "STREAMER" }),
+				],
+			});
+		});
+
+		test("itemName renders a nested FormField bound to the item", async () => {
+			const onApply = vi.fn();
+			const schema = memberSchema();
+
+			const router = createMemoryRouter(
+				[
+					{
+						path: "/",
+						element: (
+							<SendouForm
+								schema={schema}
+								defaultValues={{
+									members: [{ name: "Alice", role: "ORGANIZER" }],
+								}}
+								onApply={onApply}
+							>
+								<FormField name="members">
+									{(ctx: ArrayItemRenderContext) => (
+										<FormField name={`${ctx.itemName}.name`} />
+									)}
+								</FormField>
+							</SendouForm>
+						),
+					},
+				],
+				{ initialEntries: ["/"] },
+			);
+
+			const screen = await render(<RouterProvider router={router} />);
+			const input = screen.getByLabelText("Name");
+
+			await expect.element(input).toHaveValue("Alice");
+
+			await userEvent.type(input.element(), " Smith");
+			await screen.getByRole("button", { name: "Submit" }).click();
+
+			expect(onApply).toHaveBeenCalledWith({
+				members: [
+					expect.objectContaining({ name: "Alice Smith", role: "ORGANIZER" }),
+				],
+			});
+		});
+	});
+
 	describe("array field item removal preserves remaining items", () => {
 		test("removing a middle member preserves userSearch values of members below", async () => {
 			let latestValues: Record<string, unknown> = {};
diff --git a/app/form/SendouForm.tsx b/app/form/SendouForm.tsx
index 9ff964273..eb27b8d25 100644
--- a/app/form/SendouForm.tsx
+++ b/app/form/SendouForm.tsx
@@ -719,6 +719,20 @@ export function useOptionalFormFieldContext() {
 	return React.useContext(FormContext);
 }
 
+/**
+ * Subscribes to a single form value by (possibly nested) path, e.g. `"type"`
+ * or `"matches[2].mode"`. Unlike `useFormFieldContext` this re-renders only
+ * when that value changes, so prefer it for reading form state in components
+ * that should not re-render on every form edit.
+ */
+export function useFormValue(name: string): unknown {
+	const context = React.useContext(FormContext);
+	const store = context?.store ?? EMPTY_FORM_STORE;
+
+	const getValue = () => getNestedValue(store.values, name);
+	return React.useSyncExternalStore(store.subscribe, getValue, getValue);
+}
+
 /**
  * "First" error means first in DOM order, not first in error-map insertion
  * order — validation collects errors in schema order which does not have to
diff --git a/app/form/types.ts b/app/form/types.ts
index 3e62fd688..40dd61e8d 100644
--- a/app/form/types.ts
+++ b/app/form/types.ts
@@ -224,14 +224,10 @@ export type FormFieldProps<T extends FormField["type"]> = Omit<
 	onBlur: (latestValue?: unknown) => void;
 };
 
-export interface ArrayItemRenderContext<
-	TItem = Record<string, unknown>,
-	TForm = Record<string, unknown>,
-> {
+export interface ArrayItemRenderContext<TItem = Record<string, unknown>> {
 	index: number;
 	itemName: string;
 	values: TItem;
-	formValues: TForm;
 	setItemField: <K extends keyof TItem>(field: K, value: TItem[K]) => void;
 	canRemove: boolean;
 	remove: () => void;
diff --git a/app/routes.ts b/app/routes.ts
index cf0d4af58..d8f08167f 100644
--- a/app/routes.ts
+++ b/app/routes.ts
@@ -13,6 +13,9 @@ const devOnlyRoutes =
 					"/admin/generate-images",
 					"features/admin/routes/generate-images.tsx",
 				),
+				// verified against a production build (worker chunk, CDN fetch,
+				// React Compiler output); promote out of devOnlyRoutes on deploy
+				route("/scanner", "features/scanner/routes/scanner.tsx"),
 				route(
 					"/components",
 					"features/components-showcase/routes/components.tsx",
@@ -187,6 +190,10 @@ export default [
 			route("audit", "features/tournament-admin/routes/to.$id.admin.audit.tsx"),
 		]),
 		route("results", "features/tournament/routes/to.$id.results.tsx"),
+		route(
+			"teams/:tid/comps",
+			"features/tournament/routes/to.$id.teams.$tid.comps.ts",
+		),
 		route("streams", "features/tournament/routes/to.$id.streams.tsx"),
 
 		route("looking", "features/tournament-lfg/routes/to.$id.looking.tsx"),
@@ -352,6 +359,8 @@ export default [
 	route("/seed", "features/api-private/routes/seed.ts"),
 	route("/users", "features/api-private/routes/users.ts"),
 
+	route("/ingest", "features/scanner-ingest/routes/scanner-ingest.ts"),
+
 	layout("features/api-public/routes/api.layout.tsx", [
 		...prefix("/api", [
 			route(
diff --git a/app/styles/vars.css b/app/styles/vars.css
index 793bcaaa0..2ef18328a 100644
--- a/app/styles/vars.css
+++ b/app/styles/vars.css
@@ -129,6 +129,9 @@ html.dark [data-custom-theme],
 	--color-error: oklch(65% 0.25 10);
 	--color-error-high: oklch(87% 0.07 10);
 
+	--color-chart-alpha: #da5b76;
+	--color-chart-bravo: #6572e4;
+
 	--field-icon-checkbox: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='24' height='24' viewBox='0 0 24 24' fill='none' stroke='rgb(20, 20, 20)' stroke-width='4' stroke-linecap='round' stroke-linejoin='round'%3E%3Cpolyline points='20 6 9 17 4 12'%3E%3C/polyline%3E%3C/svg%3E");
 	--field-icon-minus: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='24' height='24' viewBox='0 0 24 24' fill='none' stroke='rgb(20, 20, 20)' stroke-width='4' stroke-linecap='round' stroke-linejoin='round'%3E%3Cline x1='5' y1='12' x2='19' y2='12'%3E%3C/line%3E%3C/svg%3E");
 	--field-icon-chevron: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='24' height='24' viewBox='0 0 24 24' fill='none' stroke='rgb(145, 145, 145)' stroke-width='2' stroke-linecap='round' stroke-linejoin='round'%3E%3Cpolyline points='6 9 12 15 18 9'%3E%3C/polyline%3E%3C/svg%3E");
@@ -181,6 +184,9 @@ html.light [data-custom-theme],
 	--color-error: oklch(65.223% 0.22164 5.216);
 	--color-error-high: oklch(41.268% 0.15511 8.446);
 
+	--color-chart-alpha: #b82851;
+	--color-chart-bravo: #4246c2;
+
 	--field-icon-checkbox: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='24' height='24' viewBox='0 0 24 24' fill='none' stroke='rgb(255, 255, 255)' stroke-width='4' stroke-linecap='round' stroke-linejoin='round'%3E%3Cpolyline points='20 6 9 17 4 12'%3E%3C/polyline%3E%3C/svg%3E");
 	--field-icon-minus: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='24' height='24' viewBox='0 0 24 24' fill='none' stroke='rgb(255, 255, 255)' stroke-width='4' stroke-linecap='round' stroke-linejoin='round'%3E%3Cline x1='5' y1='12' x2='19' y2='12'%3E%3C/line%3E%3C/svg%3E");
 	--field-icon-chevron: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='24' height='24' viewBox='0 0 24 24' fill='none' stroke='rgb(90, 90, 90)' stroke-width='2' stroke-linecap='round' stroke-linejoin='round'%3E%3Cpolyline points='6 9 12 15 18 9'%3E%3C/polyline%3E%3C/svg%3E");
diff --git a/app/utils/urls.ts b/app/utils/urls.ts
index 0c509131f..3c347b01f 100644
--- a/app/utils/urls.ts
+++ b/app/utils/urls.ts
@@ -167,6 +167,7 @@ export const TIER_LIST_MAKER_URL = "/tier-list-maker";
 export const ANALYZER_URL = "/analyzer";
 export const COMP_ANALYZER_URL = "/comp-analyzer";
 export const OBJECT_DAMAGE_CALCULATOR_URL = "/object-damage-calculator";
+export const SCANNER_PAGE = "/scanner";
 export const VODS_PAGE = "/vods";
 export const LEADERBOARDS_PAGE = "/leaderboards";
 export const LINKS_PAGE = "/links";
@@ -418,6 +419,13 @@ export const tournamentTeamPage = ({
 	tournamentId: number;
 	tournamentTeamId: number;
 }) => `/to/${tournamentId}/teams/${tournamentTeamId}`;
+export const tournamentTeamCompsPage = ({
+	tournamentId,
+	tournamentTeamId,
+}: {
+	tournamentId: number;
+	tournamentTeamId: number;
+}) => `${tournamentTeamPage({ tournamentId, tournamentTeamId })}/comps`;
 export const tournamentInfoPage = (tournamentId: number) =>
 	`/to/${tournamentId}/info`;
 export const tournamentRegisterPage = (tournamentId: number) =>
diff --git a/biome.json b/biome.json
index 4eaa48c2a..9ba034c55 100644
--- a/biome.json
+++ b/biome.json
@@ -7,6 +7,8 @@
 			"!scripts/output/**/*",
 			"!app/db/seed/data/placements.json",
 			"!build/**/*",
+			"!app/features/scanner/tests/fixtures",
+			"!public/scanner/**/*",
 			"!test-results/**/*",
 			"!playwright-report/**/*",
 			"!.react-router/**/*",
diff --git a/locales/da/common.json b/locales/da/common.json
index f657eaaf8..ceec40aed 100644
--- a/locales/da/common.json
+++ b/locales/da/common.json
@@ -183,6 +183,9 @@
 	"actions.settings": "",
 	"actions.reveal": "",
 	"noResults": "",
+	"objectiveTimeline.timeLeft": "",
+	"objectiveTimeline.penalty": "",
+	"objectiveTimeline.inControl": "",
 	"maps.createMapList": "Lav bane-liste",
 	"maps.halfSz": "50% DD",
 	"maps.mapPool": "Banepulje",
diff --git a/locales/da/q.json b/locales/da/q.json
index 85a07f026..ec8cd71c4 100644
--- a/locales/da/q.json
+++ b/locales/da/q.json
@@ -181,6 +181,12 @@
 	"match.timeline.explainer.ban": "",
 	"match.timeline.explainer.substitution": "",
 	"match.timeline.explainer.spChange": "",
+	"match.timeline.points": "",
+	"match.timeline.details": "",
+	"match.timeline.stats.paint": "",
+	"match.timeline.stats.kills": "",
+	"match.timeline.stats.deaths": "",
+	"match.timeline.stats.specials": "",
 	"match.waitingForConfirmation": "",
 	"match.undoReport": "",
 	"match.weapon.yourWeapon": "",
diff --git a/locales/de/common.json b/locales/de/common.json
index 0b71ae248..3c79b9c2e 100644
--- a/locales/de/common.json
+++ b/locales/de/common.json
@@ -183,6 +183,9 @@
 	"actions.settings": "",
 	"actions.reveal": "",
 	"noResults": "",
+	"objectiveTimeline.timeLeft": "",
+	"objectiveTimeline.penalty": "",
+	"objectiveTimeline.inControl": "",
 	"maps.createMapList": "Arenen-Liste erstellen",
 	"maps.halfSz": "50% Herrschaft",
 	"maps.mapPool": "Arenen-Pool",
diff --git a/locales/de/q.json b/locales/de/q.json
index 9a8713b34..a860eda1b 100644
--- a/locales/de/q.json
+++ b/locales/de/q.json
@@ -181,6 +181,12 @@
 	"match.timeline.explainer.ban": "",
 	"match.timeline.explainer.substitution": "",
 	"match.timeline.explainer.spChange": "",
+	"match.timeline.points": "",
+	"match.timeline.details": "",
+	"match.timeline.stats.paint": "",
+	"match.timeline.stats.kills": "",
+	"match.timeline.stats.deaths": "",
+	"match.timeline.stats.specials": "",
 	"match.waitingForConfirmation": "",
 	"match.undoReport": "",
 	"match.weapon.yourWeapon": "",
diff --git a/locales/en/common.json b/locales/en/common.json
index 2eccb2eea..1d00170a3 100644
--- a/locales/en/common.json
+++ b/locales/en/common.json
@@ -183,6 +183,9 @@
 	"actions.settings": "Settings",
 	"actions.reveal": "Reveal",
 	"noResults": "No results",
+	"objectiveTimeline.timeLeft": "{{time}} left",
+	"objectiveTimeline.penalty": "+{{value}} penalty",
+	"objectiveTimeline.inControl": "In control",
 	"maps.createMapList": "Create map list",
 	"maps.halfSz": "50% SZ",
 	"maps.mapPool": "Map pool",
diff --git a/locales/en/q.json b/locales/en/q.json
index 0d94aab00..f649f87dc 100644
--- a/locales/en/q.json
+++ b/locales/en/q.json
@@ -181,6 +181,12 @@
 	"match.timeline.explainer.ban": "Map or mode banned",
 	"match.timeline.explainer.substitution": "Player substitution",
 	"match.timeline.explainer.spChange": "SP updates",
+	"match.timeline.points": "{{points}}p",
+	"match.timeline.details": "Details",
+	"match.timeline.stats.paint": "Paint",
+	"match.timeline.stats.kills": "K/A",
+	"match.timeline.stats.deaths": "D",
+	"match.timeline.stats.specials": "S",
 	"match.waitingForConfirmation": "Waiting for the other team to confirm the result",
 	"match.undoReport": "Undo report",
 	"match.weapon.yourWeapon": "Your weapon",
diff --git a/locales/es-ES/common.json b/locales/es-ES/common.json
index fb976e04c..6b0f7d28e 100644
--- a/locales/es-ES/common.json
+++ b/locales/es-ES/common.json
@@ -183,6 +183,9 @@
 	"actions.settings": "Ajustes",
 	"actions.reveal": "Revelar",
 	"noResults": "Sin resultados",
+	"objectiveTimeline.timeLeft": "",
+	"objectiveTimeline.penalty": "",
+	"objectiveTimeline.inControl": "",
 	"maps.createMapList": "Crear lista de mapas",
 	"maps.halfSz": "50% Pintazonas",
 	"maps.mapPool": "Rotación de mapas",
diff --git a/locales/es-ES/q.json b/locales/es-ES/q.json
index c02017b4a..3618b4ff1 100644
--- a/locales/es-ES/q.json
+++ b/locales/es-ES/q.json
@@ -181,6 +181,12 @@
 	"match.timeline.explainer.ban": "Mapa o modo baneado",
 	"match.timeline.explainer.substitution": "Sustitución de jugador",
 	"match.timeline.explainer.spChange": "Actualizaciones de SP",
+	"match.timeline.points": "",
+	"match.timeline.details": "",
+	"match.timeline.stats.paint": "",
+	"match.timeline.stats.kills": "",
+	"match.timeline.stats.deaths": "",
+	"match.timeline.stats.specials": "",
 	"match.waitingForConfirmation": "Esperando a que el otro equipo confirme el resultado",
 	"match.undoReport": "Deshacer reporte",
 	"match.weapon.yourWeapon": "Tu arma",
diff --git a/locales/es-US/common.json b/locales/es-US/common.json
index 7be4ebffd..72931ba36 100644
--- a/locales/es-US/common.json
+++ b/locales/es-US/common.json
@@ -183,6 +183,9 @@
 	"actions.settings": "",
 	"actions.reveal": "",
 	"noResults": "",
+	"objectiveTimeline.timeLeft": "",
+	"objectiveTimeline.penalty": "",
+	"objectiveTimeline.inControl": "",
 	"maps.createMapList": "Crear lista de escenarios",
 	"maps.halfSz": "50% Pintazonas",
 	"maps.mapPool": "Grupo de escenario",
diff --git a/locales/es-US/q.json b/locales/es-US/q.json
index 83243ea58..7324869ea 100644
--- a/locales/es-US/q.json
+++ b/locales/es-US/q.json
@@ -181,6 +181,12 @@
 	"match.timeline.explainer.ban": "",
 	"match.timeline.explainer.substitution": "",
 	"match.timeline.explainer.spChange": "",
+	"match.timeline.points": "",
+	"match.timeline.details": "",
+	"match.timeline.stats.paint": "",
+	"match.timeline.stats.kills": "",
+	"match.timeline.stats.deaths": "",
+	"match.timeline.stats.specials": "",
 	"match.waitingForConfirmation": "",
 	"match.undoReport": "",
 	"match.weapon.yourWeapon": "",
diff --git a/locales/fr-CA/common.json b/locales/fr-CA/common.json
index 8d798a448..a40db3692 100644
--- a/locales/fr-CA/common.json
+++ b/locales/fr-CA/common.json
@@ -183,6 +183,9 @@
 	"actions.settings": "",
 	"actions.reveal": "",
 	"noResults": "",
+	"objectiveTimeline.timeLeft": "",
+	"objectiveTimeline.penalty": "",
+	"objectiveTimeline.inControl": "",
 	"maps.createMapList": "Créer une liste de stages",
 	"maps.halfSz": "50% DdZ",
 	"maps.mapPool": "Pool de stages",
diff --git a/locales/fr-CA/q.json b/locales/fr-CA/q.json
index b8a5a2413..54f13a278 100644
--- a/locales/fr-CA/q.json
+++ b/locales/fr-CA/q.json
@@ -181,6 +181,12 @@
 	"match.timeline.explainer.ban": "",
 	"match.timeline.explainer.substitution": "",
 	"match.timeline.explainer.spChange": "",
+	"match.timeline.points": "",
+	"match.timeline.details": "",
+	"match.timeline.stats.paint": "",
+	"match.timeline.stats.kills": "",
+	"match.timeline.stats.deaths": "",
+	"match.timeline.stats.specials": "",
 	"match.waitingForConfirmation": "",
 	"match.undoReport": "",
 	"match.weapon.yourWeapon": "",
diff --git a/locales/fr-EU/common.json b/locales/fr-EU/common.json
index c7b04ce74..0a404d144 100644
--- a/locales/fr-EU/common.json
+++ b/locales/fr-EU/common.json
@@ -183,6 +183,9 @@
 	"actions.settings": "",
 	"actions.reveal": "",
 	"noResults": "Aucun résultats",
+	"objectiveTimeline.timeLeft": "",
+	"objectiveTimeline.penalty": "",
+	"objectiveTimeline.inControl": "",
 	"maps.createMapList": "Créer une liste de stages",
 	"maps.halfSz": "50% DdZ",
 	"maps.mapPool": "Pool de stages",
diff --git a/locales/fr-EU/q.json b/locales/fr-EU/q.json
index 877a560e7..3fa68443a 100644
--- a/locales/fr-EU/q.json
+++ b/locales/fr-EU/q.json
@@ -181,6 +181,12 @@
 	"match.timeline.explainer.ban": "",
 	"match.timeline.explainer.substitution": "",
 	"match.timeline.explainer.spChange": "",
+	"match.timeline.points": "",
+	"match.timeline.details": "",
+	"match.timeline.stats.paint": "",
+	"match.timeline.stats.kills": "",
+	"match.timeline.stats.deaths": "",
+	"match.timeline.stats.specials": "",
 	"match.waitingForConfirmation": "",
 	"match.undoReport": "",
 	"match.weapon.yourWeapon": "",
diff --git a/locales/he/common.json b/locales/he/common.json
index ee88563de..f8279c427 100644
--- a/locales/he/common.json
+++ b/locales/he/common.json
@@ -183,6 +183,9 @@
 	"actions.settings": "",
 	"actions.reveal": "",
 	"noResults": "",
+	"objectiveTimeline.timeLeft": "",
+	"objectiveTimeline.penalty": "",
+	"objectiveTimeline.inControl": "",
 	"maps.createMapList": "יצירת רשימת מפות",
 	"maps.halfSz": "50% SZ",
 	"maps.mapPool": "מאגר מפות",
diff --git a/locales/he/q.json b/locales/he/q.json
index 1629db379..5cc660ca5 100644
--- a/locales/he/q.json
+++ b/locales/he/q.json
@@ -181,6 +181,12 @@
 	"match.timeline.explainer.ban": "",
 	"match.timeline.explainer.substitution": "",
 	"match.timeline.explainer.spChange": "",
+	"match.timeline.points": "",
+	"match.timeline.details": "",
+	"match.timeline.stats.paint": "",
+	"match.timeline.stats.kills": "",
+	"match.timeline.stats.deaths": "",
+	"match.timeline.stats.specials": "",
 	"match.waitingForConfirmation": "",
 	"match.undoReport": "",
 	"match.weapon.yourWeapon": "",
diff --git a/locales/it/common.json b/locales/it/common.json
index d85f28b7f..22cc4e1eb 100644
--- a/locales/it/common.json
+++ b/locales/it/common.json
@@ -183,6 +183,9 @@
 	"actions.settings": "",
 	"actions.reveal": "",
 	"noResults": "",
+	"objectiveTimeline.timeLeft": "",
+	"objectiveTimeline.penalty": "",
+	"objectiveTimeline.inControl": "",
 	"maps.createMapList": "Crea lista scenari",
 	"maps.halfSz": "50% ZS",
 	"maps.mapPool": "Pool di scenari",
diff --git a/locales/it/q.json b/locales/it/q.json
index 1ab669121..cd83b9cd5 100644
--- a/locales/it/q.json
+++ b/locales/it/q.json
@@ -181,6 +181,12 @@
 	"match.timeline.explainer.ban": "",
 	"match.timeline.explainer.substitution": "",
 	"match.timeline.explainer.spChange": "",
+	"match.timeline.points": "",
+	"match.timeline.details": "",
+	"match.timeline.stats.paint": "",
+	"match.timeline.stats.kills": "",
+	"match.timeline.stats.deaths": "",
+	"match.timeline.stats.specials": "",
 	"match.waitingForConfirmation": "",
 	"match.undoReport": "",
 	"match.weapon.yourWeapon": "",
diff --git a/locales/ja/common.json b/locales/ja/common.json
index fb7bf943e..880dea3f5 100644
--- a/locales/ja/common.json
+++ b/locales/ja/common.json
@@ -183,6 +183,9 @@
 	"actions.settings": "設定",
 	"actions.reveal": "表示",
 	"noResults": "戦績無し",
+	"objectiveTimeline.timeLeft": "",
+	"objectiveTimeline.penalty": "",
+	"objectiveTimeline.inControl": "",
 	"maps.createMapList": "ステージリストを作る",
 	"maps.halfSz": "半分エリア",
 	"maps.mapPool": "選択可能なステージ",
diff --git a/locales/ja/q.json b/locales/ja/q.json
index 7b9596e7a..cabbb3199 100644
--- a/locales/ja/q.json
+++ b/locales/ja/q.json
@@ -181,6 +181,12 @@
 	"match.timeline.explainer.ban": "",
 	"match.timeline.explainer.substitution": "",
 	"match.timeline.explainer.spChange": "",
+	"match.timeline.points": "",
+	"match.timeline.details": "",
+	"match.timeline.stats.paint": "",
+	"match.timeline.stats.kills": "",
+	"match.timeline.stats.deaths": "",
+	"match.timeline.stats.specials": "",
 	"match.waitingForConfirmation": "",
 	"match.undoReport": "",
 	"match.weapon.yourWeapon": "",
diff --git a/locales/ko/common.json b/locales/ko/common.json
index 469a3a21b..8a7afd1dc 100644
--- a/locales/ko/common.json
+++ b/locales/ko/common.json
@@ -183,6 +183,9 @@
 	"actions.settings": "",
 	"actions.reveal": "",
 	"noResults": "",
+	"objectiveTimeline.timeLeft": "",
+	"objectiveTimeline.penalty": "",
+	"objectiveTimeline.inControl": "",
 	"maps.createMapList": "맵 목록 생성",
 	"maps.halfSz": "에어리어 50%",
 	"maps.mapPool": "맵 풀",
diff --git a/locales/ko/q.json b/locales/ko/q.json
index 9a8713b34..a860eda1b 100644
--- a/locales/ko/q.json
+++ b/locales/ko/q.json
@@ -181,6 +181,12 @@
 	"match.timeline.explainer.ban": "",
 	"match.timeline.explainer.substitution": "",
 	"match.timeline.explainer.spChange": "",
+	"match.timeline.points": "",
+	"match.timeline.details": "",
+	"match.timeline.stats.paint": "",
+	"match.timeline.stats.kills": "",
+	"match.timeline.stats.deaths": "",
+	"match.timeline.stats.specials": "",
 	"match.waitingForConfirmation": "",
 	"match.undoReport": "",
 	"match.weapon.yourWeapon": "",
diff --git a/locales/nl/common.json b/locales/nl/common.json
index 8531789d6..879c40925 100644
--- a/locales/nl/common.json
+++ b/locales/nl/common.json
@@ -183,6 +183,9 @@
 	"actions.settings": "",
 	"actions.reveal": "",
 	"noResults": "",
+	"objectiveTimeline.timeLeft": "",
+	"objectiveTimeline.penalty": "",
+	"objectiveTimeline.inControl": "",
 	"maps.createMapList": "Maak levellijst",
 	"maps.halfSz": "50% SZ",
 	"maps.mapPool": "Beschikbare levels",
diff --git a/locales/nl/q.json b/locales/nl/q.json
index 9a8713b34..a860eda1b 100644
--- a/locales/nl/q.json
+++ b/locales/nl/q.json
@@ -181,6 +181,12 @@
 	"match.timeline.explainer.ban": "",
 	"match.timeline.explainer.substitution": "",
 	"match.timeline.explainer.spChange": "",
+	"match.timeline.points": "",
+	"match.timeline.details": "",
+	"match.timeline.stats.paint": "",
+	"match.timeline.stats.kills": "",
+	"match.timeline.stats.deaths": "",
+	"match.timeline.stats.specials": "",
 	"match.waitingForConfirmation": "",
 	"match.undoReport": "",
 	"match.weapon.yourWeapon": "",
diff --git a/locales/pl/common.json b/locales/pl/common.json
index 52115bc5e..d26d7e96d 100644
--- a/locales/pl/common.json
+++ b/locales/pl/common.json
@@ -183,6 +183,9 @@
 	"actions.settings": "",
 	"actions.reveal": "",
 	"noResults": "",
+	"objectiveTimeline.timeLeft": "",
+	"objectiveTimeline.penalty": "",
+	"objectiveTimeline.inControl": "",
 	"maps.createMapList": "Stwórz liste map",
 	"maps.halfSz": "50% SZ",
 	"maps.mapPool": "Pula map",
diff --git a/locales/pl/q.json b/locales/pl/q.json
index 9a8713b34..a860eda1b 100644
--- a/locales/pl/q.json
+++ b/locales/pl/q.json
@@ -181,6 +181,12 @@
 	"match.timeline.explainer.ban": "",
 	"match.timeline.explainer.substitution": "",
 	"match.timeline.explainer.spChange": "",
+	"match.timeline.points": "",
+	"match.timeline.details": "",
+	"match.timeline.stats.paint": "",
+	"match.timeline.stats.kills": "",
+	"match.timeline.stats.deaths": "",
+	"match.timeline.stats.specials": "",
 	"match.waitingForConfirmation": "",
 	"match.undoReport": "",
 	"match.weapon.yourWeapon": "",
diff --git a/locales/pt-BR/common.json b/locales/pt-BR/common.json
index 1fc26caee..7a530fcf7 100644
--- a/locales/pt-BR/common.json
+++ b/locales/pt-BR/common.json
@@ -183,6 +183,9 @@
 	"actions.settings": "",
 	"actions.reveal": "",
 	"noResults": "",
+	"objectiveTimeline.timeLeft": "",
+	"objectiveTimeline.penalty": "",
+	"objectiveTimeline.inControl": "",
 	"maps.createMapList": "Criar lista de mapas",
 	"maps.halfSz": "50% Zones",
 	"maps.mapPool": "Seleção de mapas",
diff --git a/locales/pt-BR/q.json b/locales/pt-BR/q.json
index 02fd76cc0..1b9aef7bb 100644
--- a/locales/pt-BR/q.json
+++ b/locales/pt-BR/q.json
@@ -181,6 +181,12 @@
 	"match.timeline.explainer.ban": "",
 	"match.timeline.explainer.substitution": "",
 	"match.timeline.explainer.spChange": "",
+	"match.timeline.points": "",
+	"match.timeline.details": "",
+	"match.timeline.stats.paint": "",
+	"match.timeline.stats.kills": "",
+	"match.timeline.stats.deaths": "",
+	"match.timeline.stats.specials": "",
 	"match.waitingForConfirmation": "",
 	"match.undoReport": "",
 	"match.weapon.yourWeapon": "",
diff --git a/locales/ru/common.json b/locales/ru/common.json
index ff5100391..b6bec184d 100644
--- a/locales/ru/common.json
+++ b/locales/ru/common.json
@@ -183,6 +183,9 @@
 	"actions.settings": "",
 	"actions.reveal": "",
 	"noResults": "Нет результатов",
+	"objectiveTimeline.timeLeft": "",
+	"objectiveTimeline.penalty": "",
+	"objectiveTimeline.inControl": "",
 	"maps.createMapList": "Создать список карт",
 	"maps.halfSz": "50% Зон",
 	"maps.mapPool": "Пул карт",
diff --git a/locales/ru/q.json b/locales/ru/q.json
index 7559a8284..48a9f181c 100644
--- a/locales/ru/q.json
+++ b/locales/ru/q.json
@@ -181,6 +181,12 @@
 	"match.timeline.explainer.ban": "",
 	"match.timeline.explainer.substitution": "",
 	"match.timeline.explainer.spChange": "",
+	"match.timeline.points": "",
+	"match.timeline.details": "",
+	"match.timeline.stats.paint": "",
+	"match.timeline.stats.kills": "",
+	"match.timeline.stats.deaths": "",
+	"match.timeline.stats.specials": "",
 	"match.waitingForConfirmation": "",
 	"match.undoReport": "",
 	"match.weapon.yourWeapon": "",
diff --git a/locales/zh/common.json b/locales/zh/common.json
index af2f3506d..c83d115a0 100644
--- a/locales/zh/common.json
+++ b/locales/zh/common.json
@@ -183,6 +183,9 @@
 	"actions.settings": "设置",
 	"actions.reveal": "显示",
 	"noResults": "无结果",
+	"objectiveTimeline.timeLeft": "",
+	"objectiveTimeline.penalty": "",
+	"objectiveTimeline.inControl": "",
 	"maps.createMapList": "创建场地列表",
 	"maps.halfSz": "真格区域占 50%",
 	"maps.mapPool": "场地池",
diff --git a/locales/zh/q.json b/locales/zh/q.json
index 6a477ed68..2a9a96628 100644
--- a/locales/zh/q.json
+++ b/locales/zh/q.json
@@ -181,6 +181,12 @@
 	"match.timeline.explainer.ban": "已禁用场地或模式",
 	"match.timeline.explainer.substitution": "选手轮换",
 	"match.timeline.explainer.spChange": "SP 更新",
+	"match.timeline.points": "",
+	"match.timeline.details": "",
+	"match.timeline.stats.paint": "",
+	"match.timeline.stats.kills": "",
+	"match.timeline.stats.deaths": "",
+	"match.timeline.stats.specials": "",
 	"match.waitingForConfirmation": "正在等待对方队伍确认结果",
 	"match.undoReport": "撤销汇报",
 	"match.weapon.yourWeapon": "您的武器",
diff --git a/migrations/20260804000000-ingest.ts b/migrations/20260804000000-ingest.ts
new file mode 100644
index 000000000..db1d710b3
--- /dev/null
+++ b/migrations/20260804000000-ingest.ts
@@ -0,0 +1,95 @@
+import { type Kysely, sql } from "kysely";
+
+/** Tables for scanner-ingested matches and their links to reported game results */
+export async function up(db: Kysely<any>): Promise<void> {
+	// kysely does not wrap sqlite migrations in a transaction, so do it here
+	await db.transaction().execute(async (trx) => {
+		await trx.schema
+			.createTable("IngestedMatch")
+			.addColumn("id", "integer", (col) => col.primaryKey())
+			.addColumn("povUserId", "integer", (col) =>
+				col.references("User.id").onDelete("set null"),
+			)
+			.addColumn("submitterUserId", "integer", (col) =>
+				col.references("User.id").onDelete("set null"),
+			)
+			.addColumn("playedAt", "integer")
+			.addColumn("data", "text", (col) => col.notNull())
+			.addColumn("matchHash", "text", (col) => col.unique().notNull())
+			.addColumn("tournamentIdHint", "integer", (col) =>
+				col.references("Tournament.id").onDelete("set null"),
+			)
+			.addColumn("groupMatchIdHint", "integer", (col) =>
+				col.references("GroupMatch.id").onDelete("set null"),
+			)
+			.addColumn("createdAt", "integer", (col) =>
+				col.notNull().defaultTo(sql`(strftime('%s', 'now'))`),
+			)
+			// every table in this schema is strict
+			.modifyEnd(sql`strict`)
+			.execute();
+
+		await trx.schema
+			.createIndex("ingested_match_pov_user_id_played_at")
+			.on("IngestedMatch")
+			.columns(["povUserId", "playedAt"])
+			.execute();
+
+		await trx.schema
+			.createIndex("ingested_match_tournament_id_hint")
+			.on("IngestedMatch")
+			.column("tournamentIdHint")
+			.execute();
+
+		await trx.schema
+			.createIndex("ingested_match_group_match_id_hint")
+			.on("IngestedMatch")
+			.column("groupMatchIdHint")
+			.execute();
+
+		await trx.schema
+			.createTable("IngestedMatchLink")
+			.addColumn("id", "integer", (col) => col.primaryKey())
+			.addColumn("ingestedMatchId", "integer", (col) =>
+				col
+					.notNull()
+					.unique()
+					.references("IngestedMatch.id")
+					.onDelete("cascade"),
+			)
+			.addColumn("tournamentMatchGameResultId", "integer", (col) =>
+				col.references("TournamentMatchGameResult.id").onDelete("cascade"),
+			)
+			.addColumn("groupMatchMapId", "integer", (col) =>
+				col.references("GroupMatchMap.id").onDelete("cascade"),
+			)
+			.addColumn("createdAt", "integer", (col) =>
+				col.notNull().defaultTo(sql`(strftime('%s', 'now'))`),
+			)
+			.addCheckConstraint(
+				"ingested_match_link_one_target",
+				sql`("tournamentMatchGameResultId" is not null) + ("groupMatchMapId" is not null) = 1`,
+			)
+			.modifyEnd(sql`strict`)
+			.execute();
+
+		await trx.schema
+			.createIndex("ingested_match_link_tournament_match_game_result_id")
+			.on("IngestedMatchLink")
+			.column("tournamentMatchGameResultId")
+			.execute();
+
+		await trx.schema
+			.createIndex("ingested_match_link_group_match_map_id")
+			.on("IngestedMatchLink")
+			.column("groupMatchMapId")
+			.execute();
+
+		// ingest context resolution prunes reported games by a createdAt window
+		await trx.schema
+			.createIndex("tournament_match_game_result_created_at")
+			.on("TournamentMatchGameResult")
+			.column("createdAt")
+			.execute();
+	});
+}
diff --git a/package.json b/package.json
index 91adbffec..186b432c7 100644
--- a/package.json
+++ b/package.json
@@ -30,6 +30,14 @@
 		"test:unit:browser": "cross-env VITE_SITE_DOMAIN=http://localhost:5173 BROWSER_HEADLESS=true vitest --silent=passed-only run",
 		"test:browser:ui": "cross-env VITE_SITE_DOMAIN=http://localhost:5173 vitest --silent=passed-only --project browser",
 		"test:unit:browser:ui": "cross-env VITE_SITE_DOMAIN=http://localhost:5173 vitest --silent=passed-only",
+		"test:scanner": "vitest run --project scanner",
+		"scanner:report": "vite-node -c scripts/scanner/vite-node.config.ts scripts/scanner/report.ts",
+		"scanner:fixtures": "vite-node -c scripts/scanner/vite-node.config.ts scripts/scanner/run-fixtures.ts",
+		"scanner:replay": "vite-node -c scripts/scanner/vite-node.config.ts scripts/scanner/replay-frames.ts",
+		"scanner:bootstrap-atlas": "vite-node -c scripts/scanner/vite-node.config.ts scripts/scanner/bootstrap-atlas-from-fixture.ts",
+		"scanner:build-glyph-atlas": "vite-node -c scripts/scanner/vite-node.config.ts scripts/scanner/build-glyph-atlas.ts",
+		"scanner:build-localized-entries": "vite-node -c scripts/scanner/vite-node.config.ts scripts/scanner/build-localized-entries.ts",
+		"scanner:build-planner-signatures": "vite-node -c scripts/scanner/vite-node.config.ts scripts/scanner/build-planner-signatures.ts",
 		"test:e2e": "playwright test",
 		"test:e2e:flaky-detect": "playwright test --repeat-each=10 --max-failures=1",
 		"check-plural-collapse": "node --experimental-strip-types scripts/collapse-single-plural-keys.ts --check",
@@ -53,6 +61,7 @@
 		"@react-router/node": "8.3.0",
 		"@react-router/serve": "8.1.0",
 		"@sentry/react-router": "10.69.0",
+		"@techstark/opencv-js": "5.0.0-release.1",
 		"@tldraw/tldraw": "3.12.1",
 		"@zumer/snapdom": "2.23.1",
 		"chart.js": "4.5.1",
@@ -69,6 +78,7 @@
 		"kysely": "0.29.0",
 		"lucide-react": "1.28.0",
 		"markdown-to-jsx": "9.9.0",
+		"mediabunny": "1.50.6",
 		"nanoid": "6.0.0",
 		"node-cron": "4.6.0",
 		"nprogress": "0.2.0",
@@ -100,6 +110,7 @@
 	"devDependencies": {
 		"@babel/preset-typescript": "7.29.7",
 		"@biomejs/biome": "2.5.6",
+		"@napi-rs/canvas": "1.0.2",
 		"@playwright/test": "1.62.0",
 		"@react-router/dev": "8.3.0",
 		"@types/node": "26.1.2",
@@ -114,6 +125,7 @@
 		"i18next-locales-sync": "2.1.1",
 		"knip": "6.29.0",
 		"magic-string": "1.1.0",
+		"sharp": "^0.35.3",
 		"sql-formatter": "15.8.2",
 		"typescript": "7.0.2",
 		"vite": "8.1.5",
diff --git a/patches/@techstark__opencv-js@5.0.0-release.1.patch b/patches/@techstark__opencv-js@5.0.0-release.1.patch
new file mode 100644
index 000000000..855fcf8c1
--- /dev/null
+++ b/patches/@techstark__opencv-js@5.0.0-release.1.patch
@@ -0,0 +1,13 @@
+diff --git a/dist/opencv.js b/dist/opencv.js
+index 0ad5948a0b3bc2caa751c80b17a8ccd237dd3a70..2346f10d411eafc727a78f5c847e089612f7021b 100644
+--- a/dist/opencv.js
++++ b/dist/opencv.js
+@@ -8,7 +8,7 @@
+     // Node. Does not work with strict CommonJS, but
+     // only CommonJS-like environments that support module.exports,
+     // like Node.
+-    module.exports = factory();
++    module.exports = { cvReadyPromise: factory() };
+   } else if (typeof window === 'object') {
+     // Browser globals
+     root.cv = factory();
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 5c8bd2451..b5ba99109 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -6,6 +6,7 @@ settings:
 
 patchedDependencies:
   '@react-router/serve@8.1.0': 0073d0acad5d92eea7ef30ed24d736df9f4d59e204f8358ecb3b06b9ea9d8738
+  '@techstark/opencv-js@5.0.0-release.1': 0e23b4243e8e2f88294c00eefdf8dfc3624f59442bd0c8d075be89a8136144f3
   kysely@0.29.0: a3e94339939b1be5b70610601e96fff19ed5678aab525de24b52dfc5212c686a
 
 importers:
@@ -51,6 +52,9 @@ importers:
       '@sentry/react-router':
         specifier: 10.69.0
         version: 10.69.0(@opentelemetry/core@2.10.0(@opentelemetry/api@1.9.1))(@react-router/node@8.3.0(react-router@8.3.0(react-dom@19.2.8(react@19.2.8))(react@19.2.8))(typescript@7.0.2))(react-router@8.3.0(react-dom@19.2.8(react@19.2.8))(react@19.2.8))(react@19.2.8)
+      '@techstark/opencv-js':
+        specifier: 5.0.0-release.1
+        version: 5.0.0-release.1(patch_hash=0e23b4243e8e2f88294c00eefdf8dfc3624f59442bd0c8d075be89a8136144f3)
       '@tldraw/tldraw':
         specifier: 3.12.1
         version: 3.12.1(@types/react-dom@19.2.3(@types/react@19.2.17))(@types/react@19.2.17)(react-dom@19.2.8(react@19.2.8))(react@19.2.8)
@@ -99,6 +103,9 @@ importers:
       markdown-to-jsx:
         specifier: 9.9.0
         version: 9.9.0(react@19.2.8)
+      mediabunny:
+        specifier: 1.50.6
+        version: 1.50.6
       nanoid:
         specifier: 6.0.0
         version: 6.0.0
@@ -187,6 +194,9 @@ importers:
       '@biomejs/biome':
         specifier: 2.5.6
         version: 2.5.6
+      '@napi-rs/canvas':
+        specifier: 1.0.2
+        version: 1.0.2
       '@playwright/test':
         specifier: 1.62.0
         version: 1.62.0
@@ -229,6 +239,9 @@ importers:
       magic-string:
         specifier: 1.1.0
         version: 1.1.0
+      sharp:
+        specifier: ^0.35.3
+        version: 0.35.3(@types/node@26.1.2)
       sql-formatter:
         specifier: 15.8.2
         version: 15.8.2
@@ -626,6 +639,168 @@ packages:
   '@floating-ui/utils@0.2.11':
     resolution: {integrity: sha512-RiB/yIh78pcIxl6lLMG0CgBXAZ2Y0eVHqMPYugu+9U0AeT6YBeiJpf7lbdJNIugFP5SIjwNRgo4DhR1Qxi26Gg==}
 
+  '@img/colour@1.1.0':
+    resolution: {integrity: sha512-Td76q7j57o/tLVdgS746cYARfSyxk8iEfRxewL9h4OMzYhbW4TAcppl0mT4eyqXddh6L/jwoM75mo7ixa/pCeQ==}
+    engines: {node: '>=18'}
+
+  '@img/sharp-darwin-arm64@0.35.3':
+    resolution: {integrity: sha512-RMnFX7YQsMoh7lWfcM4NEHHymBX/rLuKNPVM84XE9ONPcaSCDgE7CHIHpSgPcO2xcRthgBy1HfNO319mwhIAkg==}
+    engines: {node: '>=20.9.0'}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@img/sharp-darwin-x64@0.35.3':
+    resolution: {integrity: sha512-Xo+5uFBtLN0BKqieTxiFzFPQAUlBbbH5iBKyRX/z1JrbnYsHTfKJnUfL8+p2TPXr1pXqao4eeL4Rl144uDpK9w==}
+    engines: {node: '>=20.9.0'}
+    cpu: [x64]
+    os: [darwin]
+
+  '@img/sharp-freebsd-wasm32@0.35.3':
+    resolution: {integrity: sha512-lUxcqWIj2wMQ9BrwNjngcr1gWUr5xgaGThBRqPPalIC2n67Cqj1uPh8NnA/ZhAg8hUbKl+kVHKwgUIwe6ZYPrg==}
+    engines: {node: '>=20.9.0'}
+    os: [freebsd]
+
+  '@img/sharp-libvips-darwin-arm64@1.3.2':
+    resolution: {integrity: sha512-9J6ypZFpQBj4YnePGoq/S38w6nz+vqg5WZLrLGY4YuSemdMq47GMLBPO42MzwdGwpg/agZ7xzZcFHa48xlywfg==}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@img/sharp-libvips-darwin-x64@1.3.2':
+    resolution: {integrity: sha512-m2pW1n6cns9VaubNwsZ+c3CRYjxNQWgJ5gPlnL1nbBcpkBvFm6SCFN5o0psFHI8w9n11NKhFkeEDns98tiqbEw==}
+    cpu: [x64]
+    os: [darwin]
+
+  '@img/sharp-libvips-linux-arm64@1.3.2':
+    resolution: {integrity: sha512-dqVSFynCox4C/J8kT16V7SIFAns0IjgLwkvYT7p8LQVmJ5OS5b6tI9IGflxTeuBS//zXeFIUbwt5dwxyZ17cnA==}
+    cpu: [arm64]
+    os: [linux]
+    libc: [glibc]
+
+  '@img/sharp-libvips-linux-arm@1.3.2':
+    resolution: {integrity: sha512-1eMLzy92I4J6rmi4mAT8yC3HxOtniyGELlzGbNMLLeqe052ahFQ0h6LFq+lh5DsDIdYViIDst08abvSbcEdLXQ==}
+    cpu: [arm]
+    os: [linux]
+    libc: [glibc]
+
+  '@img/sharp-libvips-linux-ppc64@1.3.2':
+    resolution: {integrity: sha512-3z0NHDxD6n5I9gc05U1eW1AyRm+Gznzq3naMrthPNqE6oYykcogW0l/jfpJdjYnuNl8R7yI9pNbE1XiUeyq0Aw==}
+    cpu: [ppc64]
+    os: [linux]
+    libc: [glibc]
+
+  '@img/sharp-libvips-linux-riscv64@1.3.2':
+    resolution: {integrity: sha512-bsb4rI+NldGOsXuej2r8OdSS8+zXDVaCWxyWrcv6kneTOlgAHtZABRzBBCwdsPiD90J4myNJuHpg6kA20ImW/w==}
+    cpu: [riscv64]
+    os: [linux]
+    libc: [glibc]
+
+  '@img/sharp-libvips-linux-s390x@1.3.2':
+    resolution: {integrity: sha512-/ABshyj8gCpyIrNXnHn4LorDJ0HHm1VhXPBlxZ8zAtfVPAaSafXPGn+sUSIRiwaSBy0mmFjSjiXI5mkcwdChKQ==}
+    cpu: [s390x]
+    os: [linux]
+    libc: [glibc]
+
+  '@img/sharp-libvips-linux-x64@1.3.2':
+    resolution: {integrity: sha512-ITPEtgffGJ0S6G9dRyw/366tJQqFRcHWPHhC+Stpg3Z8AEMrDrTr2lhdz4f/Y/HMbRh//7Z5mBzEpVdi62Oc3w==}
+    cpu: [x64]
+    os: [linux]
+    libc: [glibc]
+
+  '@img/sharp-libvips-linuxmusl-arm64@1.3.2':
+    resolution: {integrity: sha512-zE9EdiUzUmg5mDT5a1rk5fYJ6GWPloTwWBYDS14naqHsL+EaMpDj1AWnpLgh3u0YCORv2Tt50wrcrpYqkP97Kw==}
+    cpu: [arm64]
+    os: [linux]
+    libc: [musl]
+
+  '@img/sharp-libvips-linuxmusl-x64@1.3.2':
+    resolution: {integrity: sha512-m0lrLiUt+lBYnCFr8qV/65yMR4E/c7/wf78I5eKTdkEakFAlZ9QlzEM3QIhhAwVeUhLAHLcCq7a7Vszq/oFNZQ==}
+    cpu: [x64]
+    os: [linux]
+    libc: [musl]
+
+  '@img/sharp-linux-arm64@0.35.3':
+    resolution: {integrity: sha512-QgKDspHPnrU+GQ55XPhGwyhC8acLVOOSyAvo1oVfFmrIXLkDNmGWzAfDZ4xK8oSA1qBQrALcHX0G5UZni/SuFQ==}
+    engines: {node: '>=20.9.0'}
+    cpu: [arm64]
+    os: [linux]
+    libc: [glibc]
+
+  '@img/sharp-linux-arm@0.35.3':
+    resolution: {integrity: sha512-affVWCTLooy8TSxbDx2qkzuDeaWLNVBA+P//FNBirHsXpP2fuBhk5AuboYUnrDnzoXes8GFjpTx0SBFOCRg+FA==}
+    engines: {node: '>=20.9.0'}
+    cpu: [arm]
+    os: [linux]
+    libc: [glibc]
+
+  '@img/sharp-linux-ppc64@0.35.3':
+    resolution: {integrity: sha512-sMd8rDxmpLOwv/7N44klFjOD5DUO7FLdjiXDI0hoxYaf7Ar262dQIEkosE98bps+5HPLtp/EvNqeqQtOycP/IA==}
+    engines: {node: '>=20.9.0'}
+    cpu: [ppc64]
+    os: [linux]
+    libc: [glibc]
+
+  '@img/sharp-linux-riscv64@0.35.3':
+    resolution: {integrity: sha512-0Eob78yjlYPfL5vMNWAW55l3R9Y6BQS/gOfe0ZcP9mEz9ohhKSt4im1hayiknXgf8AWrFqMvJcKIdmLmEe7yeQ==}
+    engines: {node: '>=20.9.0'}
+    cpu: [riscv64]
+    os: [linux]
+    libc: [glibc]
+
+  '@img/sharp-linux-s390x@0.35.3':
+    resolution: {integrity: sha512-KgAxQ0DxpNOq1rG2t5cgTgShJFGSuU7XO45cqC+1NVOuZnP6tlgZRuSYOfNupGkHID0o3cJOsw4DVeJpMovcGw==}
+    engines: {node: '>=20.9.0'}
+    cpu: [s390x]
+    os: [linux]
+    libc: [glibc]
+
+  '@img/sharp-linux-x64@0.35.3':
+    resolution: {integrity: sha512-8pqvxubL2PGdhlPy6GLqzDYMUjyRmKAwKHYKixpdJYBUK7PJ0C029XdsnpFIdgRZG68fZiGdHVWcKPvtiPB4cA==}
+    engines: {node: '>=20.9.0'}
+    cpu: [x64]
+    os: [linux]
+    libc: [glibc]
+
+  '@img/sharp-linuxmusl-arm64@0.35.3':
+    resolution: {integrity: sha512-Vz0iQjzzcSX3HCbfwFfCSG/9SCIqyO0mH2sXyiHaAYfBk0cRsCWXRyQYX0ovCK/PAQBbTzQ0dsPQHh5MAFL59w==}
+    engines: {node: '>=20.9.0'}
+    cpu: [arm64]
+    os: [linux]
+    libc: [musl]
+
+  '@img/sharp-linuxmusl-x64@0.35.3':
+    resolution: {integrity: sha512-6O1NPKcDVj9QEdg7Hx549EX8U0rp6yXQERqru6yRN7fGBn32UvIRJUlWnk+8xDCiG76hXVBbX82NZ/ZKr0euIg==}
+    engines: {node: '>=20.9.0'}
+    cpu: [x64]
+    os: [linux]
+    libc: [musl]
+
+  '@img/sharp-wasm32@0.35.3':
+    resolution: {integrity: sha512-cZ0XkcYGpHZkqW6iCkqTcmUC0CD9DhD5d/qeZlZkfRBn6GnHniZXLUo5+9xw8Iv76YE6LQFN9YNBlKREcCG76w==}
+    engines: {node: '>=20.9.0'}
+
+  '@img/sharp-webcontainers-wasm32@0.35.3':
+    resolution: {integrity: sha512-2rnq7bX3NzeR2T4YWgz8qiG4h3TSdMe+vN1iQXpJleSJ3SM5zQ8Fy2SyyXAWlbxpEZ2Y+Z4u1BePgJEYbSy80Q==}
+    engines: {node: '>=20.9.0'}
+    cpu: [wasm32]
+
+  '@img/sharp-win32-arm64@0.35.3':
+    resolution: {integrity: sha512-4bPwFdMbeC4JQ8L8LOyWp6nsHcboP5fxkp6iPOXz2Vg49R42TuMs2whkJ5OAP4/Ul035qOzy0AecOF9VOscn4w==}
+    engines: {node: '>=20.9.0'}
+    cpu: [arm64]
+    os: [win32]
+
+  '@img/sharp-win32-ia32@0.35.3':
+    resolution: {integrity: sha512-r53mXsBN6lFUDiST764SvgwUdHAqM4rPAiDzAmf4fLoB6X/rkfyTrLCg6+g17wJJiCmB3JYgHuUldCWUIRFSXw==}
+    engines: {node: ^20.9.0}
+    cpu: [ia32]
+    os: [win32]
+
+  '@img/sharp-win32-x64@0.35.3':
+    resolution: {integrity: sha512-D4y1vNeZrIIJCN+uHaWVtH86B+aCrdMYYjicy9pXHvbGZeGYLLSd3wdVuC37FxVXlU1ARsk84eKWfWMXGYEqvA==}
+    engines: {node: '>=20.9.0'}
+    cpu: [x64]
+    os: [win32]
+
   '@internationalized/date@3.12.2':
     resolution: {integrity: sha512-FY1Y+H64NDs+HAF6omlnWxm3mEpfgaCSWtL5l551ZZfImA+kGjPFgrnJrGjH6lfmLL0g8Z/mBu1R3kufeCp6Jw==}
 
@@ -657,6 +832,81 @@ packages:
   '@mjackson/headers@0.10.0':
     resolution: {integrity: sha512-U1Eu1gF979k7ZoIBsJyD+T5l9MjtPONsZfoXfktsQHPJD0s7SokBGx+tLKDLsOY+gzVYAWS0yRFDNY8cgbQzWQ==}
 
+  '@napi-rs/canvas-android-arm64@1.0.2':
+    resolution: {integrity: sha512-IMXKVQod0ol4vt3gmClUfXz4JAgHYESGPCUqmH3lQxBoL0K/2greJaQE1HVBVxWWFKfLc4OLZVdxg7kXVyXv+g==}
+    engines: {node: '>= 10'}
+    cpu: [arm64]
+    os: [android]
+
+  '@napi-rs/canvas-darwin-arm64@1.0.2':
+    resolution: {integrity: sha512-Sc8tPi6cF+5lqOzCCKFALJHhDiRwyMzTPYm3bbhdXsOunU0lQO5f05ucyOzN2r55I23Hg5bsjH63uSCvWp3EgQ==}
+    engines: {node: '>= 10'}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@napi-rs/canvas-darwin-x64@1.0.2':
+    resolution: {integrity: sha512-niDXZ9LhKB1zLrUdYB64RHQFDGz9rr0eGx061qtJJU3U20EMMIx28ADF5fVYbhtOgkWQrBjFicfaye1yM0U62A==}
+    engines: {node: '>= 10'}
+    cpu: [x64]
+    os: [darwin]
+
+  '@napi-rs/canvas-linux-arm-gnueabihf@1.0.2':
+    resolution: {integrity: sha512-sgatQL9JxGRH/Amzcvu0P3t8Am3duou74CisfuJ41Dwt8cWy723z/9KZ8LlgmxfypEwEZxSTNFJtU8d281lmhQ==}
+    engines: {node: '>= 10'}
+    cpu: [arm]
+    os: [linux]
+
+  '@napi-rs/canvas-linux-arm64-gnu@1.0.2':
+    resolution: {integrity: sha512-dgKuX0peF3xwY6ZF5QxGS4wbfDqpoFAJYXiLSp+guZKARQUKMkRqZSDrXKj7nfrec3UCMzC0PFCPte0ES98AiA==}
+    engines: {node: '>= 10'}
+    cpu: [arm64]
+    os: [linux]
+    libc: [glibc]
+
+  '@napi-rs/canvas-linux-arm64-musl@1.0.2':
+    resolution: {integrity: sha512-qwROoDIC9upfvDoRLuPn2aNg9CGW1x0Ygr4k2Or+8paA9d0qBLwk87U+g8KQpoOviKoPoiwl97kvBYuYD7qZoA==}
+    engines: {node: '>= 10'}
+    cpu: [arm64]
+    os: [linux]
+    libc: [musl]
+
+  '@napi-rs/canvas-linux-riscv64-gnu@1.0.2':
+    resolution: {integrity: sha512-fXRjnPihdnbO6qy1QQOgxAonb68A0TCEG7rj1x7v7rxNElsE8EVIKIEUTvyDtU+sthYSbX+8e7g3oZiLGnOmxw==}
+    engines: {node: '>= 10'}
+    cpu: [riscv64]
+    os: [linux]
+    libc: [glibc]
+
+  '@napi-rs/canvas-linux-x64-gnu@1.0.2':
+    resolution: {integrity: sha512-nPR97DXhbWIAy7yazF3jc06kEPMqYMLmPzFOVNlwKPfIoSChnI+x7dc0hTLaihz3jxrjL6j4BbA7earxfx4X3g==}
+    engines: {node: '>= 10'}
+    cpu: [x64]
+    os: [linux]
+    libc: [glibc]
+
+  '@napi-rs/canvas-linux-x64-musl@1.0.2':
+    resolution: {integrity: sha512-l7zZY5+jL5qnBZtDz7CoBtY6p7EkHu422g/0zWwrOrzIwWyWxZFRfZZORY1UG7YApymPLx+UbOkN206xXn/c1Q==}
+    engines: {node: '>= 10'}
+    cpu: [x64]
+    os: [linux]
+    libc: [musl]
+
+  '@napi-rs/canvas-win32-arm64-msvc@1.0.2':
+    resolution: {integrity: sha512-yE0koHCFF4PIbMc2o2SEALhnipz7WBISh5glLvQiomtIoCcW0np3H4Lw93ceJAfJttTTeIIWFbwH84F7EVzjMQ==}
+    engines: {node: '>= 10'}
+    cpu: [arm64]
+    os: [win32]
+
+  '@napi-rs/canvas-win32-x64-msvc@1.0.2':
+    resolution: {integrity: sha512-okU8/t2foV6C31n0GtvEMbfD5rOFc70+/6xUNME9Guld29sgSOIGUEDScAWFlcP3k5TYQRl9TNkwJEEjh15w8A==}
+    engines: {node: '>= 10'}
+    cpu: [x64]
+    os: [win32]
+
+  '@napi-rs/canvas@1.0.2':
+    resolution: {integrity: sha512-EYEqlMYaCbpZDz+IgDH5xp9MTd3ui4dmGqbQYryhMLnSRxrhHKq5KQWHHKxFUcEP4Hp8/BWgvqXocX4j7iSbOQ==}
+    engines: {node: '>= 10'}
+
   '@napi-rs/wasm-runtime@1.1.6':
     resolution: {integrity: sha512-ZLv/JdUfkvOy9eCnnBaGfiO+XimbjebAeO+MRQqD/B+FR1tnRN0tpKSJHRbE8sFfS6aqsXZ67TQjfwfsxULVbg==}
     peerDependencies:
@@ -2428,6 +2678,9 @@ packages:
   '@swc/helpers@0.5.23':
     resolution: {integrity: sha512-5lSsMOTXURePglDfvuAQUqkGek9Hg2kksOYay2m0+XR++b2NWYL/4sWyuvVBIs8oKnJaxkdi9whaL/sqN13afw==}
 
+  '@techstark/opencv-js@5.0.0-release.1':
+    resolution: {integrity: sha512-PIm+eB0MFtieXoNC2GRao0dv/02sehG+Nv2nSW5D6pQm6J/4WqvDHm0RyoqOmGYQm67jdGiaOdIeTShCY3PIUg==}
+
   '@tiptap/core@2.27.2':
     resolution: {integrity: sha512-ABL1N6eoxzDzC1bYvkMbvyexHacszsKdVPYqhl5GwHLOvpZcv9VE9QaKwDILTyz5voCA0lGcAAXZp+qnXOk5lQ==}
     peerDependencies:
@@ -2620,6 +2873,12 @@ packages:
   '@types/deep-eql@4.0.2':
     resolution: {integrity: sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==}
 
+  '@types/dom-mediacapture-transform@0.1.12':
+    resolution: {integrity: sha512-d7/QsLRwF864A5mgIM/YrfiglHoYn7zgCcAoJgW404r+2DwnNr7EBbLnCWpmOMgH8y0te73L1AV6H1bmauaWFw==}
+
+  '@types/dom-webcodecs@0.1.13':
+    resolution: {integrity: sha512-O5hkiFIcjjszPIYyUSyvScyvrBoV3NOEEZx/pMlsu44TKzWNkLVBBxnxJz42in5n3QIolYOcBYFCPZZ0h8SkwQ==}
+
   '@types/estree@1.0.9':
     resolution: {integrity: sha512-GhdPgy1el4/ImP05X05Uw4cw2/M93BCUmnEvWZNStlCzEKME4Fkk+YpoA5OiHNQmoS7Cafb8Xa3Pya8m1Qrzeg==}
 
@@ -3618,6 +3877,9 @@ packages:
     resolution: {integrity: sha512-aisnrDP4GNe06UcKFnV5bfMNPBUw4jsLGaWwWfnH3v02GnBuXX2MCVn5RbrWo0j3pczUilYblq7fQ7Nw2t5XKw==}
     engines: {node: '>= 0.8'}
 
+  mediabunny@1.50.6:
+    resolution: {integrity: sha512-ktHEuGFZ1lqXx16CQiViawxg8Kn2cBcpudjjko7dMuDHMT8W/UrQ0ojhfrXL69/nUrbVFGMwmu58pFz9d0MyOQ==}
+
   merge-descriptors@2.0.0:
     resolution: {integrity: sha512-Snk314V5ayFLhp3fkUREub6WtjBfPdCPY1Ln8/8munuLuiYhsABgBVWsozAG+MWMbVEvcdcpbi9R7ww22l9Q3g==}
     engines: {node: '>=18'}
@@ -4176,6 +4438,15 @@ packages:
   setprototypeof@1.2.0:
     resolution: {integrity: sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==}
 
+  sharp@0.35.3:
+    resolution: {integrity: sha512-ej0zVHuZGHCiABXcNxeYhpRnPNPAcvbG8RMdBAhDAxLKkCRVSpK3Iyu7qbqw3JMzoj0REeM6f3tJLtVwl0023Q==}
+    engines: {node: '>=20.9.0'}
+    peerDependencies:
+      '@types/node': '*'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
   shebang-command@2.0.0:
     resolution: {integrity: sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==}
     engines: {node: '>=8'}
@@ -5150,6 +5421,112 @@ snapshots:
 
   '@floating-ui/utils@0.2.11': {}
 
+  '@img/colour@1.1.0': {}
+
+  '@img/sharp-darwin-arm64@0.35.3':
+    optionalDependencies:
+      '@img/sharp-libvips-darwin-arm64': 1.3.2
+    optional: true
+
+  '@img/sharp-darwin-x64@0.35.3':
+    optionalDependencies:
+      '@img/sharp-libvips-darwin-x64': 1.3.2
+    optional: true
+
+  '@img/sharp-freebsd-wasm32@0.35.3':
+    dependencies:
+      '@img/sharp-wasm32': 0.35.3
+    optional: true
+
+  '@img/sharp-libvips-darwin-arm64@1.3.2':
+    optional: true
+
+  '@img/sharp-libvips-darwin-x64@1.3.2':
+    optional: true
+
+  '@img/sharp-libvips-linux-arm64@1.3.2':
+    optional: true
+
+  '@img/sharp-libvips-linux-arm@1.3.2':
+    optional: true
+
+  '@img/sharp-libvips-linux-ppc64@1.3.2':
+    optional: true
+
+  '@img/sharp-libvips-linux-riscv64@1.3.2':
+    optional: true
+
+  '@img/sharp-libvips-linux-s390x@1.3.2':
+    optional: true
+
+  '@img/sharp-libvips-linux-x64@1.3.2':
+    optional: true
+
+  '@img/sharp-libvips-linuxmusl-arm64@1.3.2':
+    optional: true
+
+  '@img/sharp-libvips-linuxmusl-x64@1.3.2':
+    optional: true
+
+  '@img/sharp-linux-arm64@0.35.3':
+    optionalDependencies:
+      '@img/sharp-libvips-linux-arm64': 1.3.2
+    optional: true
+
+  '@img/sharp-linux-arm@0.35.3':
+    optionalDependencies:
+      '@img/sharp-libvips-linux-arm': 1.3.2
+    optional: true
+
+  '@img/sharp-linux-ppc64@0.35.3':
+    optionalDependencies:
+      '@img/sharp-libvips-linux-ppc64': 1.3.2
+    optional: true
+
+  '@img/sharp-linux-riscv64@0.35.3':
+    optionalDependencies:
+      '@img/sharp-libvips-linux-riscv64': 1.3.2
+    optional: true
+
+  '@img/sharp-linux-s390x@0.35.3':
+    optionalDependencies:
+      '@img/sharp-libvips-linux-s390x': 1.3.2
+    optional: true
+
+  '@img/sharp-linux-x64@0.35.3':
+    optionalDependencies:
+      '@img/sharp-libvips-linux-x64': 1.3.2
+    optional: true
+
+  '@img/sharp-linuxmusl-arm64@0.35.3':
+    optionalDependencies:
+      '@img/sharp-libvips-linuxmusl-arm64': 1.3.2
+    optional: true
+
+  '@img/sharp-linuxmusl-x64@0.35.3':
+    optionalDependencies:
+      '@img/sharp-libvips-linuxmusl-x64': 1.3.2
+    optional: true
+
+  '@img/sharp-wasm32@0.35.3':
+    dependencies:
+      '@emnapi/runtime': 1.11.2
+    optional: true
+
+  '@img/sharp-webcontainers-wasm32@0.35.3':
+    dependencies:
+      '@img/sharp-wasm32': 0.35.3
+    optional: true
+
+  '@img/sharp-win32-arm64@0.35.3':
+    optional: true
+
+  '@img/sharp-win32-ia32@0.35.3':
+    optional: true
+
+  '@img/sharp-win32-x64@0.35.3':
+    optional: true
+
   '@internationalized/date@3.12.2':
     dependencies:
       '@swc/helpers': 0.5.23
@@ -5185,6 +5562,53 @@ snapshots:
 
   '@mjackson/headers@0.10.0': {}
 
+  '@napi-rs/canvas-android-arm64@1.0.2':
+    optional: true
+
+  '@napi-rs/canvas-darwin-arm64@1.0.2':
+    optional: true
+
+  '@napi-rs/canvas-darwin-x64@1.0.2':
+    optional: true
+
+  '@napi-rs/canvas-linux-arm-gnueabihf@1.0.2':
+    optional: true
+
+  '@napi-rs/canvas-linux-arm64-gnu@1.0.2':
+    optional: true
+
+  '@napi-rs/canvas-linux-arm64-musl@1.0.2':
+    optional: true
+
+  '@napi-rs/canvas-linux-riscv64-gnu@1.0.2':
+    optional: true
+
+  '@napi-rs/canvas-linux-x64-gnu@1.0.2':
+    optional: true
+
+  '@napi-rs/canvas-linux-x64-musl@1.0.2':
+    optional: true
+
+  '@napi-rs/canvas-win32-arm64-msvc@1.0.2':
+    optional: true
+
+  '@napi-rs/canvas-win32-x64-msvc@1.0.2':
+    optional: true
+
+  '@napi-rs/canvas@1.0.2':
+    optionalDependencies:
+      '@napi-rs/canvas-android-arm64': 1.0.2
+      '@napi-rs/canvas-darwin-arm64': 1.0.2
+      '@napi-rs/canvas-darwin-x64': 1.0.2
+      '@napi-rs/canvas-linux-arm-gnueabihf': 1.0.2
+      '@napi-rs/canvas-linux-arm64-gnu': 1.0.2
+      '@napi-rs/canvas-linux-arm64-musl': 1.0.2
+      '@napi-rs/canvas-linux-riscv64-gnu': 1.0.2
+      '@napi-rs/canvas-linux-x64-gnu': 1.0.2
+      '@napi-rs/canvas-linux-x64-musl': 1.0.2
+      '@napi-rs/canvas-win32-arm64-msvc': 1.0.2
+      '@napi-rs/canvas-win32-x64-msvc': 1.0.2
+
   '@napi-rs/wasm-runtime@1.1.6(@emnapi/core@1.11.1)(@emnapi/runtime@1.11.1)':
     dependencies:
       '@emnapi/core': 1.11.1
@@ -6967,6 +7391,8 @@ snapshots:
     dependencies:
       tslib: 2.8.1
 
+  '@techstark/opencv-js@5.0.0-release.1(patch_hash=0e23b4243e8e2f88294c00eefdf8dfc3624f59442bd0c8d075be89a8136144f3)': {}
+
   '@tiptap/core@2.27.2(@tiptap/pm@2.27.2)':
     dependencies:
       '@tiptap/pm': 2.27.2
@@ -7213,6 +7639,12 @@ snapshots:
 
   '@types/deep-eql@4.0.2': {}
 
+  '@types/dom-mediacapture-transform@0.1.12':
+    dependencies:
+      '@types/dom-webcodecs': 0.1.13
+
+  '@types/dom-webcodecs@0.1.13': {}
+
   '@types/estree@1.0.9': {}
 
   '@types/linkify-it@5.0.0': {}
@@ -8108,6 +8540,11 @@ snapshots:
 
   media-typer@1.1.0: {}
 
+  mediabunny@1.50.6:
+    dependencies:
+      '@types/dom-mediacapture-transform': 0.1.12
+      '@types/dom-webcodecs': 0.1.13
+
   merge-descriptors@2.0.0: {}
 
   meriyah@6.1.4: {}
@@ -8719,6 +9156,39 @@ snapshots:
 
   setprototypeof@1.2.0: {}
 
+  sharp@0.35.3(@types/node@26.1.2):
+    dependencies:
+      '@img/colour': 1.1.0
+      detect-libc: 2.1.2
+      semver: 7.8.5
+    optionalDependencies:
+      '@img/sharp-darwin-arm64': 0.35.3
+      '@img/sharp-darwin-x64': 0.35.3
+      '@img/sharp-freebsd-wasm32': 0.35.3
+      '@img/sharp-libvips-darwin-arm64': 1.3.2
+      '@img/sharp-libvips-darwin-x64': 1.3.2
+      '@img/sharp-libvips-linux-arm': 1.3.2
+      '@img/sharp-libvips-linux-arm64': 1.3.2
+      '@img/sharp-libvips-linux-ppc64': 1.3.2
+      '@img/sharp-libvips-linux-riscv64': 1.3.2
+      '@img/sharp-libvips-linux-s390x': 1.3.2
+      '@img/sharp-libvips-linux-x64': 1.3.2
+      '@img/sharp-libvips-linuxmusl-arm64': 1.3.2
+      '@img/sharp-libvips-linuxmusl-x64': 1.3.2
+      '@img/sharp-linux-arm': 0.35.3
+      '@img/sharp-linux-arm64': 0.35.3
+      '@img/sharp-linux-ppc64': 0.35.3
+      '@img/sharp-linux-riscv64': 0.35.3
+      '@img/sharp-linux-s390x': 0.35.3
+      '@img/sharp-linux-x64': 0.35.3
+      '@img/sharp-linuxmusl-arm64': 0.35.3
+      '@img/sharp-linuxmusl-x64': 0.35.3
+      '@img/sharp-webcontainers-wasm32': 0.35.3
+      '@img/sharp-win32-arm64': 0.35.3
+      '@img/sharp-win32-ia32': 0.35.3
+      '@img/sharp-win32-x64': 0.35.3
+      '@types/node': 26.1.2
+
   shebang-command@2.0.0:
     dependencies:
       shebang-regex: 3.0.0
diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml
index 691adcd5c..8688ab089 100644
--- a/pnpm-workspace.yaml
+++ b/pnpm-workspace.yaml
@@ -5,4 +5,5 @@ allowBuilds:
   esbuild: true
 patchedDependencies:
   '@react-router/serve@8.1.0': patches/@react-router__serve@8.1.0.patch
+  '@techstark/opencv-js@5.0.0-release.1': patches/@techstark__opencv-js@5.0.0-release.1.patch
   kysely@0.29.0: patches/kysely@0.29.0.patch
diff --git a/public/scanner/v1/glyphs/death-tag-name.json b/public/scanner/v1/glyphs/death-tag-name.json
new file mode 100644
index 000000000..92458381e
--- /dev/null
+++ b/public/scanner/v1/glyphs/death-tag-name.json
@@ -0,0 +1,12029 @@
+{
+  "height": 42,
+  "glyphs": [
+    {
+      "char": "ー",
+      "x": 2,
+      "y": 2,
+      "w": 33,
+      "h": 17,
+      "source": "fixture"
+    },
+    {
+      "char": "F",
+      "x": 37,
+      "y": 2,
+      "w": 31,
+      "h": 45,
+      "source": "fixture"
+    },
+    {
+      "char": "G",
+      "x": 70,
+      "y": 2,
+      "w": 42,
+      "h": 45,
+      "source": "fixture"
+    },
+    {
+      "char": "x",
+      "x": 114,
+      "y": 2,
+      "w": 33,
+      "h": 36,
+      "source": "fixture"
+    },
+    {
+      "char": "あ",
+      "x": 149,
+      "y": 2,
+      "w": 49,
+      "h": 50,
+      "source": "fixture"
+    },
+    {
+      "char": "い",
+      "x": 200,
+      "y": 2,
+      "w": 48,
+      "h": 38,
+      "source": "fixture"
+    },
+    {
+      "char": "か",
+      "x": 250,
+      "y": 2,
+      "w": 57,
+      "h": 49,
+      "source": "fixture"
+    },
+    {
+      "char": "げ",
+      "x": 309,
+      "y": 2,
+      "w": 50,
+      "h": 66,
+      "source": "fixture"
+    },
+    {
+      "char": "ご",
+      "x": 361,
+      "y": 2,
+      "w": 41,
+      "h": 68,
+      "source": "fixture"
+    },
+    {
+      "char": "さ",
+      "x": 404,
+      "y": 2,
+      "w": 44,
+      "h": 50,
+      "source": "fixture"
+    },
+    {
+      "char": "ス",
+      "x": 450,
+      "y": 2,
+      "w": 46,
+      "h": 46,
+      "source": "fixture"
+    },
+    {
+      "char": "ぜ",
+      "x": 498,
+      "y": 2,
+      "w": 52,
+      "h": 66,
+      "source": "fixture"
+    },
+    {
+      "char": "タ",
+      "x": 552,
+      "y": 2,
+      "w": 41,
+      "h": 47,
+      "source": "fixture"
+    },
+    {
+      "char": "だ",
+      "x": 595,
+      "y": 2,
+      "w": 50,
+      "h": 55,
+      "source": "fixture"
+    },
+    {
+      "char": "ド",
+      "x": 647,
+      "y": 2,
+      "w": 41,
+      "h": 53,
+      "source": "fixture"
+    },
+    {
+      "char": "に",
+      "x": 690,
+      "y": 2,
+      "w": 51,
+      "h": 44,
+      "source": "fixture"
+    },
+    {
+      "char": "パ",
+      "x": 743,
+      "y": 2,
+      "w": 52,
+      "h": 53,
+      "source": "fixture"
+    },
+    {
+      "char": "パ",
+      "x": 797,
+      "y": 2,
+      "w": 54,
+      "h": 54,
+      "source": "fixture"
+    },
+    {
+      "char": "め",
+      "x": 853,
+      "y": 2,
+      "w": 54,
+      "h": 42,
+      "source": "fixture"
+    },
+    {
+      "char": "ん",
+      "x": 909,
+      "y": 2,
+      "w": 47,
+      "h": 49,
+      "source": "fixture"
+    },
+    {
+      "char": "ん",
+      "x": 958,
+      "y": 2,
+      "w": 47,
+      "h": 49,
+      "source": "fixture"
+    },
+    {
+      "char": "ん",
+      "x": 1007,
+      "y": 2,
+      "w": 47,
+      "h": 49,
+      "source": "fixture"
+    },
+    {
+      "char": "ン",
+      "x": 1056,
+      "y": 2,
+      "w": 43,
+      "h": 45,
+      "source": "fixture"
+    },
+    {
+      "char": "!",
+      "x": 1101,
+      "y": 2,
+      "w": 22,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "!",
+      "x": 1125,
+      "y": 2,
+      "w": 23,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "\"",
+      "x": 1150,
+      "y": 2,
+      "w": 20,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "\"",
+      "x": 1172,
+      "y": 2,
+      "w": 21,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "#",
+      "x": 1195,
+      "y": 2,
+      "w": 43,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "#",
+      "x": 1240,
+      "y": 2,
+      "w": 44,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "$",
+      "x": 1286,
+      "y": 2,
+      "w": 38,
+      "h": 51,
+      "source": "font"
+    },
+    {
+      "char": "$",
+      "x": 1326,
+      "y": 2,
+      "w": 39,
+      "h": 51,
+      "source": "font"
+    },
+    {
+      "char": "%",
+      "x": 1367,
+      "y": 2,
+      "w": 52,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "%",
+      "x": 1421,
+      "y": 2,
+      "w": 52,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "&",
+      "x": 1475,
+      "y": 2,
+      "w": 40,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "&",
+      "x": 1517,
+      "y": 2,
+      "w": 41,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "'",
+      "x": 1560,
+      "y": 2,
+      "w": 11,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "'",
+      "x": 1573,
+      "y": 2,
+      "w": 12,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "(",
+      "x": 2,
+      "y": 72,
+      "w": 25,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "(",
+      "x": 29,
+      "y": 72,
+      "w": 25,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": ")",
+      "x": 56,
+      "y": 72,
+      "w": 25,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": ")",
+      "x": 83,
+      "y": 72,
+      "w": 26,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "*",
+      "x": 111,
+      "y": 72,
+      "w": 27,
+      "h": 25,
+      "source": "font"
+    },
+    {
+      "char": "*",
+      "x": 140,
+      "y": 72,
+      "w": 27,
+      "h": 26,
+      "source": "font"
+    },
+    {
+      "char": "+",
+      "x": 169,
+      "y": 72,
+      "w": 35,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "+",
+      "x": 206,
+      "y": 72,
+      "w": 36,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": ",",
+      "x": 244,
+      "y": 72,
+      "w": 15,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": ",",
+      "x": 261,
+      "y": 72,
+      "w": 15,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "-",
+      "x": 278,
+      "y": 72,
+      "w": 22,
+      "h": 12,
+      "source": "font"
+    },
+    {
+      "char": "-",
+      "x": 302,
+      "y": 72,
+      "w": 22,
+      "h": 12,
+      "source": "font"
+    },
+    {
+      "char": ".",
+      "x": 326,
+      "y": 72,
+      "w": 13,
+      "h": 12,
+      "source": "font"
+    },
+    {
+      "char": ".",
+      "x": 341,
+      "y": 72,
+      "w": 14,
+      "h": 13,
+      "source": "font"
+    },
+    {
+      "char": "/",
+      "x": 357,
+      "y": 72,
+      "w": 24,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "/",
+      "x": 383,
+      "y": 72,
+      "w": 24,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "0",
+      "x": 409,
+      "y": 72,
+      "w": 36,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "0",
+      "x": 447,
+      "y": 72,
+      "w": 37,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "1",
+      "x": 486,
+      "y": 72,
+      "w": 23,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "1",
+      "x": 511,
+      "y": 72,
+      "w": 23,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "2",
+      "x": 536,
+      "y": 72,
+      "w": 35,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "2",
+      "x": 573,
+      "y": 72,
+      "w": 36,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "3",
+      "x": 611,
+      "y": 72,
+      "w": 33,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "3",
+      "x": 646,
+      "y": 72,
+      "w": 34,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "4",
+      "x": 682,
+      "y": 72,
+      "w": 36,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "4",
+      "x": 720,
+      "y": 72,
+      "w": 36,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "5",
+      "x": 758,
+      "y": 72,
+      "w": 35,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "5",
+      "x": 795,
+      "y": 72,
+      "w": 35,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "6",
+      "x": 832,
+      "y": 72,
+      "w": 38,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "6",
+      "x": 872,
+      "y": 72,
+      "w": 39,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "7",
+      "x": 913,
+      "y": 72,
+      "w": 34,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "7",
+      "x": 949,
+      "y": 72,
+      "w": 35,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "8",
+      "x": 986,
+      "y": 72,
+      "w": 34,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "8",
+      "x": 1022,
+      "y": 72,
+      "w": 35,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "9",
+      "x": 1059,
+      "y": 72,
+      "w": 38,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "9",
+      "x": 1099,
+      "y": 72,
+      "w": 39,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": ":",
+      "x": 1140,
+      "y": 72,
+      "w": 13,
+      "h": 33,
+      "source": "font"
+    },
+    {
+      "char": ":",
+      "x": 1155,
+      "y": 72,
+      "w": 14,
+      "h": 33,
+      "source": "font"
+    },
+    {
+      "char": ";",
+      "x": 1171,
+      "y": 72,
+      "w": 14,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": ";",
+      "x": 1187,
+      "y": 72,
+      "w": 14,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "<",
+      "x": 1203,
+      "y": 72,
+      "w": 26,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "<",
+      "x": 1231,
+      "y": 72,
+      "w": 26,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "=",
+      "x": 1259,
+      "y": 72,
+      "w": 32,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "=",
+      "x": 1293,
+      "y": 72,
+      "w": 32,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": ">",
+      "x": 1327,
+      "y": 72,
+      "w": 26,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": ">",
+      "x": 1355,
+      "y": 72,
+      "w": 26,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "?",
+      "x": 1383,
+      "y": 72,
+      "w": 36,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "?",
+      "x": 1421,
+      "y": 72,
+      "w": 37,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "@",
+      "x": 1460,
+      "y": 72,
+      "w": 42,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "@",
+      "x": 1504,
+      "y": 72,
+      "w": 43,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "A",
+      "x": 1549,
+      "y": 72,
+      "w": 39,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "A",
+      "x": 2,
+      "y": 124,
+      "w": 40,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "B",
+      "x": 44,
+      "y": 124,
+      "w": 34,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "B",
+      "x": 80,
+      "y": 124,
+      "w": 35,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "C",
+      "x": 117,
+      "y": 124,
+      "w": 37,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "C",
+      "x": 156,
+      "y": 124,
+      "w": 38,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "D",
+      "x": 196,
+      "y": 124,
+      "w": 36,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "D",
+      "x": 234,
+      "y": 124,
+      "w": 37,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "E",
+      "x": 273,
+      "y": 124,
+      "w": 28,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "E",
+      "x": 303,
+      "y": 124,
+      "w": 28,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "F",
+      "x": 333,
+      "y": 124,
+      "w": 29,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "F",
+      "x": 364,
+      "y": 124,
+      "w": 30,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "G",
+      "x": 396,
+      "y": 124,
+      "w": 39,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "G",
+      "x": 437,
+      "y": 124,
+      "w": 40,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "H",
+      "x": 479,
+      "y": 124,
+      "w": 36,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "H",
+      "x": 517,
+      "y": 124,
+      "w": 37,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "I",
+      "x": 556,
+      "y": 124,
+      "w": 15,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "I",
+      "x": 573,
+      "y": 124,
+      "w": 16,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "J",
+      "x": 591,
+      "y": 124,
+      "w": 35,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "J",
+      "x": 628,
+      "y": 124,
+      "w": 35,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "K",
+      "x": 665,
+      "y": 124,
+      "w": 39,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "K",
+      "x": 706,
+      "y": 124,
+      "w": 40,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "L",
+      "x": 748,
+      "y": 124,
+      "w": 26,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "L",
+      "x": 776,
+      "y": 124,
+      "w": 26,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "M",
+      "x": 804,
+      "y": 124,
+      "w": 50,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "M",
+      "x": 856,
+      "y": 124,
+      "w": 51,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "N",
+      "x": 909,
+      "y": 124,
+      "w": 40,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "N",
+      "x": 951,
+      "y": 124,
+      "w": 41,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "O",
+      "x": 994,
+      "y": 124,
+      "w": 36,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "O",
+      "x": 1032,
+      "y": 124,
+      "w": 37,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "P",
+      "x": 1071,
+      "y": 124,
+      "w": 36,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "P",
+      "x": 1109,
+      "y": 124,
+      "w": 36,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "Q",
+      "x": 1147,
+      "y": 124,
+      "w": 36,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "Q",
+      "x": 1185,
+      "y": 124,
+      "w": 37,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "R",
+      "x": 1224,
+      "y": 124,
+      "w": 36,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "R",
+      "x": 1262,
+      "y": 124,
+      "w": 36,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "S",
+      "x": 1300,
+      "y": 124,
+      "w": 32,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "S",
+      "x": 1334,
+      "y": 124,
+      "w": 33,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "T",
+      "x": 1369,
+      "y": 124,
+      "w": 37,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "T",
+      "x": 1408,
+      "y": 124,
+      "w": 38,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "U",
+      "x": 1448,
+      "y": 124,
+      "w": 37,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "U",
+      "x": 1487,
+      "y": 124,
+      "w": 38,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "V",
+      "x": 1527,
+      "y": 124,
+      "w": 40,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "V",
+      "x": 2,
+      "y": 172,
+      "w": 41,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "W",
+      "x": 45,
+      "y": 172,
+      "w": 55,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "W",
+      "x": 102,
+      "y": 172,
+      "w": 56,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "X",
+      "x": 160,
+      "y": 172,
+      "w": 41,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "X",
+      "x": 203,
+      "y": 172,
+      "w": 42,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "Y",
+      "x": 247,
+      "y": 172,
+      "w": 37,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "Y",
+      "x": 286,
+      "y": 172,
+      "w": 38,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "Z",
+      "x": 326,
+      "y": 172,
+      "w": 35,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "Z",
+      "x": 363,
+      "y": 172,
+      "w": 35,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "[",
+      "x": 400,
+      "y": 172,
+      "w": 21,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "[",
+      "x": 423,
+      "y": 172,
+      "w": 21,
+      "h": 51,
+      "source": "font"
+    },
+    {
+      "char": "\\",
+      "x": 446,
+      "y": 172,
+      "w": 24,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "\\",
+      "x": 472,
+      "y": 172,
+      "w": 24,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "]",
+      "x": 498,
+      "y": 172,
+      "w": 20,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "]",
+      "x": 520,
+      "y": 172,
+      "w": 21,
+      "h": 51,
+      "source": "font"
+    },
+    {
+      "char": "^",
+      "x": 543,
+      "y": 172,
+      "w": 33,
+      "h": 25,
+      "source": "font"
+    },
+    {
+      "char": "^",
+      "x": 578,
+      "y": 172,
+      "w": 34,
+      "h": 26,
+      "source": "font"
+    },
+    {
+      "char": "_",
+      "x": 614,
+      "y": 172,
+      "w": 25,
+      "h": 12,
+      "source": "font"
+    },
+    {
+      "char": "_",
+      "x": 641,
+      "y": 172,
+      "w": 26,
+      "h": 12,
+      "source": "font"
+    },
+    {
+      "char": "`",
+      "x": 669,
+      "y": 172,
+      "w": 18,
+      "h": 15,
+      "source": "font"
+    },
+    {
+      "char": "`",
+      "x": 689,
+      "y": 172,
+      "w": 19,
+      "h": 15,
+      "source": "font"
+    },
+    {
+      "char": "a",
+      "x": 710,
+      "y": 172,
+      "w": 33,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "a",
+      "x": 745,
+      "y": 172,
+      "w": 34,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "b",
+      "x": 781,
+      "y": 172,
+      "w": 34,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "b",
+      "x": 817,
+      "y": 172,
+      "w": 34,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "c",
+      "x": 853,
+      "y": 172,
+      "w": 31,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "c",
+      "x": 886,
+      "y": 172,
+      "w": 32,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "d",
+      "x": 920,
+      "y": 172,
+      "w": 34,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "d",
+      "x": 956,
+      "y": 172,
+      "w": 35,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "e",
+      "x": 993,
+      "y": 172,
+      "w": 35,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "e",
+      "x": 1030,
+      "y": 172,
+      "w": 36,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "f",
+      "x": 1068,
+      "y": 172,
+      "w": 24,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "f",
+      "x": 1094,
+      "y": 172,
+      "w": 25,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "g",
+      "x": 1121,
+      "y": 172,
+      "w": 36,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "g",
+      "x": 1159,
+      "y": 172,
+      "w": 36,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "h",
+      "x": 1197,
+      "y": 172,
+      "w": 35,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "h",
+      "x": 1234,
+      "y": 172,
+      "w": 36,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "i",
+      "x": 1272,
+      "y": 172,
+      "w": 17,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "i",
+      "x": 1291,
+      "y": 172,
+      "w": 17,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "j",
+      "x": 1310,
+      "y": 172,
+      "w": 24,
+      "h": 52,
+      "source": "font"
+    },
+    {
+      "char": "j",
+      "x": 1336,
+      "y": 172,
+      "w": 25,
+      "h": 52,
+      "source": "font"
+    },
+    {
+      "char": "k",
+      "x": 1363,
+      "y": 172,
+      "w": 34,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "k",
+      "x": 1399,
+      "y": 172,
+      "w": 35,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "l",
+      "x": 1436,
+      "y": 172,
+      "w": 17,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "l",
+      "x": 1455,
+      "y": 172,
+      "w": 17,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "m",
+      "x": 1474,
+      "y": 172,
+      "w": 50,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "m",
+      "x": 1526,
+      "y": 172,
+      "w": 51,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "n",
+      "x": 2,
+      "y": 226,
+      "w": 36,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "n",
+      "x": 40,
+      "y": 226,
+      "w": 36,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "o",
+      "x": 78,
+      "y": 226,
+      "w": 34,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "o",
+      "x": 114,
+      "y": 226,
+      "w": 34,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "p",
+      "x": 150,
+      "y": 226,
+      "w": 34,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "p",
+      "x": 186,
+      "y": 226,
+      "w": 35,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "q",
+      "x": 223,
+      "y": 226,
+      "w": 35,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "q",
+      "x": 260,
+      "y": 226,
+      "w": 35,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "r",
+      "x": 297,
+      "y": 226,
+      "w": 25,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "r",
+      "x": 324,
+      "y": 226,
+      "w": 26,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "s",
+      "x": 352,
+      "y": 226,
+      "w": 29,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "s",
+      "x": 383,
+      "y": 226,
+      "w": 30,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "t",
+      "x": 415,
+      "y": 226,
+      "w": 29,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "t",
+      "x": 446,
+      "y": 226,
+      "w": 30,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "u",
+      "x": 478,
+      "y": 226,
+      "w": 35,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "u",
+      "x": 515,
+      "y": 226,
+      "w": 36,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "v",
+      "x": 553,
+      "y": 226,
+      "w": 34,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "v",
+      "x": 589,
+      "y": 226,
+      "w": 35,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "w",
+      "x": 626,
+      "y": 226,
+      "w": 43,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "w",
+      "x": 671,
+      "y": 226,
+      "w": 44,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "x",
+      "x": 717,
+      "y": 226,
+      "w": 35,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "x",
+      "x": 754,
+      "y": 226,
+      "w": 35,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "y",
+      "x": 791,
+      "y": 226,
+      "w": 37,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "y",
+      "x": 830,
+      "y": 226,
+      "w": 39,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "z",
+      "x": 871,
+      "y": 226,
+      "w": 27,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "z",
+      "x": 900,
+      "y": 226,
+      "w": 28,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "{",
+      "x": 930,
+      "y": 226,
+      "w": 21,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "{",
+      "x": 953,
+      "y": 226,
+      "w": 21,
+      "h": 51,
+      "source": "font"
+    },
+    {
+      "char": "|",
+      "x": 976,
+      "y": 226,
+      "w": 12,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "|",
+      "x": 990,
+      "y": 226,
+      "w": 12,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "}",
+      "x": 1004,
+      "y": 226,
+      "w": 21,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "}",
+      "x": 1027,
+      "y": 226,
+      "w": 21,
+      "h": 51,
+      "source": "font"
+    },
+    {
+      "char": "~",
+      "x": 1050,
+      "y": 226,
+      "w": 21,
+      "h": 12,
+      "source": "font"
+    },
+    {
+      "char": "~",
+      "x": 1073,
+      "y": 226,
+      "w": 21,
+      "h": 12,
+      "source": "font"
+    },
+    {
+      "char": "¡",
+      "x": 1096,
+      "y": 226,
+      "w": 23,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "¡",
+      "x": 1121,
+      "y": 226,
+      "w": 22,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "¢",
+      "x": 1145,
+      "y": 226,
+      "w": 32,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "¢",
+      "x": 1179,
+      "y": 226,
+      "w": 33,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "£",
+      "x": 1214,
+      "y": 226,
+      "w": 30,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "£",
+      "x": 1246,
+      "y": 226,
+      "w": 31,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "¤",
+      "x": 1279,
+      "y": 226,
+      "w": 31,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "¤",
+      "x": 1312,
+      "y": 226,
+      "w": 31,
+      "h": 30,
+      "source": "font"
+    },
+    {
+      "char": "¥",
+      "x": 1345,
+      "y": 226,
+      "w": 37,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "¥",
+      "x": 1384,
+      "y": 226,
+      "w": 38,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "¦",
+      "x": 1424,
+      "y": 226,
+      "w": 12,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "¦",
+      "x": 1438,
+      "y": 226,
+      "w": 12,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "§",
+      "x": 1452,
+      "y": 226,
+      "w": 35,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "§",
+      "x": 1489,
+      "y": 226,
+      "w": 35,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "¨",
+      "x": 1526,
+      "y": 226,
+      "w": 24,
+      "h": 10,
+      "source": "font"
+    },
+    {
+      "char": "¨",
+      "x": 1552,
+      "y": 226,
+      "w": 24,
+      "h": 11,
+      "source": "font"
+    },
+    {
+      "char": "©",
+      "x": 2,
+      "y": 279,
+      "w": 41,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "©",
+      "x": 45,
+      "y": 279,
+      "w": 41,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "ª",
+      "x": 88,
+      "y": 279,
+      "w": 12,
+      "h": 12,
+      "source": "font"
+    },
+    {
+      "char": "ª",
+      "x": 102,
+      "y": 279,
+      "w": 12,
+      "h": 13,
+      "source": "font"
+    },
+    {
+      "char": "«",
+      "x": 116,
+      "y": 279,
+      "w": 38,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "«",
+      "x": 156,
+      "y": 279,
+      "w": 39,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "¬",
+      "x": 197,
+      "y": 279,
+      "w": 43,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "¬",
+      "x": 242,
+      "y": 279,
+      "w": 44,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "®",
+      "x": 288,
+      "y": 279,
+      "w": 41,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "®",
+      "x": 331,
+      "y": 279,
+      "w": 41,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "¯",
+      "x": 374,
+      "y": 279,
+      "w": 20,
+      "h": 9,
+      "source": "font"
+    },
+    {
+      "char": "¯",
+      "x": 396,
+      "y": 279,
+      "w": 21,
+      "h": 10,
+      "source": "font"
+    },
+    {
+      "char": "°",
+      "x": 419,
+      "y": 279,
+      "w": 14,
+      "h": 13,
+      "source": "font"
+    },
+    {
+      "char": "°",
+      "x": 435,
+      "y": 279,
+      "w": 14,
+      "h": 13,
+      "source": "font"
+    },
+    {
+      "char": "±",
+      "x": 451,
+      "y": 279,
+      "w": 35,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "±",
+      "x": 488,
+      "y": 279,
+      "w": 36,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "²",
+      "x": 526,
+      "y": 279,
+      "w": 16,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "²",
+      "x": 544,
+      "y": 279,
+      "w": 16,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "³",
+      "x": 562,
+      "y": 279,
+      "w": 14,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "³",
+      "x": 578,
+      "y": 279,
+      "w": 14,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "´",
+      "x": 594,
+      "y": 279,
+      "w": 16,
+      "h": 13,
+      "source": "font"
+    },
+    {
+      "char": "´",
+      "x": 612,
+      "y": 279,
+      "w": 16,
+      "h": 14,
+      "source": "font"
+    },
+    {
+      "char": "µ",
+      "x": 630,
+      "y": 279,
+      "w": 37,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "µ",
+      "x": 669,
+      "y": 279,
+      "w": 38,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "¶",
+      "x": 709,
+      "y": 279,
+      "w": 36,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "¶",
+      "x": 747,
+      "y": 279,
+      "w": 37,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "·",
+      "x": 786,
+      "y": 279,
+      "w": 15,
+      "h": 15,
+      "source": "font"
+    },
+    {
+      "char": "·",
+      "x": 803,
+      "y": 279,
+      "w": 16,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "¸",
+      "x": 821,
+      "y": 279,
+      "w": 14,
+      "h": 14,
+      "source": "font"
+    },
+    {
+      "char": "¸",
+      "x": 837,
+      "y": 279,
+      "w": 13,
+      "h": 14,
+      "source": "font"
+    },
+    {
+      "char": "¹",
+      "x": 852,
+      "y": 279,
+      "w": 9,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "¹",
+      "x": 863,
+      "y": 279,
+      "w": 9,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "º",
+      "x": 874,
+      "y": 279,
+      "w": 17,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "º",
+      "x": 893,
+      "y": 279,
+      "w": 17,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "»",
+      "x": 912,
+      "y": 279,
+      "w": 38,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "»",
+      "x": 952,
+      "y": 279,
+      "w": 39,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "¼",
+      "x": 993,
+      "y": 279,
+      "w": 43,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "¼",
+      "x": 1038,
+      "y": 279,
+      "w": 44,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "½",
+      "x": 1084,
+      "y": 279,
+      "w": 45,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "½",
+      "x": 1131,
+      "y": 279,
+      "w": 46,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "¾",
+      "x": 1179,
+      "y": 279,
+      "w": 50,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "¾",
+      "x": 1231,
+      "y": 279,
+      "w": 50,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "¿",
+      "x": 1283,
+      "y": 279,
+      "w": 37,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "¿",
+      "x": 1322,
+      "y": 279,
+      "w": 38,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "À",
+      "x": 1362,
+      "y": 279,
+      "w": 39,
+      "h": 57,
+      "source": "font"
+    },
+    {
+      "char": "À",
+      "x": 1403,
+      "y": 279,
+      "w": 40,
+      "h": 58,
+      "source": "font"
+    },
+    {
+      "char": "Á",
+      "x": 1445,
+      "y": 279,
+      "w": 40,
+      "h": 57,
+      "source": "font"
+    },
+    {
+      "char": "Á",
+      "x": 1487,
+      "y": 279,
+      "w": 40,
+      "h": 58,
+      "source": "font"
+    },
+    {
+      "char": "Â",
+      "x": 1529,
+      "y": 279,
+      "w": 40,
+      "h": 58,
+      "source": "font"
+    },
+    {
+      "char": "Â",
+      "x": 2,
+      "y": 339,
+      "w": 41,
+      "h": 59,
+      "source": "font"
+    },
+    {
+      "char": "Ã",
+      "x": 45,
+      "y": 339,
+      "w": 39,
+      "h": 55,
+      "source": "font"
+    },
+    {
+      "char": "Ã",
+      "x": 86,
+      "y": 339,
+      "w": 40,
+      "h": 56,
+      "source": "font"
+    },
+    {
+      "char": "Ä",
+      "x": 128,
+      "y": 339,
+      "w": 40,
+      "h": 54,
+      "source": "font"
+    },
+    {
+      "char": "Ä",
+      "x": 170,
+      "y": 339,
+      "w": 40,
+      "h": 55,
+      "source": "font"
+    },
+    {
+      "char": "Å",
+      "x": 212,
+      "y": 339,
+      "w": 39,
+      "h": 57,
+      "source": "font"
+    },
+    {
+      "char": "Å",
+      "x": 253,
+      "y": 339,
+      "w": 40,
+      "h": 58,
+      "source": "font"
+    },
+    {
+      "char": "Æ",
+      "x": 295,
+      "y": 339,
+      "w": 45,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "Æ",
+      "x": 342,
+      "y": 339,
+      "w": 46,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "Ç",
+      "x": 390,
+      "y": 339,
+      "w": 37,
+      "h": 55,
+      "source": "font"
+    },
+    {
+      "char": "Ç",
+      "x": 429,
+      "y": 339,
+      "w": 38,
+      "h": 55,
+      "source": "font"
+    },
+    {
+      "char": "È",
+      "x": 469,
+      "y": 339,
+      "w": 28,
+      "h": 56,
+      "source": "font"
+    },
+    {
+      "char": "È",
+      "x": 499,
+      "y": 339,
+      "w": 28,
+      "h": 58,
+      "source": "font"
+    },
+    {
+      "char": "É",
+      "x": 529,
+      "y": 339,
+      "w": 28,
+      "h": 57,
+      "source": "font"
+    },
+    {
+      "char": "É",
+      "x": 559,
+      "y": 339,
+      "w": 29,
+      "h": 58,
+      "source": "font"
+    },
+    {
+      "char": "Ê",
+      "x": 590,
+      "y": 339,
+      "w": 28,
+      "h": 58,
+      "source": "font"
+    },
+    {
+      "char": "Ê",
+      "x": 620,
+      "y": 339,
+      "w": 29,
+      "h": 59,
+      "source": "font"
+    },
+    {
+      "char": "Ë",
+      "x": 651,
+      "y": 339,
+      "w": 28,
+      "h": 54,
+      "source": "font"
+    },
+    {
+      "char": "Ë",
+      "x": 681,
+      "y": 339,
+      "w": 28,
+      "h": 55,
+      "source": "font"
+    },
+    {
+      "char": "Ì",
+      "x": 711,
+      "y": 339,
+      "w": 16,
+      "h": 57,
+      "source": "font"
+    },
+    {
+      "char": "Ì",
+      "x": 729,
+      "y": 339,
+      "w": 16,
+      "h": 58,
+      "source": "font"
+    },
+    {
+      "char": "Í",
+      "x": 747,
+      "y": 339,
+      "w": 16,
+      "h": 57,
+      "source": "font"
+    },
+    {
+      "char": "Í",
+      "x": 765,
+      "y": 339,
+      "w": 16,
+      "h": 58,
+      "source": "font"
+    },
+    {
+      "char": "Î",
+      "x": 783,
+      "y": 339,
+      "w": 20,
+      "h": 58,
+      "source": "font"
+    },
+    {
+      "char": "Î",
+      "x": 805,
+      "y": 339,
+      "w": 20,
+      "h": 59,
+      "source": "font"
+    },
+    {
+      "char": "Ï",
+      "x": 827,
+      "y": 339,
+      "w": 24,
+      "h": 55,
+      "source": "font"
+    },
+    {
+      "char": "Ï",
+      "x": 853,
+      "y": 339,
+      "w": 24,
+      "h": 56,
+      "source": "font"
+    },
+    {
+      "char": "Ð",
+      "x": 879,
+      "y": 339,
+      "w": 41,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "Ð",
+      "x": 922,
+      "y": 339,
+      "w": 42,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "Ñ",
+      "x": 966,
+      "y": 339,
+      "w": 39,
+      "h": 55,
+      "source": "font"
+    },
+    {
+      "char": "Ñ",
+      "x": 1007,
+      "y": 339,
+      "w": 40,
+      "h": 56,
+      "source": "font"
+    },
+    {
+      "char": "Ò",
+      "x": 1049,
+      "y": 339,
+      "w": 36,
+      "h": 57,
+      "source": "font"
+    },
+    {
+      "char": "Ò",
+      "x": 1087,
+      "y": 339,
+      "w": 37,
+      "h": 58,
+      "source": "font"
+    },
+    {
+      "char": "Ó",
+      "x": 1126,
+      "y": 339,
+      "w": 36,
+      "h": 57,
+      "source": "font"
+    },
+    {
+      "char": "Ó",
+      "x": 1164,
+      "y": 339,
+      "w": 37,
+      "h": 58,
+      "source": "font"
+    },
+    {
+      "char": "Ô",
+      "x": 1203,
+      "y": 339,
+      "w": 37,
+      "h": 58,
+      "source": "font"
+    },
+    {
+      "char": "Ô",
+      "x": 1242,
+      "y": 339,
+      "w": 37,
+      "h": 59,
+      "source": "font"
+    },
+    {
+      "char": "Õ",
+      "x": 1281,
+      "y": 339,
+      "w": 37,
+      "h": 55,
+      "source": "font"
+    },
+    {
+      "char": "Õ",
+      "x": 1320,
+      "y": 339,
+      "w": 38,
+      "h": 56,
+      "source": "font"
+    },
+    {
+      "char": "Ö",
+      "x": 1360,
+      "y": 339,
+      "w": 37,
+      "h": 54,
+      "source": "font"
+    },
+    {
+      "char": "Ö",
+      "x": 1399,
+      "y": 339,
+      "w": 38,
+      "h": 55,
+      "source": "font"
+    },
+    {
+      "char": "×",
+      "x": 1439,
+      "y": 339,
+      "w": 36,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "×",
+      "x": 1477,
+      "y": 339,
+      "w": 37,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "Ø",
+      "x": 1516,
+      "y": 339,
+      "w": 37,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "Ø",
+      "x": 1555,
+      "y": 339,
+      "w": 38,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "Ù",
+      "x": 2,
+      "y": 400,
+      "w": 37,
+      "h": 57,
+      "source": "font"
+    },
+    {
+      "char": "Ù",
+      "x": 41,
+      "y": 400,
+      "w": 38,
+      "h": 58,
+      "source": "font"
+    },
+    {
+      "char": "Ú",
+      "x": 81,
+      "y": 400,
+      "w": 38,
+      "h": 57,
+      "source": "font"
+    },
+    {
+      "char": "Ú",
+      "x": 121,
+      "y": 400,
+      "w": 38,
+      "h": 58,
+      "source": "font"
+    },
+    {
+      "char": "Û",
+      "x": 161,
+      "y": 400,
+      "w": 38,
+      "h": 58,
+      "source": "font"
+    },
+    {
+      "char": "Û",
+      "x": 201,
+      "y": 400,
+      "w": 38,
+      "h": 59,
+      "source": "font"
+    },
+    {
+      "char": "Ü",
+      "x": 241,
+      "y": 400,
+      "w": 37,
+      "h": 55,
+      "source": "font"
+    },
+    {
+      "char": "Ü",
+      "x": 280,
+      "y": 400,
+      "w": 38,
+      "h": 56,
+      "source": "font"
+    },
+    {
+      "char": "Ý",
+      "x": 320,
+      "y": 400,
+      "w": 37,
+      "h": 57,
+      "source": "font"
+    },
+    {
+      "char": "Ý",
+      "x": 359,
+      "y": 400,
+      "w": 38,
+      "h": 58,
+      "source": "font"
+    },
+    {
+      "char": "Þ",
+      "x": 399,
+      "y": 400,
+      "w": 36,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "Þ",
+      "x": 437,
+      "y": 400,
+      "w": 37,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "ß",
+      "x": 476,
+      "y": 400,
+      "w": 35,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "ß",
+      "x": 513,
+      "y": 400,
+      "w": 36,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "à",
+      "x": 551,
+      "y": 400,
+      "w": 34,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "à",
+      "x": 587,
+      "y": 400,
+      "w": 34,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "á",
+      "x": 623,
+      "y": 400,
+      "w": 34,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "á",
+      "x": 659,
+      "y": 400,
+      "w": 34,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "â",
+      "x": 695,
+      "y": 400,
+      "w": 34,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "â",
+      "x": 731,
+      "y": 400,
+      "w": 34,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "ã",
+      "x": 767,
+      "y": 400,
+      "w": 33,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "ã",
+      "x": 802,
+      "y": 400,
+      "w": 34,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ä",
+      "x": 838,
+      "y": 400,
+      "w": 33,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "ä",
+      "x": 873,
+      "y": 400,
+      "w": 34,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "å",
+      "x": 909,
+      "y": 400,
+      "w": 34,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "å",
+      "x": 945,
+      "y": 400,
+      "w": 34,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "æ",
+      "x": 981,
+      "y": 400,
+      "w": 51,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "æ",
+      "x": 1034,
+      "y": 400,
+      "w": 52,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "ç",
+      "x": 1088,
+      "y": 400,
+      "w": 31,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "ç",
+      "x": 1121,
+      "y": 400,
+      "w": 32,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "è",
+      "x": 1155,
+      "y": 400,
+      "w": 35,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "è",
+      "x": 1192,
+      "y": 400,
+      "w": 36,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "é",
+      "x": 1230,
+      "y": 400,
+      "w": 35,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "é",
+      "x": 1267,
+      "y": 400,
+      "w": 35,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "ê",
+      "x": 1304,
+      "y": 400,
+      "w": 35,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "ê",
+      "x": 1341,
+      "y": 400,
+      "w": 36,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "ë",
+      "x": 1379,
+      "y": 400,
+      "w": 35,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "ë",
+      "x": 1416,
+      "y": 400,
+      "w": 35,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ì",
+      "x": 1453,
+      "y": 400,
+      "w": 17,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "ì",
+      "x": 1472,
+      "y": 400,
+      "w": 17,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "í",
+      "x": 1491,
+      "y": 400,
+      "w": 17,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "í",
+      "x": 1510,
+      "y": 400,
+      "w": 17,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "î",
+      "x": 1529,
+      "y": 400,
+      "w": 21,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "î",
+      "x": 1552,
+      "y": 400,
+      "w": 21,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "ï",
+      "x": 2,
+      "y": 461,
+      "w": 24,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "ï",
+      "x": 28,
+      "y": 461,
+      "w": 24,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ð",
+      "x": 54,
+      "y": 461,
+      "w": 34,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "ð",
+      "x": 90,
+      "y": 461,
+      "w": 35,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "ñ",
+      "x": 127,
+      "y": 461,
+      "w": 36,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ñ",
+      "x": 165,
+      "y": 461,
+      "w": 37,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "ò",
+      "x": 204,
+      "y": 461,
+      "w": 34,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "ò",
+      "x": 240,
+      "y": 461,
+      "w": 34,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "ó",
+      "x": 276,
+      "y": 461,
+      "w": 34,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "ó",
+      "x": 312,
+      "y": 461,
+      "w": 34,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "ô",
+      "x": 348,
+      "y": 461,
+      "w": 33,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "ô",
+      "x": 383,
+      "y": 461,
+      "w": 34,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "õ",
+      "x": 419,
+      "y": 461,
+      "w": 34,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "õ",
+      "x": 455,
+      "y": 461,
+      "w": 34,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ö",
+      "x": 491,
+      "y": 461,
+      "w": 34,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "ö",
+      "x": 527,
+      "y": 461,
+      "w": 34,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "÷",
+      "x": 563,
+      "y": 461,
+      "w": 38,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "÷",
+      "x": 603,
+      "y": 461,
+      "w": 39,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "ø",
+      "x": 644,
+      "y": 461,
+      "w": 34,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "ø",
+      "x": 680,
+      "y": 461,
+      "w": 35,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "ù",
+      "x": 717,
+      "y": 461,
+      "w": 36,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "ù",
+      "x": 755,
+      "y": 461,
+      "w": 37,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "ú",
+      "x": 794,
+      "y": 461,
+      "w": 35,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "ú",
+      "x": 831,
+      "y": 461,
+      "w": 36,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "û",
+      "x": 869,
+      "y": 461,
+      "w": 36,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "û",
+      "x": 907,
+      "y": 461,
+      "w": 37,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "ü",
+      "x": 946,
+      "y": 461,
+      "w": 36,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "ü",
+      "x": 984,
+      "y": 461,
+      "w": 36,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ý",
+      "x": 1022,
+      "y": 461,
+      "w": 38,
+      "h": 56,
+      "source": "font"
+    },
+    {
+      "char": "ý",
+      "x": 1062,
+      "y": 461,
+      "w": 38,
+      "h": 56,
+      "source": "font"
+    },
+    {
+      "char": "þ",
+      "x": 1102,
+      "y": 461,
+      "w": 35,
+      "h": 51,
+      "source": "font"
+    },
+    {
+      "char": "þ",
+      "x": 1139,
+      "y": 461,
+      "w": 36,
+      "h": 53,
+      "source": "font"
+    },
+    {
+      "char": "ÿ",
+      "x": 1177,
+      "y": 461,
+      "w": 38,
+      "h": 53,
+      "source": "font"
+    },
+    {
+      "char": "ÿ",
+      "x": 1217,
+      "y": 461,
+      "w": 38,
+      "h": 54,
+      "source": "font"
+    },
+    {
+      "char": "ぁ",
+      "x": 1257,
+      "y": 461,
+      "w": 33,
+      "h": 33,
+      "source": "font"
+    },
+    {
+      "char": "ぁ",
+      "x": 1292,
+      "y": 461,
+      "w": 33,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "あ",
+      "x": 1327,
+      "y": 461,
+      "w": 45,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "あ",
+      "x": 1374,
+      "y": 461,
+      "w": 46,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "ぃ",
+      "x": 1422,
+      "y": 461,
+      "w": 33,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "ぃ",
+      "x": 1457,
+      "y": 461,
+      "w": 34,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "い",
+      "x": 1493,
+      "y": 461,
+      "w": 45,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "い",
+      "x": 1540,
+      "y": 461,
+      "w": 46,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "ぅ",
+      "x": 2,
+      "y": 519,
+      "w": 24,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "ぅ",
+      "x": 28,
+      "y": 519,
+      "w": 24,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "う",
+      "x": 54,
+      "y": 519,
+      "w": 33,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "う",
+      "x": 89,
+      "y": 519,
+      "w": 33,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "ぇ",
+      "x": 124,
+      "y": 519,
+      "w": 30,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "ぇ",
+      "x": 156,
+      "y": 519,
+      "w": 30,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "え",
+      "x": 188,
+      "y": 519,
+      "w": 40,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "え",
+      "x": 230,
+      "y": 519,
+      "w": 41,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "ぉ",
+      "x": 273,
+      "y": 519,
+      "w": 34,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "ぉ",
+      "x": 309,
+      "y": 519,
+      "w": 35,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "お",
+      "x": 346,
+      "y": 519,
+      "w": 48,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "お",
+      "x": 396,
+      "y": 519,
+      "w": 48,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "か",
+      "x": 446,
+      "y": 519,
+      "w": 53,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "か",
+      "x": 501,
+      "y": 519,
+      "w": 54,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "が",
+      "x": 557,
+      "y": 519,
+      "w": 53,
+      "h": 58,
+      "source": "font"
+    },
+    {
+      "char": "が",
+      "x": 612,
+      "y": 519,
+      "w": 54,
+      "h": 59,
+      "source": "font"
+    },
+    {
+      "char": "き",
+      "x": 668,
+      "y": 519,
+      "w": 36,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "き",
+      "x": 706,
+      "y": 519,
+      "w": 36,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ぎ",
+      "x": 744,
+      "y": 519,
+      "w": 37,
+      "h": 60,
+      "source": "font"
+    },
+    {
+      "char": "ぎ",
+      "x": 783,
+      "y": 519,
+      "w": 37,
+      "h": 61,
+      "source": "font"
+    },
+    {
+      "char": "く",
+      "x": 822,
+      "y": 519,
+      "w": 34,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "く",
+      "x": 858,
+      "y": 519,
+      "w": 35,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ぐ",
+      "x": 895,
+      "y": 519,
+      "w": 40,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "ぐ",
+      "x": 937,
+      "y": 519,
+      "w": 41,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "け",
+      "x": 980,
+      "y": 519,
+      "w": 46,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "け",
+      "x": 1028,
+      "y": 519,
+      "w": 47,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "げ",
+      "x": 1077,
+      "y": 519,
+      "w": 46,
+      "h": 61,
+      "source": "font"
+    },
+    {
+      "char": "げ",
+      "x": 1125,
+      "y": 519,
+      "w": 47,
+      "h": 62,
+      "source": "font"
+    },
+    {
+      "char": "こ",
+      "x": 1174,
+      "y": 519,
+      "w": 34,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "こ",
+      "x": 1210,
+      "y": 519,
+      "w": 35,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "ご",
+      "x": 1247,
+      "y": 519,
+      "w": 37,
+      "h": 62,
+      "source": "font"
+    },
+    {
+      "char": "ご",
+      "x": 1286,
+      "y": 519,
+      "w": 37,
+      "h": 63,
+      "source": "font"
+    },
+    {
+      "char": "さ",
+      "x": 1325,
+      "y": 519,
+      "w": 41,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "さ",
+      "x": 1368,
+      "y": 519,
+      "w": 42,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "ざ",
+      "x": 1412,
+      "y": 519,
+      "w": 42,
+      "h": 62,
+      "source": "font"
+    },
+    {
+      "char": "ざ",
+      "x": 1456,
+      "y": 519,
+      "w": 43,
+      "h": 63,
+      "source": "font"
+    },
+    {
+      "char": "し",
+      "x": 1501,
+      "y": 519,
+      "w": 37,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "し",
+      "x": 1540,
+      "y": 519,
+      "w": 37,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "じ",
+      "x": 2,
+      "y": 584,
+      "w": 38,
+      "h": 52,
+      "source": "font"
+    },
+    {
+      "char": "じ",
+      "x": 42,
+      "y": 584,
+      "w": 39,
+      "h": 53,
+      "source": "font"
+    },
+    {
+      "char": "す",
+      "x": 83,
+      "y": 584,
+      "w": 40,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "す",
+      "x": 125,
+      "y": 584,
+      "w": 41,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "ず",
+      "x": 168,
+      "y": 584,
+      "w": 41,
+      "h": 61,
+      "source": "font"
+    },
+    {
+      "char": "ず",
+      "x": 211,
+      "y": 584,
+      "w": 42,
+      "h": 62,
+      "source": "font"
+    },
+    {
+      "char": "せ",
+      "x": 255,
+      "y": 584,
+      "w": 48,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "せ",
+      "x": 305,
+      "y": 584,
+      "w": 47,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "ぜ",
+      "x": 354,
+      "y": 584,
+      "w": 48,
+      "h": 60,
+      "source": "font"
+    },
+    {
+      "char": "ぜ",
+      "x": 404,
+      "y": 584,
+      "w": 47,
+      "h": 61,
+      "source": "font"
+    },
+    {
+      "char": "そ",
+      "x": 453,
+      "y": 584,
+      "w": 39,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "そ",
+      "x": 494,
+      "y": 584,
+      "w": 40,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "ぞ",
+      "x": 536,
+      "y": 584,
+      "w": 40,
+      "h": 61,
+      "source": "font"
+    },
+    {
+      "char": "ぞ",
+      "x": 578,
+      "y": 584,
+      "w": 41,
+      "h": 62,
+      "source": "font"
+    },
+    {
+      "char": "た",
+      "x": 621,
+      "y": 584,
+      "w": 46,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "た",
+      "x": 669,
+      "y": 584,
+      "w": 47,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "だ",
+      "x": 718,
+      "y": 584,
+      "w": 47,
+      "h": 52,
+      "source": "font"
+    },
+    {
+      "char": "だ",
+      "x": 767,
+      "y": 584,
+      "w": 48,
+      "h": 52,
+      "source": "font"
+    },
+    {
+      "char": "ち",
+      "x": 817,
+      "y": 584,
+      "w": 39,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ち",
+      "x": 858,
+      "y": 584,
+      "w": 39,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "ぢ",
+      "x": 899,
+      "y": 584,
+      "w": 43,
+      "h": 56,
+      "source": "font"
+    },
+    {
+      "char": "ぢ",
+      "x": 944,
+      "y": 584,
+      "w": 44,
+      "h": 57,
+      "source": "font"
+    },
+    {
+      "char": "っ",
+      "x": 990,
+      "y": 584,
+      "w": 33,
+      "h": 30,
+      "source": "font"
+    },
+    {
+      "char": "っ",
+      "x": 1025,
+      "y": 584,
+      "w": 34,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "つ",
+      "x": 1061,
+      "y": 584,
+      "w": 40,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "つ",
+      "x": 1103,
+      "y": 584,
+      "w": 40,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "づ",
+      "x": 1145,
+      "y": 584,
+      "w": 43,
+      "h": 51,
+      "source": "font"
+    },
+    {
+      "char": "づ",
+      "x": 1190,
+      "y": 584,
+      "w": 44,
+      "h": 52,
+      "source": "font"
+    },
+    {
+      "char": "て",
+      "x": 1236,
+      "y": 584,
+      "w": 41,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "て",
+      "x": 1279,
+      "y": 584,
+      "w": 42,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "で",
+      "x": 1323,
+      "y": 584,
+      "w": 41,
+      "h": 61,
+      "source": "font"
+    },
+    {
+      "char": "で",
+      "x": 1366,
+      "y": 584,
+      "w": 42,
+      "h": 62,
+      "source": "font"
+    },
+    {
+      "char": "と",
+      "x": 1410,
+      "y": 584,
+      "w": 36,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "と",
+      "x": 1448,
+      "y": 584,
+      "w": 36,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "ど",
+      "x": 1486,
+      "y": 584,
+      "w": 38,
+      "h": 56,
+      "source": "font"
+    },
+    {
+      "char": "ど",
+      "x": 1526,
+      "y": 584,
+      "w": 38,
+      "h": 57,
+      "source": "font"
+    },
+    {
+      "char": "な",
+      "x": 2,
+      "y": 648,
+      "w": 47,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "な",
+      "x": 51,
+      "y": 648,
+      "w": 47,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "に",
+      "x": 100,
+      "y": 648,
+      "w": 46,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "に",
+      "x": 148,
+      "y": 648,
+      "w": 47,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "ぬ",
+      "x": 197,
+      "y": 648,
+      "w": 53,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "ぬ",
+      "x": 252,
+      "y": 648,
+      "w": 54,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "ね",
+      "x": 308,
+      "y": 648,
+      "w": 50,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ね",
+      "x": 360,
+      "y": 648,
+      "w": 51,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "の",
+      "x": 413,
+      "y": 648,
+      "w": 47,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "の",
+      "x": 462,
+      "y": 648,
+      "w": 48,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "は",
+      "x": 512,
+      "y": 648,
+      "w": 46,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "は",
+      "x": 560,
+      "y": 648,
+      "w": 46,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ば",
+      "x": 608,
+      "y": 648,
+      "w": 48,
+      "h": 61,
+      "source": "font"
+    },
+    {
+      "char": "ば",
+      "x": 658,
+      "y": 648,
+      "w": 49,
+      "h": 62,
+      "source": "font"
+    },
+    {
+      "char": "ぱ",
+      "x": 709,
+      "y": 648,
+      "w": 48,
+      "h": 61,
+      "source": "font"
+    },
+    {
+      "char": "ぱ",
+      "x": 759,
+      "y": 648,
+      "w": 49,
+      "h": 62,
+      "source": "font"
+    },
+    {
+      "char": "ひ",
+      "x": 810,
+      "y": 648,
+      "w": 41,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "ひ",
+      "x": 853,
+      "y": 648,
+      "w": 42,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "び",
+      "x": 897,
+      "y": 648,
+      "w": 44,
+      "h": 54,
+      "source": "font"
+    },
+    {
+      "char": "び",
+      "x": 943,
+      "y": 648,
+      "w": 45,
+      "h": 55,
+      "source": "font"
+    },
+    {
+      "char": "ぴ",
+      "x": 990,
+      "y": 648,
+      "w": 43,
+      "h": 54,
+      "source": "font"
+    },
+    {
+      "char": "ぴ",
+      "x": 1035,
+      "y": 648,
+      "w": 44,
+      "h": 55,
+      "source": "font"
+    },
+    {
+      "char": "ふ",
+      "x": 1081,
+      "y": 648,
+      "w": 56,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "ふ",
+      "x": 1139,
+      "y": 648,
+      "w": 57,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ぶ",
+      "x": 1198,
+      "y": 648,
+      "w": 58,
+      "h": 51,
+      "source": "font"
+    },
+    {
+      "char": "ぶ",
+      "x": 1258,
+      "y": 648,
+      "w": 59,
+      "h": 52,
+      "source": "font"
+    },
+    {
+      "char": "ぷ",
+      "x": 1319,
+      "y": 648,
+      "w": 56,
+      "h": 55,
+      "source": "font"
+    },
+    {
+      "char": "ぷ",
+      "x": 1377,
+      "y": 648,
+      "w": 57,
+      "h": 56,
+      "source": "font"
+    },
+    {
+      "char": "へ",
+      "x": 1436,
+      "y": 648,
+      "w": 51,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "へ",
+      "x": 1489,
+      "y": 648,
+      "w": 52,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "べ",
+      "x": 1543,
+      "y": 648,
+      "w": 52,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "べ",
+      "x": 2,
+      "y": 712,
+      "w": 53,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "ぺ",
+      "x": 57,
+      "y": 712,
+      "w": 51,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "ぺ",
+      "x": 110,
+      "y": 712,
+      "w": 52,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "ほ",
+      "x": 164,
+      "y": 712,
+      "w": 46,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "ほ",
+      "x": 212,
+      "y": 712,
+      "w": 47,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ぼ",
+      "x": 261,
+      "y": 712,
+      "w": 46,
+      "h": 61,
+      "source": "font"
+    },
+    {
+      "char": "ぼ",
+      "x": 309,
+      "y": 712,
+      "w": 47,
+      "h": 62,
+      "source": "font"
+    },
+    {
+      "char": "ぽ",
+      "x": 358,
+      "y": 712,
+      "w": 50,
+      "h": 60,
+      "source": "font"
+    },
+    {
+      "char": "ぽ",
+      "x": 410,
+      "y": 712,
+      "w": 50,
+      "h": 61,
+      "source": "font"
+    },
+    {
+      "char": "ま",
+      "x": 462,
+      "y": 712,
+      "w": 35,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ま",
+      "x": 499,
+      "y": 712,
+      "w": 35,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "み",
+      "x": 536,
+      "y": 712,
+      "w": 48,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "み",
+      "x": 586,
+      "y": 712,
+      "w": 48,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "む",
+      "x": 636,
+      "y": 712,
+      "w": 51,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "む",
+      "x": 689,
+      "y": 712,
+      "w": 52,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "め",
+      "x": 743,
+      "y": 712,
+      "w": 51,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "め",
+      "x": 796,
+      "y": 712,
+      "w": 51,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "も",
+      "x": 849,
+      "y": 712,
+      "w": 38,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "も",
+      "x": 889,
+      "y": 712,
+      "w": 39,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "ゃ",
+      "x": 930,
+      "y": 712,
+      "w": 34,
+      "h": 33,
+      "source": "font"
+    },
+    {
+      "char": "ゃ",
+      "x": 966,
+      "y": 712,
+      "w": 35,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "や",
+      "x": 1003,
+      "y": 712,
+      "w": 44,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "や",
+      "x": 1049,
+      "y": 712,
+      "w": 45,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ゅ",
+      "x": 1096,
+      "y": 712,
+      "w": 36,
+      "h": 33,
+      "source": "font"
+    },
+    {
+      "char": "ゅ",
+      "x": 1134,
+      "y": 712,
+      "w": 37,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "ゆ",
+      "x": 1173,
+      "y": 712,
+      "w": 50,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ゆ",
+      "x": 1225,
+      "y": 712,
+      "w": 51,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ょ",
+      "x": 1278,
+      "y": 712,
+      "w": 29,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "ょ",
+      "x": 1309,
+      "y": 712,
+      "w": 29,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "よ",
+      "x": 1340,
+      "y": 712,
+      "w": 36,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "よ",
+      "x": 1378,
+      "y": 712,
+      "w": 37,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ら",
+      "x": 1417,
+      "y": 712,
+      "w": 37,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ら",
+      "x": 1456,
+      "y": 712,
+      "w": 38,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "り",
+      "x": 1496,
+      "y": 712,
+      "w": 38,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "り",
+      "x": 1536,
+      "y": 712,
+      "w": 39,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "る",
+      "x": 2,
+      "y": 776,
+      "w": 37,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "る",
+      "x": 41,
+      "y": 776,
+      "w": 38,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "れ",
+      "x": 81,
+      "y": 776,
+      "w": 47,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "れ",
+      "x": 130,
+      "y": 776,
+      "w": 48,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "ろ",
+      "x": 180,
+      "y": 776,
+      "w": 35,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "ろ",
+      "x": 217,
+      "y": 776,
+      "w": 35,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ゎ",
+      "x": 254,
+      "y": 776,
+      "w": 35,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "ゎ",
+      "x": 291,
+      "y": 776,
+      "w": 35,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "わ",
+      "x": 328,
+      "y": 776,
+      "w": 47,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "わ",
+      "x": 377,
+      "y": 776,
+      "w": 48,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "を",
+      "x": 427,
+      "y": 776,
+      "w": 33,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "を",
+      "x": 462,
+      "y": 776,
+      "w": 34,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "ん",
+      "x": 498,
+      "y": 776,
+      "w": 44,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "ん",
+      "x": 544,
+      "y": 776,
+      "w": 45,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ゔ",
+      "x": 591,
+      "y": 776,
+      "w": 33,
+      "h": 61,
+      "source": "font"
+    },
+    {
+      "char": "ゔ",
+      "x": 626,
+      "y": 776,
+      "w": 34,
+      "h": 62,
+      "source": "font"
+    },
+    {
+      "char": "ゕ",
+      "x": 662,
+      "y": 776,
+      "w": 37,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "ゕ",
+      "x": 701,
+      "y": 776,
+      "w": 38,
+      "h": 33,
+      "source": "font"
+    },
+    {
+      "char": "ゖ",
+      "x": 741,
+      "y": 776,
+      "w": 34,
+      "h": 33,
+      "source": "font"
+    },
+    {
+      "char": "ゖ",
+      "x": 777,
+      "y": 776,
+      "w": 35,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "ァ",
+      "x": 814,
+      "y": 776,
+      "w": 36,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "ァ",
+      "x": 852,
+      "y": 776,
+      "w": 37,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "ア",
+      "x": 891,
+      "y": 776,
+      "w": 45,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "ア",
+      "x": 938,
+      "y": 776,
+      "w": 45,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "ィ",
+      "x": 985,
+      "y": 776,
+      "w": 31,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "ィ",
+      "x": 1018,
+      "y": 776,
+      "w": 32,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "イ",
+      "x": 1052,
+      "y": 776,
+      "w": 38,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "イ",
+      "x": 1092,
+      "y": 776,
+      "w": 38,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "ゥ",
+      "x": 1132,
+      "y": 776,
+      "w": 34,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "ゥ",
+      "x": 1168,
+      "y": 776,
+      "w": 35,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "ウ",
+      "x": 1205,
+      "y": 776,
+      "w": 41,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "ウ",
+      "x": 1248,
+      "y": 776,
+      "w": 42,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ェ",
+      "x": 1292,
+      "y": 776,
+      "w": 32,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "ェ",
+      "x": 1326,
+      "y": 776,
+      "w": 32,
+      "h": 33,
+      "source": "font"
+    },
+    {
+      "char": "エ",
+      "x": 1360,
+      "y": 776,
+      "w": 39,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "エ",
+      "x": 1401,
+      "y": 776,
+      "w": 40,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "ォ",
+      "x": 1443,
+      "y": 776,
+      "w": 35,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "ォ",
+      "x": 1480,
+      "y": 776,
+      "w": 36,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "オ",
+      "x": 1518,
+      "y": 776,
+      "w": 43,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "オ",
+      "x": 2,
+      "y": 840,
+      "w": 44,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "カ",
+      "x": 48,
+      "y": 840,
+      "w": 41,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "カ",
+      "x": 91,
+      "y": 840,
+      "w": 41,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ガ",
+      "x": 134,
+      "y": 840,
+      "w": 46,
+      "h": 56,
+      "source": "font"
+    },
+    {
+      "char": "ガ",
+      "x": 182,
+      "y": 840,
+      "w": 46,
+      "h": 57,
+      "source": "font"
+    },
+    {
+      "char": "キ",
+      "x": 230,
+      "y": 840,
+      "w": 37,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "キ",
+      "x": 269,
+      "y": 840,
+      "w": 37,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ギ",
+      "x": 308,
+      "y": 840,
+      "w": 45,
+      "h": 54,
+      "source": "font"
+    },
+    {
+      "char": "ギ",
+      "x": 355,
+      "y": 840,
+      "w": 46,
+      "h": 55,
+      "source": "font"
+    },
+    {
+      "char": "ク",
+      "x": 403,
+      "y": 840,
+      "w": 41,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "ク",
+      "x": 446,
+      "y": 840,
+      "w": 41,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "グ",
+      "x": 489,
+      "y": 840,
+      "w": 41,
+      "h": 60,
+      "source": "font"
+    },
+    {
+      "char": "グ",
+      "x": 532,
+      "y": 840,
+      "w": 41,
+      "h": 61,
+      "source": "font"
+    },
+    {
+      "char": "ケ",
+      "x": 575,
+      "y": 840,
+      "w": 45,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ケ",
+      "x": 622,
+      "y": 840,
+      "w": 46,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "ゲ",
+      "x": 670,
+      "y": 840,
+      "w": 45,
+      "h": 57,
+      "source": "font"
+    },
+    {
+      "char": "ゲ",
+      "x": 717,
+      "y": 840,
+      "w": 46,
+      "h": 58,
+      "source": "font"
+    },
+    {
+      "char": "コ",
+      "x": 765,
+      "y": 840,
+      "w": 35,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "コ",
+      "x": 802,
+      "y": 840,
+      "w": 36,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "ゴ",
+      "x": 840,
+      "y": 840,
+      "w": 35,
+      "h": 57,
+      "source": "font"
+    },
+    {
+      "char": "ゴ",
+      "x": 877,
+      "y": 840,
+      "w": 36,
+      "h": 58,
+      "source": "font"
+    },
+    {
+      "char": "サ",
+      "x": 915,
+      "y": 840,
+      "w": 50,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "サ",
+      "x": 967,
+      "y": 840,
+      "w": 51,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ザ",
+      "x": 1020,
+      "y": 840,
+      "w": 50,
+      "h": 61,
+      "source": "font"
+    },
+    {
+      "char": "ザ",
+      "x": 1072,
+      "y": 840,
+      "w": 51,
+      "h": 62,
+      "source": "font"
+    },
+    {
+      "char": "シ",
+      "x": 1125,
+      "y": 840,
+      "w": 41,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "シ",
+      "x": 1168,
+      "y": 840,
+      "w": 42,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "ジ",
+      "x": 1212,
+      "y": 840,
+      "w": 42,
+      "h": 60,
+      "source": "font"
+    },
+    {
+      "char": "ジ",
+      "x": 1256,
+      "y": 840,
+      "w": 43,
+      "h": 61,
+      "source": "font"
+    },
+    {
+      "char": "ス",
+      "x": 1301,
+      "y": 840,
+      "w": 44,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "ス",
+      "x": 1347,
+      "y": 840,
+      "w": 45,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "ズ",
+      "x": 1394,
+      "y": 840,
+      "w": 44,
+      "h": 59,
+      "source": "font"
+    },
+    {
+      "char": "ズ",
+      "x": 1440,
+      "y": 840,
+      "w": 45,
+      "h": 60,
+      "source": "font"
+    },
+    {
+      "char": "セ",
+      "x": 1487,
+      "y": 840,
+      "w": 49,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "セ",
+      "x": 1538,
+      "y": 840,
+      "w": 50,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ゼ",
+      "x": 2,
+      "y": 904,
+      "w": 49,
+      "h": 57,
+      "source": "font"
+    },
+    {
+      "char": "ゼ",
+      "x": 53,
+      "y": 904,
+      "w": 50,
+      "h": 58,
+      "source": "font"
+    },
+    {
+      "char": "ソ",
+      "x": 105,
+      "y": 904,
+      "w": 47,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "ソ",
+      "x": 154,
+      "y": 904,
+      "w": 48,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "ゾ",
+      "x": 204,
+      "y": 904,
+      "w": 47,
+      "h": 57,
+      "source": "font"
+    },
+    {
+      "char": "ゾ",
+      "x": 253,
+      "y": 904,
+      "w": 48,
+      "h": 59,
+      "source": "font"
+    },
+    {
+      "char": "タ",
+      "x": 303,
+      "y": 904,
+      "w": 40,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "タ",
+      "x": 345,
+      "y": 904,
+      "w": 41,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "ダ",
+      "x": 388,
+      "y": 904,
+      "w": 40,
+      "h": 60,
+      "source": "font"
+    },
+    {
+      "char": "ダ",
+      "x": 430,
+      "y": 904,
+      "w": 41,
+      "h": 61,
+      "source": "font"
+    },
+    {
+      "char": "チ",
+      "x": 473,
+      "y": 904,
+      "w": 39,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "チ",
+      "x": 514,
+      "y": 904,
+      "w": 39,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "ヂ",
+      "x": 555,
+      "y": 904,
+      "w": 39,
+      "h": 62,
+      "source": "font"
+    },
+    {
+      "char": "ヂ",
+      "x": 596,
+      "y": 904,
+      "w": 39,
+      "h": 63,
+      "source": "font"
+    },
+    {
+      "char": "ッ",
+      "x": 637,
+      "y": 904,
+      "w": 38,
+      "h": 33,
+      "source": "font"
+    },
+    {
+      "char": "ッ",
+      "x": 677,
+      "y": 904,
+      "w": 38,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "ツ",
+      "x": 717,
+      "y": 904,
+      "w": 48,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "ツ",
+      "x": 767,
+      "y": 904,
+      "w": 49,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "ヅ",
+      "x": 818,
+      "y": 904,
+      "w": 48,
+      "h": 59,
+      "source": "font"
+    },
+    {
+      "char": "ヅ",
+      "x": 868,
+      "y": 904,
+      "w": 49,
+      "h": 60,
+      "source": "font"
+    },
+    {
+      "char": "テ",
+      "x": 919,
+      "y": 904,
+      "w": 40,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "テ",
+      "x": 961,
+      "y": 904,
+      "w": 41,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "デ",
+      "x": 1004,
+      "y": 904,
+      "w": 40,
+      "h": 62,
+      "source": "font"
+    },
+    {
+      "char": "デ",
+      "x": 1046,
+      "y": 904,
+      "w": 41,
+      "h": 63,
+      "source": "font"
+    },
+    {
+      "char": "ト",
+      "x": 1089,
+      "y": 904,
+      "w": 33,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "ト",
+      "x": 1124,
+      "y": 904,
+      "w": 33,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ド",
+      "x": 1159,
+      "y": 904,
+      "w": 38,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "ド",
+      "x": 1199,
+      "y": 904,
+      "w": 39,
+      "h": 51,
+      "source": "font"
+    },
+    {
+      "char": "ナ",
+      "x": 1240,
+      "y": 904,
+      "w": 38,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ナ",
+      "x": 1280,
+      "y": 904,
+      "w": 39,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "ニ",
+      "x": 1321,
+      "y": 904,
+      "w": 38,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "ニ",
+      "x": 1361,
+      "y": 904,
+      "w": 38,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "ヌ",
+      "x": 1401,
+      "y": 904,
+      "w": 35,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "ヌ",
+      "x": 1438,
+      "y": 904,
+      "w": 36,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ネ",
+      "x": 1476,
+      "y": 904,
+      "w": 43,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ネ",
+      "x": 1521,
+      "y": 904,
+      "w": 44,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "ノ",
+      "x": 1567,
+      "y": 904,
+      "w": 30,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "ノ",
+      "x": 2,
+      "y": 969,
+      "w": 30,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "ハ",
+      "x": 34,
+      "y": 969,
+      "w": 52,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "ハ",
+      "x": 88,
+      "y": 969,
+      "w": 53,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "バ",
+      "x": 143,
+      "y": 969,
+      "w": 52,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "バ",
+      "x": 197,
+      "y": 969,
+      "w": 53,
+      "h": 51,
+      "source": "font"
+    },
+    {
+      "char": "パ",
+      "x": 252,
+      "y": 969,
+      "w": 51,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "パ",
+      "x": 305,
+      "y": 969,
+      "w": 52,
+      "h": 51,
+      "source": "font"
+    },
+    {
+      "char": "ヒ",
+      "x": 359,
+      "y": 969,
+      "w": 36,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "ヒ",
+      "x": 397,
+      "y": 969,
+      "w": 37,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "ビ",
+      "x": 436,
+      "y": 969,
+      "w": 40,
+      "h": 52,
+      "source": "font"
+    },
+    {
+      "char": "ビ",
+      "x": 478,
+      "y": 969,
+      "w": 41,
+      "h": 53,
+      "source": "font"
+    },
+    {
+      "char": "ピ",
+      "x": 521,
+      "y": 969,
+      "w": 40,
+      "h": 53,
+      "source": "font"
+    },
+    {
+      "char": "ピ",
+      "x": 563,
+      "y": 969,
+      "w": 41,
+      "h": 54,
+      "source": "font"
+    },
+    {
+      "char": "フ",
+      "x": 606,
+      "y": 969,
+      "w": 39,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "フ",
+      "x": 647,
+      "y": 969,
+      "w": 40,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "ブ",
+      "x": 689,
+      "y": 969,
+      "w": 39,
+      "h": 61,
+      "source": "font"
+    },
+    {
+      "char": "ブ",
+      "x": 730,
+      "y": 969,
+      "w": 40,
+      "h": 62,
+      "source": "font"
+    },
+    {
+      "char": "プ",
+      "x": 772,
+      "y": 969,
+      "w": 39,
+      "h": 61,
+      "source": "font"
+    },
+    {
+      "char": "プ",
+      "x": 813,
+      "y": 969,
+      "w": 40,
+      "h": 62,
+      "source": "font"
+    },
+    {
+      "char": "ヘ",
+      "x": 855,
+      "y": 969,
+      "w": 50,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "ヘ",
+      "x": 907,
+      "y": 969,
+      "w": 51,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "ベ",
+      "x": 960,
+      "y": 969,
+      "w": 51,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "ベ",
+      "x": 1013,
+      "y": 969,
+      "w": 52,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "ペ",
+      "x": 1067,
+      "y": 969,
+      "w": 50,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "ペ",
+      "x": 1119,
+      "y": 969,
+      "w": 51,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "ホ",
+      "x": 1172,
+      "y": 969,
+      "w": 47,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "ホ",
+      "x": 1221,
+      "y": 969,
+      "w": 48,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "ボ",
+      "x": 1271,
+      "y": 969,
+      "w": 47,
+      "h": 61,
+      "source": "font"
+    },
+    {
+      "char": "ボ",
+      "x": 1320,
+      "y": 969,
+      "w": 48,
+      "h": 62,
+      "source": "font"
+    },
+    {
+      "char": "ポ",
+      "x": 1370,
+      "y": 969,
+      "w": 47,
+      "h": 57,
+      "source": "font"
+    },
+    {
+      "char": "ポ",
+      "x": 1419,
+      "y": 969,
+      "w": 48,
+      "h": 58,
+      "source": "font"
+    },
+    {
+      "char": "マ",
+      "x": 1469,
+      "y": 969,
+      "w": 44,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "マ",
+      "x": 1515,
+      "y": 969,
+      "w": 45,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "ミ",
+      "x": 1562,
+      "y": 969,
+      "w": 36,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "ミ",
+      "x": 2,
+      "y": 1033,
+      "w": 36,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "ム",
+      "x": 40,
+      "y": 1033,
+      "w": 49,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "ム",
+      "x": 91,
+      "y": 1033,
+      "w": 49,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "メ",
+      "x": 142,
+      "y": 1033,
+      "w": 40,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "メ",
+      "x": 184,
+      "y": 1033,
+      "w": 41,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "モ",
+      "x": 227,
+      "y": 1033,
+      "w": 38,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "モ",
+      "x": 267,
+      "y": 1033,
+      "w": 39,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ャ",
+      "x": 308,
+      "y": 1033,
+      "w": 35,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "ャ",
+      "x": 345,
+      "y": 1033,
+      "w": 36,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "ヤ",
+      "x": 383,
+      "y": 1033,
+      "w": 45,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "ヤ",
+      "x": 430,
+      "y": 1033,
+      "w": 46,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ュ",
+      "x": 478,
+      "y": 1033,
+      "w": 30,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "ュ",
+      "x": 510,
+      "y": 1033,
+      "w": 31,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "ユ",
+      "x": 543,
+      "y": 1033,
+      "w": 41,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "ユ",
+      "x": 586,
+      "y": 1033,
+      "w": 41,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "ョ",
+      "x": 629,
+      "y": 1033,
+      "w": 24,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "ョ",
+      "x": 655,
+      "y": 1033,
+      "w": 25,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "ヨ",
+      "x": 682,
+      "y": 1033,
+      "w": 31,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "ヨ",
+      "x": 715,
+      "y": 1033,
+      "w": 32,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "ラ",
+      "x": 749,
+      "y": 1033,
+      "w": 38,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "ラ",
+      "x": 789,
+      "y": 1033,
+      "w": 38,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "リ",
+      "x": 829,
+      "y": 1033,
+      "w": 37,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "リ",
+      "x": 868,
+      "y": 1033,
+      "w": 38,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "ル",
+      "x": 908,
+      "y": 1033,
+      "w": 49,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "ル",
+      "x": 959,
+      "y": 1033,
+      "w": 50,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "レ",
+      "x": 1011,
+      "y": 1033,
+      "w": 34,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "レ",
+      "x": 1047,
+      "y": 1033,
+      "w": 35,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "ロ",
+      "x": 1084,
+      "y": 1033,
+      "w": 37,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "ロ",
+      "x": 1123,
+      "y": 1033,
+      "w": 38,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "ヮ",
+      "x": 1163,
+      "y": 1033,
+      "w": 34,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "ヮ",
+      "x": 1199,
+      "y": 1033,
+      "w": 35,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "ワ",
+      "x": 1236,
+      "y": 1033,
+      "w": 43,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "ワ",
+      "x": 1281,
+      "y": 1033,
+      "w": 44,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "ヲ",
+      "x": 1327,
+      "y": 1033,
+      "w": 39,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "ヲ",
+      "x": 1368,
+      "y": 1033,
+      "w": 40,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "ン",
+      "x": 1410,
+      "y": 1033,
+      "w": 40,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "ン",
+      "x": 1452,
+      "y": 1033,
+      "w": 41,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "ヴ",
+      "x": 1495,
+      "y": 1033,
+      "w": 48,
+      "h": 56,
+      "source": "font"
+    },
+    {
+      "char": "ヴ",
+      "x": 1545,
+      "y": 1033,
+      "w": 49,
+      "h": 57,
+      "source": "font"
+    },
+    {
+      "char": "ヵ",
+      "x": 2,
+      "y": 1092,
+      "w": 36,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "ヵ",
+      "x": 40,
+      "y": 1092,
+      "w": 36,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "ヶ",
+      "x": 78,
+      "y": 1092,
+      "w": 36,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "ヶ",
+      "x": 116,
+      "y": 1092,
+      "w": 36,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "・",
+      "x": 154,
+      "y": 1092,
+      "w": 16,
+      "h": 15,
+      "source": "font"
+    },
+    {
+      "char": "・",
+      "x": 172,
+      "y": 1092,
+      "w": 16,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "ー",
+      "x": 190,
+      "y": 1092,
+      "w": 31,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "ー",
+      "x": 223,
+      "y": 1092,
+      "w": 32,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "、",
+      "x": 257,
+      "y": 1092,
+      "w": 15,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "、",
+      "x": 274,
+      "y": 1092,
+      "w": 15,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "。",
+      "x": 291,
+      "y": 1092,
+      "w": 16,
+      "h": 15,
+      "source": "font"
+    },
+    {
+      "char": "。",
+      "x": 309,
+      "y": 1092,
+      "w": 16,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "「",
+      "x": 327,
+      "y": 1092,
+      "w": 22,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "「",
+      "x": 351,
+      "y": 1092,
+      "w": 23,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "」",
+      "x": 376,
+      "y": 1092,
+      "w": 22,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "」",
+      "x": 400,
+      "y": 1092,
+      "w": 23,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "★",
+      "x": 425,
+      "y": 1092,
+      "w": 44,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "★",
+      "x": 471,
+      "y": 1092,
+      "w": 46,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "☆",
+      "x": 519,
+      "y": 1092,
+      "w": 44,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "☆",
+      "x": 565,
+      "y": 1092,
+      "w": 46,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "•",
+      "x": 613,
+      "y": 1092,
+      "w": 41,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "•",
+      "x": 656,
+      "y": 1092,
+      "w": 41,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "♪",
+      "x": 699,
+      "y": 1092,
+      "w": 36,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "♪",
+      "x": 737,
+      "y": 1092,
+      "w": 37,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "!",
+      "x": 776,
+      "y": 1092,
+      "w": 19,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "!",
+      "x": 797,
+      "y": 1092,
+      "w": 20,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "\"",
+      "x": 819,
+      "y": 1092,
+      "w": 24,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "\"",
+      "x": 845,
+      "y": 1092,
+      "w": 24,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "#",
+      "x": 871,
+      "y": 1092,
+      "w": 38,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "#",
+      "x": 911,
+      "y": 1092,
+      "w": 39,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "$",
+      "x": 952,
+      "y": 1092,
+      "w": 35,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "$",
+      "x": 989,
+      "y": 1092,
+      "w": 36,
+      "h": 52,
+      "source": "font"
+    },
+    {
+      "char": "%",
+      "x": 1027,
+      "y": 1092,
+      "w": 50,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "%",
+      "x": 1079,
+      "y": 1092,
+      "w": 52,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "&",
+      "x": 1133,
+      "y": 1092,
+      "w": 40,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "&",
+      "x": 1175,
+      "y": 1092,
+      "w": 41,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "'",
+      "x": 1218,
+      "y": 1092,
+      "w": 13,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "'",
+      "x": 1233,
+      "y": 1092,
+      "w": 13,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "(",
+      "x": 1248,
+      "y": 1092,
+      "w": 19,
+      "h": 54,
+      "source": "font"
+    },
+    {
+      "char": "(",
+      "x": 1269,
+      "y": 1092,
+      "w": 20,
+      "h": 56,
+      "source": "font"
+    },
+    {
+      "char": ")",
+      "x": 1291,
+      "y": 1092,
+      "w": 23,
+      "h": 54,
+      "source": "font"
+    },
+    {
+      "char": ")",
+      "x": 1316,
+      "y": 1092,
+      "w": 23,
+      "h": 56,
+      "source": "font"
+    },
+    {
+      "char": "*",
+      "x": 1341,
+      "y": 1092,
+      "w": 28,
+      "h": 26,
+      "source": "font"
+    },
+    {
+      "char": "*",
+      "x": 1371,
+      "y": 1092,
+      "w": 29,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "+",
+      "x": 1402,
+      "y": 1092,
+      "w": 34,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "+",
+      "x": 1438,
+      "y": 1092,
+      "w": 36,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": ",",
+      "x": 1476,
+      "y": 1092,
+      "w": 15,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": ",",
+      "x": 1493,
+      "y": 1092,
+      "w": 15,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "-",
+      "x": 1510,
+      "y": 1092,
+      "w": 23,
+      "h": 13,
+      "source": "font"
+    },
+    {
+      "char": "-",
+      "x": 1535,
+      "y": 1092,
+      "w": 24,
+      "h": 13,
+      "source": "font"
+    },
+    {
+      "char": ".",
+      "x": 1561,
+      "y": 1092,
+      "w": 15,
+      "h": 12,
+      "source": "font"
+    },
+    {
+      "char": ".",
+      "x": 1578,
+      "y": 1092,
+      "w": 15,
+      "h": 12,
+      "source": "font"
+    },
+    {
+      "char": "/",
+      "x": 2,
+      "y": 1150,
+      "w": 26,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "/",
+      "x": 30,
+      "y": 1150,
+      "w": 27,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "0",
+      "x": 59,
+      "y": 1150,
+      "w": 37,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "0",
+      "x": 98,
+      "y": 1150,
+      "w": 38,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "1",
+      "x": 138,
+      "y": 1150,
+      "w": 26,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "1",
+      "x": 166,
+      "y": 1150,
+      "w": 26,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "2",
+      "x": 194,
+      "y": 1150,
+      "w": 34,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "2",
+      "x": 230,
+      "y": 1150,
+      "w": 36,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "3",
+      "x": 268,
+      "y": 1150,
+      "w": 35,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "3",
+      "x": 305,
+      "y": 1150,
+      "w": 37,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "4",
+      "x": 344,
+      "y": 1150,
+      "w": 36,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "4",
+      "x": 382,
+      "y": 1150,
+      "w": 38,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "5",
+      "x": 422,
+      "y": 1150,
+      "w": 35,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "5",
+      "x": 459,
+      "y": 1150,
+      "w": 37,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "6",
+      "x": 498,
+      "y": 1150,
+      "w": 37,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "6",
+      "x": 537,
+      "y": 1150,
+      "w": 38,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "7",
+      "x": 577,
+      "y": 1150,
+      "w": 35,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "7",
+      "x": 614,
+      "y": 1150,
+      "w": 36,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "8",
+      "x": 652,
+      "y": 1150,
+      "w": 37,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "8",
+      "x": 691,
+      "y": 1150,
+      "w": 38,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "9",
+      "x": 731,
+      "y": 1150,
+      "w": 37,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "9",
+      "x": 770,
+      "y": 1150,
+      "w": 38,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": ":",
+      "x": 810,
+      "y": 1150,
+      "w": 15,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": ":",
+      "x": 827,
+      "y": 1150,
+      "w": 14,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": ";",
+      "x": 843,
+      "y": 1150,
+      "w": 15,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": ";",
+      "x": 860,
+      "y": 1150,
+      "w": 14,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "<",
+      "x": 876,
+      "y": 1150,
+      "w": 29,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "<",
+      "x": 907,
+      "y": 1150,
+      "w": 29,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "=",
+      "x": 938,
+      "y": 1150,
+      "w": 34,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "=",
+      "x": 974,
+      "y": 1150,
+      "w": 35,
+      "h": 24,
+      "source": "font"
+    },
+    {
+      "char": ">",
+      "x": 1011,
+      "y": 1150,
+      "w": 28,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": ">",
+      "x": 1041,
+      "y": 1150,
+      "w": 29,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "?",
+      "x": 1072,
+      "y": 1150,
+      "w": 34,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "?",
+      "x": 1108,
+      "y": 1150,
+      "w": 34,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "@",
+      "x": 1144,
+      "y": 1150,
+      "w": 47,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "@",
+      "x": 1193,
+      "y": 1150,
+      "w": 49,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "A",
+      "x": 1244,
+      "y": 1150,
+      "w": 44,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "A",
+      "x": 1290,
+      "y": 1150,
+      "w": 45,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "B",
+      "x": 1337,
+      "y": 1150,
+      "w": 37,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "B",
+      "x": 1376,
+      "y": 1150,
+      "w": 38,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "C",
+      "x": 1416,
+      "y": 1150,
+      "w": 40,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "C",
+      "x": 1458,
+      "y": 1150,
+      "w": 42,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "D",
+      "x": 1502,
+      "y": 1150,
+      "w": 40,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "D",
+      "x": 1544,
+      "y": 1150,
+      "w": 41,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "E",
+      "x": 2,
+      "y": 1199,
+      "w": 34,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "E",
+      "x": 38,
+      "y": 1199,
+      "w": 35,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "F",
+      "x": 75,
+      "y": 1199,
+      "w": 31,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "F",
+      "x": 108,
+      "y": 1199,
+      "w": 32,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "G",
+      "x": 142,
+      "y": 1199,
+      "w": 41,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "G",
+      "x": 185,
+      "y": 1199,
+      "w": 42,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "H",
+      "x": 229,
+      "y": 1199,
+      "w": 38,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "H",
+      "x": 269,
+      "y": 1199,
+      "w": 39,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "I",
+      "x": 310,
+      "y": 1199,
+      "w": 16,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "I",
+      "x": 328,
+      "y": 1199,
+      "w": 17,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "J",
+      "x": 347,
+      "y": 1199,
+      "w": 26,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "J",
+      "x": 375,
+      "y": 1199,
+      "w": 27,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "K",
+      "x": 404,
+      "y": 1199,
+      "w": 39,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "K",
+      "x": 445,
+      "y": 1199,
+      "w": 40,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "L",
+      "x": 487,
+      "y": 1199,
+      "w": 32,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "L",
+      "x": 521,
+      "y": 1199,
+      "w": 33,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "M",
+      "x": 556,
+      "y": 1199,
+      "w": 45,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "M",
+      "x": 603,
+      "y": 1199,
+      "w": 47,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "N",
+      "x": 652,
+      "y": 1199,
+      "w": 38,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "N",
+      "x": 692,
+      "y": 1199,
+      "w": 39,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "O",
+      "x": 733,
+      "y": 1199,
+      "w": 42,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "O",
+      "x": 777,
+      "y": 1199,
+      "w": 44,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "P",
+      "x": 823,
+      "y": 1199,
+      "w": 35,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "P",
+      "x": 860,
+      "y": 1199,
+      "w": 37,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "Q",
+      "x": 899,
+      "y": 1199,
+      "w": 44,
+      "h": 52,
+      "source": "font"
+    },
+    {
+      "char": "Q",
+      "x": 945,
+      "y": 1199,
+      "w": 46,
+      "h": 54,
+      "source": "font"
+    },
+    {
+      "char": "R",
+      "x": 993,
+      "y": 1199,
+      "w": 38,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "R",
+      "x": 1033,
+      "y": 1199,
+      "w": 39,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "S",
+      "x": 1074,
+      "y": 1199,
+      "w": 36,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "S",
+      "x": 1112,
+      "y": 1199,
+      "w": 38,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "T",
+      "x": 1152,
+      "y": 1199,
+      "w": 35,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "T",
+      "x": 1189,
+      "y": 1199,
+      "w": 36,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "U",
+      "x": 1227,
+      "y": 1199,
+      "w": 38,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "U",
+      "x": 1267,
+      "y": 1199,
+      "w": 39,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "V",
+      "x": 1308,
+      "y": 1199,
+      "w": 42,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "V",
+      "x": 1352,
+      "y": 1199,
+      "w": 43,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "W",
+      "x": 1397,
+      "y": 1199,
+      "w": 54,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "W",
+      "x": 1453,
+      "y": 1199,
+      "w": 56,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "X",
+      "x": 1511,
+      "y": 1199,
+      "w": 40,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "X",
+      "x": 1553,
+      "y": 1199,
+      "w": 41,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "Y",
+      "x": 2,
+      "y": 1255,
+      "w": 40,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "Y",
+      "x": 44,
+      "y": 1255,
+      "w": 41,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "Z",
+      "x": 87,
+      "y": 1255,
+      "w": 35,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "Z",
+      "x": 124,
+      "y": 1255,
+      "w": 36,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "[",
+      "x": 162,
+      "y": 1255,
+      "w": 18,
+      "h": 53,
+      "source": "font"
+    },
+    {
+      "char": "[",
+      "x": 182,
+      "y": 1255,
+      "w": 18,
+      "h": 55,
+      "source": "font"
+    },
+    {
+      "char": "\\",
+      "x": 202,
+      "y": 1255,
+      "w": 26,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "\\",
+      "x": 230,
+      "y": 1255,
+      "w": 27,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "]",
+      "x": 259,
+      "y": 1255,
+      "w": 21,
+      "h": 53,
+      "source": "font"
+    },
+    {
+      "char": "]",
+      "x": 282,
+      "y": 1255,
+      "w": 21,
+      "h": 55,
+      "source": "font"
+    },
+    {
+      "char": "^",
+      "x": 305,
+      "y": 1255,
+      "w": 34,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "^",
+      "x": 341,
+      "y": 1255,
+      "w": 36,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "_",
+      "x": 379,
+      "y": 1255,
+      "w": 28,
+      "h": 7,
+      "source": "font"
+    },
+    {
+      "char": "_",
+      "x": 409,
+      "y": 1255,
+      "w": 29,
+      "h": 8,
+      "source": "font"
+    },
+    {
+      "char": "`",
+      "x": 440,
+      "y": 1255,
+      "w": 21,
+      "h": 15,
+      "source": "font"
+    },
+    {
+      "char": "`",
+      "x": 463,
+      "y": 1255,
+      "w": 22,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "a",
+      "x": 487,
+      "y": 1255,
+      "w": 34,
+      "h": 33,
+      "source": "font"
+    },
+    {
+      "char": "a",
+      "x": 523,
+      "y": 1255,
+      "w": 35,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "b",
+      "x": 560,
+      "y": 1255,
+      "w": 33,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "b",
+      "x": 595,
+      "y": 1255,
+      "w": 34,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "c",
+      "x": 631,
+      "y": 1255,
+      "w": 31,
+      "h": 33,
+      "source": "font"
+    },
+    {
+      "char": "c",
+      "x": 664,
+      "y": 1255,
+      "w": 33,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "d",
+      "x": 699,
+      "y": 1255,
+      "w": 33,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "d",
+      "x": 734,
+      "y": 1255,
+      "w": 35,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "e",
+      "x": 771,
+      "y": 1255,
+      "w": 32,
+      "h": 33,
+      "source": "font"
+    },
+    {
+      "char": "e",
+      "x": 805,
+      "y": 1255,
+      "w": 33,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "f",
+      "x": 840,
+      "y": 1255,
+      "w": 22,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "f",
+      "x": 864,
+      "y": 1255,
+      "w": 22,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "g",
+      "x": 888,
+      "y": 1255,
+      "w": 33,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "g",
+      "x": 923,
+      "y": 1255,
+      "w": 34,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "h",
+      "x": 959,
+      "y": 1255,
+      "w": 32,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "h",
+      "x": 993,
+      "y": 1255,
+      "w": 33,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "i",
+      "x": 1028,
+      "y": 1255,
+      "w": 14,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "i",
+      "x": 1044,
+      "y": 1255,
+      "w": 15,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "j",
+      "x": 1061,
+      "y": 1255,
+      "w": 20,
+      "h": 54,
+      "source": "font"
+    },
+    {
+      "char": "j",
+      "x": 1083,
+      "y": 1255,
+      "w": 21,
+      "h": 55,
+      "source": "font"
+    },
+    {
+      "char": "k",
+      "x": 1106,
+      "y": 1255,
+      "w": 32,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "k",
+      "x": 1140,
+      "y": 1255,
+      "w": 33,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "l",
+      "x": 1175,
+      "y": 1255,
+      "w": 14,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "l",
+      "x": 1191,
+      "y": 1255,
+      "w": 14,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "m",
+      "x": 1207,
+      "y": 1255,
+      "w": 44,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "m",
+      "x": 1253,
+      "y": 1255,
+      "w": 45,
+      "h": 33,
+      "source": "font"
+    },
+    {
+      "char": "n",
+      "x": 1300,
+      "y": 1255,
+      "w": 32,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "n",
+      "x": 1334,
+      "y": 1255,
+      "w": 33,
+      "h": 33,
+      "source": "font"
+    },
+    {
+      "char": "o",
+      "x": 1369,
+      "y": 1255,
+      "w": 34,
+      "h": 33,
+      "source": "font"
+    },
+    {
+      "char": "o",
+      "x": 1405,
+      "y": 1255,
+      "w": 35,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "p",
+      "x": 1442,
+      "y": 1255,
+      "w": 33,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "p",
+      "x": 1477,
+      "y": 1255,
+      "w": 34,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "q",
+      "x": 1513,
+      "y": 1255,
+      "w": 33,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "q",
+      "x": 1548,
+      "y": 1255,
+      "w": 35,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "r",
+      "x": 2,
+      "y": 1312,
+      "w": 22,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "r",
+      "x": 26,
+      "y": 1312,
+      "w": 23,
+      "h": 33,
+      "source": "font"
+    },
+    {
+      "char": "s",
+      "x": 51,
+      "y": 1312,
+      "w": 30,
+      "h": 33,
+      "source": "font"
+    },
+    {
+      "char": "s",
+      "x": 83,
+      "y": 1312,
+      "w": 32,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "t",
+      "x": 117,
+      "y": 1312,
+      "w": 22,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "t",
+      "x": 141,
+      "y": 1312,
+      "w": 23,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "u",
+      "x": 166,
+      "y": 1312,
+      "w": 32,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "u",
+      "x": 200,
+      "y": 1312,
+      "w": 33,
+      "h": 33,
+      "source": "font"
+    },
+    {
+      "char": "v",
+      "x": 235,
+      "y": 1312,
+      "w": 34,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "v",
+      "x": 271,
+      "y": 1312,
+      "w": 35,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "w",
+      "x": 308,
+      "y": 1312,
+      "w": 47,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "w",
+      "x": 357,
+      "y": 1312,
+      "w": 48,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "x",
+      "x": 407,
+      "y": 1312,
+      "w": 34,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "x",
+      "x": 443,
+      "y": 1312,
+      "w": 35,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "y",
+      "x": 480,
+      "y": 1312,
+      "w": 33,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "y",
+      "x": 515,
+      "y": 1312,
+      "w": 34,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "z",
+      "x": 551,
+      "y": 1312,
+      "w": 30,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "z",
+      "x": 583,
+      "y": 1312,
+      "w": 30,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "{",
+      "x": 615,
+      "y": 1312,
+      "w": 18,
+      "h": 54,
+      "source": "font"
+    },
+    {
+      "char": "{",
+      "x": 635,
+      "y": 1312,
+      "w": 19,
+      "h": 57,
+      "source": "font"
+    },
+    {
+      "char": "|",
+      "x": 656,
+      "y": 1312,
+      "w": 9,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "|",
+      "x": 667,
+      "y": 1312,
+      "w": 9,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "}",
+      "x": 678,
+      "y": 1312,
+      "w": 21,
+      "h": 55,
+      "source": "font"
+    },
+    {
+      "char": "}",
+      "x": 701,
+      "y": 1312,
+      "w": 21,
+      "h": 57,
+      "source": "font"
+    },
+    {
+      "char": "~",
+      "x": 724,
+      "y": 1312,
+      "w": 20,
+      "h": 15,
+      "source": "font"
+    },
+    {
+      "char": "~",
+      "x": 746,
+      "y": 1312,
+      "w": 21,
+      "h": 14,
+      "source": "font"
+    },
+    {
+      "char": "¡",
+      "x": 769,
+      "y": 1312,
+      "w": 19,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "¡",
+      "x": 790,
+      "y": 1312,
+      "w": 19,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "¢",
+      "x": 811,
+      "y": 1312,
+      "w": 32,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "¢",
+      "x": 845,
+      "y": 1312,
+      "w": 33,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "£",
+      "x": 880,
+      "y": 1312,
+      "w": 36,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "£",
+      "x": 918,
+      "y": 1312,
+      "w": 37,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "¤",
+      "x": 957,
+      "y": 1312,
+      "w": 30,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "¤",
+      "x": 989,
+      "y": 1312,
+      "w": 31,
+      "h": 33,
+      "source": "font"
+    },
+    {
+      "char": "¥",
+      "x": 1022,
+      "y": 1312,
+      "w": 39,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "¥",
+      "x": 1063,
+      "y": 1312,
+      "w": 41,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "¦",
+      "x": 1106,
+      "y": 1312,
+      "w": 9,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "¦",
+      "x": 1117,
+      "y": 1312,
+      "w": 9,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "§",
+      "x": 1128,
+      "y": 1312,
+      "w": 35,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "§",
+      "x": 1165,
+      "y": 1312,
+      "w": 37,
+      "h": 51,
+      "source": "font"
+    },
+    {
+      "char": "¨",
+      "x": 1204,
+      "y": 1312,
+      "w": 23,
+      "h": 12,
+      "source": "font"
+    },
+    {
+      "char": "¨",
+      "x": 1229,
+      "y": 1312,
+      "w": 24,
+      "h": 13,
+      "source": "font"
+    },
+    {
+      "char": "©",
+      "x": 1255,
+      "y": 1312,
+      "w": 40,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "©",
+      "x": 1297,
+      "y": 1312,
+      "w": 42,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "ª",
+      "x": 1341,
+      "y": 1312,
+      "w": 19,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "ª",
+      "x": 1362,
+      "y": 1312,
+      "w": 19,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "«",
+      "x": 1383,
+      "y": 1312,
+      "w": 30,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "«",
+      "x": 1415,
+      "y": 1312,
+      "w": 31,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "¬",
+      "x": 1448,
+      "y": 1312,
+      "w": 28,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "¬",
+      "x": 1478,
+      "y": 1312,
+      "w": 29,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "®",
+      "x": 1509,
+      "y": 1312,
+      "w": 40,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "®",
+      "x": 1551,
+      "y": 1312,
+      "w": 42,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "¯",
+      "x": 2,
+      "y": 1371,
+      "w": 20,
+      "h": 9,
+      "source": "font"
+    },
+    {
+      "char": "¯",
+      "x": 24,
+      "y": 1371,
+      "w": 21,
+      "h": 9,
+      "source": "font"
+    },
+    {
+      "char": "°",
+      "x": 47,
+      "y": 1371,
+      "w": 18,
+      "h": 15,
+      "source": "font"
+    },
+    {
+      "char": "°",
+      "x": 67,
+      "y": 1371,
+      "w": 18,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "±",
+      "x": 87,
+      "y": 1371,
+      "w": 36,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "±",
+      "x": 125,
+      "y": 1371,
+      "w": 38,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "²",
+      "x": 165,
+      "y": 1371,
+      "w": 20,
+      "h": 25,
+      "source": "font"
+    },
+    {
+      "char": "²",
+      "x": 187,
+      "y": 1371,
+      "w": 21,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "³",
+      "x": 210,
+      "y": 1371,
+      "w": 21,
+      "h": 26,
+      "source": "font"
+    },
+    {
+      "char": "³",
+      "x": 233,
+      "y": 1371,
+      "w": 22,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "´",
+      "x": 257,
+      "y": 1371,
+      "w": 16,
+      "h": 14,
+      "source": "font"
+    },
+    {
+      "char": "´",
+      "x": 275,
+      "y": 1371,
+      "w": 16,
+      "h": 15,
+      "source": "font"
+    },
+    {
+      "char": "µ",
+      "x": 293,
+      "y": 1371,
+      "w": 31,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "µ",
+      "x": 326,
+      "y": 1371,
+      "w": 32,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "¶",
+      "x": 360,
+      "y": 1371,
+      "w": 33,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "¶",
+      "x": 395,
+      "y": 1371,
+      "w": 34,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "·",
+      "x": 431,
+      "y": 1371,
+      "w": 13,
+      "h": 13,
+      "source": "font"
+    },
+    {
+      "char": "·",
+      "x": 446,
+      "y": 1371,
+      "w": 13,
+      "h": 13,
+      "source": "font"
+    },
+    {
+      "char": "¸",
+      "x": 461,
+      "y": 1371,
+      "w": 16,
+      "h": 13,
+      "source": "font"
+    },
+    {
+      "char": "¸",
+      "x": 479,
+      "y": 1371,
+      "w": 17,
+      "h": 13,
+      "source": "font"
+    },
+    {
+      "char": "¹",
+      "x": 498,
+      "y": 1371,
+      "w": 18,
+      "h": 25,
+      "source": "font"
+    },
+    {
+      "char": "¹",
+      "x": 518,
+      "y": 1371,
+      "w": 18,
+      "h": 26,
+      "source": "font"
+    },
+    {
+      "char": "º",
+      "x": 538,
+      "y": 1371,
+      "w": 18,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "º",
+      "x": 558,
+      "y": 1371,
+      "w": 18,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "»",
+      "x": 578,
+      "y": 1371,
+      "w": 31,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "»",
+      "x": 611,
+      "y": 1371,
+      "w": 33,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "¼",
+      "x": 646,
+      "y": 1371,
+      "w": 42,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "¼",
+      "x": 690,
+      "y": 1371,
+      "w": 43,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "½",
+      "x": 735,
+      "y": 1371,
+      "w": 41,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "½",
+      "x": 778,
+      "y": 1371,
+      "w": 43,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "¾",
+      "x": 823,
+      "y": 1371,
+      "w": 43,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "¾",
+      "x": 868,
+      "y": 1371,
+      "w": 44,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "¿",
+      "x": 914,
+      "y": 1371,
+      "w": 34,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "¿",
+      "x": 950,
+      "y": 1371,
+      "w": 35,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "À",
+      "x": 987,
+      "y": 1371,
+      "w": 44,
+      "h": 57,
+      "source": "font"
+    },
+    {
+      "char": "À",
+      "x": 1033,
+      "y": 1371,
+      "w": 45,
+      "h": 59,
+      "source": "font"
+    },
+    {
+      "char": "Á",
+      "x": 1080,
+      "y": 1371,
+      "w": 44,
+      "h": 58,
+      "source": "font"
+    },
+    {
+      "char": "Á",
+      "x": 1126,
+      "y": 1371,
+      "w": 45,
+      "h": 59,
+      "source": "font"
+    },
+    {
+      "char": "Â",
+      "x": 1173,
+      "y": 1371,
+      "w": 44,
+      "h": 58,
+      "source": "font"
+    },
+    {
+      "char": "Â",
+      "x": 1219,
+      "y": 1371,
+      "w": 45,
+      "h": 59,
+      "source": "font"
+    },
+    {
+      "char": "Ã",
+      "x": 1266,
+      "y": 1371,
+      "w": 44,
+      "h": 57,
+      "source": "font"
+    },
+    {
+      "char": "Ã",
+      "x": 1312,
+      "y": 1371,
+      "w": 45,
+      "h": 58,
+      "source": "font"
+    },
+    {
+      "char": "Ä",
+      "x": 1359,
+      "y": 1371,
+      "w": 44,
+      "h": 56,
+      "source": "font"
+    },
+    {
+      "char": "Ä",
+      "x": 1405,
+      "y": 1371,
+      "w": 45,
+      "h": 58,
+      "source": "font"
+    },
+    {
+      "char": "Å",
+      "x": 1452,
+      "y": 1371,
+      "w": 44,
+      "h": 57,
+      "source": "font"
+    },
+    {
+      "char": "Å",
+      "x": 1498,
+      "y": 1371,
+      "w": 45,
+      "h": 59,
+      "source": "font"
+    },
+    {
+      "char": "Æ",
+      "x": 1545,
+      "y": 1371,
+      "w": 49,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "Æ",
+      "x": 2,
+      "y": 1432,
+      "w": 51,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "Ç",
+      "x": 55,
+      "y": 1432,
+      "w": 40,
+      "h": 54,
+      "source": "font"
+    },
+    {
+      "char": "Ç",
+      "x": 97,
+      "y": 1432,
+      "w": 42,
+      "h": 55,
+      "source": "font"
+    },
+    {
+      "char": "È",
+      "x": 141,
+      "y": 1432,
+      "w": 34,
+      "h": 58,
+      "source": "font"
+    },
+    {
+      "char": "È",
+      "x": 177,
+      "y": 1432,
+      "w": 35,
+      "h": 59,
+      "source": "font"
+    },
+    {
+      "char": "É",
+      "x": 214,
+      "y": 1432,
+      "w": 34,
+      "h": 57,
+      "source": "font"
+    },
+    {
+      "char": "É",
+      "x": 250,
+      "y": 1432,
+      "w": 35,
+      "h": 59,
+      "source": "font"
+    },
+    {
+      "char": "Ê",
+      "x": 287,
+      "y": 1432,
+      "w": 34,
+      "h": 57,
+      "source": "font"
+    },
+    {
+      "char": "Ê",
+      "x": 323,
+      "y": 1432,
+      "w": 35,
+      "h": 59,
+      "source": "font"
+    },
+    {
+      "char": "Ë",
+      "x": 360,
+      "y": 1432,
+      "w": 34,
+      "h": 56,
+      "source": "font"
+    },
+    {
+      "char": "Ë",
+      "x": 396,
+      "y": 1432,
+      "w": 35,
+      "h": 58,
+      "source": "font"
+    },
+    {
+      "char": "Ì",
+      "x": 433,
+      "y": 1432,
+      "w": 16,
+      "h": 57,
+      "source": "font"
+    },
+    {
+      "char": "Ì",
+      "x": 451,
+      "y": 1432,
+      "w": 17,
+      "h": 59,
+      "source": "font"
+    },
+    {
+      "char": "Í",
+      "x": 470,
+      "y": 1432,
+      "w": 16,
+      "h": 57,
+      "source": "font"
+    },
+    {
+      "char": "Í",
+      "x": 488,
+      "y": 1432,
+      "w": 17,
+      "h": 59,
+      "source": "font"
+    },
+    {
+      "char": "Î",
+      "x": 507,
+      "y": 1432,
+      "w": 23,
+      "h": 57,
+      "source": "font"
+    },
+    {
+      "char": "Î",
+      "x": 532,
+      "y": 1432,
+      "w": 24,
+      "h": 59,
+      "source": "font"
+    },
+    {
+      "char": "Ï",
+      "x": 558,
+      "y": 1432,
+      "w": 23,
+      "h": 55,
+      "source": "font"
+    },
+    {
+      "char": "Ï",
+      "x": 583,
+      "y": 1432,
+      "w": 24,
+      "h": 58,
+      "source": "font"
+    },
+    {
+      "char": "Ð",
+      "x": 609,
+      "y": 1432,
+      "w": 42,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "Ð",
+      "x": 653,
+      "y": 1432,
+      "w": 43,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "Ñ",
+      "x": 698,
+      "y": 1432,
+      "w": 38,
+      "h": 56,
+      "source": "font"
+    },
+    {
+      "char": "Ñ",
+      "x": 738,
+      "y": 1432,
+      "w": 39,
+      "h": 58,
+      "source": "font"
+    },
+    {
+      "char": "Ò",
+      "x": 779,
+      "y": 1432,
+      "w": 42,
+      "h": 58,
+      "source": "font"
+    },
+    {
+      "char": "Ò",
+      "x": 823,
+      "y": 1432,
+      "w": 44,
+      "h": 60,
+      "source": "font"
+    },
+    {
+      "char": "Ó",
+      "x": 869,
+      "y": 1432,
+      "w": 42,
+      "h": 58,
+      "source": "font"
+    },
+    {
+      "char": "Ó",
+      "x": 913,
+      "y": 1432,
+      "w": 44,
+      "h": 60,
+      "source": "font"
+    },
+    {
+      "char": "Ô",
+      "x": 959,
+      "y": 1432,
+      "w": 42,
+      "h": 58,
+      "source": "font"
+    },
+    {
+      "char": "Ô",
+      "x": 1003,
+      "y": 1432,
+      "w": 44,
+      "h": 60,
+      "source": "font"
+    },
+    {
+      "char": "Õ",
+      "x": 1049,
+      "y": 1432,
+      "w": 42,
+      "h": 58,
+      "source": "font"
+    },
+    {
+      "char": "Õ",
+      "x": 1093,
+      "y": 1432,
+      "w": 44,
+      "h": 59,
+      "source": "font"
+    },
+    {
+      "char": "Ö",
+      "x": 1139,
+      "y": 1432,
+      "w": 42,
+      "h": 57,
+      "source": "font"
+    },
+    {
+      "char": "Ö",
+      "x": 1183,
+      "y": 1432,
+      "w": 44,
+      "h": 58,
+      "source": "font"
+    },
+    {
+      "char": "×",
+      "x": 1229,
+      "y": 1432,
+      "w": 38,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "×",
+      "x": 1269,
+      "y": 1432,
+      "w": 38,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "Ø",
+      "x": 1309,
+      "y": 1432,
+      "w": 44,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "Ø",
+      "x": 1355,
+      "y": 1432,
+      "w": 46,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "Ù",
+      "x": 1403,
+      "y": 1432,
+      "w": 38,
+      "h": 58,
+      "source": "font"
+    },
+    {
+      "char": "Ù",
+      "x": 1443,
+      "y": 1432,
+      "w": 39,
+      "h": 60,
+      "source": "font"
+    },
+    {
+      "char": "Ú",
+      "x": 1484,
+      "y": 1432,
+      "w": 38,
+      "h": 58,
+      "source": "font"
+    },
+    {
+      "char": "Ú",
+      "x": 1524,
+      "y": 1432,
+      "w": 39,
+      "h": 60,
+      "source": "font"
+    },
+    {
+      "char": "Û",
+      "x": 2,
+      "y": 1494,
+      "w": 38,
+      "h": 58,
+      "source": "font"
+    },
+    {
+      "char": "Û",
+      "x": 42,
+      "y": 1494,
+      "w": 39,
+      "h": 60,
+      "source": "font"
+    },
+    {
+      "char": "Ü",
+      "x": 83,
+      "y": 1494,
+      "w": 38,
+      "h": 56,
+      "source": "font"
+    },
+    {
+      "char": "Ü",
+      "x": 123,
+      "y": 1494,
+      "w": 39,
+      "h": 59,
+      "source": "font"
+    },
+    {
+      "char": "Ý",
+      "x": 164,
+      "y": 1494,
+      "w": 40,
+      "h": 57,
+      "source": "font"
+    },
+    {
+      "char": "Ý",
+      "x": 206,
+      "y": 1494,
+      "w": 41,
+      "h": 59,
+      "source": "font"
+    },
+    {
+      "char": "Þ",
+      "x": 249,
+      "y": 1494,
+      "w": 35,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "Þ",
+      "x": 286,
+      "y": 1494,
+      "w": 37,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "ß",
+      "x": 325,
+      "y": 1494,
+      "w": 32,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "ß",
+      "x": 359,
+      "y": 1494,
+      "w": 33,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "à",
+      "x": 394,
+      "y": 1494,
+      "w": 34,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "à",
+      "x": 430,
+      "y": 1494,
+      "w": 35,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "á",
+      "x": 467,
+      "y": 1494,
+      "w": 34,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "á",
+      "x": 503,
+      "y": 1494,
+      "w": 35,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "â",
+      "x": 540,
+      "y": 1494,
+      "w": 34,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "â",
+      "x": 576,
+      "y": 1494,
+      "w": 35,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "ã",
+      "x": 613,
+      "y": 1494,
+      "w": 34,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "ã",
+      "x": 649,
+      "y": 1494,
+      "w": 35,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "ä",
+      "x": 686,
+      "y": 1494,
+      "w": 34,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ä",
+      "x": 722,
+      "y": 1494,
+      "w": 35,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "å",
+      "x": 759,
+      "y": 1494,
+      "w": 34,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "å",
+      "x": 795,
+      "y": 1494,
+      "w": 35,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "æ",
+      "x": 832,
+      "y": 1494,
+      "w": 48,
+      "h": 33,
+      "source": "font"
+    },
+    {
+      "char": "æ",
+      "x": 882,
+      "y": 1494,
+      "w": 49,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "ç",
+      "x": 933,
+      "y": 1494,
+      "w": 31,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "ç",
+      "x": 966,
+      "y": 1494,
+      "w": 33,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "è",
+      "x": 1001,
+      "y": 1494,
+      "w": 32,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "è",
+      "x": 1035,
+      "y": 1494,
+      "w": 33,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "é",
+      "x": 1070,
+      "y": 1494,
+      "w": 32,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "é",
+      "x": 1104,
+      "y": 1494,
+      "w": 33,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "ê",
+      "x": 1139,
+      "y": 1494,
+      "w": 32,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "ê",
+      "x": 1173,
+      "y": 1494,
+      "w": 33,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "ë",
+      "x": 1208,
+      "y": 1494,
+      "w": 32,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ë",
+      "x": 1242,
+      "y": 1494,
+      "w": 33,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "ì",
+      "x": 1277,
+      "y": 1494,
+      "w": 16,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ì",
+      "x": 1295,
+      "y": 1494,
+      "w": 17,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "í",
+      "x": 1314,
+      "y": 1494,
+      "w": 16,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "í",
+      "x": 1332,
+      "y": 1494,
+      "w": 17,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "î",
+      "x": 1351,
+      "y": 1494,
+      "w": 24,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "î",
+      "x": 1377,
+      "y": 1494,
+      "w": 24,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "ï",
+      "x": 1403,
+      "y": 1494,
+      "w": 23,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "ï",
+      "x": 1428,
+      "y": 1494,
+      "w": 24,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ð",
+      "x": 1454,
+      "y": 1494,
+      "w": 32,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ð",
+      "x": 1488,
+      "y": 1494,
+      "w": 33,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "ñ",
+      "x": 1523,
+      "y": 1494,
+      "w": 32,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ñ",
+      "x": 1557,
+      "y": 1494,
+      "w": 33,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "ò",
+      "x": 2,
+      "y": 1556,
+      "w": 34,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "ò",
+      "x": 38,
+      "y": 1556,
+      "w": 35,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "ó",
+      "x": 75,
+      "y": 1556,
+      "w": 34,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "ó",
+      "x": 111,
+      "y": 1556,
+      "w": 35,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "ô",
+      "x": 148,
+      "y": 1556,
+      "w": 34,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "ô",
+      "x": 184,
+      "y": 1556,
+      "w": 35,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "õ",
+      "x": 221,
+      "y": 1556,
+      "w": 34,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "õ",
+      "x": 257,
+      "y": 1556,
+      "w": 35,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "ö",
+      "x": 294,
+      "y": 1556,
+      "w": 34,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ö",
+      "x": 330,
+      "y": 1556,
+      "w": 35,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "÷",
+      "x": 367,
+      "y": 1556,
+      "w": 40,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "÷",
+      "x": 409,
+      "y": 1556,
+      "w": 40,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "ø",
+      "x": 451,
+      "y": 1556,
+      "w": 36,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "ø",
+      "x": 489,
+      "y": 1556,
+      "w": 36,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "ù",
+      "x": 527,
+      "y": 1556,
+      "w": 32,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "ù",
+      "x": 561,
+      "y": 1556,
+      "w": 33,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "ú",
+      "x": 596,
+      "y": 1556,
+      "w": 32,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "ú",
+      "x": 630,
+      "y": 1556,
+      "w": 33,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "û",
+      "x": 665,
+      "y": 1556,
+      "w": 32,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "û",
+      "x": 699,
+      "y": 1556,
+      "w": 33,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "ü",
+      "x": 734,
+      "y": 1556,
+      "w": 32,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ü",
+      "x": 768,
+      "y": 1556,
+      "w": 33,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "ý",
+      "x": 803,
+      "y": 1556,
+      "w": 33,
+      "h": 57,
+      "source": "font"
+    },
+    {
+      "char": "ý",
+      "x": 838,
+      "y": 1556,
+      "w": 34,
+      "h": 58,
+      "source": "font"
+    },
+    {
+      "char": "þ",
+      "x": 874,
+      "y": 1556,
+      "w": 33,
+      "h": 54,
+      "source": "font"
+    },
+    {
+      "char": "þ",
+      "x": 909,
+      "y": 1556,
+      "w": 34,
+      "h": 56,
+      "source": "font"
+    },
+    {
+      "char": "ÿ",
+      "x": 945,
+      "y": 1556,
+      "w": 33,
+      "h": 56,
+      "source": "font"
+    },
+    {
+      "char": "ÿ",
+      "x": 980,
+      "y": 1556,
+      "w": 34,
+      "h": 57,
+      "source": "font"
+    },
+    {
+      "char": "ぁ",
+      "x": 1016,
+      "y": 1556,
+      "w": 41,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "ぁ",
+      "x": 1059,
+      "y": 1556,
+      "w": 43,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "あ",
+      "x": 1104,
+      "y": 1556,
+      "w": 48,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "あ",
+      "x": 1154,
+      "y": 1556,
+      "w": 49,
+      "h": 51,
+      "source": "font"
+    },
+    {
+      "char": "ぃ",
+      "x": 1205,
+      "y": 1556,
+      "w": 40,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "ぃ",
+      "x": 1247,
+      "y": 1556,
+      "w": 42,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "い",
+      "x": 1291,
+      "y": 1556,
+      "w": 46,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "い",
+      "x": 1339,
+      "y": 1556,
+      "w": 48,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "ぅ",
+      "x": 1389,
+      "y": 1556,
+      "w": 38,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "ぅ",
+      "x": 1429,
+      "y": 1556,
+      "w": 38,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "う",
+      "x": 1469,
+      "y": 1556,
+      "w": 44,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "う",
+      "x": 1515,
+      "y": 1556,
+      "w": 46,
+      "h": 52,
+      "source": "font"
+    },
+    {
+      "char": "ぇ",
+      "x": 2,
+      "y": 1616,
+      "w": 40,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "ぇ",
+      "x": 44,
+      "y": 1616,
+      "w": 41,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "え",
+      "x": 87,
+      "y": 1616,
+      "w": 46,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "え",
+      "x": 135,
+      "y": 1616,
+      "w": 48,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "ぉ",
+      "x": 185,
+      "y": 1616,
+      "w": 42,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "ぉ",
+      "x": 229,
+      "y": 1616,
+      "w": 42,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "お",
+      "x": 273,
+      "y": 1616,
+      "w": 48,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "お",
+      "x": 323,
+      "y": 1616,
+      "w": 50,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "か",
+      "x": 375,
+      "y": 1616,
+      "w": 52,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "か",
+      "x": 429,
+      "y": 1616,
+      "w": 54,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "が",
+      "x": 485,
+      "y": 1616,
+      "w": 53,
+      "h": 51,
+      "source": "font"
+    },
+    {
+      "char": "が",
+      "x": 540,
+      "y": 1616,
+      "w": 55,
+      "h": 53,
+      "source": "font"
+    },
+    {
+      "char": "き",
+      "x": 597,
+      "y": 1616,
+      "w": 45,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "き",
+      "x": 644,
+      "y": 1616,
+      "w": 46,
+      "h": 52,
+      "source": "font"
+    },
+    {
+      "char": "ぎ",
+      "x": 692,
+      "y": 1616,
+      "w": 51,
+      "h": 52,
+      "source": "font"
+    },
+    {
+      "char": "ぎ",
+      "x": 745,
+      "y": 1616,
+      "w": 53,
+      "h": 54,
+      "source": "font"
+    },
+    {
+      "char": "く",
+      "x": 800,
+      "y": 1616,
+      "w": 46,
+      "h": 51,
+      "source": "font"
+    },
+    {
+      "char": "く",
+      "x": 848,
+      "y": 1616,
+      "w": 46,
+      "h": 53,
+      "source": "font"
+    },
+    {
+      "char": "ぐ",
+      "x": 896,
+      "y": 1616,
+      "w": 49,
+      "h": 51,
+      "source": "font"
+    },
+    {
+      "char": "ぐ",
+      "x": 947,
+      "y": 1616,
+      "w": 50,
+      "h": 53,
+      "source": "font"
+    },
+    {
+      "char": "け",
+      "x": 999,
+      "y": 1616,
+      "w": 46,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "け",
+      "x": 1047,
+      "y": 1616,
+      "w": 48,
+      "h": 51,
+      "source": "font"
+    },
+    {
+      "char": "げ",
+      "x": 1097,
+      "y": 1616,
+      "w": 53,
+      "h": 53,
+      "source": "font"
+    },
+    {
+      "char": "げ",
+      "x": 1152,
+      "y": 1616,
+      "w": 55,
+      "h": 55,
+      "source": "font"
+    },
+    {
+      "char": "こ",
+      "x": 1209,
+      "y": 1616,
+      "w": 47,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "こ",
+      "x": 1258,
+      "y": 1616,
+      "w": 49,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ご",
+      "x": 1309,
+      "y": 1616,
+      "w": 52,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "ご",
+      "x": 1363,
+      "y": 1616,
+      "w": 54,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "さ",
+      "x": 1419,
+      "y": 1616,
+      "w": 45,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "さ",
+      "x": 1466,
+      "y": 1616,
+      "w": 46,
+      "h": 52,
+      "source": "font"
+    },
+    {
+      "char": "ざ",
+      "x": 1514,
+      "y": 1616,
+      "w": 51,
+      "h": 53,
+      "source": "font"
+    },
+    {
+      "char": "ざ",
+      "x": 2,
+      "y": 1673,
+      "w": 53,
+      "h": 55,
+      "source": "font"
+    },
+    {
+      "char": "し",
+      "x": 57,
+      "y": 1673,
+      "w": 42,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "し",
+      "x": 101,
+      "y": 1673,
+      "w": 45,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "じ",
+      "x": 148,
+      "y": 1673,
+      "w": 42,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "じ",
+      "x": 192,
+      "y": 1673,
+      "w": 45,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "す",
+      "x": 239,
+      "y": 1673,
+      "w": 47,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "す",
+      "x": 288,
+      "y": 1673,
+      "w": 49,
+      "h": 52,
+      "source": "font"
+    },
+    {
+      "char": "ず",
+      "x": 339,
+      "y": 1673,
+      "w": 53,
+      "h": 54,
+      "source": "font"
+    },
+    {
+      "char": "ず",
+      "x": 394,
+      "y": 1673,
+      "w": 55,
+      "h": 55,
+      "source": "font"
+    },
+    {
+      "char": "せ",
+      "x": 451,
+      "y": 1673,
+      "w": 50,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "せ",
+      "x": 503,
+      "y": 1673,
+      "w": 52,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "ぜ",
+      "x": 557,
+      "y": 1673,
+      "w": 56,
+      "h": 51,
+      "source": "font"
+    },
+    {
+      "char": "ぜ",
+      "x": 615,
+      "y": 1673,
+      "w": 58,
+      "h": 53,
+      "source": "font"
+    },
+    {
+      "char": "そ",
+      "x": 675,
+      "y": 1673,
+      "w": 47,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "そ",
+      "x": 724,
+      "y": 1673,
+      "w": 49,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "ぞ",
+      "x": 775,
+      "y": 1673,
+      "w": 51,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "ぞ",
+      "x": 828,
+      "y": 1673,
+      "w": 52,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "た",
+      "x": 882,
+      "y": 1673,
+      "w": 48,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "た",
+      "x": 932,
+      "y": 1673,
+      "w": 50,
+      "h": 51,
+      "source": "font"
+    },
+    {
+      "char": "だ",
+      "x": 984,
+      "y": 1673,
+      "w": 48,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "だ",
+      "x": 1034,
+      "y": 1673,
+      "w": 50,
+      "h": 51,
+      "source": "font"
+    },
+    {
+      "char": "ち",
+      "x": 1086,
+      "y": 1673,
+      "w": 45,
+      "h": 51,
+      "source": "font"
+    },
+    {
+      "char": "ち",
+      "x": 1133,
+      "y": 1673,
+      "w": 47,
+      "h": 52,
+      "source": "font"
+    },
+    {
+      "char": "ぢ",
+      "x": 1182,
+      "y": 1673,
+      "w": 50,
+      "h": 51,
+      "source": "font"
+    },
+    {
+      "char": "ぢ",
+      "x": 1234,
+      "y": 1673,
+      "w": 52,
+      "h": 53,
+      "source": "font"
+    },
+    {
+      "char": "っ",
+      "x": 1288,
+      "y": 1673,
+      "w": 42,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "っ",
+      "x": 1332,
+      "y": 1673,
+      "w": 43,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "つ",
+      "x": 1377,
+      "y": 1673,
+      "w": 49,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "つ",
+      "x": 1428,
+      "y": 1673,
+      "w": 51,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "づ",
+      "x": 1481,
+      "y": 1673,
+      "w": 53,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "づ",
+      "x": 1536,
+      "y": 1673,
+      "w": 55,
+      "h": 52,
+      "source": "font"
+    },
+    {
+      "char": "て",
+      "x": 2,
+      "y": 1730,
+      "w": 47,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "て",
+      "x": 51,
+      "y": 1730,
+      "w": 49,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "で",
+      "x": 102,
+      "y": 1730,
+      "w": 47,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "で",
+      "x": 151,
+      "y": 1730,
+      "w": 49,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "と",
+      "x": 202,
+      "y": 1730,
+      "w": 44,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "と",
+      "x": 248,
+      "y": 1730,
+      "w": 44,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "ど",
+      "x": 294,
+      "y": 1730,
+      "w": 47,
+      "h": 51,
+      "source": "font"
+    },
+    {
+      "char": "ど",
+      "x": 343,
+      "y": 1730,
+      "w": 49,
+      "h": 52,
+      "source": "font"
+    },
+    {
+      "char": "な",
+      "x": 394,
+      "y": 1730,
+      "w": 50,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "な",
+      "x": 446,
+      "y": 1730,
+      "w": 52,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "に",
+      "x": 500,
+      "y": 1730,
+      "w": 47,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "に",
+      "x": 549,
+      "y": 1730,
+      "w": 48,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "ぬ",
+      "x": 599,
+      "y": 1730,
+      "w": 51,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "ぬ",
+      "x": 652,
+      "y": 1730,
+      "w": 53,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "ね",
+      "x": 707,
+      "y": 1730,
+      "w": 52,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "ね",
+      "x": 761,
+      "y": 1730,
+      "w": 54,
+      "h": 52,
+      "source": "font"
+    },
+    {
+      "char": "の",
+      "x": 817,
+      "y": 1730,
+      "w": 50,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "の",
+      "x": 869,
+      "y": 1730,
+      "w": 52,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "は",
+      "x": 923,
+      "y": 1730,
+      "w": 49,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "は",
+      "x": 974,
+      "y": 1730,
+      "w": 51,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "ば",
+      "x": 1027,
+      "y": 1730,
+      "w": 53,
+      "h": 51,
+      "source": "font"
+    },
+    {
+      "char": "ば",
+      "x": 1082,
+      "y": 1730,
+      "w": 55,
+      "h": 53,
+      "source": "font"
+    },
+    {
+      "char": "ぱ",
+      "x": 1139,
+      "y": 1730,
+      "w": 51,
+      "h": 51,
+      "source": "font"
+    },
+    {
+      "char": "ぱ",
+      "x": 1192,
+      "y": 1730,
+      "w": 53,
+      "h": 53,
+      "source": "font"
+    },
+    {
+      "char": "ひ",
+      "x": 1247,
+      "y": 1730,
+      "w": 51,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ひ",
+      "x": 1300,
+      "y": 1730,
+      "w": 53,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "び",
+      "x": 1355,
+      "y": 1730,
+      "w": 53,
+      "h": 52,
+      "source": "font"
+    },
+    {
+      "char": "び",
+      "x": 1410,
+      "y": 1730,
+      "w": 55,
+      "h": 54,
+      "source": "font"
+    },
+    {
+      "char": "ぴ",
+      "x": 1467,
+      "y": 1730,
+      "w": 52,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "ぴ",
+      "x": 1521,
+      "y": 1730,
+      "w": 54,
+      "h": 52,
+      "source": "font"
+    },
+    {
+      "char": "ふ",
+      "x": 2,
+      "y": 1786,
+      "w": 53,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "ふ",
+      "x": 57,
+      "y": 1786,
+      "w": 55,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "ぶ",
+      "x": 114,
+      "y": 1786,
+      "w": 53,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "ぶ",
+      "x": 169,
+      "y": 1786,
+      "w": 55,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "ぷ",
+      "x": 226,
+      "y": 1786,
+      "w": 53,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "ぷ",
+      "x": 281,
+      "y": 1786,
+      "w": 55,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "へ",
+      "x": 338,
+      "y": 1786,
+      "w": 52,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "へ",
+      "x": 392,
+      "y": 1786,
+      "w": 54,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "べ",
+      "x": 448,
+      "y": 1786,
+      "w": 52,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "べ",
+      "x": 502,
+      "y": 1786,
+      "w": 54,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "ぺ",
+      "x": 558,
+      "y": 1786,
+      "w": 52,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ぺ",
+      "x": 612,
+      "y": 1786,
+      "w": 54,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "ほ",
+      "x": 668,
+      "y": 1786,
+      "w": 49,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "ほ",
+      "x": 719,
+      "y": 1786,
+      "w": 51,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "ぼ",
+      "x": 772,
+      "y": 1786,
+      "w": 55,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "ぼ",
+      "x": 829,
+      "y": 1786,
+      "w": 57,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "ぽ",
+      "x": 888,
+      "y": 1786,
+      "w": 50,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "ぽ",
+      "x": 940,
+      "y": 1786,
+      "w": 52,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "ま",
+      "x": 994,
+      "y": 1786,
+      "w": 46,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "ま",
+      "x": 1042,
+      "y": 1786,
+      "w": 48,
+      "h": 51,
+      "source": "font"
+    },
+    {
+      "char": "み",
+      "x": 1092,
+      "y": 1786,
+      "w": 51,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "み",
+      "x": 1145,
+      "y": 1786,
+      "w": 53,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "む",
+      "x": 1200,
+      "y": 1786,
+      "w": 50,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "む",
+      "x": 1252,
+      "y": 1786,
+      "w": 52,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "め",
+      "x": 1306,
+      "y": 1786,
+      "w": 50,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "め",
+      "x": 1358,
+      "y": 1786,
+      "w": 52,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "も",
+      "x": 1412,
+      "y": 1786,
+      "w": 48,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "も",
+      "x": 1462,
+      "y": 1786,
+      "w": 50,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "ゃ",
+      "x": 1514,
+      "y": 1786,
+      "w": 43,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "ゃ",
+      "x": 2,
+      "y": 1839,
+      "w": 44,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "や",
+      "x": 48,
+      "y": 1839,
+      "w": 50,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "や",
+      "x": 100,
+      "y": 1839,
+      "w": 51,
+      "h": 51,
+      "source": "font"
+    },
+    {
+      "char": "ゅ",
+      "x": 153,
+      "y": 1839,
+      "w": 42,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "ゅ",
+      "x": 197,
+      "y": 1839,
+      "w": 44,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "ゆ",
+      "x": 243,
+      "y": 1839,
+      "w": 49,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "ゆ",
+      "x": 294,
+      "y": 1839,
+      "w": 51,
+      "h": 51,
+      "source": "font"
+    },
+    {
+      "char": "ょ",
+      "x": 347,
+      "y": 1839,
+      "w": 41,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "ょ",
+      "x": 390,
+      "y": 1839,
+      "w": 43,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "よ",
+      "x": 435,
+      "y": 1839,
+      "w": 49,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "よ",
+      "x": 486,
+      "y": 1839,
+      "w": 51,
+      "h": 51,
+      "source": "font"
+    },
+    {
+      "char": "ら",
+      "x": 539,
+      "y": 1839,
+      "w": 45,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "ら",
+      "x": 586,
+      "y": 1839,
+      "w": 46,
+      "h": 52,
+      "source": "font"
+    },
+    {
+      "char": "り",
+      "x": 634,
+      "y": 1839,
+      "w": 41,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "り",
+      "x": 677,
+      "y": 1839,
+      "w": 42,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "る",
+      "x": 721,
+      "y": 1839,
+      "w": 49,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "る",
+      "x": 772,
+      "y": 1839,
+      "w": 51,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "れ",
+      "x": 825,
+      "y": 1839,
+      "w": 52,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "れ",
+      "x": 879,
+      "y": 1839,
+      "w": 54,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "ろ",
+      "x": 935,
+      "y": 1839,
+      "w": 48,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "ろ",
+      "x": 985,
+      "y": 1839,
+      "w": 50,
+      "h": 52,
+      "source": "font"
+    },
+    {
+      "char": "ゎ",
+      "x": 1037,
+      "y": 1839,
+      "w": 43,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "ゎ",
+      "x": 1082,
+      "y": 1839,
+      "w": 44,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "わ",
+      "x": 1128,
+      "y": 1839,
+      "w": 50,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "わ",
+      "x": 1180,
+      "y": 1839,
+      "w": 51,
+      "h": 52,
+      "source": "font"
+    },
+    {
+      "char": "ゐ",
+      "x": 1233,
+      "y": 1839,
+      "w": 48,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ゐ",
+      "x": 1283,
+      "y": 1839,
+      "w": 50,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "ゑ",
+      "x": 1335,
+      "y": 1839,
+      "w": 51,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "ゑ",
+      "x": 1388,
+      "y": 1839,
+      "w": 53,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "を",
+      "x": 1443,
+      "y": 1839,
+      "w": 49,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "を",
+      "x": 1494,
+      "y": 1839,
+      "w": 51,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "ん",
+      "x": 1547,
+      "y": 1839,
+      "w": 50,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "ん",
+      "x": 2,
+      "y": 1893,
+      "w": 52,
+      "h": 51,
+      "source": "font"
+    },
+    {
+      "char": "ゔ",
+      "x": 56,
+      "y": 1893,
+      "w": 50,
+      "h": 53,
+      "source": "font"
+    },
+    {
+      "char": "ゔ",
+      "x": 108,
+      "y": 1893,
+      "w": 52,
+      "h": 55,
+      "source": "font"
+    },
+    {
+      "char": "ゕ",
+      "x": 162,
+      "y": 1893,
+      "w": 44,
+      "h": 55,
+      "source": "font"
+    },
+    {
+      "char": "ゕ",
+      "x": 208,
+      "y": 1893,
+      "w": 46,
+      "h": 57,
+      "source": "font"
+    },
+    {
+      "char": "ゖ",
+      "x": 256,
+      "y": 1893,
+      "w": 44,
+      "h": 55,
+      "source": "font"
+    },
+    {
+      "char": "ゖ",
+      "x": 302,
+      "y": 1893,
+      "w": 46,
+      "h": 57,
+      "source": "font"
+    },
+    {
+      "char": "ァ",
+      "x": 350,
+      "y": 1893,
+      "w": 41,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "ァ",
+      "x": 393,
+      "y": 1893,
+      "w": 42,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "ア",
+      "x": 437,
+      "y": 1893,
+      "w": 47,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "ア",
+      "x": 486,
+      "y": 1893,
+      "w": 49,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "ィ",
+      "x": 537,
+      "y": 1893,
+      "w": 41,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "ィ",
+      "x": 580,
+      "y": 1893,
+      "w": 43,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "イ",
+      "x": 625,
+      "y": 1893,
+      "w": 48,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "イ",
+      "x": 675,
+      "y": 1893,
+      "w": 50,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "ゥ",
+      "x": 727,
+      "y": 1893,
+      "w": 39,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "ゥ",
+      "x": 768,
+      "y": 1893,
+      "w": 39,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "ウ",
+      "x": 809,
+      "y": 1893,
+      "w": 45,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "ウ",
+      "x": 856,
+      "y": 1893,
+      "w": 47,
+      "h": 52,
+      "source": "font"
+    },
+    {
+      "char": "ェ",
+      "x": 905,
+      "y": 1893,
+      "w": 42,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "ェ",
+      "x": 949,
+      "y": 1893,
+      "w": 43,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "エ",
+      "x": 994,
+      "y": 1893,
+      "w": 48,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "エ",
+      "x": 1044,
+      "y": 1893,
+      "w": 50,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "ォ",
+      "x": 1096,
+      "y": 1893,
+      "w": 42,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "ォ",
+      "x": 1140,
+      "y": 1893,
+      "w": 43,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "オ",
+      "x": 1185,
+      "y": 1893,
+      "w": 49,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "オ",
+      "x": 1236,
+      "y": 1893,
+      "w": 50,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "カ",
+      "x": 1288,
+      "y": 1893,
+      "w": 46,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "カ",
+      "x": 1336,
+      "y": 1893,
+      "w": 48,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "ガ",
+      "x": 1386,
+      "y": 1893,
+      "w": 50,
+      "h": 51,
+      "source": "font"
+    },
+    {
+      "char": "ガ",
+      "x": 1438,
+      "y": 1893,
+      "w": 52,
+      "h": 52,
+      "source": "font"
+    },
+    {
+      "char": "キ",
+      "x": 1492,
+      "y": 1893,
+      "w": 47,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "キ",
+      "x": 1541,
+      "y": 1893,
+      "w": 49,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "ギ",
+      "x": 2,
+      "y": 1952,
+      "w": 50,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "ギ",
+      "x": 54,
+      "y": 1952,
+      "w": 52,
+      "h": 52,
+      "source": "font"
+    },
+    {
+      "char": "ク",
+      "x": 108,
+      "y": 1952,
+      "w": 50,
+      "h": 51,
+      "source": "font"
+    },
+    {
+      "char": "ク",
+      "x": 160,
+      "y": 1952,
+      "w": 52,
+      "h": 53,
+      "source": "font"
+    },
+    {
+      "char": "グ",
+      "x": 214,
+      "y": 1952,
+      "w": 55,
+      "h": 53,
+      "source": "font"
+    },
+    {
+      "char": "グ",
+      "x": 271,
+      "y": 1952,
+      "w": 57,
+      "h": 55,
+      "source": "font"
+    },
+    {
+      "char": "ケ",
+      "x": 330,
+      "y": 1952,
+      "w": 49,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "ケ",
+      "x": 381,
+      "y": 1952,
+      "w": 51,
+      "h": 51,
+      "source": "font"
+    },
+    {
+      "char": "ゲ",
+      "x": 434,
+      "y": 1952,
+      "w": 51,
+      "h": 52,
+      "source": "font"
+    },
+    {
+      "char": "ゲ",
+      "x": 487,
+      "y": 1952,
+      "w": 53,
+      "h": 53,
+      "source": "font"
+    },
+    {
+      "char": "コ",
+      "x": 542,
+      "y": 1952,
+      "w": 41,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "コ",
+      "x": 585,
+      "y": 1952,
+      "w": 43,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "ゴ",
+      "x": 630,
+      "y": 1952,
+      "w": 50,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "ゴ",
+      "x": 682,
+      "y": 1952,
+      "w": 51,
+      "h": 51,
+      "source": "font"
+    },
+    {
+      "char": "サ",
+      "x": 735,
+      "y": 1952,
+      "w": 50,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "サ",
+      "x": 787,
+      "y": 1952,
+      "w": 52,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "ザ",
+      "x": 841,
+      "y": 1952,
+      "w": 55,
+      "h": 51,
+      "source": "font"
+    },
+    {
+      "char": "ザ",
+      "x": 898,
+      "y": 1952,
+      "w": 57,
+      "h": 53,
+      "source": "font"
+    },
+    {
+      "char": "シ",
+      "x": 957,
+      "y": 1952,
+      "w": 49,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "シ",
+      "x": 1008,
+      "y": 1952,
+      "w": 51,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "ジ",
+      "x": 1061,
+      "y": 1952,
+      "w": 49,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "ジ",
+      "x": 1112,
+      "y": 1952,
+      "w": 51,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "ス",
+      "x": 1165,
+      "y": 1952,
+      "w": 50,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "ス",
+      "x": 1217,
+      "y": 1952,
+      "w": 52,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ズ",
+      "x": 1271,
+      "y": 1952,
+      "w": 50,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "ズ",
+      "x": 1323,
+      "y": 1952,
+      "w": 52,
+      "h": 51,
+      "source": "font"
+    },
+    {
+      "char": "セ",
+      "x": 1377,
+      "y": 1952,
+      "w": 48,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "セ",
+      "x": 1427,
+      "y": 1952,
+      "w": 50,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "ゼ",
+      "x": 1479,
+      "y": 1952,
+      "w": 50,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "ゼ",
+      "x": 1531,
+      "y": 1952,
+      "w": 52,
+      "h": 52,
+      "source": "font"
+    },
+    {
+      "char": "ソ",
+      "x": 2,
+      "y": 2009,
+      "w": 46,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "ソ",
+      "x": 50,
+      "y": 2009,
+      "w": 48,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ゾ",
+      "x": 100,
+      "y": 2009,
+      "w": 48,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "ゾ",
+      "x": 150,
+      "y": 2009,
+      "w": 50,
+      "h": 52,
+      "source": "font"
+    },
+    {
+      "char": "タ",
+      "x": 202,
+      "y": 2009,
+      "w": 50,
+      "h": 51,
+      "source": "font"
+    },
+    {
+      "char": "タ",
+      "x": 254,
+      "y": 2009,
+      "w": 52,
+      "h": 53,
+      "source": "font"
+    },
+    {
+      "char": "ダ",
+      "x": 308,
+      "y": 2009,
+      "w": 55,
+      "h": 54,
+      "source": "font"
+    },
+    {
+      "char": "ダ",
+      "x": 365,
+      "y": 2009,
+      "w": 56,
+      "h": 56,
+      "source": "font"
+    },
+    {
+      "char": "チ",
+      "x": 423,
+      "y": 2009,
+      "w": 48,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "チ",
+      "x": 473,
+      "y": 2009,
+      "w": 50,
+      "h": 52,
+      "source": "font"
+    },
+    {
+      "char": "ヂ",
+      "x": 525,
+      "y": 2009,
+      "w": 55,
+      "h": 52,
+      "source": "font"
+    },
+    {
+      "char": "ヂ",
+      "x": 582,
+      "y": 2009,
+      "w": 56,
+      "h": 54,
+      "source": "font"
+    },
+    {
+      "char": "ッ",
+      "x": 640,
+      "y": 2009,
+      "w": 41,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "ッ",
+      "x": 683,
+      "y": 2009,
+      "w": 43,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "ツ",
+      "x": 728,
+      "y": 2009,
+      "w": 48,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ツ",
+      "x": 778,
+      "y": 2009,
+      "w": 50,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "ヅ",
+      "x": 830,
+      "y": 2009,
+      "w": 48,
+      "h": 51,
+      "source": "font"
+    },
+    {
+      "char": "ヅ",
+      "x": 880,
+      "y": 2009,
+      "w": 50,
+      "h": 53,
+      "source": "font"
+    },
+    {
+      "char": "テ",
+      "x": 932,
+      "y": 2009,
+      "w": 48,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "テ",
+      "x": 982,
+      "y": 2009,
+      "w": 50,
+      "h": 51,
+      "source": "font"
+    },
+    {
+      "char": "デ",
+      "x": 1034,
+      "y": 2009,
+      "w": 52,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "デ",
+      "x": 1088,
+      "y": 2009,
+      "w": 53,
+      "h": 51,
+      "source": "font"
+    },
+    {
+      "char": "ト",
+      "x": 1143,
+      "y": 2009,
+      "w": 41,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "ト",
+      "x": 1186,
+      "y": 2009,
+      "w": 42,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "ド",
+      "x": 1230,
+      "y": 2009,
+      "w": 41,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "ド",
+      "x": 1273,
+      "y": 2009,
+      "w": 42,
+      "h": 51,
+      "source": "font"
+    },
+    {
+      "char": "ナ",
+      "x": 1317,
+      "y": 2009,
+      "w": 48,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "ナ",
+      "x": 1367,
+      "y": 2009,
+      "w": 50,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "ニ",
+      "x": 1419,
+      "y": 2009,
+      "w": 48,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "ニ",
+      "x": 1469,
+      "y": 2009,
+      "w": 50,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "ヌ",
+      "x": 1521,
+      "y": 2009,
+      "w": 50,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ヌ",
+      "x": 2,
+      "y": 2067,
+      "w": 52,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "ネ",
+      "x": 56,
+      "y": 2067,
+      "w": 51,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "ネ",
+      "x": 109,
+      "y": 2067,
+      "w": 53,
+      "h": 51,
+      "source": "font"
+    },
+    {
+      "char": "ノ",
+      "x": 164,
+      "y": 2067,
+      "w": 43,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "ノ",
+      "x": 209,
+      "y": 2067,
+      "w": 45,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "ハ",
+      "x": 256,
+      "y": 2067,
+      "w": 54,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "ハ",
+      "x": 312,
+      "y": 2067,
+      "w": 55,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "バ",
+      "x": 369,
+      "y": 2067,
+      "w": 55,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "バ",
+      "x": 426,
+      "y": 2067,
+      "w": 57,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "パ",
+      "x": 485,
+      "y": 2067,
+      "w": 54,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "パ",
+      "x": 541,
+      "y": 2067,
+      "w": 56,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ヒ",
+      "x": 599,
+      "y": 2067,
+      "w": 43,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ヒ",
+      "x": 644,
+      "y": 2067,
+      "w": 44,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "ビ",
+      "x": 690,
+      "y": 2067,
+      "w": 48,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "ビ",
+      "x": 740,
+      "y": 2067,
+      "w": 49,
+      "h": 51,
+      "source": "font"
+    },
+    {
+      "char": "ピ",
+      "x": 791,
+      "y": 2067,
+      "w": 46,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "ピ",
+      "x": 839,
+      "y": 2067,
+      "w": 47,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "フ",
+      "x": 888,
+      "y": 2067,
+      "w": 47,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "フ",
+      "x": 937,
+      "y": 2067,
+      "w": 47,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "ブ",
+      "x": 986,
+      "y": 2067,
+      "w": 54,
+      "h": 53,
+      "source": "font"
+    },
+    {
+      "char": "ブ",
+      "x": 1042,
+      "y": 2067,
+      "w": 56,
+      "h": 55,
+      "source": "font"
+    },
+    {
+      "char": "プ",
+      "x": 1100,
+      "y": 2067,
+      "w": 52,
+      "h": 53,
+      "source": "font"
+    },
+    {
+      "char": "プ",
+      "x": 1154,
+      "y": 2067,
+      "w": 54,
+      "h": 55,
+      "source": "font"
+    },
+    {
+      "char": "ヘ",
+      "x": 1210,
+      "y": 2067,
+      "w": 52,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "ヘ",
+      "x": 1264,
+      "y": 2067,
+      "w": 54,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "ベ",
+      "x": 1320,
+      "y": 2067,
+      "w": 52,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ベ",
+      "x": 1374,
+      "y": 2067,
+      "w": 54,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "ペ",
+      "x": 1430,
+      "y": 2067,
+      "w": 52,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "ペ",
+      "x": 1484,
+      "y": 2067,
+      "w": 54,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ホ",
+      "x": 1540,
+      "y": 2067,
+      "w": 51,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "ホ",
+      "x": 2,
+      "y": 2124,
+      "w": 53,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "ボ",
+      "x": 57,
+      "y": 2124,
+      "w": 51,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "ボ",
+      "x": 110,
+      "y": 2124,
+      "w": 53,
+      "h": 51,
+      "source": "font"
+    },
+    {
+      "char": "ポ",
+      "x": 165,
+      "y": 2124,
+      "w": 51,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "ポ",
+      "x": 218,
+      "y": 2124,
+      "w": 53,
+      "h": 52,
+      "source": "font"
+    },
+    {
+      "char": "マ",
+      "x": 273,
+      "y": 2124,
+      "w": 49,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "マ",
+      "x": 324,
+      "y": 2124,
+      "w": 51,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "ミ",
+      "x": 377,
+      "y": 2124,
+      "w": 46,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "ミ",
+      "x": 425,
+      "y": 2124,
+      "w": 47,
+      "h": 51,
+      "source": "font"
+    },
+    {
+      "char": "ム",
+      "x": 474,
+      "y": 2124,
+      "w": 51,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ム",
+      "x": 527,
+      "y": 2124,
+      "w": 53,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "メ",
+      "x": 582,
+      "y": 2124,
+      "w": 48,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "メ",
+      "x": 632,
+      "y": 2124,
+      "w": 50,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "モ",
+      "x": 684,
+      "y": 2124,
+      "w": 47,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "モ",
+      "x": 733,
+      "y": 2124,
+      "w": 49,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "ャ",
+      "x": 784,
+      "y": 2124,
+      "w": 42,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "ャ",
+      "x": 828,
+      "y": 2124,
+      "w": 44,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "ヤ",
+      "x": 874,
+      "y": 2124,
+      "w": 49,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "ヤ",
+      "x": 925,
+      "y": 2124,
+      "w": 51,
+      "h": 51,
+      "source": "font"
+    },
+    {
+      "char": "ュ",
+      "x": 978,
+      "y": 2124,
+      "w": 42,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "ュ",
+      "x": 1022,
+      "y": 2124,
+      "w": 44,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "ユ",
+      "x": 1068,
+      "y": 2124,
+      "w": 50,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "ユ",
+      "x": 1120,
+      "y": 2124,
+      "w": 52,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "ョ",
+      "x": 1174,
+      "y": 2124,
+      "w": 37,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "ョ",
+      "x": 1213,
+      "y": 2124,
+      "w": 38,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "ヨ",
+      "x": 1253,
+      "y": 2124,
+      "w": 42,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "ヨ",
+      "x": 1297,
+      "y": 2124,
+      "w": 44,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "ラ",
+      "x": 1343,
+      "y": 2124,
+      "w": 46,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "ラ",
+      "x": 1391,
+      "y": 2124,
+      "w": 48,
+      "h": 51,
+      "source": "font"
+    },
+    {
+      "char": "リ",
+      "x": 1441,
+      "y": 2124,
+      "w": 38,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "リ",
+      "x": 1481,
+      "y": 2124,
+      "w": 40,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "ル",
+      "x": 1523,
+      "y": 2124,
+      "w": 53,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "ル",
+      "x": 2,
+      "y": 2178,
+      "w": 55,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "レ",
+      "x": 59,
+      "y": 2178,
+      "w": 43,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "レ",
+      "x": 104,
+      "y": 2178,
+      "w": 45,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "ロ",
+      "x": 151,
+      "y": 2178,
+      "w": 45,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "ロ",
+      "x": 198,
+      "y": 2178,
+      "w": 46,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "ヮ",
+      "x": 246,
+      "y": 2178,
+      "w": 39,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "ヮ",
+      "x": 287,
+      "y": 2178,
+      "w": 41,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "ワ",
+      "x": 330,
+      "y": 2178,
+      "w": 45,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "ワ",
+      "x": 377,
+      "y": 2178,
+      "w": 47,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "ヰ",
+      "x": 426,
+      "y": 2178,
+      "w": 48,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "ヰ",
+      "x": 476,
+      "y": 2178,
+      "w": 50,
+      "h": 51,
+      "source": "font"
+    },
+    {
+      "char": "ヱ",
+      "x": 528,
+      "y": 2178,
+      "w": 48,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "ヱ",
+      "x": 578,
+      "y": 2178,
+      "w": 50,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "ヲ",
+      "x": 630,
+      "y": 2178,
+      "w": 44,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "ヲ",
+      "x": 676,
+      "y": 2178,
+      "w": 46,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "ン",
+      "x": 724,
+      "y": 2178,
+      "w": 48,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ン",
+      "x": 774,
+      "y": 2178,
+      "w": 50,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "ヴ",
+      "x": 826,
+      "y": 2178,
+      "w": 51,
+      "h": 52,
+      "source": "font"
+    },
+    {
+      "char": "ヴ",
+      "x": 879,
+      "y": 2178,
+      "w": 53,
+      "h": 54,
+      "source": "font"
+    },
+    {
+      "char": "ヵ",
+      "x": 934,
+      "y": 2178,
+      "w": 40,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "ヵ",
+      "x": 976,
+      "y": 2178,
+      "w": 42,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "ヶ",
+      "x": 1020,
+      "y": 2178,
+      "w": 42,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "ヶ",
+      "x": 1064,
+      "y": 2178,
+      "w": 43,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "ヷ",
+      "x": 1109,
+      "y": 2178,
+      "w": 50,
+      "h": 54,
+      "source": "font"
+    },
+    {
+      "char": "ヷ",
+      "x": 1161,
+      "y": 2178,
+      "w": 52,
+      "h": 56,
+      "source": "font"
+    },
+    {
+      "char": "ヸ",
+      "x": 1215,
+      "y": 2178,
+      "w": 54,
+      "h": 51,
+      "source": "font"
+    },
+    {
+      "char": "ヸ",
+      "x": 1271,
+      "y": 2178,
+      "w": 56,
+      "h": 53,
+      "source": "font"
+    },
+    {
+      "char": "ヹ",
+      "x": 1329,
+      "y": 2178,
+      "w": 54,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "ヹ",
+      "x": 1385,
+      "y": 2178,
+      "w": 56,
+      "h": 51,
+      "source": "font"
+    },
+    {
+      "char": "ヺ",
+      "x": 1443,
+      "y": 2178,
+      "w": 49,
+      "h": 54,
+      "source": "font"
+    },
+    {
+      "char": "ヺ",
+      "x": 1494,
+      "y": 2178,
+      "w": 51,
+      "h": 56,
+      "source": "font"
+    },
+    {
+      "char": "・",
+      "x": 1547,
+      "y": 2178,
+      "w": 12,
+      "h": 13,
+      "source": "font"
+    },
+    {
+      "char": "・",
+      "x": 1561,
+      "y": 2178,
+      "w": 14,
+      "h": 13,
+      "source": "font"
+    },
+    {
+      "char": "ー",
+      "x": 2,
+      "y": 2236,
+      "w": 46,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "ー",
+      "x": 50,
+      "y": 2236,
+      "w": 48,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "、",
+      "x": 100,
+      "y": 2236,
+      "w": 24,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "、",
+      "x": 126,
+      "y": 2236,
+      "w": 25,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "。",
+      "x": 153,
+      "y": 2236,
+      "w": 23,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "。",
+      "x": 178,
+      "y": 2236,
+      "w": 23,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "「",
+      "x": 203,
+      "y": 2236,
+      "w": 19,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "「",
+      "x": 224,
+      "y": 2236,
+      "w": 19,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "」",
+      "x": 245,
+      "y": 2236,
+      "w": 25,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "」",
+      "x": 272,
+      "y": 2236,
+      "w": 26,
+      "h": 51,
+      "source": "font"
+    },
+    {
+      "char": "★",
+      "x": 300,
+      "y": 2236,
+      "w": 53,
+      "h": 53,
+      "source": "font"
+    },
+    {
+      "char": "★",
+      "x": 355,
+      "y": 2236,
+      "w": 56,
+      "h": 55,
+      "source": "font"
+    },
+    {
+      "char": "☆",
+      "x": 413,
+      "y": 2236,
+      "w": 53,
+      "h": 54,
+      "source": "font"
+    },
+    {
+      "char": "☆",
+      "x": 468,
+      "y": 2236,
+      "w": 56,
+      "h": 56,
+      "source": "font"
+    },
+    {
+      "char": "•",
+      "x": 526,
+      "y": 2236,
+      "w": 48,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "•",
+      "x": 576,
+      "y": 2236,
+      "w": 50,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "♪",
+      "x": 628,
+      "y": 2236,
+      "w": 38,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "♪",
+      "x": 668,
+      "y": 2236,
+      "w": 39,
+      "h": 50,
+      "source": "font"
+    }
+  ]
+}
\ No newline at end of file
diff --git a/public/scanner/v1/glyphs/death-tag-name.png b/public/scanner/v1/glyphs/death-tag-name.png
new file mode 100644
index 000000000..34b9a7053
Binary files /dev/null and b/public/scanner/v1/glyphs/death-tag-name.png differ
diff --git a/public/scanner/v1/glyphs/death-weapon-ja.json b/public/scanner/v1/glyphs/death-weapon-ja.json
new file mode 100644
index 000000000..092a1a78d
--- /dev/null
+++ b/public/scanner/v1/glyphs/death-weapon-ja.json
@@ -0,0 +1,4725 @@
+{
+  "height": 40,
+  "glyphs": [
+    {
+      "char": "！",
+      "x": 2,
+      "y": 2,
+      "w": 11,
+      "h": 38,
+      "source": "fixture"
+    },
+    {
+      "char": "α",
+      "x": 15,
+      "y": 2,
+      "w": 27,
+      "h": 28,
+      "source": "fixture"
+    },
+    {
+      "char": "イ",
+      "x": 44,
+      "y": 2,
+      "w": 23,
+      "h": 37,
+      "source": "fixture"
+    },
+    {
+      "char": "ク",
+      "x": 69,
+      "y": 2,
+      "w": 25,
+      "h": 35,
+      "source": "fixture"
+    },
+    {
+      "char": "ク",
+      "x": 96,
+      "y": 2,
+      "w": 25,
+      "h": 35,
+      "source": "fixture"
+    },
+    {
+      "char": "ス",
+      "x": 123,
+      "y": 2,
+      "w": 28,
+      "h": 36,
+      "source": "fixture"
+    },
+    {
+      "char": "た",
+      "x": 153,
+      "y": 2,
+      "w": 26,
+      "h": 37,
+      "source": "fixture"
+    },
+    {
+      "char": "ッ",
+      "x": 181,
+      "y": 2,
+      "w": 25,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "で",
+      "x": 208,
+      "y": 2,
+      "w": 25,
+      "h": 44,
+      "source": "fixture"
+    },
+    {
+      "char": "や",
+      "x": 235,
+      "y": 2,
+      "w": 30,
+      "h": 37,
+      "source": "fixture"
+    },
+    {
+      "char": "ら",
+      "x": 267,
+      "y": 2,
+      "w": 24,
+      "h": 40,
+      "source": "fixture"
+    },
+    {
+      "char": "リ",
+      "x": 293,
+      "y": 2,
+      "w": 24,
+      "h": 34,
+      "source": "fixture"
+    },
+    {
+      "char": "れ",
+      "x": 319,
+      "y": 2,
+      "w": 30,
+      "h": 37,
+      "source": "fixture"
+    },
+    {
+      "char": "ン",
+      "x": 351,
+      "y": 2,
+      "w": 27,
+      "h": 33,
+      "source": "fixture"
+    },
+    {
+      "char": "R",
+      "x": 380,
+      "y": 2,
+      "w": 22,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "R",
+      "x": 404,
+      "y": 2,
+      "w": 24,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "ブ",
+      "x": 430,
+      "y": 2,
+      "w": 30,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "ブ",
+      "x": 462,
+      "y": 2,
+      "w": 31,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ラ",
+      "x": 495,
+      "y": 2,
+      "w": 25,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "ラ",
+      "x": 522,
+      "y": 2,
+      "w": 27,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "ス",
+      "x": 551,
+      "y": 2,
+      "w": 28,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "ス",
+      "x": 581,
+      "y": 2,
+      "w": 30,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "タ",
+      "x": 613,
+      "y": 2,
+      "w": 26,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "タ",
+      "x": 641,
+      "y": 2,
+      "w": 27,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ー",
+      "x": 670,
+      "y": 2,
+      "w": 27,
+      "h": 10,
+      "source": "font"
+    },
+    {
+      "char": "ー",
+      "x": 699,
+      "y": 2,
+      "w": 28,
+      "h": 10,
+      "source": "font"
+    },
+    {
+      "char": "エ",
+      "x": 729,
+      "y": 2,
+      "w": 30,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "エ",
+      "x": 761,
+      "y": 2,
+      "w": 31,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "リ",
+      "x": 794,
+      "y": 2,
+      "w": 23,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "リ",
+      "x": 819,
+      "y": 2,
+      "w": 23,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "ト",
+      "x": 844,
+      "y": 2,
+      "w": 21,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "ト",
+      "x": 867,
+      "y": 2,
+      "w": 22,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "デ",
+      "x": 891,
+      "y": 2,
+      "w": 31,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "デ",
+      "x": 924,
+      "y": 2,
+      "w": 32,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "コ",
+      "x": 958,
+      "y": 2,
+      "w": 27,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "コ",
+      "x": 987,
+      "y": 2,
+      "w": 29,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "W",
+      "x": 1018,
+      "y": 2,
+      "w": 34,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "W",
+      "x": 1054,
+      "y": 2,
+      "w": 35,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "N",
+      "x": 1091,
+      "y": 2,
+      "w": 27,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "N",
+      "x": 1120,
+      "y": 2,
+      "w": 27,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "T",
+      "x": 1149,
+      "y": 2,
+      "w": 22,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "T",
+      "x": 1173,
+      "y": 2,
+      "w": 22,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "ク",
+      "x": 1197,
+      "y": 2,
+      "w": 28,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "ク",
+      "x": 1227,
+      "y": 2,
+      "w": 28,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ッ",
+      "x": 1257,
+      "y": 2,
+      "w": 25,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "ッ",
+      "x": 1284,
+      "y": 2,
+      "w": 26,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "シ",
+      "x": 1312,
+      "y": 2,
+      "w": 31,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "シ",
+      "x": 1345,
+      "y": 2,
+      "w": 32,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "ュ",
+      "x": 1379,
+      "y": 2,
+      "w": 25,
+      "h": 25,
+      "source": "font"
+    },
+    {
+      "char": "ュ",
+      "x": 1406,
+      "y": 2,
+      "w": 26,
+      "h": 26,
+      "source": "font"
+    },
+    {
+      "char": "ネ",
+      "x": 1434,
+      "y": 2,
+      "w": 29,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "ネ",
+      "x": 1465,
+      "y": 2,
+      "w": 30,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "オ",
+      "x": 1497,
+      "y": 2,
+      "w": 29,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "オ",
+      "x": 1528,
+      "y": 2,
+      "w": 30,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "ピ",
+      "x": 1560,
+      "y": 2,
+      "w": 27,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "ピ",
+      "x": 2,
+      "y": 50,
+      "w": 29,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "ド",
+      "x": 33,
+      "y": 50,
+      "w": 21,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "ド",
+      "x": 56,
+      "y": 50,
+      "w": 22,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "ロ",
+      "x": 80,
+      "y": 50,
+      "w": 27,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "ロ",
+      "x": 109,
+      "y": 50,
+      "w": 28,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "ン",
+      "x": 139,
+      "y": 50,
+      "w": 29,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "ン",
+      "x": 170,
+      "y": 50,
+      "w": 30,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "グ",
+      "x": 202,
+      "y": 50,
+      "w": 30,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "グ",
+      "x": 234,
+      "y": 50,
+      "w": 30,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "カ",
+      "x": 266,
+      "y": 50,
+      "w": 27,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "カ",
+      "x": 295,
+      "y": 50,
+      "w": 28,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "ム",
+      "x": 325,
+      "y": 50,
+      "w": 29,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "ム",
+      "x": 356,
+      "y": 50,
+      "w": 31,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "ホ",
+      "x": 389,
+      "y": 50,
+      "w": 31,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "ホ",
+      "x": 422,
+      "y": 50,
+      "w": 33,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "艶",
+      "x": 457,
+      "y": 50,
+      "w": 33,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "艶",
+      "x": 492,
+      "y": 50,
+      "w": 34,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "S",
+      "x": 528,
+      "y": 50,
+      "w": 21,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "S",
+      "x": 551,
+      "y": 50,
+      "w": 22,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "-",
+      "x": 575,
+      "y": 50,
+      "w": 16,
+      "h": 10,
+      "source": "font"
+    },
+    {
+      "char": "-",
+      "x": 593,
+      "y": 50,
+      "w": 16,
+      "h": 10,
+      "source": "font"
+    },
+    {
+      "char": "B",
+      "x": 611,
+      "y": 50,
+      "w": 22,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "B",
+      "x": 635,
+      "y": 50,
+      "w": 23,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "L",
+      "x": 660,
+      "y": 50,
+      "w": 22,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "L",
+      "x": 684,
+      "y": 50,
+      "w": 23,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "A",
+      "x": 709,
+      "y": 50,
+      "w": 32,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "A",
+      "x": 743,
+      "y": 50,
+      "w": 33,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "9",
+      "x": 778,
+      "y": 50,
+      "w": 21,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "9",
+      "x": 801,
+      "y": 50,
+      "w": 22,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "2",
+      "x": 825,
+      "y": 50,
+      "w": 21,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "2",
+      "x": 848,
+      "y": 50,
+      "w": 22,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "1",
+      "x": 872,
+      "y": 50,
+      "w": 13,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "1",
+      "x": 887,
+      "y": 50,
+      "w": 14,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "ノ",
+      "x": 903,
+      "y": 50,
+      "w": 21,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "ノ",
+      "x": 926,
+      "y": 50,
+      "w": 22,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "ヴ",
+      "x": 950,
+      "y": 50,
+      "w": 31,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "ヴ",
+      "x": 983,
+      "y": 50,
+      "w": 33,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "ァ",
+      "x": 1018,
+      "y": 50,
+      "w": 25,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "ァ",
+      "x": 1045,
+      "y": 50,
+      "w": 25,
+      "h": 33,
+      "source": "font"
+    },
+    {
+      "char": "ダ",
+      "x": 1072,
+      "y": 50,
+      "w": 29,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "ダ",
+      "x": 1103,
+      "y": 50,
+      "w": 30,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "レ",
+      "x": 1135,
+      "y": 50,
+      "w": 23,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "レ",
+      "x": 1160,
+      "y": 50,
+      "w": 25,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "プ",
+      "x": 1187,
+      "y": 50,
+      "w": 30,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "プ",
+      "x": 1219,
+      "y": 50,
+      "w": 32,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "フ",
+      "x": 1253,
+      "y": 50,
+      "w": 26,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "フ",
+      "x": 1281,
+      "y": 50,
+      "w": 27,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "ィ",
+      "x": 1310,
+      "y": 50,
+      "w": 22,
+      "h": 33,
+      "source": "font"
+    },
+    {
+      "char": "ィ",
+      "x": 1334,
+      "y": 50,
+      "w": 24,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "セ",
+      "x": 1360,
+      "y": 50,
+      "w": 29,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "セ",
+      "x": 1391,
+      "y": 50,
+      "w": 30,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "・",
+      "x": 1423,
+      "y": 50,
+      "w": 11,
+      "h": 14,
+      "source": "font"
+    },
+    {
+      "char": "・",
+      "x": 1436,
+      "y": 50,
+      "w": 12,
+      "h": 14,
+      "source": "font"
+    },
+    {
+      "char": "ヒ",
+      "x": 1450,
+      "y": 50,
+      "w": 24,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "ヒ",
+      "x": 1476,
+      "y": 50,
+      "w": 25,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "Z",
+      "x": 1503,
+      "y": 50,
+      "w": 24,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "Z",
+      "x": 1529,
+      "y": 50,
+      "w": 25,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "パ",
+      "x": 1556,
+      "y": 50,
+      "w": 33,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "パ",
+      "x": 2,
+      "y": 98,
+      "w": 34,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "サ",
+      "x": 38,
+      "y": 98,
+      "w": 29,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "サ",
+      "x": 69,
+      "y": 98,
+      "w": 30,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "イ",
+      "x": 101,
+      "y": 98,
+      "w": 28,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "イ",
+      "x": 131,
+      "y": 98,
+      "w": 29,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "彗",
+      "x": 162,
+      "y": 98,
+      "w": 31,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "彗",
+      "x": 195,
+      "y": 98,
+      "w": 32,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "ソ",
+      "x": 229,
+      "y": 98,
+      "w": 29,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "ソ",
+      "x": 260,
+      "y": 98,
+      "w": 29,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "チ",
+      "x": 291,
+      "y": 98,
+      "w": 29,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "チ",
+      "x": 322,
+      "y": 98,
+      "w": 31,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "バ",
+      "x": 355,
+      "y": 98,
+      "w": 33,
+      "h": 33,
+      "source": "font"
+    },
+    {
+      "char": "バ",
+      "x": 390,
+      "y": 98,
+      "w": 34,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "4",
+      "x": 426,
+      "y": 98,
+      "w": 22,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "4",
+      "x": 450,
+      "y": 98,
+      "w": 22,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "式",
+      "x": 474,
+      "y": 98,
+      "w": 30,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "式",
+      "x": 506,
+      "y": 98,
+      "w": 31,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "竹",
+      "x": 539,
+      "y": 98,
+      "w": 32,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "竹",
+      "x": 573,
+      "y": 98,
+      "w": 32,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "筒",
+      "x": 607,
+      "y": 98,
+      "w": 31,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "筒",
+      "x": 640,
+      "y": 98,
+      "w": 33,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "銃",
+      "x": 675,
+      "y": 98,
+      "w": 33,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "銃",
+      "x": 710,
+      "y": 98,
+      "w": 34,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "甲",
+      "x": 746,
+      "y": 98,
+      "w": 27,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "甲",
+      "x": 775,
+      "y": 98,
+      "w": 27,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "乙",
+      "x": 804,
+      "y": 98,
+      "w": 29,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "乙",
+      "x": 835,
+      "y": 98,
+      "w": 31,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "K",
+      "x": 868,
+      "y": 98,
+      "w": 24,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "K",
+      "x": 894,
+      "y": 98,
+      "w": 25,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "ボ",
+      "x": 921,
+      "y": 98,
+      "w": 31,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "ボ",
+      "x": 954,
+      "y": 98,
+      "w": 33,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "F",
+      "x": 989,
+      "y": 98,
+      "w": 22,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "F",
+      "x": 1013,
+      "y": 98,
+      "w": 23,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "ャ",
+      "x": 1038,
+      "y": 98,
+      "w": 24,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "ャ",
+      "x": 1064,
+      "y": 98,
+      "w": 25,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "ジ",
+      "x": 1091,
+      "y": 98,
+      "w": 31,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "ジ",
+      "x": 1124,
+      "y": 98,
+      "w": 32,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "P",
+      "x": 1158,
+      "y": 98,
+      "w": 23,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "P",
+      "x": 1183,
+      "y": 98,
+      "w": 24,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "E",
+      "x": 1209,
+      "y": 98,
+      "w": 22,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "E",
+      "x": 1233,
+      "y": 98,
+      "w": 23,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "/",
+      "x": 1258,
+      "y": 98,
+      "w": 18,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "/",
+      "x": 1278,
+      "y": 98,
+      "w": 19,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "5",
+      "x": 1299,
+      "y": 98,
+      "w": 20,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "5",
+      "x": 1321,
+      "y": 98,
+      "w": 21,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "H",
+      "x": 1344,
+      "y": 98,
+      "w": 27,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "H",
+      "x": 1373,
+      "y": 98,
+      "w": 28,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "α",
+      "x": 1403,
+      "y": 98,
+      "w": 23,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "α",
+      "x": 1428,
+      "y": 98,
+      "w": 25,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "β",
+      "x": 1455,
+      "y": 98,
+      "w": 24,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "β",
+      "x": 1481,
+      "y": 98,
+      "w": 24,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "ア",
+      "x": 1507,
+      "y": 98,
+      "w": 29,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "ア",
+      "x": 1538,
+      "y": 98,
+      "w": 31,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "ル",
+      "x": 2,
+      "y": 145,
+      "w": 32,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "ル",
+      "x": 36,
+      "y": 145,
+      "w": 34,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "蹄",
+      "x": 72,
+      "y": 145,
+      "w": 33,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "蹄",
+      "x": 107,
+      "y": 145,
+      "w": 34,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "ケ",
+      "x": 143,
+      "y": 145,
+      "w": 30,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "ケ",
+      "x": 175,
+      "y": 145,
+      "w": 31,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "ビ",
+      "x": 208,
+      "y": 145,
+      "w": 28,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "ビ",
+      "x": 238,
+      "y": 145,
+      "w": 29,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "ガ",
+      "x": 269,
+      "y": 145,
+      "w": 29,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "ガ",
+      "x": 300,
+      "y": 145,
+      "w": 30,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "マ",
+      "x": 332,
+      "y": 145,
+      "w": 29,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "マ",
+      "x": 363,
+      "y": 145,
+      "w": 29,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "ニ",
+      "x": 394,
+      "y": 145,
+      "w": 30,
+      "h": 30,
+      "source": "font"
+    },
+    {
+      "char": "ニ",
+      "x": 426,
+      "y": 145,
+      "w": 31,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "耀",
+      "x": 459,
+      "y": 145,
+      "w": 33,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "耀",
+      "x": 494,
+      "y": 145,
+      "w": 34,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "O",
+      "x": 530,
+      "y": 145,
+      "w": 29,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "O",
+      "x": 561,
+      "y": 145,
+      "w": 31,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "ワ",
+      "x": 594,
+      "y": 145,
+      "w": 28,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "ワ",
+      "x": 624,
+      "y": 145,
+      "w": 29,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "G",
+      "x": 655,
+      "y": 145,
+      "w": 27,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "G",
+      "x": 684,
+      "y": 145,
+      "w": 28,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "ナ",
+      "x": 714,
+      "y": 145,
+      "w": 29,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "ナ",
+      "x": 745,
+      "y": 145,
+      "w": 30,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "モ",
+      "x": 777,
+      "y": 145,
+      "w": 29,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "モ",
+      "x": 808,
+      "y": 145,
+      "w": 31,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "テ",
+      "x": 841,
+      "y": 145,
+      "w": 29,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "テ",
+      "x": 872,
+      "y": 145,
+      "w": 31,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "冥",
+      "x": 905,
+      "y": 145,
+      "w": 29,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "冥",
+      "x": 936,
+      "y": 145,
+      "w": 31,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "ォ",
+      "x": 969,
+      "y": 145,
+      "w": 23,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "ォ",
+      "x": 994,
+      "y": 145,
+      "w": 25,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "惑",
+      "x": 1021,
+      "y": 145,
+      "w": 31,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "惑",
+      "x": 1054,
+      "y": 145,
+      "w": 33,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "ミ",
+      "x": 1089,
+      "y": 145,
+      "w": 24,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "ミ",
+      "x": 1115,
+      "y": 145,
+      "w": 25,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "U",
+      "x": 1142,
+      "y": 145,
+      "w": 24,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "U",
+      "x": 1168,
+      "y": 145,
+      "w": 25,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "封",
+      "x": 1195,
+      "y": 145,
+      "w": 33,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "封",
+      "x": 1230,
+      "y": 145,
+      "w": 34,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "ェ",
+      "x": 1266,
+      "y": 145,
+      "w": 25,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "ェ",
+      "x": 1293,
+      "y": 145,
+      "w": 26,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "繚",
+      "x": 1321,
+      "y": 145,
+      "w": 34,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "繚",
+      "x": 1357,
+      "y": 145,
+      "w": 35,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "張",
+      "x": 1394,
+      "y": 145,
+      "w": 32,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "張",
+      "x": 1428,
+      "y": 145,
+      "w": 33,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "替",
+      "x": 1463,
+      "y": 145,
+      "w": 32,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "替",
+      "x": 1497,
+      "y": 145,
+      "w": 33,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "傘",
+      "x": 1532,
+      "y": 145,
+      "w": 33,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "傘",
+      "x": 2,
+      "y": 192,
+      "w": 35,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "キ",
+      "x": 39,
+      "y": 192,
+      "w": 27,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "キ",
+      "x": 68,
+      "y": 192,
+      "w": 29,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "C",
+      "x": 99,
+      "y": 192,
+      "w": 21,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "C",
+      "x": 122,
+      "y": 192,
+      "w": 22,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "M",
+      "x": 146,
+      "y": 192,
+      "w": 30,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "M",
+      "x": 178,
+      "y": 192,
+      "w": 31,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "彩",
+      "x": 211,
+      "y": 192,
+      "w": 32,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "彩",
+      "x": 245,
+      "y": 192,
+      "w": 34,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "わ",
+      "x": 281,
+      "y": 192,
+      "w": 30,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "わ",
+      "x": 313,
+      "y": 192,
+      "w": 32,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "か",
+      "x": 347,
+      "y": 192,
+      "w": 32,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "か",
+      "x": 381,
+      "y": 192,
+      "w": 32,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "ば",
+      "x": 415,
+      "y": 192,
+      "w": 32,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "ば",
+      "x": 449,
+      "y": 192,
+      "w": 33,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "も",
+      "x": 484,
+      "y": 192,
+      "w": 26,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "も",
+      "x": 512,
+      "y": 192,
+      "w": 27,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "み",
+      "x": 541,
+      "y": 192,
+      "w": 32,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "み",
+      "x": 575,
+      "y": 192,
+      "w": 33,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "じ",
+      "x": 610,
+      "y": 192,
+      "w": 23,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "じ",
+      "x": 635,
+      "y": 192,
+      "w": 23,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "ザ",
+      "x": 660,
+      "y": 192,
+      "w": 32,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "ザ",
+      "x": 694,
+      "y": 192,
+      "w": 33,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": ".",
+      "x": 729,
+      "y": 192,
+      "w": 9,
+      "h": 11,
+      "source": "font"
+    },
+    {
+      "char": ".",
+      "x": 740,
+      "y": 192,
+      "w": 9,
+      "h": 11,
+      "source": "font"
+    },
+    {
+      "char": "6",
+      "x": 751,
+      "y": 192,
+      "w": 21,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "6",
+      "x": 774,
+      "y": 192,
+      "w": 22,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "爪",
+      "x": 798,
+      "y": 192,
+      "w": 29,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "爪",
+      "x": 829,
+      "y": 192,
+      "w": 30,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "煌",
+      "x": 861,
+      "y": 192,
+      "w": 33,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "煌",
+      "x": 896,
+      "y": 192,
+      "w": 34,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ペ",
+      "x": 932,
+      "y": 192,
+      "w": 33,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "ペ",
+      "x": 967,
+      "y": 192,
+      "w": 34,
+      "h": 30,
+      "source": "font"
+    },
+    {
+      "char": "8",
+      "x": 1003,
+      "y": 192,
+      "w": 21,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "8",
+      "x": 1026,
+      "y": 192,
+      "w": 22,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "3",
+      "x": 1050,
+      "y": 192,
+      "w": 20,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "3",
+      "x": 1072,
+      "y": 192,
+      "w": 21,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "D",
+      "x": 1095,
+      "y": 192,
+      "w": 25,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "D",
+      "x": 1122,
+      "y": 192,
+      "w": 25,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "箔",
+      "x": 1149,
+      "y": 192,
+      "w": 31,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "箔",
+      "x": 1182,
+      "y": 192,
+      "w": 33,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "角",
+      "x": 1217,
+      "y": 192,
+      "w": 30,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "角",
+      "x": 1249,
+      "y": 192,
+      "w": 31,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "ゲ",
+      "x": 1282,
+      "y": 192,
+      "w": 31,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "ゲ",
+      "x": 1315,
+      "y": 192,
+      "w": 33,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "ハ",
+      "x": 1350,
+      "y": 192,
+      "w": 33,
+      "h": 33,
+      "source": "font"
+    },
+    {
+      "char": "ハ",
+      "x": 1385,
+      "y": 192,
+      "w": 34,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "圧",
+      "x": 1421,
+      "y": 192,
+      "w": 32,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "圧",
+      "x": 1455,
+      "y": 192,
+      "w": 34,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "Y",
+      "x": 1491,
+      "y": 192,
+      "w": 25,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "Y",
+      "x": 1518,
+      "y": 192,
+      "w": 26,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "7",
+      "x": 1546,
+      "y": 192,
+      "w": 21,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "7",
+      "x": 1569,
+      "y": 192,
+      "w": 21,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "V",
+      "x": 2,
+      "y": 240,
+      "w": 23,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "V",
+      "x": 27,
+      "y": 240,
+      "w": 24,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "燈",
+      "x": 53,
+      "y": 240,
+      "w": 33,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "燈",
+      "x": 88,
+      "y": 240,
+      "w": 35,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "0",
+      "x": 125,
+      "y": 240,
+      "w": 21,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "0",
+      "x": 148,
+      "y": 240,
+      "w": 22,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "I",
+      "x": 172,
+      "y": 240,
+      "w": 9,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "I",
+      "x": 183,
+      "y": 240,
+      "w": 10,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "ポ",
+      "x": 195,
+      "y": 240,
+      "w": 31,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "ポ",
+      "x": 228,
+      "y": 240,
+      "w": 33,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "ズ",
+      "x": 263,
+      "y": 240,
+      "w": 31,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "ズ",
+      "x": 296,
+      "y": 240,
+      "w": 33,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "ウ",
+      "x": 331,
+      "y": 240,
+      "w": 28,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "ウ",
+      "x": 361,
+      "y": 240,
+      "w": 30,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "メ",
+      "x": 393,
+      "y": 240,
+      "w": 29,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "メ",
+      "x": 424,
+      "y": 240,
+      "w": 30,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "c",
+      "x": 456,
+      "y": 240,
+      "w": 19,
+      "h": 26,
+      "source": "font"
+    },
+    {
+      "char": "c",
+      "x": 477,
+      "y": 240,
+      "w": 20,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "h",
+      "x": 499,
+      "y": 240,
+      "w": 22,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "h",
+      "x": 523,
+      "y": 240,
+      "w": 23,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "ョ",
+      "x": 548,
+      "y": 240,
+      "w": 19,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "ョ",
+      "x": 569,
+      "y": 240,
+      "w": 19,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "や",
+      "x": 590,
+      "y": 240,
+      "w": 29,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "や",
+      "x": 621,
+      "y": 240,
+      "w": 30,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "ら",
+      "x": 653,
+      "y": 240,
+      "w": 21,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "ら",
+      "x": 676,
+      "y": 240,
+      "w": 23,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "れ",
+      "x": 701,
+      "y": 240,
+      "w": 33,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "れ",
+      "x": 736,
+      "y": 240,
+      "w": 35,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "た",
+      "x": 773,
+      "y": 240,
+      "w": 29,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "た",
+      "x": 804,
+      "y": 240,
+      "w": 30,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "！",
+      "x": 836,
+      "y": 240,
+      "w": 9,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "！",
+      "x": 847,
+      "y": 240,
+      "w": 9,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "で",
+      "x": 858,
+      "y": 240,
+      "w": 30,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "で",
+      "x": 890,
+      "y": 240,
+      "w": 31,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "R",
+      "x": 923,
+      "y": 240,
+      "w": 23,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "R",
+      "x": 948,
+      "y": 240,
+      "w": 24,
+      "h": 33,
+      "source": "font"
+    },
+    {
+      "char": "ブ",
+      "x": 974,
+      "y": 240,
+      "w": 32,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "ブ",
+      "x": 1008,
+      "y": 240,
+      "w": 34,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "ラ",
+      "x": 1044,
+      "y": 240,
+      "w": 28,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "ラ",
+      "x": 1074,
+      "y": 240,
+      "w": 29,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "ス",
+      "x": 1105,
+      "y": 240,
+      "w": 30,
+      "h": 33,
+      "source": "font"
+    },
+    {
+      "char": "ス",
+      "x": 1137,
+      "y": 240,
+      "w": 32,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "タ",
+      "x": 1171,
+      "y": 240,
+      "w": 30,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "タ",
+      "x": 1203,
+      "y": 240,
+      "w": 31,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "ー",
+      "x": 1236,
+      "y": 240,
+      "w": 28,
+      "h": 13,
+      "source": "font"
+    },
+    {
+      "char": "ー",
+      "x": 1266,
+      "y": 240,
+      "w": 30,
+      "h": 14,
+      "source": "font"
+    },
+    {
+      "char": "エ",
+      "x": 1298,
+      "y": 240,
+      "w": 30,
+      "h": 33,
+      "source": "font"
+    },
+    {
+      "char": "エ",
+      "x": 1330,
+      "y": 240,
+      "w": 31,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "リ",
+      "x": 1363,
+      "y": 240,
+      "w": 24,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "リ",
+      "x": 1389,
+      "y": 240,
+      "w": 24,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "ト",
+      "x": 1415,
+      "y": 240,
+      "w": 25,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "ト",
+      "x": 1442,
+      "y": 240,
+      "w": 26,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "デ",
+      "x": 1470,
+      "y": 240,
+      "w": 31,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "デ",
+      "x": 1503,
+      "y": 240,
+      "w": 33,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "コ",
+      "x": 1538,
+      "y": 240,
+      "w": 25,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "コ",
+      "x": 1565,
+      "y": 240,
+      "w": 27,
+      "h": 33,
+      "source": "font"
+    },
+    {
+      "char": "W",
+      "x": 2,
+      "y": 288,
+      "w": 32,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "W",
+      "x": 36,
+      "y": 288,
+      "w": 34,
+      "h": 33,
+      "source": "font"
+    },
+    {
+      "char": "N",
+      "x": 72,
+      "y": 288,
+      "w": 23,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "N",
+      "x": 97,
+      "y": 288,
+      "w": 25,
+      "h": 33,
+      "source": "font"
+    },
+    {
+      "char": "T",
+      "x": 124,
+      "y": 288,
+      "w": 22,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "T",
+      "x": 148,
+      "y": 288,
+      "w": 23,
+      "h": 33,
+      "source": "font"
+    },
+    {
+      "char": "ク",
+      "x": 173,
+      "y": 288,
+      "w": 30,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "ク",
+      "x": 205,
+      "y": 288,
+      "w": 31,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "ッ",
+      "x": 238,
+      "y": 288,
+      "w": 24,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "ッ",
+      "x": 264,
+      "y": 288,
+      "w": 26,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "シ",
+      "x": 292,
+      "y": 288,
+      "w": 30,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "シ",
+      "x": 324,
+      "y": 288,
+      "w": 31,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "ュ",
+      "x": 357,
+      "y": 288,
+      "w": 26,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "ュ",
+      "x": 385,
+      "y": 288,
+      "w": 28,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "ネ",
+      "x": 415,
+      "y": 288,
+      "w": 31,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "ネ",
+      "x": 448,
+      "y": 288,
+      "w": 33,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "オ",
+      "x": 483,
+      "y": 288,
+      "w": 30,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "オ",
+      "x": 515,
+      "y": 288,
+      "w": 31,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "ピ",
+      "x": 548,
+      "y": 288,
+      "w": 27,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "ピ",
+      "x": 577,
+      "y": 288,
+      "w": 29,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "ド",
+      "x": 608,
+      "y": 288,
+      "w": 25,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "ド",
+      "x": 635,
+      "y": 288,
+      "w": 26,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "ロ",
+      "x": 663,
+      "y": 288,
+      "w": 27,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "ロ",
+      "x": 692,
+      "y": 288,
+      "w": 28,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "ン",
+      "x": 722,
+      "y": 288,
+      "w": 30,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "ン",
+      "x": 754,
+      "y": 288,
+      "w": 31,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "グ",
+      "x": 787,
+      "y": 288,
+      "w": 33,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "グ",
+      "x": 822,
+      "y": 288,
+      "w": 35,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "カ",
+      "x": 859,
+      "y": 288,
+      "w": 29,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "カ",
+      "x": 890,
+      "y": 288,
+      "w": 29,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "ム",
+      "x": 921,
+      "y": 288,
+      "w": 31,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "ム",
+      "x": 954,
+      "y": 288,
+      "w": 32,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "ホ",
+      "x": 988,
+      "y": 288,
+      "w": 30,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "ホ",
+      "x": 1020,
+      "y": 288,
+      "w": 32,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "艶",
+      "x": 1054,
+      "y": 288,
+      "w": 30,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "艶",
+      "x": 1086,
+      "y": 288,
+      "w": 32,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "S",
+      "x": 1120,
+      "y": 288,
+      "w": 22,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "S",
+      "x": 1144,
+      "y": 288,
+      "w": 24,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "-",
+      "x": 1170,
+      "y": 288,
+      "w": 15,
+      "h": 10,
+      "source": "font"
+    },
+    {
+      "char": "-",
+      "x": 1187,
+      "y": 288,
+      "w": 15,
+      "h": 10,
+      "source": "font"
+    },
+    {
+      "char": "B",
+      "x": 1204,
+      "y": 288,
+      "w": 23,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "B",
+      "x": 1229,
+      "y": 288,
+      "w": 24,
+      "h": 33,
+      "source": "font"
+    },
+    {
+      "char": "L",
+      "x": 1255,
+      "y": 288,
+      "w": 20,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "L",
+      "x": 1277,
+      "y": 288,
+      "w": 21,
+      "h": 33,
+      "source": "font"
+    },
+    {
+      "char": "A",
+      "x": 1300,
+      "y": 288,
+      "w": 26,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "A",
+      "x": 1328,
+      "y": 288,
+      "w": 28,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "9",
+      "x": 1358,
+      "y": 288,
+      "w": 22,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "9",
+      "x": 1382,
+      "y": 288,
+      "w": 23,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "2",
+      "x": 1407,
+      "y": 288,
+      "w": 21,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "2",
+      "x": 1430,
+      "y": 288,
+      "w": 22,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "1",
+      "x": 1454,
+      "y": 288,
+      "w": 16,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "1",
+      "x": 1472,
+      "y": 288,
+      "w": 17,
+      "h": 33,
+      "source": "font"
+    },
+    {
+      "char": "ノ",
+      "x": 1491,
+      "y": 288,
+      "w": 26,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "ノ",
+      "x": 1519,
+      "y": 288,
+      "w": 27,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "ヴ",
+      "x": 1548,
+      "y": 288,
+      "w": 31,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "ヴ",
+      "x": 2,
+      "y": 332,
+      "w": 33,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "ァ",
+      "x": 37,
+      "y": 332,
+      "w": 25,
+      "h": 30,
+      "source": "font"
+    },
+    {
+      "char": "ァ",
+      "x": 64,
+      "y": 332,
+      "w": 26,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "ダ",
+      "x": 92,
+      "y": 332,
+      "w": 33,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "ダ",
+      "x": 127,
+      "y": 332,
+      "w": 35,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "レ",
+      "x": 164,
+      "y": 332,
+      "w": 27,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "レ",
+      "x": 193,
+      "y": 332,
+      "w": 28,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "プ",
+      "x": 223,
+      "y": 332,
+      "w": 31,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "プ",
+      "x": 256,
+      "y": 332,
+      "w": 33,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "フ",
+      "x": 291,
+      "y": 332,
+      "w": 28,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "フ",
+      "x": 321,
+      "y": 332,
+      "w": 29,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "ィ",
+      "x": 352,
+      "y": 332,
+      "w": 25,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "ィ",
+      "x": 379,
+      "y": 332,
+      "w": 26,
+      "h": 33,
+      "source": "font"
+    },
+    {
+      "char": "セ",
+      "x": 407,
+      "y": 332,
+      "w": 29,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "セ",
+      "x": 438,
+      "y": 332,
+      "w": 30,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "・",
+      "x": 470,
+      "y": 332,
+      "w": 9,
+      "h": 10,
+      "source": "font"
+    },
+    {
+      "char": "・",
+      "x": 481,
+      "y": 332,
+      "w": 8,
+      "h": 10,
+      "source": "font"
+    },
+    {
+      "char": "ヒ",
+      "x": 491,
+      "y": 332,
+      "w": 26,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "ヒ",
+      "x": 519,
+      "y": 332,
+      "w": 27,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "Z",
+      "x": 548,
+      "y": 332,
+      "w": 22,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "Z",
+      "x": 572,
+      "y": 332,
+      "w": 23,
+      "h": 33,
+      "source": "font"
+    },
+    {
+      "char": "パ",
+      "x": 597,
+      "y": 332,
+      "w": 32,
+      "h": 33,
+      "source": "font"
+    },
+    {
+      "char": "パ",
+      "x": 631,
+      "y": 332,
+      "w": 34,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "サ",
+      "x": 667,
+      "y": 332,
+      "w": 30,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "サ",
+      "x": 699,
+      "y": 332,
+      "w": 32,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "イ",
+      "x": 733,
+      "y": 332,
+      "w": 29,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "イ",
+      "x": 764,
+      "y": 332,
+      "w": 30,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "彗",
+      "x": 796,
+      "y": 332,
+      "w": 30,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "彗",
+      "x": 828,
+      "y": 332,
+      "w": 31,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "ソ",
+      "x": 861,
+      "y": 332,
+      "w": 28,
+      "h": 33,
+      "source": "font"
+    },
+    {
+      "char": "ソ",
+      "x": 891,
+      "y": 332,
+      "w": 29,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "チ",
+      "x": 922,
+      "y": 332,
+      "w": 29,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "チ",
+      "x": 953,
+      "y": 332,
+      "w": 30,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "バ",
+      "x": 985,
+      "y": 332,
+      "w": 33,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "バ",
+      "x": 1020,
+      "y": 332,
+      "w": 34,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "4",
+      "x": 1056,
+      "y": 332,
+      "w": 22,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "4",
+      "x": 1080,
+      "y": 332,
+      "w": 23,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "式",
+      "x": 1105,
+      "y": 332,
+      "w": 29,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "式",
+      "x": 1136,
+      "y": 332,
+      "w": 31,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "竹",
+      "x": 1169,
+      "y": 332,
+      "w": 30,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "竹",
+      "x": 1201,
+      "y": 332,
+      "w": 32,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "筒",
+      "x": 1235,
+      "y": 332,
+      "w": 30,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "筒",
+      "x": 1267,
+      "y": 332,
+      "w": 31,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "銃",
+      "x": 1300,
+      "y": 332,
+      "w": 30,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "銃",
+      "x": 1332,
+      "y": 332,
+      "w": 32,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "甲",
+      "x": 1366,
+      "y": 332,
+      "w": 28,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "甲",
+      "x": 1396,
+      "y": 332,
+      "w": 28,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "乙",
+      "x": 1426,
+      "y": 332,
+      "w": 29,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "乙",
+      "x": 1457,
+      "y": 332,
+      "w": 30,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "K",
+      "x": 1489,
+      "y": 332,
+      "w": 24,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "K",
+      "x": 1515,
+      "y": 332,
+      "w": 25,
+      "h": 33,
+      "source": "font"
+    },
+    {
+      "char": "ボ",
+      "x": 1542,
+      "y": 332,
+      "w": 30,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "ボ",
+      "x": 2,
+      "y": 376,
+      "w": 32,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "F",
+      "x": 36,
+      "y": 376,
+      "w": 19,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "F",
+      "x": 57,
+      "y": 376,
+      "w": 20,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "ャ",
+      "x": 79,
+      "y": 376,
+      "w": 26,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "ャ",
+      "x": 107,
+      "y": 376,
+      "w": 27,
+      "h": 33,
+      "source": "font"
+    },
+    {
+      "char": "ジ",
+      "x": 136,
+      "y": 376,
+      "w": 30,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "ジ",
+      "x": 168,
+      "y": 376,
+      "w": 31,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "P",
+      "x": 201,
+      "y": 376,
+      "w": 22,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "P",
+      "x": 225,
+      "y": 376,
+      "w": 23,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "E",
+      "x": 250,
+      "y": 376,
+      "w": 21,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "E",
+      "x": 273,
+      "y": 376,
+      "w": 22,
+      "h": 33,
+      "source": "font"
+    },
+    {
+      "char": "/",
+      "x": 297,
+      "y": 376,
+      "w": 15,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "/",
+      "x": 314,
+      "y": 376,
+      "w": 16,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "5",
+      "x": 332,
+      "y": 376,
+      "w": 21,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "5",
+      "x": 355,
+      "y": 376,
+      "w": 23,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "H",
+      "x": 380,
+      "y": 376,
+      "w": 23,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "H",
+      "x": 405,
+      "y": 376,
+      "w": 25,
+      "h": 33,
+      "source": "font"
+    },
+    {
+      "char": "α",
+      "x": 432,
+      "y": 376,
+      "w": 25,
+      "h": 25,
+      "source": "font"
+    },
+    {
+      "char": "α",
+      "x": 459,
+      "y": 376,
+      "w": 26,
+      "h": 26,
+      "source": "font"
+    },
+    {
+      "char": "β",
+      "x": 487,
+      "y": 376,
+      "w": 23,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "β",
+      "x": 512,
+      "y": 376,
+      "w": 25,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "ア",
+      "x": 539,
+      "y": 376,
+      "w": 29,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "ア",
+      "x": 570,
+      "y": 376,
+      "w": 31,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "ル",
+      "x": 603,
+      "y": 376,
+      "w": 32,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "ル",
+      "x": 637,
+      "y": 376,
+      "w": 34,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "蹄",
+      "x": 673,
+      "y": 376,
+      "w": 30,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "蹄",
+      "x": 705,
+      "y": 376,
+      "w": 32,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "ケ",
+      "x": 739,
+      "y": 376,
+      "w": 30,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "ケ",
+      "x": 771,
+      "y": 376,
+      "w": 31,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "ビ",
+      "x": 804,
+      "y": 376,
+      "w": 28,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "ビ",
+      "x": 834,
+      "y": 376,
+      "w": 30,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "ガ",
+      "x": 866,
+      "y": 376,
+      "w": 31,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "ガ",
+      "x": 899,
+      "y": 376,
+      "w": 32,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "マ",
+      "x": 933,
+      "y": 376,
+      "w": 30,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "マ",
+      "x": 965,
+      "y": 376,
+      "w": 32,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "ニ",
+      "x": 999,
+      "y": 376,
+      "w": 30,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "ニ",
+      "x": 1031,
+      "y": 376,
+      "w": 31,
+      "h": 33,
+      "source": "font"
+    },
+    {
+      "char": "耀",
+      "x": 1064,
+      "y": 376,
+      "w": 30,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "耀",
+      "x": 1096,
+      "y": 376,
+      "w": 32,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "O",
+      "x": 1130,
+      "y": 376,
+      "w": 26,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "O",
+      "x": 1158,
+      "y": 376,
+      "w": 27,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "ワ",
+      "x": 1187,
+      "y": 376,
+      "w": 27,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "ワ",
+      "x": 1216,
+      "y": 376,
+      "w": 29,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "G",
+      "x": 1247,
+      "y": 376,
+      "w": 25,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "G",
+      "x": 1274,
+      "y": 376,
+      "w": 26,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "ナ",
+      "x": 1302,
+      "y": 376,
+      "w": 29,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "ナ",
+      "x": 1333,
+      "y": 376,
+      "w": 30,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "モ",
+      "x": 1365,
+      "y": 376,
+      "w": 28,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "モ",
+      "x": 1395,
+      "y": 376,
+      "w": 30,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "テ",
+      "x": 1427,
+      "y": 376,
+      "w": 29,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "テ",
+      "x": 1458,
+      "y": 376,
+      "w": 30,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "冥",
+      "x": 1490,
+      "y": 376,
+      "w": 30,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "冥",
+      "x": 1522,
+      "y": 376,
+      "w": 30,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "ォ",
+      "x": 1554,
+      "y": 376,
+      "w": 25,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "ォ",
+      "x": 2,
+      "y": 419,
+      "w": 26,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "惑",
+      "x": 30,
+      "y": 419,
+      "w": 30,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "惑",
+      "x": 62,
+      "y": 419,
+      "w": 31,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "ミ",
+      "x": 95,
+      "y": 419,
+      "w": 28,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "ミ",
+      "x": 125,
+      "y": 419,
+      "w": 29,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "U",
+      "x": 156,
+      "y": 419,
+      "w": 23,
+      "h": 33,
+      "source": "font"
+    },
+    {
+      "char": "U",
+      "x": 181,
+      "y": 419,
+      "w": 25,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "封",
+      "x": 208,
+      "y": 419,
+      "w": 30,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "封",
+      "x": 240,
+      "y": 419,
+      "w": 32,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "ェ",
+      "x": 274,
+      "y": 419,
+      "w": 25,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "ェ",
+      "x": 301,
+      "y": 419,
+      "w": 26,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "繚",
+      "x": 329,
+      "y": 419,
+      "w": 30,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "繚",
+      "x": 361,
+      "y": 419,
+      "w": 32,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "張",
+      "x": 395,
+      "y": 419,
+      "w": 30,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "張",
+      "x": 427,
+      "y": 419,
+      "w": 32,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "替",
+      "x": 461,
+      "y": 419,
+      "w": 30,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "替",
+      "x": 493,
+      "y": 419,
+      "w": 32,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "傘",
+      "x": 527,
+      "y": 419,
+      "w": 30,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "傘",
+      "x": 559,
+      "y": 419,
+      "w": 31,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "キ",
+      "x": 592,
+      "y": 419,
+      "w": 28,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "キ",
+      "x": 622,
+      "y": 419,
+      "w": 30,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "C",
+      "x": 654,
+      "y": 419,
+      "w": 25,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "C",
+      "x": 681,
+      "y": 419,
+      "w": 26,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "M",
+      "x": 709,
+      "y": 419,
+      "w": 28,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "M",
+      "x": 739,
+      "y": 419,
+      "w": 29,
+      "h": 33,
+      "source": "font"
+    },
+    {
+      "char": "彩",
+      "x": 770,
+      "y": 419,
+      "w": 30,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "彩",
+      "x": 802,
+      "y": 419,
+      "w": 32,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "わ",
+      "x": 836,
+      "y": 419,
+      "w": 30,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "わ",
+      "x": 868,
+      "y": 419,
+      "w": 32,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "か",
+      "x": 902,
+      "y": 419,
+      "w": 32,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "か",
+      "x": 936,
+      "y": 419,
+      "w": 33,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "ば",
+      "x": 971,
+      "y": 419,
+      "w": 32,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "ば",
+      "x": 1005,
+      "y": 419,
+      "w": 33,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "も",
+      "x": 1040,
+      "y": 419,
+      "w": 29,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "も",
+      "x": 1071,
+      "y": 419,
+      "w": 31,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "み",
+      "x": 1104,
+      "y": 419,
+      "w": 31,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "み",
+      "x": 1137,
+      "y": 419,
+      "w": 32,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "じ",
+      "x": 1171,
+      "y": 419,
+      "w": 26,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "じ",
+      "x": 1199,
+      "y": 419,
+      "w": 27,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "ザ",
+      "x": 1228,
+      "y": 419,
+      "w": 33,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "ザ",
+      "x": 1263,
+      "y": 419,
+      "w": 35,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": ".",
+      "x": 1300,
+      "y": 419,
+      "w": 9,
+      "h": 9,
+      "source": "font"
+    },
+    {
+      "char": ".",
+      "x": 1311,
+      "y": 419,
+      "w": 10,
+      "h": 10,
+      "source": "font"
+    },
+    {
+      "char": "6",
+      "x": 1323,
+      "y": 419,
+      "w": 22,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "6",
+      "x": 1347,
+      "y": 419,
+      "w": 24,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "爪",
+      "x": 1373,
+      "y": 419,
+      "w": 30,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "爪",
+      "x": 1405,
+      "y": 419,
+      "w": 32,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "煌",
+      "x": 1439,
+      "y": 419,
+      "w": 30,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "煌",
+      "x": 1471,
+      "y": 419,
+      "w": 32,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "ペ",
+      "x": 1505,
+      "y": 419,
+      "w": 31,
+      "h": 33,
+      "source": "font"
+    },
+    {
+      "char": "ペ",
+      "x": 1538,
+      "y": 419,
+      "w": 32,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "8",
+      "x": 1572,
+      "y": 419,
+      "w": 23,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "8",
+      "x": 2,
+      "y": 461,
+      "w": 24,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "3",
+      "x": 28,
+      "y": 461,
+      "w": 22,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "3",
+      "x": 52,
+      "y": 461,
+      "w": 23,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "D",
+      "x": 77,
+      "y": 461,
+      "w": 24,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "D",
+      "x": 103,
+      "y": 461,
+      "w": 26,
+      "h": 33,
+      "source": "font"
+    },
+    {
+      "char": "箔",
+      "x": 131,
+      "y": 461,
+      "w": 30,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "箔",
+      "x": 163,
+      "y": 461,
+      "w": 31,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "角",
+      "x": 196,
+      "y": 461,
+      "w": 29,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "角",
+      "x": 227,
+      "y": 461,
+      "w": 30,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "ゲ",
+      "x": 259,
+      "y": 461,
+      "w": 31,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "ゲ",
+      "x": 292,
+      "y": 461,
+      "w": 32,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "ハ",
+      "x": 326,
+      "y": 461,
+      "w": 32,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "ハ",
+      "x": 360,
+      "y": 461,
+      "w": 34,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "圧",
+      "x": 396,
+      "y": 461,
+      "w": 30,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "圧",
+      "x": 428,
+      "y": 461,
+      "w": 32,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "Y",
+      "x": 462,
+      "y": 461,
+      "w": 24,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "Y",
+      "x": 488,
+      "y": 461,
+      "w": 25,
+      "h": 33,
+      "source": "font"
+    },
+    {
+      "char": "7",
+      "x": 515,
+      "y": 461,
+      "w": 21,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "7",
+      "x": 538,
+      "y": 461,
+      "w": 22,
+      "h": 33,
+      "source": "font"
+    },
+    {
+      "char": "V",
+      "x": 562,
+      "y": 461,
+      "w": 25,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "V",
+      "x": 589,
+      "y": 461,
+      "w": 26,
+      "h": 33,
+      "source": "font"
+    },
+    {
+      "char": "燈",
+      "x": 617,
+      "y": 461,
+      "w": 30,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "燈",
+      "x": 649,
+      "y": 461,
+      "w": 32,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "0",
+      "x": 683,
+      "y": 461,
+      "w": 22,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "0",
+      "x": 707,
+      "y": 461,
+      "w": 24,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "I",
+      "x": 733,
+      "y": 461,
+      "w": 11,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "I",
+      "x": 746,
+      "y": 461,
+      "w": 11,
+      "h": 33,
+      "source": "font"
+    },
+    {
+      "char": "ポ",
+      "x": 759,
+      "y": 461,
+      "w": 30,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "ポ",
+      "x": 791,
+      "y": 461,
+      "w": 32,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "ズ",
+      "x": 825,
+      "y": 461,
+      "w": 30,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "ズ",
+      "x": 857,
+      "y": 461,
+      "w": 32,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "ウ",
+      "x": 891,
+      "y": 461,
+      "w": 27,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "ウ",
+      "x": 920,
+      "y": 461,
+      "w": 29,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "メ",
+      "x": 951,
+      "y": 461,
+      "w": 29,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "メ",
+      "x": 982,
+      "y": 461,
+      "w": 30,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "c",
+      "x": 1014,
+      "y": 461,
+      "w": 19,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "c",
+      "x": 1035,
+      "y": 461,
+      "w": 20,
+      "h": 26,
+      "source": "font"
+    },
+    {
+      "char": "h",
+      "x": 1057,
+      "y": 461,
+      "w": 20,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "h",
+      "x": 1079,
+      "y": 461,
+      "w": 20,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "ョ",
+      "x": 1101,
+      "y": 461,
+      "w": 23,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "ョ",
+      "x": 1126,
+      "y": 461,
+      "w": 23,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "や",
+      "x": 1151,
+      "y": 461,
+      "w": 30,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "や",
+      "x": 1183,
+      "y": 461,
+      "w": 32,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "ら",
+      "x": 1217,
+      "y": 461,
+      "w": 27,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "ら",
+      "x": 1246,
+      "y": 461,
+      "w": 28,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "れ",
+      "x": 1276,
+      "y": 461,
+      "w": 32,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "れ",
+      "x": 1310,
+      "y": 461,
+      "w": 33,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "た",
+      "x": 1345,
+      "y": 461,
+      "w": 29,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "た",
+      "x": 1376,
+      "y": 461,
+      "w": 30,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "！",
+      "x": 1408,
+      "y": 461,
+      "w": 11,
+      "h": 33,
+      "source": "font"
+    },
+    {
+      "char": "！",
+      "x": 1421,
+      "y": 461,
+      "w": 13,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "で",
+      "x": 1436,
+      "y": 461,
+      "w": 28,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "で",
+      "x": 1466,
+      "y": 461,
+      "w": 30,
+      "h": 36,
+      "source": "font"
+    }
+  ]
+}
\ No newline at end of file
diff --git a/public/scanner/v1/glyphs/death-weapon-ja.png b/public/scanner/v1/glyphs/death-weapon-ja.png
new file mode 100644
index 000000000..3119a5f63
Binary files /dev/null and b/public/scanner/v1/glyphs/death-weapon-ja.png differ
diff --git a/public/scanner/v1/glyphs/death-weapon.json b/public/scanner/v1/glyphs/death-weapon.json
new file mode 100644
index 000000000..1c63cf7f4
--- /dev/null
+++ b/public/scanner/v1/glyphs/death-weapon.json
@@ -0,0 +1,2949 @@
+{
+  "height": 34,
+  "glyphs": [
+    {
+      "char": "S",
+      "x": 2,
+      "y": 2,
+      "w": 22,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "S",
+      "x": 26,
+      "y": 2,
+      "w": 22,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "p",
+      "x": 50,
+      "y": 2,
+      "w": 19,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "p",
+      "x": 71,
+      "y": 2,
+      "w": 19,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "l",
+      "x": 92,
+      "y": 2,
+      "w": 9,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "l",
+      "x": 103,
+      "y": 2,
+      "w": 8,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "o",
+      "x": 113,
+      "y": 2,
+      "w": 19,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "o",
+      "x": 134,
+      "y": 2,
+      "w": 19,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "s",
+      "x": 155,
+      "y": 2,
+      "w": 20,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "s",
+      "x": 177,
+      "y": 2,
+      "w": 20,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "h",
+      "x": 199,
+      "y": 2,
+      "w": 20,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "h",
+      "x": 221,
+      "y": 2,
+      "w": 20,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "-",
+      "x": 243,
+      "y": 2,
+      "w": 18,
+      "h": 10,
+      "source": "font"
+    },
+    {
+      "char": "-",
+      "x": 263,
+      "y": 2,
+      "w": 19,
+      "h": 11,
+      "source": "font"
+    },
+    {
+      "char": "m",
+      "x": 284,
+      "y": 2,
+      "w": 27,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "m",
+      "x": 313,
+      "y": 2,
+      "w": 28,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "a",
+      "x": 343,
+      "y": 2,
+      "w": 21,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "a",
+      "x": 366,
+      "y": 2,
+      "w": 21,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "t",
+      "x": 389,
+      "y": 2,
+      "w": 17,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "t",
+      "x": 408,
+      "y": 2,
+      "w": 18,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "i",
+      "x": 428,
+      "y": 2,
+      "w": 9,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "i",
+      "x": 439,
+      "y": 2,
+      "w": 10,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "c",
+      "x": 451,
+      "y": 2,
+      "w": 19,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "c",
+      "x": 472,
+      "y": 2,
+      "w": 20,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "N",
+      "x": 494,
+      "y": 2,
+      "w": 23,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "N",
+      "x": 519,
+      "y": 2,
+      "w": 23,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "e",
+      "x": 544,
+      "y": 2,
+      "w": 20,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "e",
+      "x": 566,
+      "y": 2,
+      "w": 20,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "r",
+      "x": 588,
+      "y": 2,
+      "w": 16,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "r",
+      "x": 606,
+      "y": 2,
+      "w": 16,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "J",
+      "x": 624,
+      "y": 2,
+      "w": 20,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "J",
+      "x": 646,
+      "y": 2,
+      "w": 20,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": ".",
+      "x": 668,
+      "y": 2,
+      "w": 10,
+      "h": 11,
+      "source": "font"
+    },
+    {
+      "char": ".",
+      "x": 680,
+      "y": 2,
+      "w": 11,
+      "h": 11,
+      "source": "font"
+    },
+    {
+      "char": "C",
+      "x": 693,
+      "y": 2,
+      "w": 20,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "C",
+      "x": 715,
+      "y": 2,
+      "w": 21,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "u",
+      "x": 738,
+      "y": 2,
+      "w": 22,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "u",
+      "x": 762,
+      "y": 2,
+      "w": 22,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "G",
+      "x": 786,
+      "y": 2,
+      "w": 22,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "G",
+      "x": 810,
+      "y": 2,
+      "w": 22,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "K",
+      "x": 834,
+      "y": 2,
+      "w": 20,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "K",
+      "x": 856,
+      "y": 2,
+      "w": 20,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "O",
+      "x": 878,
+      "y": 2,
+      "w": 21,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "O",
+      "x": 901,
+      "y": 2,
+      "w": 21,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "A",
+      "x": 924,
+      "y": 2,
+      "w": 21,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "A",
+      "x": 947,
+      "y": 2,
+      "w": 21,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "y",
+      "x": 970,
+      "y": 2,
+      "w": 20,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "y",
+      "x": 992,
+      "y": 2,
+      "w": 20,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "M",
+      "x": 1014,
+      "y": 2,
+      "w": 26,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "M",
+      "x": 1042,
+      "y": 2,
+      "w": 26,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "R",
+      "x": 1070,
+      "y": 2,
+      "w": 21,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "R",
+      "x": 1093,
+      "y": 2,
+      "w": 21,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "z",
+      "x": 1116,
+      "y": 2,
+      "w": 20,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "z",
+      "x": 1138,
+      "y": 2,
+      "w": 20,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "T",
+      "x": 1160,
+      "y": 2,
+      "w": 21,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "T",
+      "x": 1183,
+      "y": 2,
+      "w": 21,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "n",
+      "x": 1206,
+      "y": 2,
+      "w": 19,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "n",
+      "x": 1227,
+      "y": 2,
+      "w": 19,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "k",
+      "x": 1248,
+      "y": 2,
+      "w": 19,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "k",
+      "x": 1269,
+      "y": 2,
+      "w": 20,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "H",
+      "x": 1291,
+      "y": 2,
+      "w": 21,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "H",
+      "x": 1314,
+      "y": 2,
+      "w": 22,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "d",
+      "x": 1338,
+      "y": 2,
+      "w": 19,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "d",
+      "x": 1359,
+      "y": 2,
+      "w": 20,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "5",
+      "x": 1381,
+      "y": 2,
+      "w": 20,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "5",
+      "x": 1403,
+      "y": 2,
+      "w": 21,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "2",
+      "x": 1426,
+      "y": 2,
+      "w": 22,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "2",
+      "x": 1450,
+      "y": 2,
+      "w": 22,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "D",
+      "x": 1474,
+      "y": 2,
+      "w": 21,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "D",
+      "x": 1497,
+      "y": 2,
+      "w": 22,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "Z",
+      "x": 1521,
+      "y": 2,
+      "w": 20,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "Z",
+      "x": 1543,
+      "y": 2,
+      "w": 21,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "P",
+      "x": 1566,
+      "y": 2,
+      "w": 21,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "P",
+      "x": 2,
+      "y": 41,
+      "w": 22,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "'",
+      "x": 26,
+      "y": 41,
+      "w": 11,
+      "h": 15,
+      "source": "font"
+    },
+    {
+      "char": "'",
+      "x": 39,
+      "y": 41,
+      "w": 11,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "8",
+      "x": 52,
+      "y": 41,
+      "w": 21,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "8",
+      "x": 75,
+      "y": 41,
+      "w": 22,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "9",
+      "x": 99,
+      "y": 41,
+      "w": 21,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "9",
+      "x": 122,
+      "y": 41,
+      "w": 22,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "F",
+      "x": 146,
+      "y": 41,
+      "w": 19,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "F",
+      "x": 167,
+      "y": 41,
+      "w": 19,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "g",
+      "x": 188,
+      "y": 41,
+      "w": 19,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "g",
+      "x": 209,
+      "y": 41,
+      "w": 20,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "6",
+      "x": 231,
+      "y": 41,
+      "w": 21,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "6",
+      "x": 254,
+      "y": 41,
+      "w": 22,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "w",
+      "x": 278,
+      "y": 41,
+      "w": 24,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "w",
+      "x": 304,
+      "y": 41,
+      "w": 25,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "q",
+      "x": 331,
+      "y": 41,
+      "w": 18,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "q",
+      "x": 351,
+      "y": 41,
+      "w": 19,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "B",
+      "x": 372,
+      "y": 41,
+      "w": 20,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "B",
+      "x": 394,
+      "y": 41,
+      "w": 21,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "v",
+      "x": 417,
+      "y": 41,
+      "w": 19,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "v",
+      "x": 438,
+      "y": 41,
+      "w": 21,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "L",
+      "x": 461,
+      "y": 41,
+      "w": 15,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "L",
+      "x": 478,
+      "y": 41,
+      "w": 16,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "W",
+      "x": 496,
+      "y": 41,
+      "w": 29,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "W",
+      "x": 527,
+      "y": 41,
+      "w": 29,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "1",
+      "x": 558,
+      "y": 41,
+      "w": 13,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "1",
+      "x": 573,
+      "y": 41,
+      "w": 13,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "3",
+      "x": 588,
+      "y": 41,
+      "w": 22,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "3",
+      "x": 612,
+      "y": 41,
+      "w": 23,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "V",
+      "x": 637,
+      "y": 41,
+      "w": 22,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "V",
+      "x": 661,
+      "y": 41,
+      "w": 23,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "I",
+      "x": 686,
+      "y": 41,
+      "w": 10,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "I",
+      "x": 698,
+      "y": 41,
+      "w": 10,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "b",
+      "x": 710,
+      "y": 41,
+      "w": 20,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "b",
+      "x": 732,
+      "y": 41,
+      "w": 20,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "E",
+      "x": 754,
+      "y": 41,
+      "w": 19,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "E",
+      "x": 775,
+      "y": 41,
+      "w": 19,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "x",
+      "x": 796,
+      "y": 41,
+      "w": 18,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "x",
+      "x": 816,
+      "y": 41,
+      "w": 18,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "f",
+      "x": 836,
+      "y": 41,
+      "w": 18,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "f",
+      "x": 856,
+      "y": 41,
+      "w": 18,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "+",
+      "x": 876,
+      "y": 41,
+      "w": 23,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "+",
+      "x": 901,
+      "y": 41,
+      "w": 23,
+      "h": 24,
+      "source": "font"
+    },
+    {
+      "char": "4",
+      "x": 926,
+      "y": 41,
+      "w": 23,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "4",
+      "x": 951,
+      "y": 41,
+      "w": 23,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "7",
+      "x": 976,
+      "y": 41,
+      "w": 20,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "7",
+      "x": 998,
+      "y": 41,
+      "w": 21,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "U",
+      "x": 1021,
+      "y": 41,
+      "w": 21,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "U",
+      "x": 1044,
+      "y": 41,
+      "w": 22,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "X",
+      "x": 1068,
+      "y": 41,
+      "w": 19,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "X",
+      "x": 1089,
+      "y": 41,
+      "w": 20,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "0",
+      "x": 1111,
+      "y": 41,
+      "w": 22,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "0",
+      "x": 1135,
+      "y": 41,
+      "w": 23,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "j",
+      "x": 1160,
+      "y": 41,
+      "w": 13,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "j",
+      "x": 1175,
+      "y": 41,
+      "w": 13,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "·",
+      "x": 1190,
+      "y": 41,
+      "w": 11,
+      "h": 10,
+      "source": "font"
+    },
+    {
+      "char": "·",
+      "x": 1203,
+      "y": 41,
+      "w": 11,
+      "h": 10,
+      "source": "font"
+    },
+    {
+      "char": "/",
+      "x": 1216,
+      "y": 41,
+      "w": 22,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "/",
+      "x": 1240,
+      "y": 41,
+      "w": 23,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "Y",
+      "x": 1265,
+      "y": 41,
+      "w": 20,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "Y",
+      "x": 1287,
+      "y": 41,
+      "w": 20,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "ä",
+      "x": 1309,
+      "y": 41,
+      "w": 21,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "ä",
+      "x": 1332,
+      "y": 41,
+      "w": 21,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "Q",
+      "x": 1355,
+      "y": 41,
+      "w": 22,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "Q",
+      "x": 1379,
+      "y": 41,
+      "w": 23,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "ö",
+      "x": 1404,
+      "y": 41,
+      "w": 19,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "ö",
+      "x": 1425,
+      "y": 41,
+      "w": 19,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "Ü",
+      "x": 1446,
+      "y": 41,
+      "w": 21,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "Ü",
+      "x": 1469,
+      "y": 41,
+      "w": 22,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "ü",
+      "x": 1493,
+      "y": 41,
+      "w": 22,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "ü",
+      "x": 1517,
+      "y": 41,
+      "w": 22,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "é",
+      "x": 1541,
+      "y": 41,
+      "w": 20,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "é",
+      "x": 1563,
+      "y": 41,
+      "w": 20,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "(",
+      "x": 2,
+      "y": 88,
+      "w": 17,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "(",
+      "x": 21,
+      "y": 88,
+      "w": 17,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": ")",
+      "x": 40,
+      "y": 88,
+      "w": 17,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": ")",
+      "x": 59,
+      "y": 88,
+      "w": 17,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "ú",
+      "x": 78,
+      "y": 88,
+      "w": 22,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "ú",
+      "x": 102,
+      "y": 88,
+      "w": 22,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "ó",
+      "x": 126,
+      "y": 88,
+      "w": 19,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "ó",
+      "x": 147,
+      "y": 88,
+      "w": 19,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "á",
+      "x": 168,
+      "y": 88,
+      "w": 21,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "á",
+      "x": 191,
+      "y": 88,
+      "w": 21,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "í",
+      "x": 214,
+      "y": 88,
+      "w": 12,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "í",
+      "x": 228,
+      "y": 88,
+      "w": 13,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "ñ",
+      "x": 243,
+      "y": 88,
+      "w": 20,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "ñ",
+      "x": 265,
+      "y": 88,
+      "w": 22,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "É",
+      "x": 289,
+      "y": 88,
+      "w": 19,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "É",
+      "x": 310,
+      "y": 88,
+      "w": 19,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "ï",
+      "x": 331,
+      "y": 88,
+      "w": 16,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "ï",
+      "x": 349,
+      "y": 88,
+      "w": 16,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "ê",
+      "x": 367,
+      "y": 88,
+      "w": 20,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "ê",
+      "x": 389,
+      "y": 88,
+      "w": 20,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "è",
+      "x": 411,
+      "y": 88,
+      "w": 20,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "è",
+      "x": 433,
+      "y": 88,
+      "w": 20,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "ÿ",
+      "x": 455,
+      "y": 88,
+      "w": 20,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "ÿ",
+      "x": 477,
+      "y": 88,
+      "w": 20,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "ë",
+      "x": 499,
+      "y": 88,
+      "w": 20,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "ë",
+      "x": 521,
+      "y": 88,
+      "w": 20,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "«",
+      "x": 543,
+      "y": 88,
+      "w": 26,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "«",
+      "x": 571,
+      "y": 88,
+      "w": 26,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "»",
+      "x": 599,
+      "y": 88,
+      "w": 26,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "»",
+      "x": 627,
+      "y": 88,
+      "w": 26,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "ç",
+      "x": 655,
+      "y": 88,
+      "w": 19,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "ç",
+      "x": 676,
+      "y": 88,
+      "w": 20,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "!",
+      "x": 698,
+      "y": 88,
+      "w": 12,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "!",
+      "x": 712,
+      "y": 88,
+      "w": 11,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": ":",
+      "x": 725,
+      "y": 88,
+      "w": 11,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": ":",
+      "x": 738,
+      "y": 88,
+      "w": 12,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "\"",
+      "x": 752,
+      "y": 88,
+      "w": 20,
+      "h": 14,
+      "source": "font"
+    },
+    {
+      "char": "\"",
+      "x": 774,
+      "y": 88,
+      "w": 20,
+      "h": 14,
+      "source": "font"
+    },
+    {
+      "char": "S",
+      "x": 796,
+      "y": 88,
+      "w": 27,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "S",
+      "x": 825,
+      "y": 88,
+      "w": 28,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "p",
+      "x": 855,
+      "y": 88,
+      "w": 29,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "p",
+      "x": 886,
+      "y": 88,
+      "w": 29,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "l",
+      "x": 917,
+      "y": 88,
+      "w": 15,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "l",
+      "x": 934,
+      "y": 88,
+      "w": 15,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "o",
+      "x": 951,
+      "y": 88,
+      "w": 28,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "o",
+      "x": 981,
+      "y": 88,
+      "w": 28,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "s",
+      "x": 1011,
+      "y": 88,
+      "w": 24,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "s",
+      "x": 1037,
+      "y": 88,
+      "w": 24,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "h",
+      "x": 1063,
+      "y": 88,
+      "w": 30,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "h",
+      "x": 1095,
+      "y": 88,
+      "w": 30,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "-",
+      "x": 1127,
+      "y": 88,
+      "w": 18,
+      "h": 10,
+      "source": "font"
+    },
+    {
+      "char": "-",
+      "x": 1147,
+      "y": 88,
+      "w": 18,
+      "h": 11,
+      "source": "font"
+    },
+    {
+      "char": "m",
+      "x": 1167,
+      "y": 88,
+      "w": 40,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "m",
+      "x": 1209,
+      "y": 88,
+      "w": 41,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "a",
+      "x": 1252,
+      "y": 88,
+      "w": 28,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "a",
+      "x": 1282,
+      "y": 88,
+      "w": 29,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "t",
+      "x": 1313,
+      "y": 88,
+      "w": 25,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "t",
+      "x": 1340,
+      "y": 88,
+      "w": 25,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "i",
+      "x": 1367,
+      "y": 88,
+      "w": 15,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "i",
+      "x": 1384,
+      "y": 88,
+      "w": 15,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "c",
+      "x": 1401,
+      "y": 88,
+      "w": 26,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "c",
+      "x": 1429,
+      "y": 88,
+      "w": 27,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "N",
+      "x": 1458,
+      "y": 88,
+      "w": 32,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "N",
+      "x": 1492,
+      "y": 88,
+      "w": 33,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "e",
+      "x": 1527,
+      "y": 88,
+      "w": 29,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "e",
+      "x": 1558,
+      "y": 88,
+      "w": 29,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "r",
+      "x": 2,
+      "y": 137,
+      "w": 22,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "r",
+      "x": 26,
+      "y": 137,
+      "w": 22,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "J",
+      "x": 50,
+      "y": 137,
+      "w": 29,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "J",
+      "x": 81,
+      "y": 137,
+      "w": 29,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": ".",
+      "x": 112,
+      "y": 137,
+      "w": 11,
+      "h": 11,
+      "source": "font"
+    },
+    {
+      "char": ".",
+      "x": 125,
+      "y": 137,
+      "w": 11,
+      "h": 11,
+      "source": "font"
+    },
+    {
+      "char": "C",
+      "x": 138,
+      "y": 137,
+      "w": 31,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "C",
+      "x": 171,
+      "y": 137,
+      "w": 32,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "u",
+      "x": 205,
+      "y": 137,
+      "w": 30,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "u",
+      "x": 237,
+      "y": 137,
+      "w": 30,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "G",
+      "x": 269,
+      "y": 137,
+      "w": 33,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "G",
+      "x": 304,
+      "y": 137,
+      "w": 34,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "K",
+      "x": 340,
+      "y": 137,
+      "w": 32,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "K",
+      "x": 374,
+      "y": 137,
+      "w": 33,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "O",
+      "x": 409,
+      "y": 137,
+      "w": 30,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "O",
+      "x": 441,
+      "y": 137,
+      "w": 31,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "A",
+      "x": 474,
+      "y": 137,
+      "w": 32,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "A",
+      "x": 508,
+      "y": 137,
+      "w": 33,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "y",
+      "x": 543,
+      "y": 137,
+      "w": 31,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "y",
+      "x": 576,
+      "y": 137,
+      "w": 32,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "M",
+      "x": 610,
+      "y": 137,
+      "w": 41,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "M",
+      "x": 653,
+      "y": 137,
+      "w": 41,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "R",
+      "x": 696,
+      "y": 137,
+      "w": 30,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "R",
+      "x": 728,
+      "y": 137,
+      "w": 31,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "z",
+      "x": 761,
+      "y": 137,
+      "w": 23,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "z",
+      "x": 786,
+      "y": 137,
+      "w": 23,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "T",
+      "x": 811,
+      "y": 137,
+      "w": 31,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "T",
+      "x": 844,
+      "y": 137,
+      "w": 32,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "n",
+      "x": 878,
+      "y": 137,
+      "w": 30,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "n",
+      "x": 910,
+      "y": 137,
+      "w": 31,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "k",
+      "x": 943,
+      "y": 137,
+      "w": 29,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "k",
+      "x": 974,
+      "y": 137,
+      "w": 29,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "H",
+      "x": 1005,
+      "y": 137,
+      "w": 30,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "H",
+      "x": 1037,
+      "y": 137,
+      "w": 31,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "d",
+      "x": 1070,
+      "y": 137,
+      "w": 28,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "d",
+      "x": 1100,
+      "y": 137,
+      "w": 28,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "5",
+      "x": 1130,
+      "y": 137,
+      "w": 29,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "5",
+      "x": 1161,
+      "y": 137,
+      "w": 30,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "2",
+      "x": 1193,
+      "y": 137,
+      "w": 29,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "2",
+      "x": 1224,
+      "y": 137,
+      "w": 30,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "D",
+      "x": 1256,
+      "y": 137,
+      "w": 30,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "D",
+      "x": 1288,
+      "y": 137,
+      "w": 31,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "Z",
+      "x": 1321,
+      "y": 137,
+      "w": 29,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "Z",
+      "x": 1352,
+      "y": 137,
+      "w": 30,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "P",
+      "x": 1384,
+      "y": 137,
+      "w": 30,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "P",
+      "x": 1416,
+      "y": 137,
+      "w": 31,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "'",
+      "x": 1449,
+      "y": 137,
+      "w": 10,
+      "h": 15,
+      "source": "font"
+    },
+    {
+      "char": "'",
+      "x": 1461,
+      "y": 137,
+      "w": 10,
+      "h": 15,
+      "source": "font"
+    },
+    {
+      "char": "8",
+      "x": 1473,
+      "y": 137,
+      "w": 29,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "8",
+      "x": 1504,
+      "y": 137,
+      "w": 29,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "9",
+      "x": 1535,
+      "y": 137,
+      "w": 32,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "9",
+      "x": 2,
+      "y": 175,
+      "w": 32,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "F",
+      "x": 36,
+      "y": 175,
+      "w": 24,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "F",
+      "x": 62,
+      "y": 175,
+      "w": 25,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "g",
+      "x": 89,
+      "y": 175,
+      "w": 30,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "g",
+      "x": 121,
+      "y": 175,
+      "w": 31,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "6",
+      "x": 154,
+      "y": 175,
+      "w": 31,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "6",
+      "x": 187,
+      "y": 175,
+      "w": 32,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "w",
+      "x": 221,
+      "y": 175,
+      "w": 35,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "w",
+      "x": 258,
+      "y": 175,
+      "w": 36,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "q",
+      "x": 296,
+      "y": 175,
+      "w": 28,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "q",
+      "x": 326,
+      "y": 175,
+      "w": 29,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "B",
+      "x": 357,
+      "y": 175,
+      "w": 28,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "B",
+      "x": 387,
+      "y": 175,
+      "w": 28,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "v",
+      "x": 417,
+      "y": 175,
+      "w": 28,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "v",
+      "x": 447,
+      "y": 175,
+      "w": 28,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "L",
+      "x": 477,
+      "y": 175,
+      "w": 22,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "L",
+      "x": 501,
+      "y": 175,
+      "w": 22,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "W",
+      "x": 525,
+      "y": 175,
+      "w": 46,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "W",
+      "x": 573,
+      "y": 175,
+      "w": 46,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "1",
+      "x": 621,
+      "y": 175,
+      "w": 19,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "1",
+      "x": 642,
+      "y": 175,
+      "w": 20,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "3",
+      "x": 664,
+      "y": 175,
+      "w": 28,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "3",
+      "x": 694,
+      "y": 175,
+      "w": 29,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "V",
+      "x": 725,
+      "y": 175,
+      "w": 33,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "V",
+      "x": 760,
+      "y": 175,
+      "w": 33,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "I",
+      "x": 795,
+      "y": 175,
+      "w": 14,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "I",
+      "x": 811,
+      "y": 175,
+      "w": 14,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "b",
+      "x": 827,
+      "y": 175,
+      "w": 28,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "b",
+      "x": 857,
+      "y": 175,
+      "w": 29,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "E",
+      "x": 888,
+      "y": 175,
+      "w": 24,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "E",
+      "x": 914,
+      "y": 175,
+      "w": 24,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "x",
+      "x": 940,
+      "y": 175,
+      "w": 28,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "x",
+      "x": 970,
+      "y": 175,
+      "w": 29,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "f",
+      "x": 1001,
+      "y": 175,
+      "w": 21,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "f",
+      "x": 1024,
+      "y": 175,
+      "w": 21,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "+",
+      "x": 1047,
+      "y": 175,
+      "w": 29,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "+",
+      "x": 1078,
+      "y": 175,
+      "w": 29,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "4",
+      "x": 1109,
+      "y": 175,
+      "w": 30,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "4",
+      "x": 1141,
+      "y": 175,
+      "w": 31,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "7",
+      "x": 1174,
+      "y": 175,
+      "w": 29,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "7",
+      "x": 1205,
+      "y": 175,
+      "w": 29,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "U",
+      "x": 1236,
+      "y": 175,
+      "w": 31,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "U",
+      "x": 1269,
+      "y": 175,
+      "w": 32,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "X",
+      "x": 1303,
+      "y": 175,
+      "w": 33,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "X",
+      "x": 1338,
+      "y": 175,
+      "w": 34,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "0",
+      "x": 1374,
+      "y": 175,
+      "w": 30,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "0",
+      "x": 1406,
+      "y": 175,
+      "w": 31,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "j",
+      "x": 1439,
+      "y": 175,
+      "w": 20,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "j",
+      "x": 1461,
+      "y": 175,
+      "w": 20,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "·",
+      "x": 1483,
+      "y": 175,
+      "w": 13,
+      "h": 13,
+      "source": "font"
+    },
+    {
+      "char": "·",
+      "x": 1498,
+      "y": 175,
+      "w": 13,
+      "h": 13,
+      "source": "font"
+    },
+    {
+      "char": "/",
+      "x": 1513,
+      "y": 175,
+      "w": 20,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "/",
+      "x": 1535,
+      "y": 175,
+      "w": 21,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "Y",
+      "x": 1558,
+      "y": 175,
+      "w": 31,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "Y",
+      "x": 2,
+      "y": 220,
+      "w": 31,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "ä",
+      "x": 35,
+      "y": 220,
+      "w": 27,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "ä",
+      "x": 64,
+      "y": 220,
+      "w": 28,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "Q",
+      "x": 94,
+      "y": 220,
+      "w": 30,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "Q",
+      "x": 126,
+      "y": 220,
+      "w": 31,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "ö",
+      "x": 159,
+      "y": 220,
+      "w": 27,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "ö",
+      "x": 188,
+      "y": 220,
+      "w": 28,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "Ü",
+      "x": 218,
+      "y": 220,
+      "w": 31,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "Ü",
+      "x": 251,
+      "y": 220,
+      "w": 32,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ü",
+      "x": 285,
+      "y": 220,
+      "w": 29,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "ü",
+      "x": 316,
+      "y": 220,
+      "w": 30,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "é",
+      "x": 348,
+      "y": 220,
+      "w": 29,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "é",
+      "x": 379,
+      "y": 220,
+      "w": 30,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "(",
+      "x": 411,
+      "y": 220,
+      "w": 21,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "(",
+      "x": 434,
+      "y": 220,
+      "w": 21,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": ")",
+      "x": 457,
+      "y": 220,
+      "w": 21,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": ")",
+      "x": 480,
+      "y": 220,
+      "w": 22,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "ú",
+      "x": 504,
+      "y": 220,
+      "w": 29,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "ú",
+      "x": 535,
+      "y": 220,
+      "w": 30,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "ó",
+      "x": 567,
+      "y": 220,
+      "w": 28,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "ó",
+      "x": 597,
+      "y": 220,
+      "w": 28,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "á",
+      "x": 627,
+      "y": 220,
+      "w": 28,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "á",
+      "x": 657,
+      "y": 220,
+      "w": 28,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "í",
+      "x": 687,
+      "y": 220,
+      "w": 14,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "í",
+      "x": 703,
+      "y": 220,
+      "w": 14,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "ñ",
+      "x": 719,
+      "y": 220,
+      "w": 30,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "ñ",
+      "x": 751,
+      "y": 220,
+      "w": 30,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "É",
+      "x": 783,
+      "y": 220,
+      "w": 23,
+      "h": 47,
+      "source": "font"
+    },
+    {
+      "char": "É",
+      "x": 808,
+      "y": 220,
+      "w": 24,
+      "h": 48,
+      "source": "font"
+    },
+    {
+      "char": "ï",
+      "x": 834,
+      "y": 220,
+      "w": 20,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "ï",
+      "x": 856,
+      "y": 220,
+      "w": 20,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "ê",
+      "x": 878,
+      "y": 220,
+      "w": 29,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "ê",
+      "x": 909,
+      "y": 220,
+      "w": 29,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "è",
+      "x": 940,
+      "y": 220,
+      "w": 29,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "è",
+      "x": 971,
+      "y": 220,
+      "w": 30,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "ÿ",
+      "x": 1003,
+      "y": 220,
+      "w": 31,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "ÿ",
+      "x": 1036,
+      "y": 220,
+      "w": 31,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "ë",
+      "x": 1069,
+      "y": 220,
+      "w": 29,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "ë",
+      "x": 1100,
+      "y": 220,
+      "w": 30,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "«",
+      "x": 1132,
+      "y": 220,
+      "w": 31,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "«",
+      "x": 1165,
+      "y": 220,
+      "w": 32,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "»",
+      "x": 1199,
+      "y": 220,
+      "w": 31,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "»",
+      "x": 1232,
+      "y": 220,
+      "w": 32,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "ç",
+      "x": 1266,
+      "y": 220,
+      "w": 27,
+      "h": 38,
+      "source": "font"
+    },
+    {
+      "char": "ç",
+      "x": 1295,
+      "y": 220,
+      "w": 27,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "!",
+      "x": 1324,
+      "y": 220,
+      "w": 18,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "!",
+      "x": 1344,
+      "y": 220,
+      "w": 19,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": ":",
+      "x": 1365,
+      "y": 220,
+      "w": 11,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": ":",
+      "x": 1378,
+      "y": 220,
+      "w": 11,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "\"",
+      "x": 1391,
+      "y": 220,
+      "w": 17,
+      "h": 15,
+      "source": "font"
+    },
+    {
+      "char": "\"",
+      "x": 1410,
+      "y": 220,
+      "w": 17,
+      "h": 15,
+      "source": "font"
+    }
+  ]
+}
\ No newline at end of file
diff --git a/public/scanner/v1/glyphs/death-weapon.png b/public/scanner/v1/glyphs/death-weapon.png
new file mode 100644
index 000000000..924388af5
Binary files /dev/null and b/public/scanner/v1/glyphs/death-weapon.png differ
diff --git a/public/scanner/v1/glyphs/map-start-mode.json b/public/scanner/v1/glyphs/map-start-mode.json
new file mode 100644
index 000000000..55664c041
--- /dev/null
+++ b/public/scanner/v1/glyphs/map-start-mode.json
@@ -0,0 +1,1085 @@
+{
+  "height": 76,
+  "glyphs": [
+    {
+      "char": "R",
+      "x": 2,
+      "y": 2,
+      "w": 64,
+      "h": 78,
+      "source": "font"
+    },
+    {
+      "char": "R",
+      "x": 68,
+      "y": 2,
+      "w": 65,
+      "h": 78,
+      "source": "font"
+    },
+    {
+      "char": "R",
+      "x": 135,
+      "y": 2,
+      "w": 66,
+      "h": 79,
+      "source": "font"
+    },
+    {
+      "char": "e",
+      "x": 203,
+      "y": 2,
+      "w": 64,
+      "h": 62,
+      "source": "font"
+    },
+    {
+      "char": "e",
+      "x": 269,
+      "y": 2,
+      "w": 64,
+      "h": 63,
+      "source": "font"
+    },
+    {
+      "char": "e",
+      "x": 335,
+      "y": 2,
+      "w": 65,
+      "h": 64,
+      "source": "font"
+    },
+    {
+      "char": "v",
+      "x": 402,
+      "y": 2,
+      "w": 62,
+      "h": 60,
+      "source": "font"
+    },
+    {
+      "char": "v",
+      "x": 466,
+      "y": 2,
+      "w": 62,
+      "h": 61,
+      "source": "font"
+    },
+    {
+      "char": "v",
+      "x": 530,
+      "y": 2,
+      "w": 63,
+      "h": 61,
+      "source": "font"
+    },
+    {
+      "char": "i",
+      "x": 595,
+      "y": 2,
+      "w": 30,
+      "h": 77,
+      "source": "font"
+    },
+    {
+      "char": "i",
+      "x": 627,
+      "y": 2,
+      "w": 30,
+      "h": 78,
+      "source": "font"
+    },
+    {
+      "char": "i",
+      "x": 659,
+      "y": 2,
+      "w": 30,
+      "h": 78,
+      "source": "font"
+    },
+    {
+      "char": "r",
+      "x": 691,
+      "y": 2,
+      "w": 46,
+      "h": 60,
+      "source": "font"
+    },
+    {
+      "char": "r",
+      "x": 739,
+      "y": 2,
+      "w": 47,
+      "h": 61,
+      "source": "font"
+    },
+    {
+      "char": "r",
+      "x": 788,
+      "y": 2,
+      "w": 47,
+      "h": 61,
+      "source": "font"
+    },
+    {
+      "char": "k",
+      "x": 837,
+      "y": 2,
+      "w": 63,
+      "h": 77,
+      "source": "font"
+    },
+    {
+      "char": "k",
+      "x": 902,
+      "y": 2,
+      "w": 64,
+      "h": 78,
+      "source": "font"
+    },
+    {
+      "char": "k",
+      "x": 968,
+      "y": 2,
+      "w": 64,
+      "h": 79,
+      "source": "font"
+    },
+    {
+      "char": "a",
+      "x": 1034,
+      "y": 2,
+      "w": 61,
+      "h": 61,
+      "source": "font"
+    },
+    {
+      "char": "a",
+      "x": 1097,
+      "y": 2,
+      "w": 61,
+      "h": 61,
+      "source": "font"
+    },
+    {
+      "char": "a",
+      "x": 1160,
+      "y": 2,
+      "w": 62,
+      "h": 62,
+      "source": "font"
+    },
+    {
+      "char": "m",
+      "x": 1224,
+      "y": 2,
+      "w": 91,
+      "h": 61,
+      "source": "font"
+    },
+    {
+      "char": "m",
+      "x": 1317,
+      "y": 2,
+      "w": 92,
+      "h": 62,
+      "source": "font"
+    },
+    {
+      "char": "m",
+      "x": 1411,
+      "y": 2,
+      "w": 92,
+      "h": 62,
+      "source": "font"
+    },
+    {
+      "char": "p",
+      "x": 1505,
+      "y": 2,
+      "w": 62,
+      "h": 76,
+      "source": "font"
+    },
+    {
+      "char": "p",
+      "x": 2,
+      "y": 83,
+      "w": 62,
+      "h": 77,
+      "source": "font"
+    },
+    {
+      "char": "p",
+      "x": 66,
+      "y": 83,
+      "w": 63,
+      "h": 78,
+      "source": "font"
+    },
+    {
+      "char": "f",
+      "x": 131,
+      "y": 83,
+      "w": 43,
+      "h": 77,
+      "source": "font"
+    },
+    {
+      "char": "f",
+      "x": 176,
+      "y": 83,
+      "w": 44,
+      "h": 78,
+      "source": "font"
+    },
+    {
+      "char": "f",
+      "x": 222,
+      "y": 83,
+      "w": 44,
+      "h": 78,
+      "source": "font"
+    },
+    {
+      "char": "H",
+      "x": 268,
+      "y": 83,
+      "w": 66,
+      "h": 77,
+      "source": "font"
+    },
+    {
+      "char": "H",
+      "x": 336,
+      "y": 83,
+      "w": 67,
+      "h": 78,
+      "source": "font"
+    },
+    {
+      "char": "H",
+      "x": 405,
+      "y": 83,
+      "w": 68,
+      "h": 78,
+      "source": "font"
+    },
+    {
+      "char": "s",
+      "x": 475,
+      "y": 83,
+      "w": 52,
+      "h": 62,
+      "source": "font"
+    },
+    {
+      "char": "s",
+      "x": 529,
+      "y": 83,
+      "w": 52,
+      "h": 63,
+      "source": "font"
+    },
+    {
+      "char": "s",
+      "x": 583,
+      "y": 83,
+      "w": 53,
+      "h": 63,
+      "source": "font"
+    },
+    {
+      "char": "c",
+      "x": 638,
+      "y": 83,
+      "w": 57,
+      "h": 62,
+      "source": "font"
+    },
+    {
+      "char": "c",
+      "x": 697,
+      "y": 83,
+      "w": 58,
+      "h": 63,
+      "source": "font"
+    },
+    {
+      "char": "c",
+      "x": 757,
+      "y": 83,
+      "w": 58,
+      "h": 63,
+      "source": "font"
+    },
+    {
+      "char": "h",
+      "x": 817,
+      "y": 83,
+      "w": 65,
+      "h": 77,
+      "source": "font"
+    },
+    {
+      "char": "h",
+      "x": 884,
+      "y": 83,
+      "w": 66,
+      "h": 78,
+      "source": "font"
+    },
+    {
+      "char": "h",
+      "x": 952,
+      "y": 83,
+      "w": 66,
+      "h": 79,
+      "source": "font"
+    },
+    {
+      "char": "t",
+      "x": 1020,
+      "y": 83,
+      "w": 52,
+      "h": 69,
+      "source": "font"
+    },
+    {
+      "char": "t",
+      "x": 1074,
+      "y": 83,
+      "w": 53,
+      "h": 70,
+      "source": "font"
+    },
+    {
+      "char": "t",
+      "x": 1129,
+      "y": 83,
+      "w": 53,
+      "h": 70,
+      "source": "font"
+    },
+    {
+      "char": "T",
+      "x": 1184,
+      "y": 83,
+      "w": 67,
+      "h": 77,
+      "source": "font"
+    },
+    {
+      "char": "T",
+      "x": 1253,
+      "y": 83,
+      "w": 68,
+      "h": 78,
+      "source": "font"
+    },
+    {
+      "char": "T",
+      "x": 1323,
+      "y": 83,
+      "w": 68,
+      "h": 79,
+      "source": "font"
+    },
+    {
+      "char": "u",
+      "x": 1393,
+      "y": 83,
+      "w": 65,
+      "h": 61,
+      "source": "font"
+    },
+    {
+      "char": "u",
+      "x": 1460,
+      "y": 83,
+      "w": 65,
+      "h": 61,
+      "source": "font"
+    },
+    {
+      "char": "u",
+      "x": 1527,
+      "y": 83,
+      "w": 66,
+      "h": 62,
+      "source": "font"
+    },
+    {
+      "char": "-",
+      "x": 2,
+      "y": 164,
+      "w": 39,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "-",
+      "x": 43,
+      "y": 164,
+      "w": 39,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "-",
+      "x": 84,
+      "y": 164,
+      "w": 39,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "K",
+      "x": 125,
+      "y": 164,
+      "w": 72,
+      "h": 78,
+      "source": "font"
+    },
+    {
+      "char": "K",
+      "x": 199,
+      "y": 164,
+      "w": 72,
+      "h": 78,
+      "source": "font"
+    },
+    {
+      "char": "K",
+      "x": 273,
+      "y": 164,
+      "w": 73,
+      "h": 79,
+      "source": "font"
+    },
+    {
+      "char": "o",
+      "x": 348,
+      "y": 164,
+      "w": 61,
+      "h": 63,
+      "source": "font"
+    },
+    {
+      "char": "o",
+      "x": 411,
+      "y": 164,
+      "w": 62,
+      "h": 63,
+      "source": "font"
+    },
+    {
+      "char": "o",
+      "x": 475,
+      "y": 164,
+      "w": 62,
+      "h": 64,
+      "source": "font"
+    },
+    {
+      "char": "n",
+      "x": 539,
+      "y": 164,
+      "w": 65,
+      "h": 62,
+      "source": "font"
+    },
+    {
+      "char": "n",
+      "x": 606,
+      "y": 164,
+      "w": 66,
+      "h": 63,
+      "source": "font"
+    },
+    {
+      "char": "n",
+      "x": 674,
+      "y": 164,
+      "w": 66,
+      "h": 63,
+      "source": "font"
+    },
+    {
+      "char": "d",
+      "x": 742,
+      "y": 164,
+      "w": 61,
+      "h": 78,
+      "source": "font"
+    },
+    {
+      "char": "d",
+      "x": 805,
+      "y": 164,
+      "w": 62,
+      "h": 78,
+      "source": "font"
+    },
+    {
+      "char": "d",
+      "x": 869,
+      "y": 164,
+      "w": 63,
+      "h": 79,
+      "source": "font"
+    },
+    {
+      "char": "O",
+      "x": 934,
+      "y": 164,
+      "w": 66,
+      "h": 78,
+      "source": "font"
+    },
+    {
+      "char": "O",
+      "x": 1002,
+      "y": 164,
+      "w": 67,
+      "h": 79,
+      "source": "font"
+    },
+    {
+      "char": "O",
+      "x": 1071,
+      "y": 164,
+      "w": 68,
+      "h": 81,
+      "source": "font"
+    },
+    {
+      "char": "G",
+      "x": 1141,
+      "y": 164,
+      "w": 72,
+      "h": 78,
+      "source": "font"
+    },
+    {
+      "char": "G",
+      "x": 1215,
+      "y": 164,
+      "w": 73,
+      "h": 78,
+      "source": "font"
+    },
+    {
+      "char": "G",
+      "x": 1290,
+      "y": 164,
+      "w": 74,
+      "h": 79,
+      "source": "font"
+    },
+    {
+      "char": "l",
+      "x": 1366,
+      "y": 164,
+      "w": 30,
+      "h": 78,
+      "source": "font"
+    },
+    {
+      "char": "l",
+      "x": 1398,
+      "y": 164,
+      "w": 31,
+      "h": 79,
+      "source": "font"
+    },
+    {
+      "char": "l",
+      "x": 1431,
+      "y": 164,
+      "w": 31,
+      "h": 79,
+      "source": "font"
+    },
+    {
+      "char": "M",
+      "x": 1464,
+      "y": 164,
+      "w": 91,
+      "h": 78,
+      "source": "font"
+    },
+    {
+      "char": "M",
+      "x": 2,
+      "y": 247,
+      "w": 92,
+      "h": 78,
+      "source": "font"
+    },
+    {
+      "char": "M",
+      "x": 96,
+      "y": 247,
+      "w": 93,
+      "h": 79,
+      "source": "font"
+    },
+    {
+      "char": "W",
+      "x": 191,
+      "y": 247,
+      "w": 101,
+      "h": 78,
+      "source": "font"
+    },
+    {
+      "char": "W",
+      "x": 294,
+      "y": 247,
+      "w": 102,
+      "h": 78,
+      "source": "font"
+    },
+    {
+      "char": "W",
+      "x": 398,
+      "y": 247,
+      "w": 103,
+      "h": 79,
+      "source": "font"
+    },
+    {
+      "char": "S",
+      "x": 503,
+      "y": 247,
+      "w": 59,
+      "h": 77,
+      "source": "font"
+    },
+    {
+      "char": "S",
+      "x": 564,
+      "y": 247,
+      "w": 59,
+      "h": 78,
+      "source": "font"
+    },
+    {
+      "char": "S",
+      "x": 625,
+      "y": 247,
+      "w": 60,
+      "h": 79,
+      "source": "font"
+    },
+    {
+      "char": "Z",
+      "x": 687,
+      "y": 247,
+      "w": 63,
+      "h": 78,
+      "source": "font"
+    },
+    {
+      "char": "Z",
+      "x": 752,
+      "y": 247,
+      "w": 64,
+      "h": 78,
+      "source": "font"
+    },
+    {
+      "char": "Z",
+      "x": 818,
+      "y": 247,
+      "w": 65,
+      "h": 79,
+      "source": "font"
+    },
+    {
+      "char": "w",
+      "x": 885,
+      "y": 247,
+      "w": 79,
+      "h": 60,
+      "source": "font"
+    },
+    {
+      "char": "w",
+      "x": 966,
+      "y": 247,
+      "w": 80,
+      "h": 61,
+      "source": "font"
+    },
+    {
+      "char": "w",
+      "x": 1048,
+      "y": 247,
+      "w": 81,
+      "h": 61,
+      "source": "font"
+    },
+    {
+      "char": "C",
+      "x": 1131,
+      "y": 247,
+      "w": 68,
+      "h": 79,
+      "source": "font"
+    },
+    {
+      "char": "C",
+      "x": 1201,
+      "y": 247,
+      "w": 69,
+      "h": 79,
+      "source": "font"
+    },
+    {
+      "char": "C",
+      "x": 1272,
+      "y": 247,
+      "w": 70,
+      "h": 80,
+      "source": "font"
+    },
+    {
+      "char": "B",
+      "x": 1344,
+      "y": 247,
+      "w": 61,
+      "h": 77,
+      "source": "font"
+    },
+    {
+      "char": "B",
+      "x": 1407,
+      "y": 247,
+      "w": 62,
+      "h": 78,
+      "source": "font"
+    },
+    {
+      "char": "B",
+      "x": 1471,
+      "y": 247,
+      "w": 63,
+      "h": 79,
+      "source": "font"
+    },
+    {
+      "char": "z",
+      "x": 1536,
+      "y": 247,
+      "w": 49,
+      "h": 60,
+      "source": "font"
+    },
+    {
+      "char": "z",
+      "x": 2,
+      "y": 329,
+      "w": 50,
+      "h": 61,
+      "source": "font"
+    },
+    {
+      "char": "z",
+      "x": 54,
+      "y": 329,
+      "w": 50,
+      "h": 61,
+      "source": "font"
+    },
+    {
+      "char": "P",
+      "x": 106,
+      "y": 329,
+      "w": 64,
+      "h": 78,
+      "source": "font"
+    },
+    {
+      "char": "P",
+      "x": 172,
+      "y": 329,
+      "w": 65,
+      "h": 79,
+      "source": "font"
+    },
+    {
+      "char": "P",
+      "x": 239,
+      "y": 329,
+      "w": 66,
+      "h": 79,
+      "source": "font"
+    },
+    {
+      "char": "A",
+      "x": 307,
+      "y": 329,
+      "w": 72,
+      "h": 77,
+      "source": "font"
+    },
+    {
+      "char": "A",
+      "x": 381,
+      "y": 329,
+      "w": 72,
+      "h": 78,
+      "source": "font"
+    },
+    {
+      "char": "A",
+      "x": 455,
+      "y": 329,
+      "w": 73,
+      "h": 78,
+      "source": "font"
+    },
+    {
+      "char": "j",
+      "x": 530,
+      "y": 329,
+      "w": 43,
+      "h": 94,
+      "source": "font"
+    },
+    {
+      "char": "j",
+      "x": 575,
+      "y": 329,
+      "w": 44,
+      "h": 96,
+      "source": "font"
+    },
+    {
+      "char": "j",
+      "x": 621,
+      "y": 329,
+      "w": 44,
+      "h": 96,
+      "source": "font"
+    },
+    {
+      "char": "D",
+      "x": 667,
+      "y": 329,
+      "w": 66,
+      "h": 78,
+      "source": "font"
+    },
+    {
+      "char": "D",
+      "x": 735,
+      "y": 329,
+      "w": 67,
+      "h": 79,
+      "source": "font"
+    },
+    {
+      "char": "D",
+      "x": 804,
+      "y": 329,
+      "w": 68,
+      "h": 79,
+      "source": "font"
+    },
+    {
+      "char": "é",
+      "x": 874,
+      "y": 329,
+      "w": 63,
+      "h": 86,
+      "source": "font"
+    },
+    {
+      "char": "é",
+      "x": 939,
+      "y": 329,
+      "w": 64,
+      "h": 87,
+      "source": "font"
+    },
+    {
+      "char": "é",
+      "x": 1005,
+      "y": 329,
+      "w": 65,
+      "h": 88,
+      "source": "font"
+    },
+    {
+      "char": "E",
+      "x": 1072,
+      "y": 329,
+      "w": 50,
+      "h": 77,
+      "source": "font"
+    },
+    {
+      "char": "E",
+      "x": 1124,
+      "y": 329,
+      "w": 51,
+      "h": 78,
+      "source": "font"
+    },
+    {
+      "char": "E",
+      "x": 1177,
+      "y": 329,
+      "w": 51,
+      "h": 79,
+      "source": "font"
+    },
+    {
+      "char": "x",
+      "x": 1230,
+      "y": 329,
+      "w": 63,
+      "h": 60,
+      "source": "font"
+    },
+    {
+      "char": "x",
+      "x": 1295,
+      "y": 329,
+      "w": 63,
+      "h": 61,
+      "source": "font"
+    },
+    {
+      "char": "x",
+      "x": 1360,
+      "y": 329,
+      "w": 64,
+      "h": 62,
+      "source": "font"
+    },
+    {
+      "char": "q",
+      "x": 1426,
+      "y": 329,
+      "w": 61,
+      "h": 77,
+      "source": "font"
+    },
+    {
+      "char": "q",
+      "x": 1489,
+      "y": 329,
+      "w": 62,
+      "h": 78,
+      "source": "font"
+    },
+    {
+      "char": "q",
+      "x": 2,
+      "y": 427,
+      "w": 63,
+      "h": 79,
+      "source": "font"
+    },
+    {
+      "char": "b",
+      "x": 67,
+      "y": 427,
+      "w": 62,
+      "h": 78,
+      "source": "font"
+    },
+    {
+      "char": "b",
+      "x": 131,
+      "y": 427,
+      "w": 62,
+      "h": 78,
+      "source": "font"
+    },
+    {
+      "char": "b",
+      "x": 195,
+      "y": 427,
+      "w": 63,
+      "h": 79,
+      "source": "font"
+    },
+    {
+      "char": "V",
+      "x": 260,
+      "y": 427,
+      "w": 73,
+      "h": 78,
+      "source": "font"
+    },
+    {
+      "char": "V",
+      "x": 335,
+      "y": 427,
+      "w": 74,
+      "h": 78,
+      "source": "font"
+    },
+    {
+      "char": "V",
+      "x": 411,
+      "y": 427,
+      "w": 74,
+      "h": 79,
+      "source": "font"
+    },
+    {
+      "char": "g",
+      "x": 487,
+      "y": 427,
+      "w": 66,
+      "h": 77,
+      "source": "font"
+    },
+    {
+      "char": "g",
+      "x": 555,
+      "y": 427,
+      "w": 65,
+      "h": 78,
+      "source": "font"
+    },
+    {
+      "char": "g",
+      "x": 622,
+      "y": 427,
+      "w": 66,
+      "h": 79,
+      "source": "font"
+    },
+    {
+      "char": "ó",
+      "x": 690,
+      "y": 427,
+      "w": 60,
+      "h": 86,
+      "source": "font"
+    },
+    {
+      "char": "ó",
+      "x": 752,
+      "y": 427,
+      "w": 61,
+      "h": 87,
+      "source": "font"
+    },
+    {
+      "char": "ó",
+      "x": 815,
+      "y": 427,
+      "w": 62,
+      "h": 88,
+      "source": "font"
+    }
+  ]
+}
\ No newline at end of file
diff --git a/public/scanner/v1/glyphs/map-start-mode.png b/public/scanner/v1/glyphs/map-start-mode.png
new file mode 100644
index 000000000..8d35a01cb
Binary files /dev/null and b/public/scanner/v1/glyphs/map-start-mode.png differ
diff --git a/public/scanner/v1/glyphs/map-start-stage.json b/public/scanner/v1/glyphs/map-start-stage.json
new file mode 100644
index 000000000..bac245ebd
--- /dev/null
+++ b/public/scanner/v1/glyphs/map-start-stage.json
@@ -0,0 +1,1685 @@
+{
+  "height": 40,
+  "glyphs": [
+    {
+      "char": "S",
+      "x": 2,
+      "y": 2,
+      "w": 25,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "S",
+      "x": 29,
+      "y": 2,
+      "w": 25,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "S",
+      "x": 56,
+      "y": 2,
+      "w": 26,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "P",
+      "x": 84,
+      "y": 2,
+      "w": 24,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "P",
+      "x": 110,
+      "y": 2,
+      "w": 25,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "P",
+      "x": 137,
+      "y": 2,
+      "w": 25,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "A",
+      "x": 164,
+      "y": 2,
+      "w": 24,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "A",
+      "x": 190,
+      "y": 2,
+      "w": 24,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "A",
+      "x": 216,
+      "y": 2,
+      "w": 25,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "B",
+      "x": 243,
+      "y": 2,
+      "w": 23,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "B",
+      "x": 268,
+      "y": 2,
+      "w": 24,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "B",
+      "x": 294,
+      "y": 2,
+      "w": 24,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "a",
+      "x": 320,
+      "y": 2,
+      "w": 24,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "a",
+      "x": 346,
+      "y": 2,
+      "w": 24,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "a",
+      "x": 372,
+      "y": 2,
+      "w": 25,
+      "h": 33,
+      "source": "font"
+    },
+    {
+      "char": "h",
+      "x": 399,
+      "y": 2,
+      "w": 22,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "h",
+      "x": 423,
+      "y": 2,
+      "w": 22,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "h",
+      "x": 447,
+      "y": 2,
+      "w": 23,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "n",
+      "x": 472,
+      "y": 2,
+      "w": 22,
+      "h": 30,
+      "source": "font"
+    },
+    {
+      "char": "n",
+      "x": 496,
+      "y": 2,
+      "w": 22,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "n",
+      "x": 520,
+      "y": 2,
+      "w": 22,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "o",
+      "x": 544,
+      "y": 2,
+      "w": 22,
+      "h": 30,
+      "source": "font"
+    },
+    {
+      "char": "o",
+      "x": 568,
+      "y": 2,
+      "w": 22,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "o",
+      "x": 592,
+      "y": 2,
+      "w": 22,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "f",
+      "x": 616,
+      "y": 2,
+      "w": 20,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "f",
+      "x": 638,
+      "y": 2,
+      "w": 21,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "f",
+      "x": 661,
+      "y": 2,
+      "w": 21,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "L",
+      "x": 684,
+      "y": 2,
+      "w": 18,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "L",
+      "x": 704,
+      "y": 2,
+      "w": 18,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "L",
+      "x": 724,
+      "y": 2,
+      "w": 18,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "e",
+      "x": 744,
+      "y": 2,
+      "w": 23,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "e",
+      "x": 769,
+      "y": 2,
+      "w": 23,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "e",
+      "x": 794,
+      "y": 2,
+      "w": 24,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "m",
+      "x": 820,
+      "y": 2,
+      "w": 31,
+      "h": 30,
+      "source": "font"
+    },
+    {
+      "char": "m",
+      "x": 853,
+      "y": 2,
+      "w": 32,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "m",
+      "x": 887,
+      "y": 2,
+      "w": 32,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "u",
+      "x": 921,
+      "y": 2,
+      "w": 24,
+      "h": 30,
+      "source": "font"
+    },
+    {
+      "char": "u",
+      "x": 947,
+      "y": 2,
+      "w": 24,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "u",
+      "x": 973,
+      "y": 2,
+      "w": 25,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "r",
+      "x": 1000,
+      "y": 2,
+      "w": 17,
+      "h": 30,
+      "source": "font"
+    },
+    {
+      "char": "r",
+      "x": 1019,
+      "y": 2,
+      "w": 18,
+      "h": 30,
+      "source": "font"
+    },
+    {
+      "char": "r",
+      "x": 1039,
+      "y": 2,
+      "w": 18,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "i",
+      "x": 1059,
+      "y": 2,
+      "w": 11,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "i",
+      "x": 1072,
+      "y": 2,
+      "w": 11,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "i",
+      "x": 1085,
+      "y": 2,
+      "w": 10,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "K",
+      "x": 1097,
+      "y": 2,
+      "w": 23,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "K",
+      "x": 1122,
+      "y": 2,
+      "w": 22,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "K",
+      "x": 1146,
+      "y": 2,
+      "w": 22,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "s",
+      "x": 1170,
+      "y": 2,
+      "w": 21,
+      "h": 30,
+      "source": "font"
+    },
+    {
+      "char": "s",
+      "x": 1193,
+      "y": 2,
+      "w": 22,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "s",
+      "x": 1217,
+      "y": 2,
+      "w": 22,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "y",
+      "x": 1241,
+      "y": 2,
+      "w": 22,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "y",
+      "x": 1265,
+      "y": 2,
+      "w": 23,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "y",
+      "x": 1290,
+      "y": 2,
+      "w": 23,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "-",
+      "x": 1315,
+      "y": 2,
+      "w": 21,
+      "h": 11,
+      "source": "font"
+    },
+    {
+      "char": "-",
+      "x": 1338,
+      "y": 2,
+      "w": 22,
+      "h": 12,
+      "source": "font"
+    },
+    {
+      "char": "-",
+      "x": 1362,
+      "y": 2,
+      "w": 22,
+      "h": 12,
+      "source": "font"
+    },
+    {
+      "char": "Q",
+      "x": 1386,
+      "y": 2,
+      "w": 24,
+      "h": 49,
+      "source": "font"
+    },
+    {
+      "char": "Q",
+      "x": 1412,
+      "y": 2,
+      "w": 25,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "Q",
+      "x": 1439,
+      "y": 2,
+      "w": 25,
+      "h": 52,
+      "source": "font"
+    },
+    {
+      "char": "l",
+      "x": 1466,
+      "y": 2,
+      "w": 9,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "l",
+      "x": 1477,
+      "y": 2,
+      "w": 9,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "l",
+      "x": 1488,
+      "y": 2,
+      "w": 10,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "F",
+      "x": 1500,
+      "y": 2,
+      "w": 21,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "F",
+      "x": 1523,
+      "y": 2,
+      "w": 22,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "F",
+      "x": 1547,
+      "y": 2,
+      "w": 22,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "d",
+      "x": 1571,
+      "y": 2,
+      "w": 22,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "d",
+      "x": 2,
+      "y": 56,
+      "w": 23,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "d",
+      "x": 27,
+      "y": 56,
+      "w": 23,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "p",
+      "x": 52,
+      "y": 56,
+      "w": 22,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "p",
+      "x": 76,
+      "y": 56,
+      "w": 22,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "p",
+      "x": 100,
+      "y": 56,
+      "w": 22,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "k",
+      "x": 124,
+      "y": 56,
+      "w": 22,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "k",
+      "x": 148,
+      "y": 56,
+      "w": 22,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "k",
+      "x": 172,
+      "y": 56,
+      "w": 22,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "D",
+      "x": 196,
+      "y": 56,
+      "w": 24,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "D",
+      "x": 222,
+      "y": 56,
+      "w": 24,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "D",
+      "x": 248,
+      "y": 56,
+      "w": 25,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "b",
+      "x": 275,
+      "y": 56,
+      "w": 23,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "b",
+      "x": 300,
+      "y": 56,
+      "w": 23,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "b",
+      "x": 325,
+      "y": 56,
+      "w": 23,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "t",
+      "x": 350,
+      "y": 56,
+      "w": 19,
+      "h": 36,
+      "source": "font"
+    },
+    {
+      "char": "t",
+      "x": 371,
+      "y": 56,
+      "w": 19,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "t",
+      "x": 392,
+      "y": 56,
+      "w": 19,
+      "h": 37,
+      "source": "font"
+    },
+    {
+      "char": "R",
+      "x": 413,
+      "y": 56,
+      "w": 23,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "R",
+      "x": 438,
+      "y": 56,
+      "w": 24,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "R",
+      "x": 464,
+      "y": 56,
+      "w": 24,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "O",
+      "x": 490,
+      "y": 56,
+      "w": 24,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "O",
+      "x": 516,
+      "y": 56,
+      "w": 24,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "O",
+      "x": 542,
+      "y": 56,
+      "w": 24,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "M",
+      "x": 568,
+      "y": 56,
+      "w": 28,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "M",
+      "x": 598,
+      "y": 56,
+      "w": 29,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "M",
+      "x": 629,
+      "y": 56,
+      "w": 30,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "&",
+      "x": 661,
+      "y": 56,
+      "w": 34,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "&",
+      "x": 697,
+      "y": 56,
+      "w": 35,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "&",
+      "x": 734,
+      "y": 56,
+      "w": 36,
+      "h": 46,
+      "source": "font"
+    },
+    {
+      "char": "ß",
+      "x": 772,
+      "y": 56,
+      "w": 23,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "ß",
+      "x": 797,
+      "y": 56,
+      "w": 23,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "ß",
+      "x": 822,
+      "y": 56,
+      "w": 24,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "U",
+      "x": 848,
+      "y": 56,
+      "w": 24,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "U",
+      "x": 874,
+      "y": 56,
+      "w": 25,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "U",
+      "x": 901,
+      "y": 56,
+      "w": 25,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "'",
+      "x": 928,
+      "y": 56,
+      "w": 12,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "'",
+      "x": 942,
+      "y": 56,
+      "w": 12,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "'",
+      "x": 956,
+      "y": 56,
+      "w": 13,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "c",
+      "x": 971,
+      "y": 56,
+      "w": 22,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "c",
+      "x": 995,
+      "y": 56,
+      "w": 23,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "c",
+      "x": 1020,
+      "y": 56,
+      "w": 23,
+      "h": 33,
+      "source": "font"
+    },
+    {
+      "char": "g",
+      "x": 1045,
+      "y": 56,
+      "w": 22,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "g",
+      "x": 1069,
+      "y": 56,
+      "w": 22,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "g",
+      "x": 1093,
+      "y": 56,
+      "w": 23,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "ü",
+      "x": 1118,
+      "y": 56,
+      "w": 24,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "ü",
+      "x": 1144,
+      "y": 56,
+      "w": 24,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "ü",
+      "x": 1170,
+      "y": 56,
+      "w": 25,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "C",
+      "x": 1197,
+      "y": 56,
+      "w": 23,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "C",
+      "x": 1222,
+      "y": 56,
+      "w": 24,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "C",
+      "x": 1248,
+      "y": 56,
+      "w": 24,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "ö",
+      "x": 1274,
+      "y": 56,
+      "w": 22,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "ö",
+      "x": 1298,
+      "y": 56,
+      "w": 22,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "ö",
+      "x": 1322,
+      "y": 56,
+      "w": 22,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "w",
+      "x": 1346,
+      "y": 56,
+      "w": 28,
+      "h": 30,
+      "source": "font"
+    },
+    {
+      "char": "w",
+      "x": 1376,
+      "y": 56,
+      "w": 28,
+      "h": 30,
+      "source": "font"
+    },
+    {
+      "char": "w",
+      "x": 1406,
+      "y": 56,
+      "w": 29,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "T",
+      "x": 1437,
+      "y": 56,
+      "w": 24,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "T",
+      "x": 1463,
+      "y": 56,
+      "w": 24,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "T",
+      "x": 1489,
+      "y": 56,
+      "w": 25,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "v",
+      "x": 1516,
+      "y": 56,
+      "w": 22,
+      "h": 30,
+      "source": "font"
+    },
+    {
+      "char": "v",
+      "x": 1540,
+      "y": 56,
+      "w": 23,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "v",
+      "x": 1565,
+      "y": 56,
+      "w": 23,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "H",
+      "x": 2,
+      "y": 104,
+      "w": 24,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "H",
+      "x": 28,
+      "y": 104,
+      "w": 25,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "H",
+      "x": 55,
+      "y": 104,
+      "w": 25,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "W",
+      "x": 82,
+      "y": 104,
+      "w": 33,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "W",
+      "x": 117,
+      "y": 104,
+      "w": 34,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "W",
+      "x": 153,
+      "y": 104,
+      "w": 34,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "E",
+      "x": 189,
+      "y": 104,
+      "w": 22,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "E",
+      "x": 213,
+      "y": 104,
+      "w": 22,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "E",
+      "x": 237,
+      "y": 104,
+      "w": 22,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": ".",
+      "x": 261,
+      "y": 104,
+      "w": 12,
+      "h": 11,
+      "source": "font"
+    },
+    {
+      "char": ".",
+      "x": 275,
+      "y": 104,
+      "w": 12,
+      "h": 12,
+      "source": "font"
+    },
+    {
+      "char": ".",
+      "x": 289,
+      "y": 104,
+      "w": 12,
+      "h": 12,
+      "source": "font"
+    },
+    {
+      "char": "I",
+      "x": 303,
+      "y": 104,
+      "w": 11,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "I",
+      "x": 316,
+      "y": 104,
+      "w": 11,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "I",
+      "x": 329,
+      "y": 104,
+      "w": 11,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "G",
+      "x": 342,
+      "y": 104,
+      "w": 25,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "G",
+      "x": 369,
+      "y": 104,
+      "w": 25,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "G",
+      "x": 396,
+      "y": 104,
+      "w": 25,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "ó",
+      "x": 423,
+      "y": 104,
+      "w": 22,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "ó",
+      "x": 447,
+      "y": 104,
+      "w": 22,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "ó",
+      "x": 471,
+      "y": 104,
+      "w": 22,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "ñ",
+      "x": 495,
+      "y": 104,
+      "w": 23,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "ñ",
+      "x": 520,
+      "y": 104,
+      "w": 24,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "ñ",
+      "x": 546,
+      "y": 104,
+      "w": 24,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "q",
+      "x": 572,
+      "y": 104,
+      "w": 21,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "q",
+      "x": 595,
+      "y": 104,
+      "w": 21,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "q",
+      "x": 618,
+      "y": 104,
+      "w": 22,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "V",
+      "x": 642,
+      "y": 104,
+      "w": 25,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "V",
+      "x": 669,
+      "y": 104,
+      "w": 26,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "V",
+      "x": 697,
+      "y": 104,
+      "w": 26,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "í",
+      "x": 725,
+      "y": 104,
+      "w": 14,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "í",
+      "x": 741,
+      "y": 104,
+      "w": 15,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "í",
+      "x": 758,
+      "y": 104,
+      "w": 15,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "j",
+      "x": 775,
+      "y": 104,
+      "w": 14,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "j",
+      "x": 791,
+      "y": 104,
+      "w": 14,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "j",
+      "x": 807,
+      "y": 104,
+      "w": 15,
+      "h": 52,
+      "source": "font"
+    },
+    {
+      "char": "á",
+      "x": 824,
+      "y": 104,
+      "w": 24,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "á",
+      "x": 850,
+      "y": 104,
+      "w": 24,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "á",
+      "x": 876,
+      "y": 104,
+      "w": 25,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "N",
+      "x": 903,
+      "y": 104,
+      "w": 25,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "N",
+      "x": 930,
+      "y": 104,
+      "w": 25,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "N",
+      "x": 957,
+      "y": 104,
+      "w": 26,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "è",
+      "x": 985,
+      "y": 104,
+      "w": 23,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "è",
+      "x": 1010,
+      "y": 104,
+      "w": 23,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "è",
+      "x": 1035,
+      "y": 104,
+      "w": 24,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "é",
+      "x": 1061,
+      "y": 104,
+      "w": 23,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "é",
+      "x": 1086,
+      "y": 104,
+      "w": 23,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "é",
+      "x": 1111,
+      "y": 104,
+      "w": 24,
+      "h": 45,
+      "source": "font"
+    },
+    {
+      "char": "$",
+      "x": 1137,
+      "y": 104,
+      "w": 27,
+      "h": 50,
+      "source": "font"
+    },
+    {
+      "char": "$",
+      "x": 1166,
+      "y": 104,
+      "w": 28,
+      "h": 51,
+      "source": "font"
+    },
+    {
+      "char": "$",
+      "x": 1196,
+      "y": 104,
+      "w": 28,
+      "h": 52,
+      "source": "font"
+    },
+    {
+      "char": "x",
+      "x": 1226,
+      "y": 104,
+      "w": 21,
+      "h": 30,
+      "source": "font"
+    },
+    {
+      "char": "x",
+      "x": 1249,
+      "y": 104,
+      "w": 21,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "x",
+      "x": 1272,
+      "y": 104,
+      "w": 21,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "z",
+      "x": 1295,
+      "y": 104,
+      "w": 23,
+      "h": 30,
+      "source": "font"
+    },
+    {
+      "char": "z",
+      "x": 1320,
+      "y": 104,
+      "w": 23,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "z",
+      "x": 1345,
+      "y": 104,
+      "w": 23,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "ò",
+      "x": 1370,
+      "y": 104,
+      "w": 22,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "ò",
+      "x": 1394,
+      "y": 104,
+      "w": 22,
+      "h": 43,
+      "source": "font"
+    },
+    {
+      "char": "ò",
+      "x": 1418,
+      "y": 104,
+      "w": 22,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "ë",
+      "x": 1442,
+      "y": 104,
+      "w": 23,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "ë",
+      "x": 1467,
+      "y": 104,
+      "w": 23,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "ë",
+      "x": 1492,
+      "y": 104,
+      "w": 24,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "ï",
+      "x": 1518,
+      "y": 104,
+      "w": 18,
+      "h": 39,
+      "source": "font"
+    },
+    {
+      "char": "ï",
+      "x": 1538,
+      "y": 104,
+      "w": 19,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "ï",
+      "x": 1559,
+      "y": 104,
+      "w": 19,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "Z",
+      "x": 2,
+      "y": 158,
+      "w": 23,
+      "h": 40,
+      "source": "font"
+    },
+    {
+      "char": "Z",
+      "x": 27,
+      "y": 158,
+      "w": 24,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "Z",
+      "x": 53,
+      "y": 158,
+      "w": 24,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "«",
+      "x": 79,
+      "y": 158,
+      "w": 29,
+      "h": 26,
+      "source": "font"
+    },
+    {
+      "char": "«",
+      "x": 110,
+      "y": 158,
+      "w": 30,
+      "h": 26,
+      "source": "font"
+    },
+    {
+      "char": "«",
+      "x": 142,
+      "y": 158,
+      "w": 31,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "»",
+      "x": 175,
+      "y": 158,
+      "w": 29,
+      "h": 26,
+      "source": "font"
+    },
+    {
+      "char": "»",
+      "x": 206,
+      "y": 158,
+      "w": 30,
+      "h": 26,
+      "source": "font"
+    },
+    {
+      "char": "»",
+      "x": 238,
+      "y": 158,
+      "w": 31,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "9",
+      "x": 271,
+      "y": 158,
+      "w": 24,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "9",
+      "x": 297,
+      "y": 158,
+      "w": 25,
+      "h": 41,
+      "source": "font"
+    },
+    {
+      "char": "9",
+      "x": 324,
+      "y": 158,
+      "w": 25,
+      "h": 42,
+      "source": "font"
+    },
+    {
+      "char": "à",
+      "x": 351,
+      "y": 158,
+      "w": 24,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "à",
+      "x": 377,
+      "y": 158,
+      "w": 24,
+      "h": 44,
+      "source": "font"
+    },
+    {
+      "char": "à",
+      "x": 403,
+      "y": 158,
+      "w": 25,
+      "h": 45,
+      "source": "font"
+    }
+  ]
+}
\ No newline at end of file
diff --git a/public/scanner/v1/glyphs/map-start-stage.png b/public/scanner/v1/glyphs/map-start-stage.png
new file mode 100644
index 000000000..f72eeee7f
Binary files /dev/null and b/public/scanner/v1/glyphs/map-start-stage.png differ
diff --git a/public/scanner/v1/glyphs/scoreboard-header-line.json b/public/scanner/v1/glyphs/scoreboard-header-line.json
new file mode 100644
index 000000000..40ba45d7a
--- /dev/null
+++ b/public/scanner/v1/glyphs/scoreboard-header-line.json
@@ -0,0 +1,2037 @@
+{
+  "height": 24,
+  "glyphs": [
+    {
+      "char": "a",
+      "x": 2,
+      "y": 2,
+      "w": 21,
+      "h": 21,
+      "source": "fixture"
+    },
+    {
+      "char": "c",
+      "x": 25,
+      "y": 2,
+      "w": 13,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "c",
+      "x": 40,
+      "y": 2,
+      "w": 14,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "e",
+      "x": 56,
+      "y": 2,
+      "w": 22,
+      "h": 22,
+      "source": "fixture"
+    },
+    {
+      "char": "e",
+      "x": 80,
+      "y": 2,
+      "w": 13,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "e",
+      "x": 95,
+      "y": 2,
+      "w": 13,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "g",
+      "x": 110,
+      "y": 2,
+      "w": 13,
+      "h": 25,
+      "source": "fixture"
+    },
+    {
+      "char": "g",
+      "x": 125,
+      "y": 2,
+      "w": 13,
+      "h": 24,
+      "source": "fixture"
+    },
+    {
+      "char": "G",
+      "x": 140,
+      "y": 2,
+      "w": 14,
+      "h": 23,
+      "source": "fixture"
+    },
+    {
+      "char": "G",
+      "x": 156,
+      "y": 2,
+      "w": 15,
+      "h": 23,
+      "source": "fixture"
+    },
+    {
+      "char": "h",
+      "x": 173,
+      "y": 2,
+      "w": 13,
+      "h": 23,
+      "source": "fixture"
+    },
+    {
+      "char": "h",
+      "x": 188,
+      "y": 2,
+      "w": 14,
+      "h": 23,
+      "source": "fixture"
+    },
+    {
+      "char": "l",
+      "x": 204,
+      "y": 2,
+      "w": 12,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "n",
+      "x": 218,
+      "y": 2,
+      "w": 23,
+      "h": 22,
+      "source": "fixture"
+    },
+    {
+      "char": "o",
+      "x": 243,
+      "y": 2,
+      "w": 22,
+      "h": 22,
+      "source": "fixture"
+    },
+    {
+      "char": "o",
+      "x": 267,
+      "y": 2,
+      "w": 13,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "o",
+      "x": 282,
+      "y": 2,
+      "w": 12,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "p",
+      "x": 296,
+      "y": 2,
+      "w": 22,
+      "h": 28,
+      "source": "fixture"
+    },
+    {
+      "char": "r",
+      "x": 320,
+      "y": 2,
+      "w": 11,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "r",
+      "x": 333,
+      "y": 2,
+      "w": 11,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "s",
+      "x": 346,
+      "y": 2,
+      "w": 18,
+      "h": 22,
+      "source": "fixture"
+    },
+    {
+      "char": "S",
+      "x": 366,
+      "y": 2,
+      "w": 20,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "S",
+      "x": 388,
+      "y": 2,
+      "w": 15,
+      "h": 23,
+      "source": "fixture"
+    },
+    {
+      "char": "S",
+      "x": 405,
+      "y": 2,
+      "w": 14,
+      "h": 23,
+      "source": "fixture"
+    },
+    {
+      "char": "t",
+      "x": 421,
+      "y": 2,
+      "w": 19,
+      "h": 24,
+      "source": "fixture"
+    },
+    {
+      "char": "Z",
+      "x": 442,
+      "y": 2,
+      "w": 23,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "R",
+      "x": 467,
+      "y": 2,
+      "w": 24,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "R",
+      "x": 493,
+      "y": 2,
+      "w": 25,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "e",
+      "x": 520,
+      "y": 2,
+      "w": 23,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "e",
+      "x": 545,
+      "y": 2,
+      "w": 24,
+      "h": 24,
+      "source": "font"
+    },
+    {
+      "char": "v",
+      "x": 571,
+      "y": 2,
+      "w": 23,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "v",
+      "x": 596,
+      "y": 2,
+      "w": 24,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "i",
+      "x": 622,
+      "y": 2,
+      "w": 12,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "i",
+      "x": 636,
+      "y": 2,
+      "w": 12,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "r",
+      "x": 650,
+      "y": 2,
+      "w": 17,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "r",
+      "x": 669,
+      "y": 2,
+      "w": 18,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "k",
+      "x": 689,
+      "y": 2,
+      "w": 23,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "k",
+      "x": 714,
+      "y": 2,
+      "w": 24,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "a",
+      "x": 740,
+      "y": 2,
+      "w": 22,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "a",
+      "x": 764,
+      "y": 2,
+      "w": 23,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "m",
+      "x": 789,
+      "y": 2,
+      "w": 33,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "m",
+      "x": 824,
+      "y": 2,
+      "w": 34,
+      "h": 24,
+      "source": "font"
+    },
+    {
+      "char": "p",
+      "x": 860,
+      "y": 2,
+      "w": 23,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "p",
+      "x": 885,
+      "y": 2,
+      "w": 24,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "f",
+      "x": 911,
+      "y": 2,
+      "w": 17,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "f",
+      "x": 930,
+      "y": 2,
+      "w": 17,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "H",
+      "x": 949,
+      "y": 2,
+      "w": 24,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "H",
+      "x": 975,
+      "y": 2,
+      "w": 25,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "s",
+      "x": 1002,
+      "y": 2,
+      "w": 20,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "s",
+      "x": 1024,
+      "y": 2,
+      "w": 20,
+      "h": 24,
+      "source": "font"
+    },
+    {
+      "char": "c",
+      "x": 1046,
+      "y": 2,
+      "w": 21,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "c",
+      "x": 1069,
+      "y": 2,
+      "w": 22,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "h",
+      "x": 1093,
+      "y": 2,
+      "w": 24,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "h",
+      "x": 1119,
+      "y": 2,
+      "w": 25,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "t",
+      "x": 1146,
+      "y": 2,
+      "w": 20,
+      "h": 26,
+      "source": "font"
+    },
+    {
+      "char": "t",
+      "x": 1168,
+      "y": 2,
+      "w": 20,
+      "h": 26,
+      "source": "font"
+    },
+    {
+      "char": "T",
+      "x": 1190,
+      "y": 2,
+      "w": 25,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "T",
+      "x": 1217,
+      "y": 2,
+      "w": 26,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "u",
+      "x": 1245,
+      "y": 2,
+      "w": 24,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "u",
+      "x": 1271,
+      "y": 2,
+      "w": 24,
+      "h": 24,
+      "source": "font"
+    },
+    {
+      "char": "-",
+      "x": 1297,
+      "y": 2,
+      "w": 14,
+      "h": 8,
+      "source": "font"
+    },
+    {
+      "char": "-",
+      "x": 1313,
+      "y": 2,
+      "w": 15,
+      "h": 9,
+      "source": "font"
+    },
+    {
+      "char": "K",
+      "x": 1330,
+      "y": 2,
+      "w": 26,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "K",
+      "x": 1358,
+      "y": 2,
+      "w": 27,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "o",
+      "x": 1387,
+      "y": 2,
+      "w": 22,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "o",
+      "x": 1411,
+      "y": 2,
+      "w": 23,
+      "h": 24,
+      "source": "font"
+    },
+    {
+      "char": "n",
+      "x": 1436,
+      "y": 2,
+      "w": 24,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "n",
+      "x": 1462,
+      "y": 2,
+      "w": 25,
+      "h": 24,
+      "source": "font"
+    },
+    {
+      "char": "d",
+      "x": 1489,
+      "y": 2,
+      "w": 23,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "d",
+      "x": 1514,
+      "y": 2,
+      "w": 24,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "O",
+      "x": 1540,
+      "y": 2,
+      "w": 24,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "O",
+      "x": 1566,
+      "y": 2,
+      "w": 25,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "G",
+      "x": 2,
+      "y": 33,
+      "w": 26,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "G",
+      "x": 30,
+      "y": 33,
+      "w": 27,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "l",
+      "x": 59,
+      "y": 33,
+      "w": 12,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "l",
+      "x": 73,
+      "y": 33,
+      "w": 12,
+      "h": 30,
+      "source": "font"
+    },
+    {
+      "char": "M",
+      "x": 87,
+      "y": 33,
+      "w": 33,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "M",
+      "x": 122,
+      "y": 33,
+      "w": 34,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "W",
+      "x": 158,
+      "y": 33,
+      "w": 37,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "W",
+      "x": 197,
+      "y": 33,
+      "w": 38,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "S",
+      "x": 237,
+      "y": 33,
+      "w": 22,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "S",
+      "x": 261,
+      "y": 33,
+      "w": 22,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "Z",
+      "x": 285,
+      "y": 33,
+      "w": 23,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "Z",
+      "x": 310,
+      "y": 33,
+      "w": 24,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "w",
+      "x": 336,
+      "y": 33,
+      "w": 29,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "w",
+      "x": 367,
+      "y": 33,
+      "w": 30,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "C",
+      "x": 399,
+      "y": 33,
+      "w": 25,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "C",
+      "x": 426,
+      "y": 33,
+      "w": 26,
+      "h": 30,
+      "source": "font"
+    },
+    {
+      "char": "B",
+      "x": 454,
+      "y": 33,
+      "w": 23,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "B",
+      "x": 479,
+      "y": 33,
+      "w": 24,
+      "h": 30,
+      "source": "font"
+    },
+    {
+      "char": "z",
+      "x": 505,
+      "y": 33,
+      "w": 18,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "z",
+      "x": 525,
+      "y": 33,
+      "w": 19,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "P",
+      "x": 546,
+      "y": 33,
+      "w": 24,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "P",
+      "x": 572,
+      "y": 33,
+      "w": 25,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "A",
+      "x": 599,
+      "y": 33,
+      "w": 26,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "A",
+      "x": 627,
+      "y": 33,
+      "w": 27,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "j",
+      "x": 656,
+      "y": 33,
+      "w": 17,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "j",
+      "x": 675,
+      "y": 33,
+      "w": 17,
+      "h": 35,
+      "source": "font"
+    },
+    {
+      "char": "D",
+      "x": 694,
+      "y": 33,
+      "w": 24,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "D",
+      "x": 720,
+      "y": 33,
+      "w": 25,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "é",
+      "x": 747,
+      "y": 33,
+      "w": 23,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "é",
+      "x": 772,
+      "y": 33,
+      "w": 24,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "E",
+      "x": 798,
+      "y": 33,
+      "w": 19,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "E",
+      "x": 819,
+      "y": 33,
+      "w": 20,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "x",
+      "x": 841,
+      "y": 33,
+      "w": 22,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "x",
+      "x": 865,
+      "y": 33,
+      "w": 23,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "q",
+      "x": 890,
+      "y": 33,
+      "w": 23,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "q",
+      "x": 915,
+      "y": 33,
+      "w": 23,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "b",
+      "x": 940,
+      "y": 33,
+      "w": 23,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "b",
+      "x": 965,
+      "y": 33,
+      "w": 23,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "V",
+      "x": 990,
+      "y": 33,
+      "w": 27,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "V",
+      "x": 1019,
+      "y": 33,
+      "w": 28,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "g",
+      "x": 1049,
+      "y": 33,
+      "w": 24,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "g",
+      "x": 1075,
+      "y": 33,
+      "w": 25,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "ó",
+      "x": 1102,
+      "y": 33,
+      "w": 22,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "ó",
+      "x": 1126,
+      "y": 33,
+      "w": 23,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "S",
+      "x": 1151,
+      "y": 33,
+      "w": 14,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "S",
+      "x": 1167,
+      "y": 33,
+      "w": 14,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "P",
+      "x": 1183,
+      "y": 33,
+      "w": 12,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "P",
+      "x": 1197,
+      "y": 33,
+      "w": 13,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "A",
+      "x": 1212,
+      "y": 33,
+      "w": 13,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "A",
+      "x": 1227,
+      "y": 33,
+      "w": 13,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "B",
+      "x": 1242,
+      "y": 33,
+      "w": 13,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "B",
+      "x": 1257,
+      "y": 33,
+      "w": 12,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "a",
+      "x": 1271,
+      "y": 33,
+      "w": 12,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "a",
+      "x": 1285,
+      "y": 33,
+      "w": 12,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "h",
+      "x": 1299,
+      "y": 33,
+      "w": 11,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "h",
+      "x": 1312,
+      "y": 33,
+      "w": 12,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "n",
+      "x": 1326,
+      "y": 33,
+      "w": 11,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "n",
+      "x": 1339,
+      "y": 33,
+      "w": 11,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "o",
+      "x": 1352,
+      "y": 33,
+      "w": 12,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "o",
+      "x": 1366,
+      "y": 33,
+      "w": 12,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "f",
+      "x": 1380,
+      "y": 33,
+      "w": 11,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "f",
+      "x": 1393,
+      "y": 33,
+      "w": 12,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "L",
+      "x": 1407,
+      "y": 33,
+      "w": 10,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "L",
+      "x": 1419,
+      "y": 33,
+      "w": 9,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "e",
+      "x": 1430,
+      "y": 33,
+      "w": 12,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "e",
+      "x": 1444,
+      "y": 33,
+      "w": 13,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "m",
+      "x": 1459,
+      "y": 33,
+      "w": 16,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "m",
+      "x": 1477,
+      "y": 33,
+      "w": 16,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "u",
+      "x": 1495,
+      "y": 33,
+      "w": 12,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "u",
+      "x": 1509,
+      "y": 33,
+      "w": 13,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "r",
+      "x": 1524,
+      "y": 33,
+      "w": 9,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "r",
+      "x": 1535,
+      "y": 33,
+      "w": 10,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "i",
+      "x": 1547,
+      "y": 33,
+      "w": 6,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "i",
+      "x": 1555,
+      "y": 33,
+      "w": 6,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "K",
+      "x": 1563,
+      "y": 33,
+      "w": 11,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "K",
+      "x": 1576,
+      "y": 33,
+      "w": 12,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "s",
+      "x": 2,
+      "y": 70,
+      "w": 11,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "s",
+      "x": 15,
+      "y": 70,
+      "w": 12,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "y",
+      "x": 29,
+      "y": 70,
+      "w": 12,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "y",
+      "x": 43,
+      "y": 70,
+      "w": 13,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "-",
+      "x": 58,
+      "y": 70,
+      "w": 11,
+      "h": 7,
+      "source": "font"
+    },
+    {
+      "char": "-",
+      "x": 71,
+      "y": 70,
+      "w": 12,
+      "h": 7,
+      "source": "font"
+    },
+    {
+      "char": "Q",
+      "x": 85,
+      "y": 70,
+      "w": 13,
+      "h": 24,
+      "source": "font"
+    },
+    {
+      "char": "Q",
+      "x": 100,
+      "y": 70,
+      "w": 13,
+      "h": 26,
+      "source": "font"
+    },
+    {
+      "char": "l",
+      "x": 115,
+      "y": 70,
+      "w": 6,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "l",
+      "x": 123,
+      "y": 70,
+      "w": 6,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "F",
+      "x": 131,
+      "y": 70,
+      "w": 12,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "F",
+      "x": 145,
+      "y": 70,
+      "w": 11,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "d",
+      "x": 158,
+      "y": 70,
+      "w": 12,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "d",
+      "x": 172,
+      "y": 70,
+      "w": 13,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "p",
+      "x": 187,
+      "y": 70,
+      "w": 12,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "p",
+      "x": 201,
+      "y": 70,
+      "w": 12,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "k",
+      "x": 215,
+      "y": 70,
+      "w": 11,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "k",
+      "x": 228,
+      "y": 70,
+      "w": 12,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "D",
+      "x": 242,
+      "y": 70,
+      "w": 13,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "D",
+      "x": 257,
+      "y": 70,
+      "w": 14,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "b",
+      "x": 273,
+      "y": 70,
+      "w": 12,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "b",
+      "x": 287,
+      "y": 70,
+      "w": 13,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "t",
+      "x": 302,
+      "y": 70,
+      "w": 10,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "t",
+      "x": 314,
+      "y": 70,
+      "w": 10,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "R",
+      "x": 326,
+      "y": 70,
+      "w": 13,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "R",
+      "x": 341,
+      "y": 70,
+      "w": 13,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "O",
+      "x": 356,
+      "y": 70,
+      "w": 12,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "O",
+      "x": 370,
+      "y": 70,
+      "w": 13,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "M",
+      "x": 385,
+      "y": 70,
+      "w": 15,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "M",
+      "x": 402,
+      "y": 70,
+      "w": 15,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "&",
+      "x": 419,
+      "y": 70,
+      "w": 17,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "&",
+      "x": 438,
+      "y": 70,
+      "w": 18,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "ß",
+      "x": 458,
+      "y": 70,
+      "w": 12,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "ß",
+      "x": 472,
+      "y": 70,
+      "w": 12,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "U",
+      "x": 486,
+      "y": 70,
+      "w": 13,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "U",
+      "x": 501,
+      "y": 70,
+      "w": 14,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "'",
+      "x": 517,
+      "y": 70,
+      "w": 7,
+      "h": 9,
+      "source": "font"
+    },
+    {
+      "char": "'",
+      "x": 526,
+      "y": 70,
+      "w": 7,
+      "h": 10,
+      "source": "font"
+    },
+    {
+      "char": "c",
+      "x": 535,
+      "y": 70,
+      "w": 12,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "c",
+      "x": 549,
+      "y": 70,
+      "w": 13,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "g",
+      "x": 564,
+      "y": 70,
+      "w": 12,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "g",
+      "x": 578,
+      "y": 70,
+      "w": 13,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "ü",
+      "x": 593,
+      "y": 70,
+      "w": 12,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "ü",
+      "x": 607,
+      "y": 70,
+      "w": 13,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "C",
+      "x": 622,
+      "y": 70,
+      "w": 13,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "C",
+      "x": 637,
+      "y": 70,
+      "w": 13,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "ö",
+      "x": 652,
+      "y": 70,
+      "w": 12,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "ö",
+      "x": 666,
+      "y": 70,
+      "w": 12,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "w",
+      "x": 680,
+      "y": 70,
+      "w": 15,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "w",
+      "x": 697,
+      "y": 70,
+      "w": 15,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "T",
+      "x": 714,
+      "y": 70,
+      "w": 13,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "T",
+      "x": 729,
+      "y": 70,
+      "w": 13,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "v",
+      "x": 744,
+      "y": 70,
+      "w": 12,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "v",
+      "x": 758,
+      "y": 70,
+      "w": 12,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "H",
+      "x": 772,
+      "y": 70,
+      "w": 13,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "H",
+      "x": 787,
+      "y": 70,
+      "w": 13,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "W",
+      "x": 802,
+      "y": 70,
+      "w": 16,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "W",
+      "x": 820,
+      "y": 70,
+      "w": 17,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "E",
+      "x": 839,
+      "y": 70,
+      "w": 12,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "E",
+      "x": 853,
+      "y": 70,
+      "w": 12,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": ".",
+      "x": 867,
+      "y": 70,
+      "w": 7,
+      "h": 7,
+      "source": "font"
+    },
+    {
+      "char": ".",
+      "x": 876,
+      "y": 70,
+      "w": 7,
+      "h": 7,
+      "source": "font"
+    },
+    {
+      "char": "I",
+      "x": 885,
+      "y": 70,
+      "w": 7,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "I",
+      "x": 894,
+      "y": 70,
+      "w": 7,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "G",
+      "x": 903,
+      "y": 70,
+      "w": 13,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "G",
+      "x": 918,
+      "y": 70,
+      "w": 13,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "ó",
+      "x": 933,
+      "y": 70,
+      "w": 12,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "ó",
+      "x": 947,
+      "y": 70,
+      "w": 12,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "ñ",
+      "x": 961,
+      "y": 70,
+      "w": 13,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "ñ",
+      "x": 976,
+      "y": 70,
+      "w": 13,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "q",
+      "x": 991,
+      "y": 70,
+      "w": 12,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "q",
+      "x": 1005,
+      "y": 70,
+      "w": 12,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "V",
+      "x": 1019,
+      "y": 70,
+      "w": 14,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "V",
+      "x": 1035,
+      "y": 70,
+      "w": 14,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "í",
+      "x": 1051,
+      "y": 70,
+      "w": 8,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "í",
+      "x": 1061,
+      "y": 70,
+      "w": 8,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "j",
+      "x": 1071,
+      "y": 70,
+      "w": 8,
+      "h": 25,
+      "source": "font"
+    },
+    {
+      "char": "j",
+      "x": 1081,
+      "y": 70,
+      "w": 8,
+      "h": 26,
+      "source": "font"
+    },
+    {
+      "char": "á",
+      "x": 1091,
+      "y": 70,
+      "w": 12,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "á",
+      "x": 1105,
+      "y": 70,
+      "w": 12,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "N",
+      "x": 1119,
+      "y": 70,
+      "w": 13,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "N",
+      "x": 1134,
+      "y": 70,
+      "w": 14,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "è",
+      "x": 1150,
+      "y": 70,
+      "w": 12,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "è",
+      "x": 1164,
+      "y": 70,
+      "w": 13,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "é",
+      "x": 1179,
+      "y": 70,
+      "w": 12,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "é",
+      "x": 1193,
+      "y": 70,
+      "w": 13,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "$",
+      "x": 1208,
+      "y": 70,
+      "w": 15,
+      "h": 25,
+      "source": "font"
+    },
+    {
+      "char": "$",
+      "x": 1225,
+      "y": 70,
+      "w": 15,
+      "h": 26,
+      "source": "font"
+    },
+    {
+      "char": "x",
+      "x": 1242,
+      "y": 70,
+      "w": 11,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "x",
+      "x": 1255,
+      "y": 70,
+      "w": 12,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "z",
+      "x": 1269,
+      "y": 70,
+      "w": 12,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "z",
+      "x": 1283,
+      "y": 70,
+      "w": 13,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "ò",
+      "x": 1298,
+      "y": 70,
+      "w": 12,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "ò",
+      "x": 1312,
+      "y": 70,
+      "w": 12,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "ë",
+      "x": 1326,
+      "y": 70,
+      "w": 12,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "ë",
+      "x": 1340,
+      "y": 70,
+      "w": 13,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "ï",
+      "x": 1355,
+      "y": 70,
+      "w": 10,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "ï",
+      "x": 1367,
+      "y": 70,
+      "w": 11,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "Z",
+      "x": 1380,
+      "y": 70,
+      "w": 13,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "Z",
+      "x": 1395,
+      "y": 70,
+      "w": 13,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "«",
+      "x": 1410,
+      "y": 70,
+      "w": 15,
+      "h": 13,
+      "source": "font"
+    },
+    {
+      "char": "«",
+      "x": 1427,
+      "y": 70,
+      "w": 15,
+      "h": 14,
+      "source": "font"
+    },
+    {
+      "char": "»",
+      "x": 1444,
+      "y": 70,
+      "w": 15,
+      "h": 13,
+      "source": "font"
+    },
+    {
+      "char": "»",
+      "x": 1461,
+      "y": 70,
+      "w": 16,
+      "h": 14,
+      "source": "font"
+    },
+    {
+      "char": "9",
+      "x": 1479,
+      "y": 70,
+      "w": 13,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "9",
+      "x": 1494,
+      "y": 70,
+      "w": 13,
+      "h": 21,
+      "source": "font"
+    }
+  ]
+}
\ No newline at end of file
diff --git a/public/scanner/v1/glyphs/scoreboard-header-line.png b/public/scanner/v1/glyphs/scoreboard-header-line.png
new file mode 100644
index 000000000..c88cc0d22
Binary files /dev/null and b/public/scanner/v1/glyphs/scoreboard-header-line.png differ
diff --git a/public/scanner/v1/glyphs/scoreboard-header-lobby.json b/public/scanner/v1/glyphs/scoreboard-header-lobby.json
new file mode 100644
index 000000000..a9b39d62c
--- /dev/null
+++ b/public/scanner/v1/glyphs/scoreboard-header-lobby.json
@@ -0,0 +1,597 @@
+{
+  "height": 19,
+  "glyphs": [
+    {
+      "char": "a",
+      "x": 2,
+      "y": 2,
+      "w": 12,
+      "h": 17,
+      "source": "fixture"
+    },
+    {
+      "char": "B",
+      "x": 16,
+      "y": 2,
+      "w": 12,
+      "h": 20,
+      "source": "fixture"
+    },
+    {
+      "char": "e",
+      "x": 30,
+      "y": 2,
+      "w": 12,
+      "h": 16,
+      "source": "fixture"
+    },
+    {
+      "char": "l",
+      "x": 44,
+      "y": 2,
+      "w": 6,
+      "h": 20,
+      "source": "fixture"
+    },
+    {
+      "char": "t",
+      "x": 52,
+      "y": 2,
+      "w": 10,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "X",
+      "x": 64,
+      "y": 2,
+      "w": 11,
+      "h": 20,
+      "source": "fixture"
+    },
+    {
+      "char": "X",
+      "x": 77,
+      "y": 2,
+      "w": 11,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "X",
+      "x": 90,
+      "y": 2,
+      "w": 12,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "-",
+      "x": 104,
+      "y": 2,
+      "w": 12,
+      "h": 7,
+      "source": "font"
+    },
+    {
+      "char": "-",
+      "x": 118,
+      "y": 2,
+      "w": 12,
+      "h": 8,
+      "source": "font"
+    },
+    {
+      "char": "K",
+      "x": 132,
+      "y": 2,
+      "w": 12,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "K",
+      "x": 146,
+      "y": 2,
+      "w": 12,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "a",
+      "x": 160,
+      "y": 2,
+      "w": 12,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "a",
+      "x": 174,
+      "y": 2,
+      "w": 13,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "m",
+      "x": 189,
+      "y": 2,
+      "w": 16,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "m",
+      "x": 207,
+      "y": 2,
+      "w": 17,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "p",
+      "x": 226,
+      "y": 2,
+      "w": 12,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "p",
+      "x": 240,
+      "y": 2,
+      "w": 13,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "f",
+      "x": 255,
+      "y": 2,
+      "w": 12,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "f",
+      "x": 269,
+      "y": 2,
+      "w": 11,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "A",
+      "x": 282,
+      "y": 2,
+      "w": 13,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "A",
+      "x": 297,
+      "y": 2,
+      "w": 14,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "n",
+      "x": 313,
+      "y": 2,
+      "w": 11,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "n",
+      "x": 326,
+      "y": 2,
+      "w": 12,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "r",
+      "x": 340,
+      "y": 2,
+      "w": 10,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "r",
+      "x": 352,
+      "y": 2,
+      "w": 10,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "c",
+      "x": 364,
+      "y": 2,
+      "w": 13,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "c",
+      "x": 379,
+      "y": 2,
+      "w": 12,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "h",
+      "x": 393,
+      "y": 2,
+      "w": 12,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "h",
+      "x": 407,
+      "y": 2,
+      "w": 12,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "i",
+      "x": 421,
+      "y": 2,
+      "w": 6,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "i",
+      "x": 429,
+      "y": 2,
+      "w": 6,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "e",
+      "x": 437,
+      "y": 2,
+      "w": 13,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "e",
+      "x": 452,
+      "y": 2,
+      "w": 13,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "(",
+      "x": 467,
+      "y": 2,
+      "w": 10,
+      "h": 25,
+      "source": "font"
+    },
+    {
+      "char": "(",
+      "x": 479,
+      "y": 2,
+      "w": 11,
+      "h": 26,
+      "source": "font"
+    },
+    {
+      "char": "S",
+      "x": 492,
+      "y": 2,
+      "w": 14,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "S",
+      "x": 508,
+      "y": 2,
+      "w": 14,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": ")",
+      "x": 524,
+      "y": 2,
+      "w": 11,
+      "h": 25,
+      "source": "font"
+    },
+    {
+      "char": ")",
+      "x": 537,
+      "y": 2,
+      "w": 11,
+      "h": 25,
+      "source": "font"
+    },
+    {
+      "char": "O",
+      "x": 550,
+      "y": 2,
+      "w": 13,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "O",
+      "x": 565,
+      "y": 2,
+      "w": 13,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "P",
+      "x": 580,
+      "y": 2,
+      "w": 13,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "P",
+      "x": 595,
+      "y": 2,
+      "w": 13,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "v",
+      "x": 610,
+      "y": 2,
+      "w": 12,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "v",
+      "x": 624,
+      "y": 2,
+      "w": 13,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "t",
+      "x": 639,
+      "y": 2,
+      "w": 10,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "t",
+      "x": 651,
+      "y": 2,
+      "w": 11,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "B",
+      "x": 664,
+      "y": 2,
+      "w": 12,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "B",
+      "x": 678,
+      "y": 2,
+      "w": 13,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "l",
+      "x": 693,
+      "y": 2,
+      "w": 6,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "l",
+      "x": 701,
+      "y": 2,
+      "w": 6,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "y",
+      "x": 709,
+      "y": 2,
+      "w": 13,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "y",
+      "x": 724,
+      "y": 2,
+      "w": 13,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "s",
+      "x": 739,
+      "y": 2,
+      "w": 12,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "s",
+      "x": 753,
+      "y": 2,
+      "w": 12,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "C",
+      "x": 767,
+      "y": 2,
+      "w": 13,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "C",
+      "x": 782,
+      "y": 2,
+      "w": 14,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "o",
+      "x": 798,
+      "y": 2,
+      "w": 12,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "o",
+      "x": 812,
+      "y": 2,
+      "w": 13,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "b",
+      "x": 827,
+      "y": 2,
+      "w": 13,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "b",
+      "x": 842,
+      "y": 2,
+      "w": 13,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "ó",
+      "x": 857,
+      "y": 2,
+      "w": 12,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "ó",
+      "x": 871,
+      "y": 2,
+      "w": 13,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "d",
+      "x": 886,
+      "y": 2,
+      "w": 13,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "d",
+      "x": 901,
+      "y": 2,
+      "w": 13,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "M",
+      "x": 916,
+      "y": 2,
+      "w": 15,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "M",
+      "x": 933,
+      "y": 2,
+      "w": 16,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "é",
+      "x": 951,
+      "y": 2,
+      "w": 13,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "é",
+      "x": 966,
+      "y": 2,
+      "w": 13,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "u",
+      "x": 981,
+      "y": 2,
+      "w": 13,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "u",
+      "x": 996,
+      "y": 2,
+      "w": 13,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "g",
+      "x": 1011,
+      "y": 2,
+      "w": 13,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "g",
+      "x": 1026,
+      "y": 2,
+      "w": 12,
+      "h": 22,
+      "source": "font"
+    }
+  ]
+}
\ No newline at end of file
diff --git a/public/scanner/v1/glyphs/scoreboard-header-lobby.png b/public/scanner/v1/glyphs/scoreboard-header-lobby.png
new file mode 100644
index 000000000..65ffcede7
Binary files /dev/null and b/public/scanner/v1/glyphs/scoreboard-header-lobby.png differ
diff --git a/public/scanner/v1/glyphs/scoreboard-names.json b/public/scanner/v1/glyphs/scoreboard-names.json
new file mode 100644
index 000000000..8553cd7c2
--- /dev/null
+++ b/public/scanner/v1/glyphs/scoreboard-names.json
@@ -0,0 +1,8685 @@
+{
+  "height": 17,
+  "glyphs": [
+    {
+      "char": "_",
+      "x": 2,
+      "y": 2,
+      "w": 10,
+      "h": 5,
+      "source": "fixture"
+    },
+    {
+      "char": "・",
+      "x": 14,
+      "y": 2,
+      "w": 7,
+      "h": 6,
+      "source": "fixture"
+    },
+    {
+      "char": ".",
+      "x": 23,
+      "y": 2,
+      "w": 6,
+      "h": 6,
+      "source": "fixture"
+    },
+    {
+      "char": ".",
+      "x": 31,
+      "y": 2,
+      "w": 6,
+      "h": 6,
+      "source": "fixture"
+    },
+    {
+      "char": ".",
+      "x": 39,
+      "y": 2,
+      "w": 6,
+      "h": 6,
+      "source": "fixture"
+    },
+    {
+      "char": ".",
+      "x": 47,
+      "y": 2,
+      "w": 6,
+      "h": 6,
+      "source": "fixture"
+    },
+    {
+      "char": ".",
+      "x": 55,
+      "y": 2,
+      "w": 6,
+      "h": 6,
+      "source": "fixture"
+    },
+    {
+      "char": ".",
+      "x": 63,
+      "y": 2,
+      "w": 6,
+      "h": 6,
+      "source": "fixture"
+    },
+    {
+      "char": "×",
+      "x": 71,
+      "y": 2,
+      "w": 11,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "0",
+      "x": 84,
+      "y": 2,
+      "w": 13,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "1",
+      "x": 99,
+      "y": 2,
+      "w": 7,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "4",
+      "x": 108,
+      "y": 2,
+      "w": 12,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "a",
+      "x": 122,
+      "y": 2,
+      "w": 12,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "a",
+      "x": 136,
+      "y": 2,
+      "w": 12,
+      "h": 15,
+      "source": "fixture"
+    },
+    {
+      "char": "a",
+      "x": 150,
+      "y": 2,
+      "w": 12,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "a",
+      "x": 164,
+      "y": 2,
+      "w": 12,
+      "h": 15,
+      "source": "fixture"
+    },
+    {
+      "char": "a",
+      "x": 178,
+      "y": 2,
+      "w": 12,
+      "h": 15,
+      "source": "fixture"
+    },
+    {
+      "char": "a",
+      "x": 192,
+      "y": 2,
+      "w": 12,
+      "h": 15,
+      "source": "fixture"
+    },
+    {
+      "char": "a",
+      "x": 206,
+      "y": 2,
+      "w": 11,
+      "h": 15,
+      "source": "fixture"
+    },
+    {
+      "char": "a",
+      "x": 219,
+      "y": 2,
+      "w": 11,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "a",
+      "x": 232,
+      "y": 2,
+      "w": 11,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "b",
+      "x": 245,
+      "y": 2,
+      "w": 11,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "B",
+      "x": 258,
+      "y": 2,
+      "w": 11,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "B",
+      "x": 271,
+      "y": 2,
+      "w": 11,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "c",
+      "x": 284,
+      "y": 2,
+      "w": 11,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "c",
+      "x": 297,
+      "y": 2,
+      "w": 12,
+      "h": 15,
+      "source": "fixture"
+    },
+    {
+      "char": "c",
+      "x": 311,
+      "y": 2,
+      "w": 12,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "c",
+      "x": 325,
+      "y": 2,
+      "w": 12,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "c",
+      "x": 339,
+      "y": 2,
+      "w": 11,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "c",
+      "x": 352,
+      "y": 2,
+      "w": 11,
+      "h": 13,
+      "source": "fixture"
+    },
+    {
+      "char": "c",
+      "x": 365,
+      "y": 2,
+      "w": 11,
+      "h": 13,
+      "source": "fixture"
+    },
+    {
+      "char": "c",
+      "x": 378,
+      "y": 2,
+      "w": 11,
+      "h": 13,
+      "source": "fixture"
+    },
+    {
+      "char": "C",
+      "x": 391,
+      "y": 2,
+      "w": 12,
+      "h": 17,
+      "source": "fixture"
+    },
+    {
+      "char": "C",
+      "x": 405,
+      "y": 2,
+      "w": 12,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "C",
+      "x": 419,
+      "y": 2,
+      "w": 12,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "C",
+      "x": 433,
+      "y": 2,
+      "w": 12,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "C",
+      "x": 447,
+      "y": 2,
+      "w": 12,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "d",
+      "x": 461,
+      "y": 2,
+      "w": 12,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "d",
+      "x": 475,
+      "y": 2,
+      "w": 11,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "d",
+      "x": 488,
+      "y": 2,
+      "w": 11,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "d",
+      "x": 501,
+      "y": 2,
+      "w": 11,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "d",
+      "x": 514,
+      "y": 2,
+      "w": 11,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "d",
+      "x": 527,
+      "y": 2,
+      "w": 11,
+      "h": 19,
+      "source": "fixture"
+    },
+    {
+      "char": "d",
+      "x": 540,
+      "y": 2,
+      "w": 12,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "d",
+      "x": 554,
+      "y": 2,
+      "w": 11,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "d",
+      "x": 567,
+      "y": 2,
+      "w": 12,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "d",
+      "x": 581,
+      "y": 2,
+      "w": 11,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "D",
+      "x": 594,
+      "y": 2,
+      "w": 12,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "e",
+      "x": 608,
+      "y": 2,
+      "w": 11,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "e",
+      "x": 621,
+      "y": 2,
+      "w": 12,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "e",
+      "x": 635,
+      "y": 2,
+      "w": 11,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "e",
+      "x": 648,
+      "y": 2,
+      "w": 12,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "e",
+      "x": 662,
+      "y": 2,
+      "w": 10,
+      "h": 15,
+      "source": "fixture"
+    },
+    {
+      "char": "e",
+      "x": 674,
+      "y": 2,
+      "w": 11,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "e",
+      "x": 687,
+      "y": 2,
+      "w": 10,
+      "h": 15,
+      "source": "fixture"
+    },
+    {
+      "char": "e",
+      "x": 699,
+      "y": 2,
+      "w": 11,
+      "h": 15,
+      "source": "fixture"
+    },
+    {
+      "char": "e",
+      "x": 712,
+      "y": 2,
+      "w": 10,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "e",
+      "x": 724,
+      "y": 2,
+      "w": 11,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "e",
+      "x": 737,
+      "y": 2,
+      "w": 12,
+      "h": 15,
+      "source": "fixture"
+    },
+    {
+      "char": "e",
+      "x": 751,
+      "y": 2,
+      "w": 12,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "e",
+      "x": 765,
+      "y": 2,
+      "w": 11,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "e",
+      "x": 778,
+      "y": 2,
+      "w": 12,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "e",
+      "x": 792,
+      "y": 2,
+      "w": 12,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "e",
+      "x": 806,
+      "y": 2,
+      "w": 11,
+      "h": 13,
+      "source": "fixture"
+    },
+    {
+      "char": "e",
+      "x": 819,
+      "y": 2,
+      "w": 12,
+      "h": 13,
+      "source": "fixture"
+    },
+    {
+      "char": "e",
+      "x": 833,
+      "y": 2,
+      "w": 11,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "e",
+      "x": 846,
+      "y": 2,
+      "w": 11,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "e",
+      "x": 859,
+      "y": 2,
+      "w": 11,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "e",
+      "x": 872,
+      "y": 2,
+      "w": 10,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "e",
+      "x": 884,
+      "y": 2,
+      "w": 12,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "e",
+      "x": 898,
+      "y": 2,
+      "w": 11,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "e",
+      "x": 911,
+      "y": 2,
+      "w": 12,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "e",
+      "x": 925,
+      "y": 2,
+      "w": 11,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "e",
+      "x": 938,
+      "y": 2,
+      "w": 11,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "e",
+      "x": 951,
+      "y": 2,
+      "w": 12,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "e",
+      "x": 965,
+      "y": 2,
+      "w": 12,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "e",
+      "x": 979,
+      "y": 2,
+      "w": 12,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "e",
+      "x": 993,
+      "y": 2,
+      "w": 12,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "e",
+      "x": 1007,
+      "y": 2,
+      "w": 12,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "e",
+      "x": 1021,
+      "y": 2,
+      "w": 12,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "e",
+      "x": 1035,
+      "y": 2,
+      "w": 11,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "e",
+      "x": 1048,
+      "y": 2,
+      "w": 12,
+      "h": 13,
+      "source": "fixture"
+    },
+    {
+      "char": "e",
+      "x": 1062,
+      "y": 2,
+      "w": 11,
+      "h": 13,
+      "source": "fixture"
+    },
+    {
+      "char": "E",
+      "x": 1075,
+      "y": 2,
+      "w": 11,
+      "h": 17,
+      "source": "fixture"
+    },
+    {
+      "char": "f",
+      "x": 1088,
+      "y": 2,
+      "w": 11,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "f",
+      "x": 1101,
+      "y": 2,
+      "w": 10,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "f",
+      "x": 1113,
+      "y": 2,
+      "w": 10,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "F",
+      "x": 1125,
+      "y": 2,
+      "w": 11,
+      "h": 17,
+      "source": "fixture"
+    },
+    {
+      "char": "F",
+      "x": 1138,
+      "y": 2,
+      "w": 11,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "F",
+      "x": 1151,
+      "y": 2,
+      "w": 10,
+      "h": 17,
+      "source": "fixture"
+    },
+    {
+      "char": "g",
+      "x": 1163,
+      "y": 2,
+      "w": 11,
+      "h": 19,
+      "source": "fixture"
+    },
+    {
+      "char": "g",
+      "x": 1176,
+      "y": 2,
+      "w": 11,
+      "h": 19,
+      "source": "fixture"
+    },
+    {
+      "char": "g",
+      "x": 1189,
+      "y": 2,
+      "w": 11,
+      "h": 19,
+      "source": "fixture"
+    },
+    {
+      "char": "G",
+      "x": 1202,
+      "y": 2,
+      "w": 12,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "h",
+      "x": 1216,
+      "y": 2,
+      "w": 11,
+      "h": 19,
+      "source": "fixture"
+    },
+    {
+      "char": "h",
+      "x": 1229,
+      "y": 2,
+      "w": 11,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "h",
+      "x": 1242,
+      "y": 2,
+      "w": 12,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "h",
+      "x": 1256,
+      "y": 2,
+      "w": 12,
+      "h": 17,
+      "source": "fixture"
+    },
+    {
+      "char": "h",
+      "x": 1270,
+      "y": 2,
+      "w": 11,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "h",
+      "x": 1283,
+      "y": 2,
+      "w": 12,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "h",
+      "x": 1297,
+      "y": 2,
+      "w": 12,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "h",
+      "x": 1311,
+      "y": 2,
+      "w": 12,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "h",
+      "x": 1325,
+      "y": 2,
+      "w": 11,
+      "h": 17,
+      "source": "fixture"
+    },
+    {
+      "char": "h",
+      "x": 1338,
+      "y": 2,
+      "w": 11,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "h",
+      "x": 1351,
+      "y": 2,
+      "w": 12,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "H",
+      "x": 1365,
+      "y": 2,
+      "w": 13,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "H",
+      "x": 1380,
+      "y": 2,
+      "w": 12,
+      "h": 19,
+      "source": "fixture"
+    },
+    {
+      "char": "H",
+      "x": 1394,
+      "y": 2,
+      "w": 12,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "i",
+      "x": 1408,
+      "y": 2,
+      "w": 6,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "i",
+      "x": 1416,
+      "y": 2,
+      "w": 6,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "i",
+      "x": 1424,
+      "y": 2,
+      "w": 6,
+      "h": 19,
+      "source": "fixture"
+    },
+    {
+      "char": "i",
+      "x": 1432,
+      "y": 2,
+      "w": 5,
+      "h": 19,
+      "source": "fixture"
+    },
+    {
+      "char": "i",
+      "x": 1439,
+      "y": 2,
+      "w": 6,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "i",
+      "x": 1447,
+      "y": 2,
+      "w": 6,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "i",
+      "x": 1455,
+      "y": 2,
+      "w": 6,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "i",
+      "x": 1463,
+      "y": 2,
+      "w": 6,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "i",
+      "x": 1471,
+      "y": 2,
+      "w": 5,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "i",
+      "x": 1478,
+      "y": 2,
+      "w": 5,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "i",
+      "x": 1485,
+      "y": 2,
+      "w": 6,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "i",
+      "x": 1493,
+      "y": 2,
+      "w": 5,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "I",
+      "x": 1500,
+      "y": 2,
+      "w": 5,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "J",
+      "x": 1507,
+      "y": 2,
+      "w": 12,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "k",
+      "x": 1521,
+      "y": 2,
+      "w": 11,
+      "h": 17,
+      "source": "fixture"
+    },
+    {
+      "char": "l",
+      "x": 1534,
+      "y": 2,
+      "w": 6,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "l",
+      "x": 1542,
+      "y": 2,
+      "w": 5,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "l",
+      "x": 1549,
+      "y": 2,
+      "w": 6,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "l",
+      "x": 1557,
+      "y": 2,
+      "w": 5,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "l",
+      "x": 1564,
+      "y": 2,
+      "w": 6,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "l",
+      "x": 1572,
+      "y": 2,
+      "w": 5,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "l",
+      "x": 1579,
+      "y": 2,
+      "w": 6,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "l",
+      "x": 1587,
+      "y": 2,
+      "w": 6,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "l",
+      "x": 2,
+      "y": 23,
+      "w": 5,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "l",
+      "x": 9,
+      "y": 23,
+      "w": 5,
+      "h": 17,
+      "source": "fixture"
+    },
+    {
+      "char": "l",
+      "x": 16,
+      "y": 23,
+      "w": 5,
+      "h": 17,
+      "source": "fixture"
+    },
+    {
+      "char": "L",
+      "x": 23,
+      "y": 23,
+      "w": 9,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "m",
+      "x": 34,
+      "y": 23,
+      "w": 15,
+      "h": 15,
+      "source": "fixture"
+    },
+    {
+      "char": "m",
+      "x": 51,
+      "y": 23,
+      "w": 15,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "m",
+      "x": 68,
+      "y": 23,
+      "w": 15,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "m",
+      "x": 85,
+      "y": 23,
+      "w": 16,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "m",
+      "x": 103,
+      "y": 23,
+      "w": 15,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "M",
+      "x": 120,
+      "y": 23,
+      "w": 14,
+      "h": 17,
+      "source": "fixture"
+    },
+    {
+      "char": "n",
+      "x": 136,
+      "y": 23,
+      "w": 11,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "n",
+      "x": 149,
+      "y": 23,
+      "w": 11,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "n",
+      "x": 162,
+      "y": 23,
+      "w": 11,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "n",
+      "x": 175,
+      "y": 23,
+      "w": 10,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "n",
+      "x": 187,
+      "y": 23,
+      "w": 12,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "n",
+      "x": 201,
+      "y": 23,
+      "w": 11,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "n",
+      "x": 214,
+      "y": 23,
+      "w": 11,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "n",
+      "x": 227,
+      "y": 23,
+      "w": 10,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "n",
+      "x": 239,
+      "y": 23,
+      "w": 11,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "n",
+      "x": 252,
+      "y": 23,
+      "w": 11,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "n",
+      "x": 265,
+      "y": 23,
+      "w": 11,
+      "h": 13,
+      "source": "fixture"
+    },
+    {
+      "char": "N",
+      "x": 278,
+      "y": 23,
+      "w": 12,
+      "h": 17,
+      "source": "fixture"
+    },
+    {
+      "char": "N",
+      "x": 292,
+      "y": 23,
+      "w": 12,
+      "h": 17,
+      "source": "fixture"
+    },
+    {
+      "char": "N",
+      "x": 306,
+      "y": 23,
+      "w": 12,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "N",
+      "x": 320,
+      "y": 23,
+      "w": 13,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "o",
+      "x": 335,
+      "y": 23,
+      "w": 11,
+      "h": 15,
+      "source": "fixture"
+    },
+    {
+      "char": "o",
+      "x": 348,
+      "y": 23,
+      "w": 11,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "o",
+      "x": 361,
+      "y": 23,
+      "w": 10,
+      "h": 15,
+      "source": "fixture"
+    },
+    {
+      "char": "o",
+      "x": 373,
+      "y": 23,
+      "w": 10,
+      "h": 15,
+      "source": "fixture"
+    },
+    {
+      "char": "o",
+      "x": 385,
+      "y": 23,
+      "w": 10,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "o",
+      "x": 397,
+      "y": 23,
+      "w": 11,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "o",
+      "x": 410,
+      "y": 23,
+      "w": 10,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "o",
+      "x": 422,
+      "y": 23,
+      "w": 10,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "o",
+      "x": 434,
+      "y": 23,
+      "w": 12,
+      "h": 13,
+      "source": "fixture"
+    },
+    {
+      "char": "o",
+      "x": 448,
+      "y": 23,
+      "w": 11,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "o",
+      "x": 461,
+      "y": 23,
+      "w": 11,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "o",
+      "x": 474,
+      "y": 23,
+      "w": 11,
+      "h": 13,
+      "source": "fixture"
+    },
+    {
+      "char": "o",
+      "x": 487,
+      "y": 23,
+      "w": 11,
+      "h": 13,
+      "source": "fixture"
+    },
+    {
+      "char": "o",
+      "x": 500,
+      "y": 23,
+      "w": 11,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "O",
+      "x": 513,
+      "y": 23,
+      "w": 12,
+      "h": 17,
+      "source": "fixture"
+    },
+    {
+      "char": "O",
+      "x": 527,
+      "y": 23,
+      "w": 12,
+      "h": 17,
+      "source": "fixture"
+    },
+    {
+      "char": "O",
+      "x": 541,
+      "y": 23,
+      "w": 11,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "p",
+      "x": 554,
+      "y": 23,
+      "w": 11,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "p",
+      "x": 567,
+      "y": 23,
+      "w": 12,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "P",
+      "x": 581,
+      "y": 23,
+      "w": 12,
+      "h": 17,
+      "source": "fixture"
+    },
+    {
+      "char": "P",
+      "x": 595,
+      "y": 23,
+      "w": 12,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "P",
+      "x": 609,
+      "y": 23,
+      "w": 12,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "r",
+      "x": 623,
+      "y": 23,
+      "w": 8,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "r",
+      "x": 633,
+      "y": 23,
+      "w": 8,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "r",
+      "x": 643,
+      "y": 23,
+      "w": 9,
+      "h": 15,
+      "source": "fixture"
+    },
+    {
+      "char": "r",
+      "x": 654,
+      "y": 23,
+      "w": 10,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "r",
+      "x": 666,
+      "y": 23,
+      "w": 9,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "r",
+      "x": 677,
+      "y": 23,
+      "w": 9,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "r",
+      "x": 688,
+      "y": 23,
+      "w": 9,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "r",
+      "x": 699,
+      "y": 23,
+      "w": 9,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "r",
+      "x": 710,
+      "y": 23,
+      "w": 9,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "r",
+      "x": 721,
+      "y": 23,
+      "w": 9,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "r",
+      "x": 732,
+      "y": 23,
+      "w": 9,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "r",
+      "x": 743,
+      "y": 23,
+      "w": 9,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "r",
+      "x": 754,
+      "y": 23,
+      "w": 10,
+      "h": 13,
+      "source": "fixture"
+    },
+    {
+      "char": "r",
+      "x": 766,
+      "y": 23,
+      "w": 9,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "R",
+      "x": 777,
+      "y": 23,
+      "w": 11,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "R",
+      "x": 790,
+      "y": 23,
+      "w": 11,
+      "h": 17,
+      "source": "fixture"
+    },
+    {
+      "char": "R",
+      "x": 803,
+      "y": 23,
+      "w": 11,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "s",
+      "x": 816,
+      "y": 23,
+      "w": 11,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "s",
+      "x": 829,
+      "y": 23,
+      "w": 11,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "s",
+      "x": 842,
+      "y": 23,
+      "w": 11,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "s",
+      "x": 855,
+      "y": 23,
+      "w": 11,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "s",
+      "x": 868,
+      "y": 23,
+      "w": 11,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "s",
+      "x": 881,
+      "y": 23,
+      "w": 10,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "s",
+      "x": 893,
+      "y": 23,
+      "w": 11,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "s",
+      "x": 906,
+      "y": 23,
+      "w": 11,
+      "h": 13,
+      "source": "fixture"
+    },
+    {
+      "char": "s",
+      "x": 919,
+      "y": 23,
+      "w": 11,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "s",
+      "x": 932,
+      "y": 23,
+      "w": 10,
+      "h": 13,
+      "source": "fixture"
+    },
+    {
+      "char": "s",
+      "x": 944,
+      "y": 23,
+      "w": 10,
+      "h": 13,
+      "source": "fixture"
+    },
+    {
+      "char": "S",
+      "x": 956,
+      "y": 23,
+      "w": 13,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "S",
+      "x": 971,
+      "y": 23,
+      "w": 12,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "S",
+      "x": 985,
+      "y": 23,
+      "w": 13,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "S",
+      "x": 1000,
+      "y": 23,
+      "w": 11,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "S",
+      "x": 1013,
+      "y": 23,
+      "w": 12,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "t",
+      "x": 1027,
+      "y": 23,
+      "w": 10,
+      "h": 16,
+      "source": "fixture"
+    },
+    {
+      "char": "t",
+      "x": 1039,
+      "y": 23,
+      "w": 10,
+      "h": 16,
+      "source": "fixture"
+    },
+    {
+      "char": "t",
+      "x": 1051,
+      "y": 23,
+      "w": 10,
+      "h": 16,
+      "source": "fixture"
+    },
+    {
+      "char": "t",
+      "x": 1063,
+      "y": 23,
+      "w": 9,
+      "h": 16,
+      "source": "fixture"
+    },
+    {
+      "char": "T",
+      "x": 1074,
+      "y": 23,
+      "w": 14,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "T",
+      "x": 1090,
+      "y": 23,
+      "w": 12,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "T",
+      "x": 1104,
+      "y": 23,
+      "w": 11,
+      "h": 17,
+      "source": "fixture"
+    },
+    {
+      "char": "u",
+      "x": 1117,
+      "y": 23,
+      "w": 12,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "u",
+      "x": 1131,
+      "y": 23,
+      "w": 12,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "u",
+      "x": 1145,
+      "y": 23,
+      "w": 12,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "u",
+      "x": 1159,
+      "y": 23,
+      "w": 12,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "u",
+      "x": 1173,
+      "y": 23,
+      "w": 12,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "v",
+      "x": 1187,
+      "y": 23,
+      "w": 10,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "v",
+      "x": 1199,
+      "y": 23,
+      "w": 11,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "v",
+      "x": 1212,
+      "y": 23,
+      "w": 10,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "v",
+      "x": 1224,
+      "y": 23,
+      "w": 11,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "v",
+      "x": 1237,
+      "y": 23,
+      "w": 10,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "w",
+      "x": 1249,
+      "y": 23,
+      "w": 12,
+      "h": 15,
+      "source": "fixture"
+    },
+    {
+      "char": "w",
+      "x": 1263,
+      "y": 23,
+      "w": 13,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "y",
+      "x": 1278,
+      "y": 23,
+      "w": 11,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "y",
+      "x": 1291,
+      "y": 23,
+      "w": 12,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "y",
+      "x": 1305,
+      "y": 23,
+      "w": 12,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "y",
+      "x": 1319,
+      "y": 23,
+      "w": 12,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "z",
+      "x": 1333,
+      "y": 23,
+      "w": 11,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "z",
+      "x": 1346,
+      "y": 23,
+      "w": 11,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "α",
+      "x": 1359,
+      "y": 23,
+      "w": 15,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "ι",
+      "x": 1376,
+      "y": 23,
+      "w": 8,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "ι",
+      "x": 1386,
+      "y": 23,
+      "w": 8,
+      "h": 14,
+      "source": "fixture"
+    },
+    {
+      "char": "!",
+      "x": 1396,
+      "y": 23,
+      "w": 7,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "!",
+      "x": 1405,
+      "y": 23,
+      "w": 6,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "\"",
+      "x": 1413,
+      "y": 23,
+      "w": 10,
+      "h": 8,
+      "source": "font"
+    },
+    {
+      "char": "\"",
+      "x": 1425,
+      "y": 23,
+      "w": 11,
+      "h": 9,
+      "source": "font"
+    },
+    {
+      "char": "#",
+      "x": 1438,
+      "y": 23,
+      "w": 14,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "#",
+      "x": 1454,
+      "y": 23,
+      "w": 15,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "$",
+      "x": 1471,
+      "y": 23,
+      "w": 13,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "$",
+      "x": 1486,
+      "y": 23,
+      "w": 14,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "%",
+      "x": 1502,
+      "y": 23,
+      "w": 16,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "%",
+      "x": 1520,
+      "y": 23,
+      "w": 16,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "&",
+      "x": 1538,
+      "y": 23,
+      "w": 15,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "&",
+      "x": 1555,
+      "y": 23,
+      "w": 16,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "'",
+      "x": 1573,
+      "y": 23,
+      "w": 7,
+      "h": 9,
+      "source": "font"
+    },
+    {
+      "char": "'",
+      "x": 1582,
+      "y": 23,
+      "w": 7,
+      "h": 9,
+      "source": "font"
+    },
+    {
+      "char": "(",
+      "x": 2,
+      "y": 48,
+      "w": 9,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "(",
+      "x": 13,
+      "y": 48,
+      "w": 9,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": ")",
+      "x": 24,
+      "y": 48,
+      "w": 9,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": ")",
+      "x": 35,
+      "y": 48,
+      "w": 9,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "*",
+      "x": 46,
+      "y": 48,
+      "w": 8,
+      "h": 8,
+      "source": "font"
+    },
+    {
+      "char": "*",
+      "x": 56,
+      "y": 48,
+      "w": 8,
+      "h": 8,
+      "source": "font"
+    },
+    {
+      "char": "+",
+      "x": 66,
+      "y": 48,
+      "w": 12,
+      "h": 12,
+      "source": "font"
+    },
+    {
+      "char": "+",
+      "x": 80,
+      "y": 48,
+      "w": 13,
+      "h": 13,
+      "source": "font"
+    },
+    {
+      "char": ",",
+      "x": 95,
+      "y": 48,
+      "w": 7,
+      "h": 9,
+      "source": "font"
+    },
+    {
+      "char": ",",
+      "x": 104,
+      "y": 48,
+      "w": 7,
+      "h": 9,
+      "source": "font"
+    },
+    {
+      "char": "-",
+      "x": 113,
+      "y": 48,
+      "w": 10,
+      "h": 6,
+      "source": "font"
+    },
+    {
+      "char": "-",
+      "x": 125,
+      "y": 48,
+      "w": 10,
+      "h": 6,
+      "source": "font"
+    },
+    {
+      "char": ".",
+      "x": 137,
+      "y": 48,
+      "w": 6,
+      "h": 6,
+      "source": "font"
+    },
+    {
+      "char": ".",
+      "x": 145,
+      "y": 48,
+      "w": 6,
+      "h": 6,
+      "source": "font"
+    },
+    {
+      "char": "/",
+      "x": 153,
+      "y": 48,
+      "w": 11,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "/",
+      "x": 166,
+      "y": 48,
+      "w": 12,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "0",
+      "x": 180,
+      "y": 48,
+      "w": 12,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "0",
+      "x": 194,
+      "y": 48,
+      "w": 12,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "1",
+      "x": 208,
+      "y": 48,
+      "w": 7,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "1",
+      "x": 217,
+      "y": 48,
+      "w": 7,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "2",
+      "x": 226,
+      "y": 48,
+      "w": 11,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "2",
+      "x": 239,
+      "y": 48,
+      "w": 12,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "3",
+      "x": 253,
+      "y": 48,
+      "w": 12,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "3",
+      "x": 267,
+      "y": 48,
+      "w": 13,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "4",
+      "x": 282,
+      "y": 48,
+      "w": 11,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "4",
+      "x": 295,
+      "y": 48,
+      "w": 12,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "5",
+      "x": 309,
+      "y": 48,
+      "w": 11,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "5",
+      "x": 322,
+      "y": 48,
+      "w": 11,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "6",
+      "x": 335,
+      "y": 48,
+      "w": 11,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "6",
+      "x": 348,
+      "y": 48,
+      "w": 12,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "7",
+      "x": 362,
+      "y": 48,
+      "w": 11,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "7",
+      "x": 375,
+      "y": 48,
+      "w": 12,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "8",
+      "x": 389,
+      "y": 48,
+      "w": 11,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "8",
+      "x": 402,
+      "y": 48,
+      "w": 12,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "9",
+      "x": 416,
+      "y": 48,
+      "w": 11,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "9",
+      "x": 429,
+      "y": 48,
+      "w": 12,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": ":",
+      "x": 443,
+      "y": 48,
+      "w": 7,
+      "h": 14,
+      "source": "font"
+    },
+    {
+      "char": ":",
+      "x": 452,
+      "y": 48,
+      "w": 7,
+      "h": 15,
+      "source": "font"
+    },
+    {
+      "char": ";",
+      "x": 461,
+      "y": 48,
+      "w": 7,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": ";",
+      "x": 470,
+      "y": 48,
+      "w": 7,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "<",
+      "x": 479,
+      "y": 48,
+      "w": 10,
+      "h": 14,
+      "source": "font"
+    },
+    {
+      "char": "<",
+      "x": 491,
+      "y": 48,
+      "w": 10,
+      "h": 14,
+      "source": "font"
+    },
+    {
+      "char": "=",
+      "x": 503,
+      "y": 48,
+      "w": 11,
+      "h": 11,
+      "source": "font"
+    },
+    {
+      "char": "=",
+      "x": 516,
+      "y": 48,
+      "w": 12,
+      "h": 12,
+      "source": "font"
+    },
+    {
+      "char": ">",
+      "x": 530,
+      "y": 48,
+      "w": 10,
+      "h": 14,
+      "source": "font"
+    },
+    {
+      "char": ">",
+      "x": 542,
+      "y": 48,
+      "w": 10,
+      "h": 14,
+      "source": "font"
+    },
+    {
+      "char": "?",
+      "x": 554,
+      "y": 48,
+      "w": 15,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "?",
+      "x": 571,
+      "y": 48,
+      "w": 15,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "@",
+      "x": 588,
+      "y": 48,
+      "w": 18,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "@",
+      "x": 608,
+      "y": 48,
+      "w": 18,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "A",
+      "x": 628,
+      "y": 48,
+      "w": 12,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "A",
+      "x": 642,
+      "y": 48,
+      "w": 12,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "B",
+      "x": 656,
+      "y": 48,
+      "w": 11,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "B",
+      "x": 669,
+      "y": 48,
+      "w": 12,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "C",
+      "x": 683,
+      "y": 48,
+      "w": 11,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "C",
+      "x": 696,
+      "y": 48,
+      "w": 12,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "D",
+      "x": 710,
+      "y": 48,
+      "w": 12,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "D",
+      "x": 724,
+      "y": 48,
+      "w": 12,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "E",
+      "x": 738,
+      "y": 48,
+      "w": 11,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "E",
+      "x": 751,
+      "y": 48,
+      "w": 11,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "F",
+      "x": 764,
+      "y": 48,
+      "w": 10,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "F",
+      "x": 776,
+      "y": 48,
+      "w": 11,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "G",
+      "x": 789,
+      "y": 48,
+      "w": 12,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "G",
+      "x": 803,
+      "y": 48,
+      "w": 11,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "H",
+      "x": 816,
+      "y": 48,
+      "w": 12,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "H",
+      "x": 830,
+      "y": 48,
+      "w": 12,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "I",
+      "x": 844,
+      "y": 48,
+      "w": 6,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "I",
+      "x": 852,
+      "y": 48,
+      "w": 6,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "J",
+      "x": 860,
+      "y": 48,
+      "w": 11,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "J",
+      "x": 873,
+      "y": 48,
+      "w": 11,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "K",
+      "x": 886,
+      "y": 48,
+      "w": 11,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "K",
+      "x": 899,
+      "y": 48,
+      "w": 10,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "L",
+      "x": 911,
+      "y": 48,
+      "w": 9,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "L",
+      "x": 922,
+      "y": 48,
+      "w": 9,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "M",
+      "x": 933,
+      "y": 48,
+      "w": 14,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "M",
+      "x": 949,
+      "y": 48,
+      "w": 14,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "N",
+      "x": 965,
+      "y": 48,
+      "w": 12,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "N",
+      "x": 979,
+      "y": 48,
+      "w": 13,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "O",
+      "x": 994,
+      "y": 48,
+      "w": 12,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "O",
+      "x": 1008,
+      "y": 48,
+      "w": 12,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "P",
+      "x": 1022,
+      "y": 48,
+      "w": 12,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "P",
+      "x": 1036,
+      "y": 48,
+      "w": 12,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "Q",
+      "x": 1050,
+      "y": 48,
+      "w": 12,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "Q",
+      "x": 1064,
+      "y": 48,
+      "w": 12,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "R",
+      "x": 1078,
+      "y": 48,
+      "w": 11,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "R",
+      "x": 1091,
+      "y": 48,
+      "w": 12,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "S",
+      "x": 1105,
+      "y": 48,
+      "w": 12,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "S",
+      "x": 1119,
+      "y": 48,
+      "w": 13,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "T",
+      "x": 1134,
+      "y": 48,
+      "w": 12,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "T",
+      "x": 1148,
+      "y": 48,
+      "w": 12,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "U",
+      "x": 1162,
+      "y": 48,
+      "w": 12,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "U",
+      "x": 1176,
+      "y": 48,
+      "w": 12,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "V",
+      "x": 1190,
+      "y": 48,
+      "w": 12,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "V",
+      "x": 1204,
+      "y": 48,
+      "w": 13,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "W",
+      "x": 1219,
+      "y": 48,
+      "w": 15,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "W",
+      "x": 1236,
+      "y": 48,
+      "w": 16,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "X",
+      "x": 1254,
+      "y": 48,
+      "w": 10,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "X",
+      "x": 1266,
+      "y": 48,
+      "w": 10,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "Y",
+      "x": 1278,
+      "y": 48,
+      "w": 11,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "Y",
+      "x": 1291,
+      "y": 48,
+      "w": 11,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "Z",
+      "x": 1304,
+      "y": 48,
+      "w": 11,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "Z",
+      "x": 1317,
+      "y": 48,
+      "w": 12,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "[",
+      "x": 1331,
+      "y": 48,
+      "w": 9,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "[",
+      "x": 1342,
+      "y": 48,
+      "w": 10,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "\\",
+      "x": 1354,
+      "y": 48,
+      "w": 12,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "\\",
+      "x": 1368,
+      "y": 48,
+      "w": 13,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "]",
+      "x": 1383,
+      "y": 48,
+      "w": 9,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "]",
+      "x": 1394,
+      "y": 48,
+      "w": 10,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "^",
+      "x": 1406,
+      "y": 48,
+      "w": 13,
+      "h": 9,
+      "source": "font"
+    },
+    {
+      "char": "^",
+      "x": 1421,
+      "y": 48,
+      "w": 13,
+      "h": 10,
+      "source": "font"
+    },
+    {
+      "char": "_",
+      "x": 1436,
+      "y": 48,
+      "w": 10,
+      "h": 6,
+      "source": "font"
+    },
+    {
+      "char": "_",
+      "x": 1448,
+      "y": 48,
+      "w": 10,
+      "h": 6,
+      "source": "font"
+    },
+    {
+      "char": "`",
+      "x": 1460,
+      "y": 48,
+      "w": 7,
+      "h": 9,
+      "source": "font"
+    },
+    {
+      "char": "`",
+      "x": 1469,
+      "y": 48,
+      "w": 7,
+      "h": 9,
+      "source": "font"
+    },
+    {
+      "char": "a",
+      "x": 1478,
+      "y": 48,
+      "w": 11,
+      "h": 14,
+      "source": "font"
+    },
+    {
+      "char": "a",
+      "x": 1491,
+      "y": 48,
+      "w": 12,
+      "h": 15,
+      "source": "font"
+    },
+    {
+      "char": "b",
+      "x": 1505,
+      "y": 48,
+      "w": 11,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "b",
+      "x": 1518,
+      "y": 48,
+      "w": 12,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "c",
+      "x": 1532,
+      "y": 48,
+      "w": 11,
+      "h": 14,
+      "source": "font"
+    },
+    {
+      "char": "c",
+      "x": 1545,
+      "y": 48,
+      "w": 11,
+      "h": 15,
+      "source": "font"
+    },
+    {
+      "char": "d",
+      "x": 1558,
+      "y": 48,
+      "w": 11,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "d",
+      "x": 1571,
+      "y": 48,
+      "w": 11,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "e",
+      "x": 1584,
+      "y": 48,
+      "w": 11,
+      "h": 14,
+      "source": "font"
+    },
+    {
+      "char": "e",
+      "x": 2,
+      "y": 73,
+      "w": 12,
+      "h": 15,
+      "source": "font"
+    },
+    {
+      "char": "f",
+      "x": 16,
+      "y": 73,
+      "w": 10,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "f",
+      "x": 28,
+      "y": 73,
+      "w": 11,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "g",
+      "x": 41,
+      "y": 73,
+      "w": 11,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "g",
+      "x": 54,
+      "y": 73,
+      "w": 11,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "h",
+      "x": 67,
+      "y": 73,
+      "w": 11,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "h",
+      "x": 80,
+      "y": 73,
+      "w": 11,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "i",
+      "x": 93,
+      "y": 73,
+      "w": 6,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "i",
+      "x": 101,
+      "y": 73,
+      "w": 6,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "j",
+      "x": 109,
+      "y": 73,
+      "w": 7,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "j",
+      "x": 118,
+      "y": 73,
+      "w": 7,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "k",
+      "x": 127,
+      "y": 73,
+      "w": 11,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "k",
+      "x": 140,
+      "y": 73,
+      "w": 10,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "l",
+      "x": 152,
+      "y": 73,
+      "w": 5,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "l",
+      "x": 159,
+      "y": 73,
+      "w": 5,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "m",
+      "x": 166,
+      "y": 73,
+      "w": 15,
+      "h": 14,
+      "source": "font"
+    },
+    {
+      "char": "m",
+      "x": 183,
+      "y": 73,
+      "w": 15,
+      "h": 15,
+      "source": "font"
+    },
+    {
+      "char": "n",
+      "x": 200,
+      "y": 73,
+      "w": 11,
+      "h": 14,
+      "source": "font"
+    },
+    {
+      "char": "n",
+      "x": 213,
+      "y": 73,
+      "w": 11,
+      "h": 14,
+      "source": "font"
+    },
+    {
+      "char": "o",
+      "x": 226,
+      "y": 73,
+      "w": 11,
+      "h": 14,
+      "source": "font"
+    },
+    {
+      "char": "o",
+      "x": 239,
+      "y": 73,
+      "w": 11,
+      "h": 15,
+      "source": "font"
+    },
+    {
+      "char": "p",
+      "x": 252,
+      "y": 73,
+      "w": 11,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "p",
+      "x": 265,
+      "y": 73,
+      "w": 11,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "q",
+      "x": 278,
+      "y": 73,
+      "w": 10,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "q",
+      "x": 290,
+      "y": 73,
+      "w": 11,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "r",
+      "x": 303,
+      "y": 73,
+      "w": 9,
+      "h": 14,
+      "source": "font"
+    },
+    {
+      "char": "r",
+      "x": 314,
+      "y": 73,
+      "w": 9,
+      "h": 14,
+      "source": "font"
+    },
+    {
+      "char": "s",
+      "x": 325,
+      "y": 73,
+      "w": 10,
+      "h": 14,
+      "source": "font"
+    },
+    {
+      "char": "s",
+      "x": 337,
+      "y": 73,
+      "w": 10,
+      "h": 15,
+      "source": "font"
+    },
+    {
+      "char": "t",
+      "x": 349,
+      "y": 73,
+      "w": 9,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "t",
+      "x": 360,
+      "y": 73,
+      "w": 9,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "u",
+      "x": 371,
+      "y": 73,
+      "w": 11,
+      "h": 14,
+      "source": "font"
+    },
+    {
+      "char": "u",
+      "x": 384,
+      "y": 73,
+      "w": 11,
+      "h": 14,
+      "source": "font"
+    },
+    {
+      "char": "v",
+      "x": 397,
+      "y": 73,
+      "w": 10,
+      "h": 14,
+      "source": "font"
+    },
+    {
+      "char": "v",
+      "x": 409,
+      "y": 73,
+      "w": 11,
+      "h": 14,
+      "source": "font"
+    },
+    {
+      "char": "w",
+      "x": 422,
+      "y": 73,
+      "w": 13,
+      "h": 14,
+      "source": "font"
+    },
+    {
+      "char": "w",
+      "x": 437,
+      "y": 73,
+      "w": 14,
+      "h": 14,
+      "source": "font"
+    },
+    {
+      "char": "x",
+      "x": 453,
+      "y": 73,
+      "w": 10,
+      "h": 14,
+      "source": "font"
+    },
+    {
+      "char": "x",
+      "x": 465,
+      "y": 73,
+      "w": 11,
+      "h": 15,
+      "source": "font"
+    },
+    {
+      "char": "y",
+      "x": 478,
+      "y": 73,
+      "w": 11,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "y",
+      "x": 491,
+      "y": 73,
+      "w": 11,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "z",
+      "x": 504,
+      "y": 73,
+      "w": 11,
+      "h": 14,
+      "source": "font"
+    },
+    {
+      "char": "z",
+      "x": 517,
+      "y": 73,
+      "w": 11,
+      "h": 14,
+      "source": "font"
+    },
+    {
+      "char": "{",
+      "x": 530,
+      "y": 73,
+      "w": 8,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "{",
+      "x": 540,
+      "y": 73,
+      "w": 8,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "|",
+      "x": 550,
+      "y": 73,
+      "w": 6,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "|",
+      "x": 558,
+      "y": 73,
+      "w": 6,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "}",
+      "x": 566,
+      "y": 73,
+      "w": 8,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "}",
+      "x": 576,
+      "y": 73,
+      "w": 8,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "~",
+      "x": 586,
+      "y": 73,
+      "w": 11,
+      "h": 7,
+      "source": "font"
+    },
+    {
+      "char": "~",
+      "x": 599,
+      "y": 73,
+      "w": 12,
+      "h": 7,
+      "source": "font"
+    },
+    {
+      "char": "¡",
+      "x": 613,
+      "y": 73,
+      "w": 7,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "¡",
+      "x": 622,
+      "y": 73,
+      "w": 7,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "¢",
+      "x": 631,
+      "y": 73,
+      "w": 12,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "¢",
+      "x": 645,
+      "y": 73,
+      "w": 12,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "£",
+      "x": 659,
+      "y": 73,
+      "w": 11,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "£",
+      "x": 672,
+      "y": 73,
+      "w": 12,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "¤",
+      "x": 686,
+      "y": 73,
+      "w": 12,
+      "h": 13,
+      "source": "font"
+    },
+    {
+      "char": "¤",
+      "x": 700,
+      "y": 73,
+      "w": 13,
+      "h": 13,
+      "source": "font"
+    },
+    {
+      "char": "¥",
+      "x": 715,
+      "y": 73,
+      "w": 10,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "¥",
+      "x": 727,
+      "y": 73,
+      "w": 11,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "¦",
+      "x": 740,
+      "y": 73,
+      "w": 6,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "¦",
+      "x": 748,
+      "y": 73,
+      "w": 6,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "§",
+      "x": 756,
+      "y": 73,
+      "w": 13,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "§",
+      "x": 771,
+      "y": 73,
+      "w": 14,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "¨",
+      "x": 787,
+      "y": 73,
+      "w": 9,
+      "h": 6,
+      "source": "font"
+    },
+    {
+      "char": "¨",
+      "x": 798,
+      "y": 73,
+      "w": 10,
+      "h": 6,
+      "source": "font"
+    },
+    {
+      "char": "©",
+      "x": 810,
+      "y": 73,
+      "w": 17,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "©",
+      "x": 829,
+      "y": 73,
+      "w": 17,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "ª",
+      "x": 848,
+      "y": 73,
+      "w": 7,
+      "h": 9,
+      "source": "font"
+    },
+    {
+      "char": "ª",
+      "x": 857,
+      "y": 73,
+      "w": 7,
+      "h": 9,
+      "source": "font"
+    },
+    {
+      "char": "«",
+      "x": 866,
+      "y": 73,
+      "w": 14,
+      "h": 12,
+      "source": "font"
+    },
+    {
+      "char": "«",
+      "x": 882,
+      "y": 73,
+      "w": 14,
+      "h": 12,
+      "source": "font"
+    },
+    {
+      "char": "¬",
+      "x": 898,
+      "y": 73,
+      "w": 12,
+      "h": 8,
+      "source": "font"
+    },
+    {
+      "char": "¬",
+      "x": 912,
+      "y": 73,
+      "w": 12,
+      "h": 8,
+      "source": "font"
+    },
+    {
+      "char": "®",
+      "x": 926,
+      "y": 73,
+      "w": 17,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "®",
+      "x": 945,
+      "y": 73,
+      "w": 17,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "¯",
+      "x": 964,
+      "y": 73,
+      "w": 10,
+      "h": 6,
+      "source": "font"
+    },
+    {
+      "char": "¯",
+      "x": 976,
+      "y": 73,
+      "w": 10,
+      "h": 6,
+      "source": "font"
+    },
+    {
+      "char": "°",
+      "x": 988,
+      "y": 73,
+      "w": 8,
+      "h": 7,
+      "source": "font"
+    },
+    {
+      "char": "°",
+      "x": 998,
+      "y": 73,
+      "w": 8,
+      "h": 8,
+      "source": "font"
+    },
+    {
+      "char": "±",
+      "x": 1008,
+      "y": 73,
+      "w": 14,
+      "h": 14,
+      "source": "font"
+    },
+    {
+      "char": "±",
+      "x": 1024,
+      "y": 73,
+      "w": 15,
+      "h": 14,
+      "source": "font"
+    },
+    {
+      "char": "²",
+      "x": 1041,
+      "y": 73,
+      "w": 7,
+      "h": 8,
+      "source": "font"
+    },
+    {
+      "char": "²",
+      "x": 1050,
+      "y": 73,
+      "w": 7,
+      "h": 9,
+      "source": "font"
+    },
+    {
+      "char": "³",
+      "x": 1059,
+      "y": 73,
+      "w": 6,
+      "h": 8,
+      "source": "font"
+    },
+    {
+      "char": "³",
+      "x": 1067,
+      "y": 73,
+      "w": 7,
+      "h": 9,
+      "source": "font"
+    },
+    {
+      "char": "´",
+      "x": 1076,
+      "y": 73,
+      "w": 6,
+      "h": 7,
+      "source": "font"
+    },
+    {
+      "char": "´",
+      "x": 1084,
+      "y": 73,
+      "w": 7,
+      "h": 7,
+      "source": "font"
+    },
+    {
+      "char": "µ",
+      "x": 1093,
+      "y": 73,
+      "w": 11,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "µ",
+      "x": 1106,
+      "y": 73,
+      "w": 12,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "¶",
+      "x": 1120,
+      "y": 73,
+      "w": 12,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "¶",
+      "x": 1134,
+      "y": 73,
+      "w": 13,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "·",
+      "x": 1149,
+      "y": 73,
+      "w": 7,
+      "h": 6,
+      "source": "font"
+    },
+    {
+      "char": "·",
+      "x": 1158,
+      "y": 73,
+      "w": 6,
+      "h": 6,
+      "source": "font"
+    },
+    {
+      "char": "¸",
+      "x": 1166,
+      "y": 73,
+      "w": 6,
+      "h": 6,
+      "source": "font"
+    },
+    {
+      "char": "¸",
+      "x": 1174,
+      "y": 73,
+      "w": 7,
+      "h": 6,
+      "source": "font"
+    },
+    {
+      "char": "¹",
+      "x": 1183,
+      "y": 73,
+      "w": 4,
+      "h": 8,
+      "source": "font"
+    },
+    {
+      "char": "¹",
+      "x": 1189,
+      "y": 73,
+      "w": 4,
+      "h": 9,
+      "source": "font"
+    },
+    {
+      "char": "º",
+      "x": 1195,
+      "y": 73,
+      "w": 6,
+      "h": 9,
+      "source": "font"
+    },
+    {
+      "char": "º",
+      "x": 1203,
+      "y": 73,
+      "w": 6,
+      "h": 9,
+      "source": "font"
+    },
+    {
+      "char": "»",
+      "x": 1211,
+      "y": 73,
+      "w": 13,
+      "h": 12,
+      "source": "font"
+    },
+    {
+      "char": "»",
+      "x": 1226,
+      "y": 73,
+      "w": 14,
+      "h": 12,
+      "source": "font"
+    },
+    {
+      "char": "¼",
+      "x": 1242,
+      "y": 73,
+      "w": 13,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "¼",
+      "x": 1257,
+      "y": 73,
+      "w": 14,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "½",
+      "x": 1273,
+      "y": 73,
+      "w": 13,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "½",
+      "x": 1288,
+      "y": 73,
+      "w": 14,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "¾",
+      "x": 1304,
+      "y": 73,
+      "w": 15,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "¾",
+      "x": 1321,
+      "y": 73,
+      "w": 16,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "¿",
+      "x": 1339,
+      "y": 73,
+      "w": 14,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "¿",
+      "x": 1355,
+      "y": 73,
+      "w": 15,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "À",
+      "x": 1372,
+      "y": 73,
+      "w": 12,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "À",
+      "x": 1386,
+      "y": 73,
+      "w": 12,
+      "h": 24,
+      "source": "font"
+    },
+    {
+      "char": "Á",
+      "x": 1400,
+      "y": 73,
+      "w": 12,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "Á",
+      "x": 1414,
+      "y": 73,
+      "w": 12,
+      "h": 24,
+      "source": "font"
+    },
+    {
+      "char": "Â",
+      "x": 1428,
+      "y": 73,
+      "w": 12,
+      "h": 24,
+      "source": "font"
+    },
+    {
+      "char": "Â",
+      "x": 1442,
+      "y": 73,
+      "w": 12,
+      "h": 25,
+      "source": "font"
+    },
+    {
+      "char": "Ã",
+      "x": 1456,
+      "y": 73,
+      "w": 12,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "Ã",
+      "x": 1470,
+      "y": 73,
+      "w": 12,
+      "h": 24,
+      "source": "font"
+    },
+    {
+      "char": "Ä",
+      "x": 1484,
+      "y": 73,
+      "w": 12,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "Ä",
+      "x": 1498,
+      "y": 73,
+      "w": 12,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "Å",
+      "x": 1512,
+      "y": 73,
+      "w": 12,
+      "h": 24,
+      "source": "font"
+    },
+    {
+      "char": "Å",
+      "x": 1526,
+      "y": 73,
+      "w": 12,
+      "h": 25,
+      "source": "font"
+    },
+    {
+      "char": "Æ",
+      "x": 1540,
+      "y": 73,
+      "w": 16,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "Æ",
+      "x": 1558,
+      "y": 73,
+      "w": 16,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "Ç",
+      "x": 1576,
+      "y": 73,
+      "w": 11,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "Ç",
+      "x": 2,
+      "y": 100,
+      "w": 12,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "È",
+      "x": 16,
+      "y": 100,
+      "w": 11,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "È",
+      "x": 29,
+      "y": 100,
+      "w": 11,
+      "h": 24,
+      "source": "font"
+    },
+    {
+      "char": "É",
+      "x": 42,
+      "y": 100,
+      "w": 11,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "É",
+      "x": 55,
+      "y": 100,
+      "w": 11,
+      "h": 24,
+      "source": "font"
+    },
+    {
+      "char": "Ê",
+      "x": 68,
+      "y": 100,
+      "w": 11,
+      "h": 24,
+      "source": "font"
+    },
+    {
+      "char": "Ê",
+      "x": 81,
+      "y": 100,
+      "w": 11,
+      "h": 25,
+      "source": "font"
+    },
+    {
+      "char": "Ë",
+      "x": 94,
+      "y": 100,
+      "w": 11,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "Ë",
+      "x": 107,
+      "y": 100,
+      "w": 11,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "Ì",
+      "x": 120,
+      "y": 100,
+      "w": 7,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "Ì",
+      "x": 129,
+      "y": 100,
+      "w": 7,
+      "h": 24,
+      "source": "font"
+    },
+    {
+      "char": "Í",
+      "x": 138,
+      "y": 100,
+      "w": 7,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "Í",
+      "x": 147,
+      "y": 100,
+      "w": 7,
+      "h": 24,
+      "source": "font"
+    },
+    {
+      "char": "Î",
+      "x": 156,
+      "y": 100,
+      "w": 10,
+      "h": 24,
+      "source": "font"
+    },
+    {
+      "char": "Î",
+      "x": 168,
+      "y": 100,
+      "w": 9,
+      "h": 25,
+      "source": "font"
+    },
+    {
+      "char": "Ï",
+      "x": 179,
+      "y": 100,
+      "w": 9,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "Ï",
+      "x": 190,
+      "y": 100,
+      "w": 10,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "Ð",
+      "x": 202,
+      "y": 100,
+      "w": 12,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "Ð",
+      "x": 216,
+      "y": 100,
+      "w": 13,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "Ñ",
+      "x": 231,
+      "y": 100,
+      "w": 12,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "Ñ",
+      "x": 245,
+      "y": 100,
+      "w": 13,
+      "h": 24,
+      "source": "font"
+    },
+    {
+      "char": "Ò",
+      "x": 260,
+      "y": 100,
+      "w": 12,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "Ò",
+      "x": 274,
+      "y": 100,
+      "w": 12,
+      "h": 24,
+      "source": "font"
+    },
+    {
+      "char": "Ó",
+      "x": 288,
+      "y": 100,
+      "w": 12,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "Ó",
+      "x": 302,
+      "y": 100,
+      "w": 12,
+      "h": 24,
+      "source": "font"
+    },
+    {
+      "char": "Ô",
+      "x": 316,
+      "y": 100,
+      "w": 12,
+      "h": 24,
+      "source": "font"
+    },
+    {
+      "char": "Ô",
+      "x": 330,
+      "y": 100,
+      "w": 12,
+      "h": 25,
+      "source": "font"
+    },
+    {
+      "char": "Õ",
+      "x": 344,
+      "y": 100,
+      "w": 12,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "Õ",
+      "x": 358,
+      "y": 100,
+      "w": 12,
+      "h": 24,
+      "source": "font"
+    },
+    {
+      "char": "Ö",
+      "x": 372,
+      "y": 100,
+      "w": 12,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "Ö",
+      "x": 386,
+      "y": 100,
+      "w": 12,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "×",
+      "x": 400,
+      "y": 100,
+      "w": 11,
+      "h": 10,
+      "source": "font"
+    },
+    {
+      "char": "×",
+      "x": 413,
+      "y": 100,
+      "w": 11,
+      "h": 11,
+      "source": "font"
+    },
+    {
+      "char": "Ø",
+      "x": 426,
+      "y": 100,
+      "w": 12,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "Ø",
+      "x": 440,
+      "y": 100,
+      "w": 13,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "Ù",
+      "x": 455,
+      "y": 100,
+      "w": 12,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "Ù",
+      "x": 469,
+      "y": 100,
+      "w": 12,
+      "h": 24,
+      "source": "font"
+    },
+    {
+      "char": "Ú",
+      "x": 483,
+      "y": 100,
+      "w": 12,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "Ú",
+      "x": 497,
+      "y": 100,
+      "w": 12,
+      "h": 24,
+      "source": "font"
+    },
+    {
+      "char": "Û",
+      "x": 511,
+      "y": 100,
+      "w": 12,
+      "h": 24,
+      "source": "font"
+    },
+    {
+      "char": "Û",
+      "x": 525,
+      "y": 100,
+      "w": 12,
+      "h": 25,
+      "source": "font"
+    },
+    {
+      "char": "Ü",
+      "x": 539,
+      "y": 100,
+      "w": 12,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "Ü",
+      "x": 553,
+      "y": 100,
+      "w": 12,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "Ý",
+      "x": 567,
+      "y": 100,
+      "w": 11,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "Ý",
+      "x": 580,
+      "y": 100,
+      "w": 11,
+      "h": 24,
+      "source": "font"
+    },
+    {
+      "char": "Þ",
+      "x": 593,
+      "y": 100,
+      "w": 11,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "Þ",
+      "x": 606,
+      "y": 100,
+      "w": 11,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "ß",
+      "x": 619,
+      "y": 100,
+      "w": 11,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "ß",
+      "x": 632,
+      "y": 100,
+      "w": 12,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "à",
+      "x": 646,
+      "y": 100,
+      "w": 11,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "à",
+      "x": 659,
+      "y": 100,
+      "w": 12,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "á",
+      "x": 673,
+      "y": 100,
+      "w": 11,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "á",
+      "x": 686,
+      "y": 100,
+      "w": 12,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "â",
+      "x": 700,
+      "y": 100,
+      "w": 11,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "â",
+      "x": 713,
+      "y": 100,
+      "w": 12,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "ã",
+      "x": 727,
+      "y": 100,
+      "w": 11,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "ã",
+      "x": 740,
+      "y": 100,
+      "w": 12,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "ä",
+      "x": 754,
+      "y": 100,
+      "w": 11,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "ä",
+      "x": 767,
+      "y": 100,
+      "w": 12,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "å",
+      "x": 781,
+      "y": 100,
+      "w": 11,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "å",
+      "x": 794,
+      "y": 100,
+      "w": 12,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "æ",
+      "x": 808,
+      "y": 100,
+      "w": 17,
+      "h": 14,
+      "source": "font"
+    },
+    {
+      "char": "æ",
+      "x": 827,
+      "y": 100,
+      "w": 18,
+      "h": 15,
+      "source": "font"
+    },
+    {
+      "char": "ç",
+      "x": 847,
+      "y": 100,
+      "w": 11,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "ç",
+      "x": 860,
+      "y": 100,
+      "w": 11,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "è",
+      "x": 873,
+      "y": 100,
+      "w": 11,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "è",
+      "x": 886,
+      "y": 100,
+      "w": 12,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "é",
+      "x": 900,
+      "y": 100,
+      "w": 11,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "é",
+      "x": 913,
+      "y": 100,
+      "w": 12,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "ê",
+      "x": 927,
+      "y": 100,
+      "w": 11,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "ê",
+      "x": 940,
+      "y": 100,
+      "w": 12,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "ë",
+      "x": 954,
+      "y": 100,
+      "w": 11,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "ë",
+      "x": 967,
+      "y": 100,
+      "w": 12,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "ì",
+      "x": 981,
+      "y": 100,
+      "w": 7,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "ì",
+      "x": 990,
+      "y": 100,
+      "w": 7,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "í",
+      "x": 999,
+      "y": 100,
+      "w": 7,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "í",
+      "x": 1008,
+      "y": 100,
+      "w": 7,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "î",
+      "x": 1017,
+      "y": 100,
+      "w": 10,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "î",
+      "x": 1029,
+      "y": 100,
+      "w": 10,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "ï",
+      "x": 1041,
+      "y": 100,
+      "w": 9,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "ï",
+      "x": 1052,
+      "y": 100,
+      "w": 10,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "ð",
+      "x": 1064,
+      "y": 100,
+      "w": 12,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "ð",
+      "x": 1078,
+      "y": 100,
+      "w": 13,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "ñ",
+      "x": 1093,
+      "y": 100,
+      "w": 11,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "ñ",
+      "x": 1106,
+      "y": 100,
+      "w": 12,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "ò",
+      "x": 1120,
+      "y": 100,
+      "w": 11,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "ò",
+      "x": 1133,
+      "y": 100,
+      "w": 11,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "ó",
+      "x": 1146,
+      "y": 100,
+      "w": 11,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "ó",
+      "x": 1159,
+      "y": 100,
+      "w": 11,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "ô",
+      "x": 1172,
+      "y": 100,
+      "w": 11,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "ô",
+      "x": 1185,
+      "y": 100,
+      "w": 11,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "õ",
+      "x": 1198,
+      "y": 100,
+      "w": 11,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "õ",
+      "x": 1211,
+      "y": 100,
+      "w": 11,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "ö",
+      "x": 1224,
+      "y": 100,
+      "w": 11,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "ö",
+      "x": 1237,
+      "y": 100,
+      "w": 11,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "÷",
+      "x": 1250,
+      "y": 100,
+      "w": 12,
+      "h": 11,
+      "source": "font"
+    },
+    {
+      "char": "÷",
+      "x": 1264,
+      "y": 100,
+      "w": 12,
+      "h": 12,
+      "source": "font"
+    },
+    {
+      "char": "ø",
+      "x": 1278,
+      "y": 100,
+      "w": 10,
+      "h": 15,
+      "source": "font"
+    },
+    {
+      "char": "ø",
+      "x": 1290,
+      "y": 100,
+      "w": 11,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "ù",
+      "x": 1303,
+      "y": 100,
+      "w": 11,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "ù",
+      "x": 1316,
+      "y": 100,
+      "w": 11,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "ú",
+      "x": 1329,
+      "y": 100,
+      "w": 11,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "ú",
+      "x": 1342,
+      "y": 100,
+      "w": 11,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "û",
+      "x": 1355,
+      "y": 100,
+      "w": 11,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "û",
+      "x": 1368,
+      "y": 100,
+      "w": 11,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "ü",
+      "x": 1381,
+      "y": 100,
+      "w": 11,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "ü",
+      "x": 1394,
+      "y": 100,
+      "w": 11,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "ý",
+      "x": 1407,
+      "y": 100,
+      "w": 11,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "ý",
+      "x": 1420,
+      "y": 100,
+      "w": 11,
+      "h": 24,
+      "source": "font"
+    },
+    {
+      "char": "þ",
+      "x": 1433,
+      "y": 100,
+      "w": 11,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "þ",
+      "x": 1446,
+      "y": 100,
+      "w": 11,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "ÿ",
+      "x": 1459,
+      "y": 100,
+      "w": 11,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "ÿ",
+      "x": 1472,
+      "y": 100,
+      "w": 11,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "ぁ",
+      "x": 1485,
+      "y": 100,
+      "w": 11,
+      "h": 15,
+      "source": "font"
+    },
+    {
+      "char": "ぁ",
+      "x": 1498,
+      "y": 100,
+      "w": 12,
+      "h": 15,
+      "source": "font"
+    },
+    {
+      "char": "あ",
+      "x": 1512,
+      "y": 100,
+      "w": 15,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "あ",
+      "x": 1529,
+      "y": 100,
+      "w": 16,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "ぃ",
+      "x": 1547,
+      "y": 100,
+      "w": 12,
+      "h": 14,
+      "source": "font"
+    },
+    {
+      "char": "ぃ",
+      "x": 1561,
+      "y": 100,
+      "w": 12,
+      "h": 14,
+      "source": "font"
+    },
+    {
+      "char": "い",
+      "x": 1575,
+      "y": 100,
+      "w": 14,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "い",
+      "x": 2,
+      "y": 127,
+      "w": 15,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "ぅ",
+      "x": 19,
+      "y": 127,
+      "w": 10,
+      "h": 15,
+      "source": "font"
+    },
+    {
+      "char": "ぅ",
+      "x": 31,
+      "y": 127,
+      "w": 11,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "う",
+      "x": 44,
+      "y": 127,
+      "w": 13,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "う",
+      "x": 59,
+      "y": 127,
+      "w": 13,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "ぇ",
+      "x": 74,
+      "y": 127,
+      "w": 12,
+      "h": 15,
+      "source": "font"
+    },
+    {
+      "char": "ぇ",
+      "x": 88,
+      "y": 127,
+      "w": 13,
+      "h": 15,
+      "source": "font"
+    },
+    {
+      "char": "え",
+      "x": 103,
+      "y": 127,
+      "w": 14,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "え",
+      "x": 119,
+      "y": 127,
+      "w": 14,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "ぉ",
+      "x": 135,
+      "y": 127,
+      "w": 13,
+      "h": 15,
+      "source": "font"
+    },
+    {
+      "char": "ぉ",
+      "x": 150,
+      "y": 127,
+      "w": 13,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "お",
+      "x": 165,
+      "y": 127,
+      "w": 15,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "お",
+      "x": 182,
+      "y": 127,
+      "w": 16,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "か",
+      "x": 200,
+      "y": 127,
+      "w": 14,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "か",
+      "x": 216,
+      "y": 127,
+      "w": 15,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "が",
+      "x": 233,
+      "y": 127,
+      "w": 14,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "が",
+      "x": 249,
+      "y": 127,
+      "w": 15,
+      "h": 24,
+      "source": "font"
+    },
+    {
+      "char": "き",
+      "x": 266,
+      "y": 127,
+      "w": 13,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "き",
+      "x": 281,
+      "y": 127,
+      "w": 13,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "ぎ",
+      "x": 296,
+      "y": 127,
+      "w": 13,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "ぎ",
+      "x": 311,
+      "y": 127,
+      "w": 14,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "く",
+      "x": 327,
+      "y": 127,
+      "w": 11,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "く",
+      "x": 340,
+      "y": 127,
+      "w": 11,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "ぐ",
+      "x": 353,
+      "y": 127,
+      "w": 13,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "ぐ",
+      "x": 368,
+      "y": 127,
+      "w": 13,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "け",
+      "x": 383,
+      "y": 127,
+      "w": 14,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "け",
+      "x": 399,
+      "y": 127,
+      "w": 15,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "げ",
+      "x": 416,
+      "y": 127,
+      "w": 14,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "げ",
+      "x": 432,
+      "y": 127,
+      "w": 15,
+      "h": 24,
+      "source": "font"
+    },
+    {
+      "char": "こ",
+      "x": 449,
+      "y": 127,
+      "w": 12,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "こ",
+      "x": 463,
+      "y": 127,
+      "w": 13,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "ご",
+      "x": 478,
+      "y": 127,
+      "w": 13,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "ご",
+      "x": 493,
+      "y": 127,
+      "w": 13,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "さ",
+      "x": 508,
+      "y": 127,
+      "w": 13,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "さ",
+      "x": 523,
+      "y": 127,
+      "w": 13,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "ざ",
+      "x": 538,
+      "y": 127,
+      "w": 13,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "ざ",
+      "x": 553,
+      "y": 127,
+      "w": 14,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "し",
+      "x": 569,
+      "y": 127,
+      "w": 12,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "し",
+      "x": 583,
+      "y": 127,
+      "w": 13,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "じ",
+      "x": 598,
+      "y": 127,
+      "w": 12,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "じ",
+      "x": 612,
+      "y": 127,
+      "w": 13,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "す",
+      "x": 627,
+      "y": 127,
+      "w": 13,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "す",
+      "x": 642,
+      "y": 127,
+      "w": 14,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "ず",
+      "x": 658,
+      "y": 127,
+      "w": 14,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "ず",
+      "x": 674,
+      "y": 127,
+      "w": 14,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "せ",
+      "x": 690,
+      "y": 127,
+      "w": 14,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "せ",
+      "x": 706,
+      "y": 127,
+      "w": 15,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "ぜ",
+      "x": 723,
+      "y": 127,
+      "w": 14,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "ぜ",
+      "x": 739,
+      "y": 127,
+      "w": 15,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "そ",
+      "x": 756,
+      "y": 127,
+      "w": 12,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "そ",
+      "x": 770,
+      "y": 127,
+      "w": 12,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "ぞ",
+      "x": 784,
+      "y": 127,
+      "w": 13,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "ぞ",
+      "x": 799,
+      "y": 127,
+      "w": 14,
+      "h": 24,
+      "source": "font"
+    },
+    {
+      "char": "た",
+      "x": 815,
+      "y": 127,
+      "w": 13,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "た",
+      "x": 830,
+      "y": 127,
+      "w": 14,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "だ",
+      "x": 846,
+      "y": 127,
+      "w": 13,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "だ",
+      "x": 861,
+      "y": 127,
+      "w": 14,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "ち",
+      "x": 877,
+      "y": 127,
+      "w": 13,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "ち",
+      "x": 892,
+      "y": 127,
+      "w": 13,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "ぢ",
+      "x": 907,
+      "y": 127,
+      "w": 13,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "ぢ",
+      "x": 922,
+      "y": 127,
+      "w": 13,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "っ",
+      "x": 937,
+      "y": 127,
+      "w": 11,
+      "h": 13,
+      "source": "font"
+    },
+    {
+      "char": "っ",
+      "x": 950,
+      "y": 127,
+      "w": 12,
+      "h": 14,
+      "source": "font"
+    },
+    {
+      "char": "つ",
+      "x": 964,
+      "y": 127,
+      "w": 13,
+      "h": 15,
+      "source": "font"
+    },
+    {
+      "char": "つ",
+      "x": 979,
+      "y": 127,
+      "w": 14,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "づ",
+      "x": 995,
+      "y": 127,
+      "w": 13,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "づ",
+      "x": 1010,
+      "y": 127,
+      "w": 14,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "て",
+      "x": 1026,
+      "y": 127,
+      "w": 12,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "て",
+      "x": 1040,
+      "y": 127,
+      "w": 13,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "で",
+      "x": 1055,
+      "y": 127,
+      "w": 12,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "で",
+      "x": 1069,
+      "y": 127,
+      "w": 13,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "と",
+      "x": 1084,
+      "y": 127,
+      "w": 12,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "と",
+      "x": 1098,
+      "y": 127,
+      "w": 12,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "ど",
+      "x": 1112,
+      "y": 127,
+      "w": 13,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "ど",
+      "x": 1127,
+      "y": 127,
+      "w": 13,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "な",
+      "x": 1142,
+      "y": 127,
+      "w": 16,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "な",
+      "x": 1160,
+      "y": 127,
+      "w": 16,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "に",
+      "x": 1178,
+      "y": 127,
+      "w": 13,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "に",
+      "x": 1193,
+      "y": 127,
+      "w": 14,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "ぬ",
+      "x": 1209,
+      "y": 127,
+      "w": 17,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "ぬ",
+      "x": 1228,
+      "y": 127,
+      "w": 17,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "ね",
+      "x": 1247,
+      "y": 127,
+      "w": 16,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "ね",
+      "x": 1265,
+      "y": 127,
+      "w": 16,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "の",
+      "x": 1283,
+      "y": 127,
+      "w": 14,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "の",
+      "x": 1299,
+      "y": 127,
+      "w": 15,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "は",
+      "x": 1316,
+      "y": 127,
+      "w": 16,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "は",
+      "x": 1334,
+      "y": 127,
+      "w": 17,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "ば",
+      "x": 1353,
+      "y": 127,
+      "w": 16,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "ば",
+      "x": 1371,
+      "y": 127,
+      "w": 17,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "ぱ",
+      "x": 1390,
+      "y": 127,
+      "w": 16,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "ぱ",
+      "x": 1408,
+      "y": 127,
+      "w": 17,
+      "h": 24,
+      "source": "font"
+    },
+    {
+      "char": "ひ",
+      "x": 1427,
+      "y": 127,
+      "w": 14,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "ひ",
+      "x": 1443,
+      "y": 127,
+      "w": 14,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "び",
+      "x": 1459,
+      "y": 127,
+      "w": 14,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "び",
+      "x": 1475,
+      "y": 127,
+      "w": 15,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "ぴ",
+      "x": 1492,
+      "y": 127,
+      "w": 14,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "ぴ",
+      "x": 1508,
+      "y": 127,
+      "w": 15,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "ふ",
+      "x": 1525,
+      "y": 127,
+      "w": 15,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "ふ",
+      "x": 1542,
+      "y": 127,
+      "w": 16,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "ぶ",
+      "x": 1560,
+      "y": 127,
+      "w": 15,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "ぶ",
+      "x": 1577,
+      "y": 127,
+      "w": 16,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "ぷ",
+      "x": 2,
+      "y": 153,
+      "w": 15,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "ぷ",
+      "x": 19,
+      "y": 153,
+      "w": 16,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "へ",
+      "x": 37,
+      "y": 153,
+      "w": 12,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "へ",
+      "x": 51,
+      "y": 153,
+      "w": 13,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "べ",
+      "x": 66,
+      "y": 153,
+      "w": 13,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "べ",
+      "x": 81,
+      "y": 153,
+      "w": 14,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "ぺ",
+      "x": 97,
+      "y": 153,
+      "w": 13,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "ぺ",
+      "x": 112,
+      "y": 153,
+      "w": 14,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "ほ",
+      "x": 128,
+      "y": 153,
+      "w": 15,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "ほ",
+      "x": 145,
+      "y": 153,
+      "w": 16,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "ぼ",
+      "x": 163,
+      "y": 153,
+      "w": 15,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "ぼ",
+      "x": 180,
+      "y": 153,
+      "w": 16,
+      "h": 24,
+      "source": "font"
+    },
+    {
+      "char": "ぽ",
+      "x": 198,
+      "y": 153,
+      "w": 15,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "ぽ",
+      "x": 215,
+      "y": 153,
+      "w": 16,
+      "h": 25,
+      "source": "font"
+    },
+    {
+      "char": "ま",
+      "x": 233,
+      "y": 153,
+      "w": 12,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "ま",
+      "x": 247,
+      "y": 153,
+      "w": 13,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "み",
+      "x": 262,
+      "y": 153,
+      "w": 15,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "み",
+      "x": 279,
+      "y": 153,
+      "w": 15,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "む",
+      "x": 296,
+      "y": 153,
+      "w": 17,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "む",
+      "x": 315,
+      "y": 153,
+      "w": 17,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "め",
+      "x": 334,
+      "y": 153,
+      "w": 17,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "め",
+      "x": 353,
+      "y": 153,
+      "w": 18,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "も",
+      "x": 373,
+      "y": 153,
+      "w": 12,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "も",
+      "x": 387,
+      "y": 153,
+      "w": 13,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "ゃ",
+      "x": 402,
+      "y": 153,
+      "w": 13,
+      "h": 15,
+      "source": "font"
+    },
+    {
+      "char": "ゃ",
+      "x": 417,
+      "y": 153,
+      "w": 13,
+      "h": 15,
+      "source": "font"
+    },
+    {
+      "char": "や",
+      "x": 432,
+      "y": 153,
+      "w": 14,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "や",
+      "x": 448,
+      "y": 153,
+      "w": 15,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "ゅ",
+      "x": 465,
+      "y": 153,
+      "w": 13,
+      "h": 15,
+      "source": "font"
+    },
+    {
+      "char": "ゅ",
+      "x": 480,
+      "y": 153,
+      "w": 13,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "ゆ",
+      "x": 495,
+      "y": 153,
+      "w": 15,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "ゆ",
+      "x": 512,
+      "y": 153,
+      "w": 16,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "ょ",
+      "x": 530,
+      "y": 153,
+      "w": 12,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "ょ",
+      "x": 544,
+      "y": 153,
+      "w": 12,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "よ",
+      "x": 558,
+      "y": 153,
+      "w": 14,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "よ",
+      "x": 574,
+      "y": 153,
+      "w": 14,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "ら",
+      "x": 590,
+      "y": 153,
+      "w": 12,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "ら",
+      "x": 604,
+      "y": 153,
+      "w": 13,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "り",
+      "x": 619,
+      "y": 153,
+      "w": 12,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "り",
+      "x": 633,
+      "y": 153,
+      "w": 12,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "る",
+      "x": 647,
+      "y": 153,
+      "w": 13,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "る",
+      "x": 662,
+      "y": 153,
+      "w": 13,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "れ",
+      "x": 677,
+      "y": 153,
+      "w": 15,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "れ",
+      "x": 694,
+      "y": 153,
+      "w": 16,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "ろ",
+      "x": 712,
+      "y": 153,
+      "w": 12,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "ろ",
+      "x": 726,
+      "y": 153,
+      "w": 13,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "ゎ",
+      "x": 741,
+      "y": 153,
+      "w": 13,
+      "h": 15,
+      "source": "font"
+    },
+    {
+      "char": "ゎ",
+      "x": 756,
+      "y": 153,
+      "w": 13,
+      "h": 15,
+      "source": "font"
+    },
+    {
+      "char": "わ",
+      "x": 771,
+      "y": 153,
+      "w": 15,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "わ",
+      "x": 788,
+      "y": 153,
+      "w": 16,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "を",
+      "x": 806,
+      "y": 153,
+      "w": 12,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "を",
+      "x": 820,
+      "y": 153,
+      "w": 13,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "ん",
+      "x": 835,
+      "y": 153,
+      "w": 13,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "ん",
+      "x": 850,
+      "y": 153,
+      "w": 14,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "ゔ",
+      "x": 866,
+      "y": 153,
+      "w": 13,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "ゔ",
+      "x": 881,
+      "y": 153,
+      "w": 14,
+      "h": 24,
+      "source": "font"
+    },
+    {
+      "char": "ゕ",
+      "x": 897,
+      "y": 153,
+      "w": 12,
+      "h": 15,
+      "source": "font"
+    },
+    {
+      "char": "ゕ",
+      "x": 911,
+      "y": 153,
+      "w": 13,
+      "h": 15,
+      "source": "font"
+    },
+    {
+      "char": "ゖ",
+      "x": 926,
+      "y": 153,
+      "w": 12,
+      "h": 15,
+      "source": "font"
+    },
+    {
+      "char": "ゖ",
+      "x": 940,
+      "y": 153,
+      "w": 12,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "ァ",
+      "x": 954,
+      "y": 153,
+      "w": 12,
+      "h": 14,
+      "source": "font"
+    },
+    {
+      "char": "ァ",
+      "x": 968,
+      "y": 153,
+      "w": 12,
+      "h": 15,
+      "source": "font"
+    },
+    {
+      "char": "ア",
+      "x": 982,
+      "y": 153,
+      "w": 15,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "ア",
+      "x": 999,
+      "y": 153,
+      "w": 15,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "ィ",
+      "x": 1016,
+      "y": 153,
+      "w": 10,
+      "h": 14,
+      "source": "font"
+    },
+    {
+      "char": "ィ",
+      "x": 1028,
+      "y": 153,
+      "w": 11,
+      "h": 15,
+      "source": "font"
+    },
+    {
+      "char": "イ",
+      "x": 1041,
+      "y": 153,
+      "w": 12,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "イ",
+      "x": 1055,
+      "y": 153,
+      "w": 12,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "ゥ",
+      "x": 1069,
+      "y": 153,
+      "w": 11,
+      "h": 14,
+      "source": "font"
+    },
+    {
+      "char": "ゥ",
+      "x": 1082,
+      "y": 153,
+      "w": 12,
+      "h": 15,
+      "source": "font"
+    },
+    {
+      "char": "ウ",
+      "x": 1096,
+      "y": 153,
+      "w": 13,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "ウ",
+      "x": 1111,
+      "y": 153,
+      "w": 14,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "ェ",
+      "x": 1127,
+      "y": 153,
+      "w": 10,
+      "h": 13,
+      "source": "font"
+    },
+    {
+      "char": "ェ",
+      "x": 1139,
+      "y": 153,
+      "w": 10,
+      "h": 14,
+      "source": "font"
+    },
+    {
+      "char": "エ",
+      "x": 1151,
+      "y": 153,
+      "w": 11,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "エ",
+      "x": 1164,
+      "y": 153,
+      "w": 12,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "ォ",
+      "x": 1178,
+      "y": 153,
+      "w": 11,
+      "h": 15,
+      "source": "font"
+    },
+    {
+      "char": "ォ",
+      "x": 1191,
+      "y": 153,
+      "w": 12,
+      "h": 15,
+      "source": "font"
+    },
+    {
+      "char": "オ",
+      "x": 1205,
+      "y": 153,
+      "w": 13,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "オ",
+      "x": 1220,
+      "y": 153,
+      "w": 14,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "カ",
+      "x": 1236,
+      "y": 153,
+      "w": 13,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "カ",
+      "x": 1251,
+      "y": 153,
+      "w": 13,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "ガ",
+      "x": 1266,
+      "y": 153,
+      "w": 13,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "ガ",
+      "x": 1281,
+      "y": 153,
+      "w": 14,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "キ",
+      "x": 1297,
+      "y": 153,
+      "w": 12,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "キ",
+      "x": 1311,
+      "y": 153,
+      "w": 13,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "ギ",
+      "x": 1326,
+      "y": 153,
+      "w": 14,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "ギ",
+      "x": 1342,
+      "y": 153,
+      "w": 14,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "ク",
+      "x": 1358,
+      "y": 153,
+      "w": 12,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "ク",
+      "x": 1372,
+      "y": 153,
+      "w": 13,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "グ",
+      "x": 1387,
+      "y": 153,
+      "w": 13,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "グ",
+      "x": 1402,
+      "y": 153,
+      "w": 14,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "ケ",
+      "x": 1418,
+      "y": 153,
+      "w": 13,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "ケ",
+      "x": 1433,
+      "y": 153,
+      "w": 14,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "ゲ",
+      "x": 1449,
+      "y": 153,
+      "w": 13,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "ゲ",
+      "x": 1464,
+      "y": 153,
+      "w": 14,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "コ",
+      "x": 1480,
+      "y": 153,
+      "w": 12,
+      "h": 15,
+      "source": "font"
+    },
+    {
+      "char": "コ",
+      "x": 1494,
+      "y": 153,
+      "w": 13,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "ゴ",
+      "x": 1509,
+      "y": 153,
+      "w": 12,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "ゴ",
+      "x": 1523,
+      "y": 153,
+      "w": 13,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "サ",
+      "x": 1538,
+      "y": 153,
+      "w": 15,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "サ",
+      "x": 1555,
+      "y": 153,
+      "w": 15,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "ザ",
+      "x": 1572,
+      "y": 153,
+      "w": 16,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "ザ",
+      "x": 2,
+      "y": 180,
+      "w": 16,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "シ",
+      "x": 20,
+      "y": 180,
+      "w": 14,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "シ",
+      "x": 36,
+      "y": 180,
+      "w": 14,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "ジ",
+      "x": 52,
+      "y": 180,
+      "w": 14,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "ジ",
+      "x": 68,
+      "y": 180,
+      "w": 14,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "ス",
+      "x": 84,
+      "y": 180,
+      "w": 13,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "ス",
+      "x": 99,
+      "y": 180,
+      "w": 14,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "ズ",
+      "x": 115,
+      "y": 180,
+      "w": 14,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "ズ",
+      "x": 131,
+      "y": 180,
+      "w": 15,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "セ",
+      "x": 148,
+      "y": 180,
+      "w": 14,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "セ",
+      "x": 164,
+      "y": 180,
+      "w": 15,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "ゼ",
+      "x": 181,
+      "y": 180,
+      "w": 14,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "ゼ",
+      "x": 197,
+      "y": 180,
+      "w": 15,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "ソ",
+      "x": 214,
+      "y": 180,
+      "w": 13,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "ソ",
+      "x": 229,
+      "y": 180,
+      "w": 14,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "ゾ",
+      "x": 245,
+      "y": 180,
+      "w": 13,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "ゾ",
+      "x": 260,
+      "y": 180,
+      "w": 14,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "タ",
+      "x": 276,
+      "y": 180,
+      "w": 13,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "タ",
+      "x": 291,
+      "y": 180,
+      "w": 14,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "ダ",
+      "x": 307,
+      "y": 180,
+      "w": 13,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "ダ",
+      "x": 322,
+      "y": 180,
+      "w": 14,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "チ",
+      "x": 338,
+      "y": 180,
+      "w": 12,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "チ",
+      "x": 352,
+      "y": 180,
+      "w": 13,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "ヂ",
+      "x": 367,
+      "y": 180,
+      "w": 12,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "ヂ",
+      "x": 381,
+      "y": 180,
+      "w": 13,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "ッ",
+      "x": 396,
+      "y": 180,
+      "w": 12,
+      "h": 13,
+      "source": "font"
+    },
+    {
+      "char": "ッ",
+      "x": 410,
+      "y": 180,
+      "w": 13,
+      "h": 14,
+      "source": "font"
+    },
+    {
+      "char": "ツ",
+      "x": 425,
+      "y": 180,
+      "w": 14,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "ツ",
+      "x": 441,
+      "y": 180,
+      "w": 15,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "ヅ",
+      "x": 458,
+      "y": 180,
+      "w": 14,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "ヅ",
+      "x": 474,
+      "y": 180,
+      "w": 15,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "テ",
+      "x": 491,
+      "y": 180,
+      "w": 13,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "テ",
+      "x": 506,
+      "y": 180,
+      "w": 14,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "デ",
+      "x": 522,
+      "y": 180,
+      "w": 14,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "デ",
+      "x": 538,
+      "y": 180,
+      "w": 14,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "ト",
+      "x": 554,
+      "y": 180,
+      "w": 12,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "ト",
+      "x": 568,
+      "y": 180,
+      "w": 12,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "ド",
+      "x": 582,
+      "y": 180,
+      "w": 12,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "ド",
+      "x": 596,
+      "y": 180,
+      "w": 13,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "ナ",
+      "x": 611,
+      "y": 180,
+      "w": 13,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "ナ",
+      "x": 626,
+      "y": 180,
+      "w": 13,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "ニ",
+      "x": 641,
+      "y": 180,
+      "w": 12,
+      "h": 15,
+      "source": "font"
+    },
+    {
+      "char": "ニ",
+      "x": 655,
+      "y": 180,
+      "w": 12,
+      "h": 15,
+      "source": "font"
+    },
+    {
+      "char": "ヌ",
+      "x": 669,
+      "y": 180,
+      "w": 13,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "ヌ",
+      "x": 684,
+      "y": 180,
+      "w": 13,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "ネ",
+      "x": 699,
+      "y": 180,
+      "w": 12,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "ネ",
+      "x": 713,
+      "y": 180,
+      "w": 13,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "ノ",
+      "x": 728,
+      "y": 180,
+      "w": 12,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "ノ",
+      "x": 742,
+      "y": 180,
+      "w": 12,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "ハ",
+      "x": 756,
+      "y": 180,
+      "w": 13,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "ハ",
+      "x": 771,
+      "y": 180,
+      "w": 14,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "バ",
+      "x": 787,
+      "y": 180,
+      "w": 13,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "バ",
+      "x": 802,
+      "y": 180,
+      "w": 14,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "パ",
+      "x": 818,
+      "y": 180,
+      "w": 13,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "パ",
+      "x": 833,
+      "y": 180,
+      "w": 14,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "ヒ",
+      "x": 849,
+      "y": 180,
+      "w": 12,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "ヒ",
+      "x": 863,
+      "y": 180,
+      "w": 13,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "ビ",
+      "x": 878,
+      "y": 180,
+      "w": 12,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "ビ",
+      "x": 892,
+      "y": 180,
+      "w": 13,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "ピ",
+      "x": 907,
+      "y": 180,
+      "w": 12,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "ピ",
+      "x": 921,
+      "y": 180,
+      "w": 13,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "フ",
+      "x": 936,
+      "y": 180,
+      "w": 13,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "フ",
+      "x": 951,
+      "y": 180,
+      "w": 13,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "ブ",
+      "x": 966,
+      "y": 180,
+      "w": 13,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "ブ",
+      "x": 981,
+      "y": 180,
+      "w": 13,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "プ",
+      "x": 996,
+      "y": 180,
+      "w": 13,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "プ",
+      "x": 1011,
+      "y": 180,
+      "w": 14,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "ヘ",
+      "x": 1027,
+      "y": 180,
+      "w": 12,
+      "h": 15,
+      "source": "font"
+    },
+    {
+      "char": "ヘ",
+      "x": 1041,
+      "y": 180,
+      "w": 13,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "ベ",
+      "x": 1056,
+      "y": 180,
+      "w": 13,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "ベ",
+      "x": 1071,
+      "y": 180,
+      "w": 13,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "ペ",
+      "x": 1086,
+      "y": 180,
+      "w": 13,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "ペ",
+      "x": 1101,
+      "y": 180,
+      "w": 13,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "ホ",
+      "x": 1116,
+      "y": 180,
+      "w": 15,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "ホ",
+      "x": 1133,
+      "y": 180,
+      "w": 16,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "ボ",
+      "x": 1151,
+      "y": 180,
+      "w": 15,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "ボ",
+      "x": 1168,
+      "y": 180,
+      "w": 16,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "ポ",
+      "x": 1186,
+      "y": 180,
+      "w": 15,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "ポ",
+      "x": 1203,
+      "y": 180,
+      "w": 16,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "マ",
+      "x": 1221,
+      "y": 180,
+      "w": 13,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "マ",
+      "x": 1236,
+      "y": 180,
+      "w": 13,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "ミ",
+      "x": 1251,
+      "y": 180,
+      "w": 12,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "ミ",
+      "x": 1265,
+      "y": 180,
+      "w": 13,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "ム",
+      "x": 1280,
+      "y": 180,
+      "w": 14,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "ム",
+      "x": 1296,
+      "y": 180,
+      "w": 15,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "メ",
+      "x": 1313,
+      "y": 180,
+      "w": 12,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "メ",
+      "x": 1327,
+      "y": 180,
+      "w": 13,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "モ",
+      "x": 1342,
+      "y": 180,
+      "w": 12,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "モ",
+      "x": 1356,
+      "y": 180,
+      "w": 13,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "ャ",
+      "x": 1371,
+      "y": 180,
+      "w": 12,
+      "h": 15,
+      "source": "font"
+    },
+    {
+      "char": "ャ",
+      "x": 1385,
+      "y": 180,
+      "w": 13,
+      "h": 15,
+      "source": "font"
+    },
+    {
+      "char": "ヤ",
+      "x": 1400,
+      "y": 180,
+      "w": 14,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "ヤ",
+      "x": 1416,
+      "y": 180,
+      "w": 15,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "ュ",
+      "x": 1433,
+      "y": 180,
+      "w": 11,
+      "h": 12,
+      "source": "font"
+    },
+    {
+      "char": "ュ",
+      "x": 1446,
+      "y": 180,
+      "w": 12,
+      "h": 13,
+      "source": "font"
+    },
+    {
+      "char": "ユ",
+      "x": 1460,
+      "y": 180,
+      "w": 13,
+      "h": 15,
+      "source": "font"
+    },
+    {
+      "char": "ユ",
+      "x": 1475,
+      "y": 180,
+      "w": 14,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "ョ",
+      "x": 1491,
+      "y": 180,
+      "w": 11,
+      "h": 14,
+      "source": "font"
+    },
+    {
+      "char": "ョ",
+      "x": 1504,
+      "y": 180,
+      "w": 11,
+      "h": 14,
+      "source": "font"
+    },
+    {
+      "char": "ヨ",
+      "x": 1517,
+      "y": 180,
+      "w": 13,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "ヨ",
+      "x": 1532,
+      "y": 180,
+      "w": 13,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "ラ",
+      "x": 1547,
+      "y": 180,
+      "w": 13,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "ラ",
+      "x": 1562,
+      "y": 180,
+      "w": 13,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "リ",
+      "x": 1577,
+      "y": 180,
+      "w": 12,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "リ",
+      "x": 2,
+      "y": 205,
+      "w": 13,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "ル",
+      "x": 17,
+      "y": 205,
+      "w": 15,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "ル",
+      "x": 34,
+      "y": 205,
+      "w": 16,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "レ",
+      "x": 52,
+      "y": 205,
+      "w": 12,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "レ",
+      "x": 66,
+      "y": 205,
+      "w": 13,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "ロ",
+      "x": 81,
+      "y": 205,
+      "w": 13,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "ロ",
+      "x": 96,
+      "y": 205,
+      "w": 14,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "ヮ",
+      "x": 112,
+      "y": 205,
+      "w": 12,
+      "h": 15,
+      "source": "font"
+    },
+    {
+      "char": "ヮ",
+      "x": 126,
+      "y": 205,
+      "w": 13,
+      "h": 15,
+      "source": "font"
+    },
+    {
+      "char": "ワ",
+      "x": 141,
+      "y": 205,
+      "w": 14,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "ワ",
+      "x": 157,
+      "y": 205,
+      "w": 15,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "ヲ",
+      "x": 174,
+      "y": 205,
+      "w": 13,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "ヲ",
+      "x": 189,
+      "y": 205,
+      "w": 13,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "ン",
+      "x": 204,
+      "y": 205,
+      "w": 13,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "ン",
+      "x": 219,
+      "y": 205,
+      "w": 14,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "ヴ",
+      "x": 235,
+      "y": 205,
+      "w": 14,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "ヴ",
+      "x": 251,
+      "y": 205,
+      "w": 14,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "ヵ",
+      "x": 267,
+      "y": 205,
+      "w": 12,
+      "h": 15,
+      "source": "font"
+    },
+    {
+      "char": "ヵ",
+      "x": 281,
+      "y": 205,
+      "w": 12,
+      "h": 15,
+      "source": "font"
+    },
+    {
+      "char": "ヶ",
+      "x": 295,
+      "y": 205,
+      "w": 11,
+      "h": 15,
+      "source": "font"
+    },
+    {
+      "char": "ヶ",
+      "x": 308,
+      "y": 205,
+      "w": 11,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "・",
+      "x": 321,
+      "y": 205,
+      "w": 6,
+      "h": 6,
+      "source": "font"
+    },
+    {
+      "char": "・",
+      "x": 329,
+      "y": 205,
+      "w": 6,
+      "h": 6,
+      "source": "font"
+    },
+    {
+      "char": "ー",
+      "x": 337,
+      "y": 205,
+      "w": 11,
+      "h": 6,
+      "source": "font"
+    },
+    {
+      "char": "ー",
+      "x": 350,
+      "y": 205,
+      "w": 10,
+      "h": 6,
+      "source": "font"
+    },
+    {
+      "char": "、",
+      "x": 362,
+      "y": 205,
+      "w": 7,
+      "h": 6,
+      "source": "font"
+    },
+    {
+      "char": "、",
+      "x": 371,
+      "y": 205,
+      "w": 7,
+      "h": 7,
+      "source": "font"
+    },
+    {
+      "char": "。",
+      "x": 380,
+      "y": 205,
+      "w": 8,
+      "h": 7,
+      "source": "font"
+    },
+    {
+      "char": "。",
+      "x": 390,
+      "y": 205,
+      "w": 8,
+      "h": 8,
+      "source": "font"
+    },
+    {
+      "char": "「",
+      "x": 400,
+      "y": 205,
+      "w": 9,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "「",
+      "x": 411,
+      "y": 205,
+      "w": 10,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "」",
+      "x": 423,
+      "y": 205,
+      "w": 9,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "」",
+      "x": 434,
+      "y": 205,
+      "w": 9,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "★",
+      "x": 445,
+      "y": 205,
+      "w": 18,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "★",
+      "x": 465,
+      "y": 205,
+      "w": 19,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "☆",
+      "x": 486,
+      "y": 205,
+      "w": 18,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "☆",
+      "x": 506,
+      "y": 205,
+      "w": 19,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "•",
+      "x": 527,
+      "y": 205,
+      "w": 16,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "•",
+      "x": 545,
+      "y": 205,
+      "w": 17,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "♪",
+      "x": 564,
+      "y": 205,
+      "w": 14,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "♪",
+      "x": 580,
+      "y": 205,
+      "w": 15,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "ι",
+      "x": 597,
+      "y": 205,
+      "w": 8,
+      "h": 14,
+      "source": "font"
+    },
+    {
+      "char": "ι",
+      "x": 607,
+      "y": 205,
+      "w": 8,
+      "h": 15,
+      "source": "font"
+    },
+    {
+      "char": "α",
+      "x": 617,
+      "y": 205,
+      "w": 14,
+      "h": 14,
+      "source": "font"
+    },
+    {
+      "char": "α",
+      "x": 633,
+      "y": 205,
+      "w": 14,
+      "h": 15,
+      "source": "font"
+    },
+    {
+      "char": "′",
+      "x": 649,
+      "y": 205,
+      "w": 7,
+      "h": 8,
+      "source": "font"
+    },
+    {
+      "char": "′",
+      "x": 658,
+      "y": 205,
+      "w": 7,
+      "h": 8,
+      "source": "font"
+    },
+    {
+      "char": "‘",
+      "x": 667,
+      "y": 205,
+      "w": 6,
+      "h": 9,
+      "source": "font"
+    },
+    {
+      "char": "‘",
+      "x": 675,
+      "y": 205,
+      "w": 6,
+      "h": 9,
+      "source": "font"
+    },
+    {
+      "char": "’",
+      "x": 683,
+      "y": 205,
+      "w": 7,
+      "h": 9,
+      "source": "font"
+    },
+    {
+      "char": "’",
+      "x": 692,
+      "y": 205,
+      "w": 7,
+      "h": 9,
+      "source": "font"
+    },
+    {
+      "char": "‚",
+      "x": 701,
+      "y": 205,
+      "w": 7,
+      "h": 9,
+      "source": "font"
+    },
+    {
+      "char": "‚",
+      "x": 710,
+      "y": 205,
+      "w": 7,
+      "h": 9,
+      "source": "font"
+    },
+    {
+      "char": "‛",
+      "x": 719,
+      "y": 205,
+      "w": 7,
+      "h": 9,
+      "source": "font"
+    },
+    {
+      "char": "‛",
+      "x": 728,
+      "y": 205,
+      "w": 7,
+      "h": 9,
+      "source": "font"
+    },
+    {
+      "char": "…",
+      "x": 737,
+      "y": 205,
+      "w": 16,
+      "h": 6,
+      "source": "font"
+    },
+    {
+      "char": "…",
+      "x": 755,
+      "y": 205,
+      "w": 17,
+      "h": 6,
+      "source": "font"
+    },
+    {
+      "char": "″",
+      "x": 774,
+      "y": 205,
+      "w": 11,
+      "h": 8,
+      "source": "font"
+    },
+    {
+      "char": "″",
+      "x": 787,
+      "y": 205,
+      "w": 11,
+      "h": 8,
+      "source": "font"
+    },
+    {
+      "char": "“",
+      "x": 800,
+      "y": 205,
+      "w": 10,
+      "h": 9,
+      "source": "font"
+    },
+    {
+      "char": "“",
+      "x": 812,
+      "y": 205,
+      "w": 11,
+      "h": 9,
+      "source": "font"
+    },
+    {
+      "char": "”",
+      "x": 825,
+      "y": 205,
+      "w": 11,
+      "h": 9,
+      "source": "font"
+    },
+    {
+      "char": "”",
+      "x": 838,
+      "y": 205,
+      "w": 12,
+      "h": 9,
+      "source": "font"
+    },
+    {
+      "char": "„",
+      "x": 852,
+      "y": 205,
+      "w": 11,
+      "h": 9,
+      "source": "font"
+    },
+    {
+      "char": "„",
+      "x": 865,
+      "y": 205,
+      "w": 11,
+      "h": 9,
+      "source": "font"
+    },
+    {
+      "char": "←",
+      "x": 878,
+      "y": 205,
+      "w": 17,
+      "h": 11,
+      "source": "font"
+    },
+    {
+      "char": "←",
+      "x": 897,
+      "y": 205,
+      "w": 16,
+      "h": 12,
+      "source": "font"
+    },
+    {
+      "char": "→",
+      "x": 915,
+      "y": 205,
+      "w": 16,
+      "h": 12,
+      "source": "font"
+    },
+    {
+      "char": "→",
+      "x": 933,
+      "y": 205,
+      "w": 16,
+      "h": 12,
+      "source": "font"
+    },
+    {
+      "char": "↑",
+      "x": 951,
+      "y": 205,
+      "w": 12,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "↑",
+      "x": 965,
+      "y": 205,
+      "w": 13,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "↓",
+      "x": 980,
+      "y": 205,
+      "w": 12,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "↓",
+      "x": 994,
+      "y": 205,
+      "w": 13,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "⇒",
+      "x": 1009,
+      "y": 205,
+      "w": 16,
+      "h": 12,
+      "source": "font"
+    },
+    {
+      "char": "⇒",
+      "x": 1027,
+      "y": 205,
+      "w": 16,
+      "h": 12,
+      "source": "font"
+    },
+    {
+      "char": "⇔",
+      "x": 1045,
+      "y": 205,
+      "w": 18,
+      "h": 12,
+      "source": "font"
+    },
+    {
+      "char": "⇔",
+      "x": 1065,
+      "y": 205,
+      "w": 19,
+      "h": 12,
+      "source": "font"
+    },
+    {
+      "char": "˜",
+      "x": 1086,
+      "y": 205,
+      "w": 11,
+      "h": 6,
+      "source": "font"
+    },
+    {
+      "char": "˜",
+      "x": 1099,
+      "y": 205,
+      "w": 12,
+      "h": 7,
+      "source": "font"
+    },
+    {
+      "char": "€",
+      "x": 1113,
+      "y": 205,
+      "w": 12,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "€",
+      "x": 1127,
+      "y": 205,
+      "w": 13,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "∞",
+      "x": 1142,
+      "y": 205,
+      "w": 16,
+      "h": 10,
+      "source": "font"
+    },
+    {
+      "char": "∞",
+      "x": 1160,
+      "y": 205,
+      "w": 17,
+      "h": 11,
+      "source": "font"
+    },
+    {
+      "char": "√",
+      "x": 1179,
+      "y": 205,
+      "w": 19,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "√",
+      "x": 1200,
+      "y": 205,
+      "w": 19,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "∀",
+      "x": 1221,
+      "y": 205,
+      "w": 13,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "∀",
+      "x": 1236,
+      "y": 205,
+      "w": 14,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "⊂",
+      "x": 1252,
+      "y": 205,
+      "w": 14,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "⊂",
+      "x": 1268,
+      "y": 205,
+      "w": 15,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "⊃",
+      "x": 1285,
+      "y": 205,
+      "w": 14,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "⊃",
+      "x": 1301,
+      "y": 205,
+      "w": 14,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "∴",
+      "x": 1317,
+      "y": 205,
+      "w": 13,
+      "h": 11,
+      "source": "font"
+    },
+    {
+      "char": "∴",
+      "x": 1332,
+      "y": 205,
+      "w": 13,
+      "h": 12,
+      "source": "font"
+    },
+    {
+      "char": "∵",
+      "x": 1347,
+      "y": 205,
+      "w": 13,
+      "h": 12,
+      "source": "font"
+    },
+    {
+      "char": "∵",
+      "x": 1362,
+      "y": 205,
+      "w": 13,
+      "h": 12,
+      "source": "font"
+    },
+    {
+      "char": "∂",
+      "x": 1377,
+      "y": 205,
+      "w": 11,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "∂",
+      "x": 1390,
+      "y": 205,
+      "w": 12,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "№",
+      "x": 1404,
+      "y": 205,
+      "w": 18,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "№",
+      "x": 1424,
+      "y": 205,
+      "w": 19,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "♭",
+      "x": 1445,
+      "y": 205,
+      "w": 10,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "♭",
+      "x": 1457,
+      "y": 205,
+      "w": 11,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "♀",
+      "x": 1470,
+      "y": 205,
+      "w": 12,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "♀",
+      "x": 1484,
+      "y": 205,
+      "w": 12,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "♂",
+      "x": 1498,
+      "y": 205,
+      "w": 15,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "♂",
+      "x": 1515,
+      "y": 205,
+      "w": 15,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "◎",
+      "x": 1532,
+      "y": 205,
+      "w": 18,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "◎",
+      "x": 1552,
+      "y": 205,
+      "w": 19,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "◇",
+      "x": 1573,
+      "y": 205,
+      "w": 15,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "◇",
+      "x": 2,
+      "y": 230,
+      "w": 16,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "◆",
+      "x": 20,
+      "y": 230,
+      "w": 15,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "◆",
+      "x": 37,
+      "y": 230,
+      "w": 16,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "△",
+      "x": 55,
+      "y": 230,
+      "w": 16,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "△",
+      "x": 73,
+      "y": 230,
+      "w": 17,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "▲",
+      "x": 92,
+      "y": 230,
+      "w": 16,
+      "h": 15,
+      "source": "font"
+    },
+    {
+      "char": "▲",
+      "x": 110,
+      "y": 230,
+      "w": 15,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "▽",
+      "x": 127,
+      "y": 230,
+      "w": 16,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "▽",
+      "x": 145,
+      "y": 230,
+      "w": 17,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "▼",
+      "x": 164,
+      "y": 230,
+      "w": 15,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "▼",
+      "x": 181,
+      "y": 230,
+      "w": 16,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "†",
+      "x": 199,
+      "y": 230,
+      "w": 10,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "†",
+      "x": 211,
+      "y": 230,
+      "w": 10,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "※",
+      "x": 223,
+      "y": 230,
+      "w": 17,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "※",
+      "x": 242,
+      "y": 230,
+      "w": 18,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "™",
+      "x": 262,
+      "y": 230,
+      "w": 14,
+      "h": 9,
+      "source": "font"
+    },
+    {
+      "char": "™",
+      "x": 278,
+      "y": 230,
+      "w": 15,
+      "h": 10,
+      "source": "font"
+    },
+    {
+      "char": "『",
+      "x": 295,
+      "y": 230,
+      "w": 11,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "『",
+      "x": 308,
+      "y": 230,
+      "w": 11,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "』",
+      "x": 321,
+      "y": 230,
+      "w": 11,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "』",
+      "x": 334,
+      "y": 230,
+      "w": 11,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "【",
+      "x": 347,
+      "y": 230,
+      "w": 9,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "【",
+      "x": 358,
+      "y": 230,
+      "w": 10,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "】",
+      "x": 370,
+      "y": 230,
+      "w": 9,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "】",
+      "x": 381,
+      "y": 230,
+      "w": 10,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "〈",
+      "x": 393,
+      "y": 230,
+      "w": 12,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "〈",
+      "x": 407,
+      "y": 230,
+      "w": 12,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "〉",
+      "x": 421,
+      "y": 230,
+      "w": 11,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "〉",
+      "x": 434,
+      "y": 230,
+      "w": 12,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "《",
+      "x": 448,
+      "y": 230,
+      "w": 16,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "《",
+      "x": 466,
+      "y": 230,
+      "w": 17,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "》",
+      "x": 485,
+      "y": 230,
+      "w": 16,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "》",
+      "x": 503,
+      "y": 230,
+      "w": 17,
+      "h": 20,
+      "source": "font"
+    },
+    {
+      "char": "〔",
+      "x": 522,
+      "y": 230,
+      "w": 8,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "〔",
+      "x": 532,
+      "y": 230,
+      "w": 9,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "〕",
+      "x": 543,
+      "y": 230,
+      "w": 9,
+      "h": 21,
+      "source": "font"
+    },
+    {
+      "char": "〕",
+      "x": 554,
+      "y": 230,
+      "w": 8,
+      "h": 22,
+      "source": "font"
+    },
+    {
+      "char": "々",
+      "x": 564,
+      "y": 230,
+      "w": 12,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "々",
+      "x": 578,
+      "y": 230,
+      "w": 14,
+      "h": 16,
+      "source": "font"
+    },
+    {
+      "char": "〆",
+      "x": 594,
+      "y": 230,
+      "w": 15,
+      "h": 17,
+      "source": "font"
+    },
+    {
+      "char": "〆",
+      "x": 611,
+      "y": 230,
+      "w": 16,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "〇",
+      "x": 629,
+      "y": 230,
+      "w": 16,
+      "h": 18,
+      "source": "font"
+    },
+    {
+      "char": "〇",
+      "x": 647,
+      "y": 230,
+      "w": 16,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "〃",
+      "x": 665,
+      "y": 230,
+      "w": 13,
+      "h": 10,
+      "source": "font"
+    },
+    {
+      "char": "〃",
+      "x": 680,
+      "y": 230,
+      "w": 14,
+      "h": 10,
+      "source": "font"
+    },
+    {
+      "char": "～",
+      "x": 696,
+      "y": 230,
+      "w": 16,
+      "h": 9,
+      "source": "font"
+    },
+    {
+      "char": "～",
+      "x": 714,
+      "y": 230,
+      "w": 17,
+      "h": 9,
+      "source": "font"
+    }
+  ]
+}
\ No newline at end of file
diff --git a/public/scanner/v1/glyphs/scoreboard-names.png b/public/scanner/v1/glyphs/scoreboard-names.png
new file mode 100644
index 000000000..718fea35f
Binary files /dev/null and b/public/scanner/v1/glyphs/scoreboard-names.png differ
diff --git a/public/scanner/v1/glyphs/scoreboard-paint-digits.json b/public/scanner/v1/glyphs/scoreboard-paint-digits.json
new file mode 100644
index 000000000..190e0eb5d
--- /dev/null
+++ b/public/scanner/v1/glyphs/scoreboard-paint-digits.json
@@ -0,0 +1,381 @@
+{
+  "height": 29,
+  "glyphs": [
+    {
+      "char": "0",
+      "x": 2,
+      "y": 2,
+      "w": 19,
+      "h": 31,
+      "source": "fixture"
+    },
+    {
+      "char": "0",
+      "x": 23,
+      "y": 2,
+      "w": 19,
+      "h": 30,
+      "source": "fixture"
+    },
+    {
+      "char": "0",
+      "x": 44,
+      "y": 2,
+      "w": 20,
+      "h": 30,
+      "source": "fixture"
+    },
+    {
+      "char": "0",
+      "x": 66,
+      "y": 2,
+      "w": 18,
+      "h": 30,
+      "source": "fixture"
+    },
+    {
+      "char": "1",
+      "x": 86,
+      "y": 2,
+      "w": 10,
+      "h": 30,
+      "source": "fixture"
+    },
+    {
+      "char": "1",
+      "x": 98,
+      "y": 2,
+      "w": 10,
+      "h": 30,
+      "source": "fixture"
+    },
+    {
+      "char": "1",
+      "x": 110,
+      "y": 2,
+      "w": 10,
+      "h": 30,
+      "source": "fixture"
+    },
+    {
+      "char": "1",
+      "x": 122,
+      "y": 2,
+      "w": 10,
+      "h": 30,
+      "source": "fixture"
+    },
+    {
+      "char": "2",
+      "x": 134,
+      "y": 2,
+      "w": 18,
+      "h": 31,
+      "source": "fixture"
+    },
+    {
+      "char": "2",
+      "x": 154,
+      "y": 2,
+      "w": 18,
+      "h": 31,
+      "source": "fixture"
+    },
+    {
+      "char": "2",
+      "x": 174,
+      "y": 2,
+      "w": 18,
+      "h": 30,
+      "source": "fixture"
+    },
+    {
+      "char": "2",
+      "x": 194,
+      "y": 2,
+      "w": 18,
+      "h": 30,
+      "source": "fixture"
+    },
+    {
+      "char": "3",
+      "x": 214,
+      "y": 2,
+      "w": 19,
+      "h": 30,
+      "source": "fixture"
+    },
+    {
+      "char": "3",
+      "x": 235,
+      "y": 2,
+      "w": 19,
+      "h": 30,
+      "source": "fixture"
+    },
+    {
+      "char": "3",
+      "x": 256,
+      "y": 2,
+      "w": 19,
+      "h": 30,
+      "source": "fixture"
+    },
+    {
+      "char": "3",
+      "x": 277,
+      "y": 2,
+      "w": 18,
+      "h": 30,
+      "source": "fixture"
+    },
+    {
+      "char": "4",
+      "x": 297,
+      "y": 2,
+      "w": 19,
+      "h": 30,
+      "source": "fixture"
+    },
+    {
+      "char": "4",
+      "x": 318,
+      "y": 2,
+      "w": 19,
+      "h": 31,
+      "source": "fixture"
+    },
+    {
+      "char": "4",
+      "x": 339,
+      "y": 2,
+      "w": 19,
+      "h": 30,
+      "source": "fixture"
+    },
+    {
+      "char": "4",
+      "x": 360,
+      "y": 2,
+      "w": 18,
+      "h": 30,
+      "source": "fixture"
+    },
+    {
+      "char": "5",
+      "x": 380,
+      "y": 2,
+      "w": 18,
+      "h": 31,
+      "source": "fixture"
+    },
+    {
+      "char": "5",
+      "x": 400,
+      "y": 2,
+      "w": 17,
+      "h": 31,
+      "source": "fixture"
+    },
+    {
+      "char": "5",
+      "x": 419,
+      "y": 2,
+      "w": 18,
+      "h": 30,
+      "source": "fixture"
+    },
+    {
+      "char": "5",
+      "x": 439,
+      "y": 2,
+      "w": 18,
+      "h": 30,
+      "source": "fixture"
+    },
+    {
+      "char": "6",
+      "x": 459,
+      "y": 2,
+      "w": 18,
+      "h": 30,
+      "source": "fixture"
+    },
+    {
+      "char": "6",
+      "x": 479,
+      "y": 2,
+      "w": 18,
+      "h": 30,
+      "source": "fixture"
+    },
+    {
+      "char": "6",
+      "x": 499,
+      "y": 2,
+      "w": 18,
+      "h": 30,
+      "source": "fixture"
+    },
+    {
+      "char": "6",
+      "x": 519,
+      "y": 2,
+      "w": 18,
+      "h": 30,
+      "source": "fixture"
+    },
+    {
+      "char": "7",
+      "x": 539,
+      "y": 2,
+      "w": 18,
+      "h": 30,
+      "source": "fixture"
+    },
+    {
+      "char": "7",
+      "x": 559,
+      "y": 2,
+      "w": 17,
+      "h": 30,
+      "source": "fixture"
+    },
+    {
+      "char": "7",
+      "x": 578,
+      "y": 2,
+      "w": 18,
+      "h": 30,
+      "source": "fixture"
+    },
+    {
+      "char": "7",
+      "x": 598,
+      "y": 2,
+      "w": 17,
+      "h": 29,
+      "source": "fixture"
+    },
+    {
+      "char": "8",
+      "x": 617,
+      "y": 2,
+      "w": 18,
+      "h": 31,
+      "source": "fixture"
+    },
+    {
+      "char": "8",
+      "x": 637,
+      "y": 2,
+      "w": 19,
+      "h": 31,
+      "source": "fixture"
+    },
+    {
+      "char": "9",
+      "x": 658,
+      "y": 2,
+      "w": 18,
+      "h": 31,
+      "source": "fixture"
+    },
+    {
+      "char": "9",
+      "x": 678,
+      "y": 2,
+      "w": 18,
+      "h": 31,
+      "source": "fixture"
+    },
+    {
+      "char": "9",
+      "x": 698,
+      "y": 2,
+      "w": 18,
+      "h": 30,
+      "source": "fixture"
+    },
+    {
+      "char": "0",
+      "x": 718,
+      "y": 2,
+      "w": 20,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "1",
+      "x": 740,
+      "y": 2,
+      "w": 11,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "2",
+      "x": 753,
+      "y": 2,
+      "w": 18,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "3",
+      "x": 773,
+      "y": 2,
+      "w": 19,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "4",
+      "x": 794,
+      "y": 2,
+      "w": 19,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "5",
+      "x": 815,
+      "y": 2,
+      "w": 17,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "6",
+      "x": 834,
+      "y": 2,
+      "w": 19,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "7",
+      "x": 855,
+      "y": 2,
+      "w": 17,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "8",
+      "x": 874,
+      "y": 2,
+      "w": 19,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "9",
+      "x": 895,
+      "y": 2,
+      "w": 19,
+      "h": 31,
+      "source": "font"
+    }
+  ]
+}
\ No newline at end of file
diff --git a/public/scanner/v1/glyphs/scoreboard-paint-digits.png b/public/scanner/v1/glyphs/scoreboard-paint-digits.png
new file mode 100644
index 000000000..d195751ce
Binary files /dev/null and b/public/scanner/v1/glyphs/scoreboard-paint-digits.png differ
diff --git a/public/scanner/v1/glyphs/scoreboard-replay-code.json b/public/scanner/v1/glyphs/scoreboard-replay-code.json
new file mode 100644
index 000000000..b367071f1
--- /dev/null
+++ b/public/scanner/v1/glyphs/scoreboard-replay-code.json
@@ -0,0 +1,1805 @@
+{
+  "height": 25,
+  "glyphs": [
+    {
+      "char": "-",
+      "x": 2,
+      "y": 2,
+      "w": 14,
+      "h": 8,
+      "source": "fixture"
+    },
+    {
+      "char": "-",
+      "x": 18,
+      "y": 2,
+      "w": 15,
+      "h": 8,
+      "source": "fixture"
+    },
+    {
+      "char": "-",
+      "x": 35,
+      "y": 2,
+      "w": 15,
+      "h": 8,
+      "source": "fixture"
+    },
+    {
+      "char": "-",
+      "x": 52,
+      "y": 2,
+      "w": 15,
+      "h": 8,
+      "source": "fixture"
+    },
+    {
+      "char": "-",
+      "x": 69,
+      "y": 2,
+      "w": 15,
+      "h": 8,
+      "source": "fixture"
+    },
+    {
+      "char": "-",
+      "x": 86,
+      "y": 2,
+      "w": 15,
+      "h": 8,
+      "source": "fixture"
+    },
+    {
+      "char": "-",
+      "x": 103,
+      "y": 2,
+      "w": 15,
+      "h": 8,
+      "source": "fixture"
+    },
+    {
+      "char": "-",
+      "x": 120,
+      "y": 2,
+      "w": 15,
+      "h": 8,
+      "source": "fixture"
+    },
+    {
+      "char": "-",
+      "x": 137,
+      "y": 2,
+      "w": 15,
+      "h": 8,
+      "source": "fixture"
+    },
+    {
+      "char": "-",
+      "x": 154,
+      "y": 2,
+      "w": 15,
+      "h": 8,
+      "source": "fixture"
+    },
+    {
+      "char": "-",
+      "x": 171,
+      "y": 2,
+      "w": 15,
+      "h": 8,
+      "source": "fixture"
+    },
+    {
+      "char": "-",
+      "x": 188,
+      "y": 2,
+      "w": 15,
+      "h": 8,
+      "source": "fixture"
+    },
+    {
+      "char": "-",
+      "x": 205,
+      "y": 2,
+      "w": 15,
+      "h": 8,
+      "source": "fixture"
+    },
+    {
+      "char": "-",
+      "x": 222,
+      "y": 2,
+      "w": 15,
+      "h": 8,
+      "source": "fixture"
+    },
+    {
+      "char": "-",
+      "x": 239,
+      "y": 2,
+      "w": 15,
+      "h": 8,
+      "source": "fixture"
+    },
+    {
+      "char": "-",
+      "x": 256,
+      "y": 2,
+      "w": 15,
+      "h": 8,
+      "source": "fixture"
+    },
+    {
+      "char": "-",
+      "x": 273,
+      "y": 2,
+      "w": 15,
+      "h": 8,
+      "source": "fixture"
+    },
+    {
+      "char": "-",
+      "x": 290,
+      "y": 2,
+      "w": 15,
+      "h": 8,
+      "source": "fixture"
+    },
+    {
+      "char": "0",
+      "x": 307,
+      "y": 2,
+      "w": 17,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "0",
+      "x": 326,
+      "y": 2,
+      "w": 18,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "0",
+      "x": 346,
+      "y": 2,
+      "w": 18,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "0",
+      "x": 366,
+      "y": 2,
+      "w": 18,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "1",
+      "x": 386,
+      "y": 2,
+      "w": 10,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "1",
+      "x": 398,
+      "y": 2,
+      "w": 10,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "1",
+      "x": 410,
+      "y": 2,
+      "w": 10,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "2",
+      "x": 422,
+      "y": 2,
+      "w": 17,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "3",
+      "x": 441,
+      "y": 2,
+      "w": 18,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "3",
+      "x": 461,
+      "y": 2,
+      "w": 18,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "3",
+      "x": 481,
+      "y": 2,
+      "w": 19,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "3",
+      "x": 502,
+      "y": 2,
+      "w": 18,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "3",
+      "x": 522,
+      "y": 2,
+      "w": 19,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "4",
+      "x": 543,
+      "y": 2,
+      "w": 17,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "4",
+      "x": 562,
+      "y": 2,
+      "w": 18,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "4",
+      "x": 582,
+      "y": 2,
+      "w": 18,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "4",
+      "x": 602,
+      "y": 2,
+      "w": 18,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "5",
+      "x": 622,
+      "y": 2,
+      "w": 17,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "5",
+      "x": 641,
+      "y": 2,
+      "w": 16,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "5",
+      "x": 659,
+      "y": 2,
+      "w": 16,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "6",
+      "x": 677,
+      "y": 2,
+      "w": 16,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "6",
+      "x": 695,
+      "y": 2,
+      "w": 17,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "7",
+      "x": 714,
+      "y": 2,
+      "w": 16,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "8",
+      "x": 732,
+      "y": 2,
+      "w": 18,
+      "h": 28,
+      "source": "fixture"
+    },
+    {
+      "char": "9",
+      "x": 752,
+      "y": 2,
+      "w": 17,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "A",
+      "x": 771,
+      "y": 2,
+      "w": 16,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "A",
+      "x": 789,
+      "y": 2,
+      "w": 17,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "A",
+      "x": 808,
+      "y": 2,
+      "w": 16,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "B",
+      "x": 826,
+      "y": 2,
+      "w": 16,
+      "h": 28,
+      "source": "fixture"
+    },
+    {
+      "char": "C",
+      "x": 844,
+      "y": 2,
+      "w": 16,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "C",
+      "x": 862,
+      "y": 2,
+      "w": 17,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "C",
+      "x": 881,
+      "y": 2,
+      "w": 16,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "C",
+      "x": 899,
+      "y": 2,
+      "w": 16,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "D",
+      "x": 917,
+      "y": 2,
+      "w": 16,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "D",
+      "x": 935,
+      "y": 2,
+      "w": 17,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "D",
+      "x": 954,
+      "y": 2,
+      "w": 17,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "D",
+      "x": 973,
+      "y": 2,
+      "w": 17,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "D",
+      "x": 992,
+      "y": 2,
+      "w": 17,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "E",
+      "x": 1011,
+      "y": 2,
+      "w": 15,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "E",
+      "x": 1028,
+      "y": 2,
+      "w": 15,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "E",
+      "x": 1045,
+      "y": 2,
+      "w": 15,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "E",
+      "x": 1062,
+      "y": 2,
+      "w": 15,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "F",
+      "x": 1079,
+      "y": 2,
+      "w": 15,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "F",
+      "x": 1096,
+      "y": 2,
+      "w": 15,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "F",
+      "x": 1113,
+      "y": 2,
+      "w": 15,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "F",
+      "x": 1130,
+      "y": 2,
+      "w": 14,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "G",
+      "x": 1146,
+      "y": 2,
+      "w": 17,
+      "h": 28,
+      "source": "fixture"
+    },
+    {
+      "char": "G",
+      "x": 1165,
+      "y": 2,
+      "w": 18,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "G",
+      "x": 1185,
+      "y": 2,
+      "w": 17,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "G",
+      "x": 1204,
+      "y": 2,
+      "w": 17,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "H",
+      "x": 1223,
+      "y": 2,
+      "w": 17,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "H",
+      "x": 1242,
+      "y": 2,
+      "w": 17,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "H",
+      "x": 1261,
+      "y": 2,
+      "w": 17,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "H",
+      "x": 1280,
+      "y": 2,
+      "w": 17,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "J",
+      "x": 1299,
+      "y": 2,
+      "w": 16,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "J",
+      "x": 1317,
+      "y": 2,
+      "w": 16,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "K",
+      "x": 1335,
+      "y": 2,
+      "w": 15,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "K",
+      "x": 1352,
+      "y": 2,
+      "w": 14,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "L",
+      "x": 1368,
+      "y": 2,
+      "w": 11,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "L",
+      "x": 1381,
+      "y": 2,
+      "w": 12,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "L",
+      "x": 1395,
+      "y": 2,
+      "w": 12,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "L",
+      "x": 1409,
+      "y": 2,
+      "w": 12,
+      "h": 28,
+      "source": "fixture"
+    },
+    {
+      "char": "M",
+      "x": 1423,
+      "y": 2,
+      "w": 20,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "M",
+      "x": 1445,
+      "y": 2,
+      "w": 21,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "N",
+      "x": 1468,
+      "y": 2,
+      "w": 17,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "N",
+      "x": 1487,
+      "y": 2,
+      "w": 18,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "P",
+      "x": 1507,
+      "y": 2,
+      "w": 17,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "P",
+      "x": 1526,
+      "y": 2,
+      "w": 17,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "P",
+      "x": 1545,
+      "y": 2,
+      "w": 17,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "Q",
+      "x": 1564,
+      "y": 2,
+      "w": 18,
+      "h": 33,
+      "source": "fixture"
+    },
+    {
+      "char": "Q",
+      "x": 2,
+      "y": 37,
+      "w": 18,
+      "h": 33,
+      "source": "fixture"
+    },
+    {
+      "char": "R",
+      "x": 22,
+      "y": 37,
+      "w": 16,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "R",
+      "x": 40,
+      "y": 37,
+      "w": 16,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "R",
+      "x": 58,
+      "y": 37,
+      "w": 16,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "R",
+      "x": 76,
+      "y": 37,
+      "w": 16,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "R",
+      "x": 94,
+      "y": 37,
+      "w": 16,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "R",
+      "x": 112,
+      "y": 37,
+      "w": 16,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "S",
+      "x": 130,
+      "y": 37,
+      "w": 17,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "T",
+      "x": 149,
+      "y": 37,
+      "w": 17,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "U",
+      "x": 168,
+      "y": 37,
+      "w": 17,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "U",
+      "x": 187,
+      "y": 37,
+      "w": 17,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "U",
+      "x": 206,
+      "y": 37,
+      "w": 18,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "V",
+      "x": 226,
+      "y": 37,
+      "w": 16,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "V",
+      "x": 244,
+      "y": 37,
+      "w": 18,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "V",
+      "x": 264,
+      "y": 37,
+      "w": 17,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "W",
+      "x": 283,
+      "y": 37,
+      "w": 23,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "W",
+      "x": 308,
+      "y": 37,
+      "w": 23,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "W",
+      "x": 333,
+      "y": 37,
+      "w": 23,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "W",
+      "x": 358,
+      "y": 37,
+      "w": 23,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "X",
+      "x": 383,
+      "y": 37,
+      "w": 14,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "X",
+      "x": 399,
+      "y": 37,
+      "w": 14,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "X",
+      "x": 415,
+      "y": 37,
+      "w": 14,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "X",
+      "x": 431,
+      "y": 37,
+      "w": 14,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "X",
+      "x": 447,
+      "y": 37,
+      "w": 15,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "Y",
+      "x": 464,
+      "y": 37,
+      "w": 16,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "Y",
+      "x": 482,
+      "y": 37,
+      "w": 16,
+      "h": 27,
+      "source": "fixture"
+    },
+    {
+      "char": "0",
+      "x": 500,
+      "y": 37,
+      "w": 23,
+      "h": 26,
+      "source": "font"
+    },
+    {
+      "char": "0",
+      "x": 525,
+      "y": 37,
+      "w": 24,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "0",
+      "x": 551,
+      "y": 37,
+      "w": 24,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "1",
+      "x": 577,
+      "y": 37,
+      "w": 16,
+      "h": 26,
+      "source": "font"
+    },
+    {
+      "char": "1",
+      "x": 595,
+      "y": 37,
+      "w": 17,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "1",
+      "x": 614,
+      "y": 37,
+      "w": 17,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "2",
+      "x": 633,
+      "y": 37,
+      "w": 21,
+      "h": 26,
+      "source": "font"
+    },
+    {
+      "char": "2",
+      "x": 656,
+      "y": 37,
+      "w": 22,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "2",
+      "x": 680,
+      "y": 37,
+      "w": 22,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "3",
+      "x": 704,
+      "y": 37,
+      "w": 22,
+      "h": 26,
+      "source": "font"
+    },
+    {
+      "char": "3",
+      "x": 728,
+      "y": 37,
+      "w": 23,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "3",
+      "x": 753,
+      "y": 37,
+      "w": 24,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "4",
+      "x": 779,
+      "y": 37,
+      "w": 23,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "4",
+      "x": 804,
+      "y": 37,
+      "w": 23,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "4",
+      "x": 829,
+      "y": 37,
+      "w": 24,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "5",
+      "x": 855,
+      "y": 37,
+      "w": 22,
+      "h": 26,
+      "source": "font"
+    },
+    {
+      "char": "5",
+      "x": 879,
+      "y": 37,
+      "w": 23,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "5",
+      "x": 904,
+      "y": 37,
+      "w": 23,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "6",
+      "x": 929,
+      "y": 37,
+      "w": 23,
+      "h": 26,
+      "source": "font"
+    },
+    {
+      "char": "6",
+      "x": 954,
+      "y": 37,
+      "w": 24,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "6",
+      "x": 980,
+      "y": 37,
+      "w": 24,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "7",
+      "x": 1006,
+      "y": 37,
+      "w": 21,
+      "h": 26,
+      "source": "font"
+    },
+    {
+      "char": "7",
+      "x": 1029,
+      "y": 37,
+      "w": 22,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "7",
+      "x": 1053,
+      "y": 37,
+      "w": 23,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "8",
+      "x": 1078,
+      "y": 37,
+      "w": 23,
+      "h": 26,
+      "source": "font"
+    },
+    {
+      "char": "8",
+      "x": 1103,
+      "y": 37,
+      "w": 24,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "8",
+      "x": 1129,
+      "y": 37,
+      "w": 24,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "9",
+      "x": 1155,
+      "y": 37,
+      "w": 23,
+      "h": 26,
+      "source": "font"
+    },
+    {
+      "char": "9",
+      "x": 1180,
+      "y": 37,
+      "w": 23,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "9",
+      "x": 1205,
+      "y": 37,
+      "w": 24,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "A",
+      "x": 1231,
+      "y": 37,
+      "w": 27,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "A",
+      "x": 1260,
+      "y": 37,
+      "w": 28,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "A",
+      "x": 1290,
+      "y": 37,
+      "w": 29,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "B",
+      "x": 1321,
+      "y": 37,
+      "w": 23,
+      "h": 26,
+      "source": "font"
+    },
+    {
+      "char": "B",
+      "x": 1346,
+      "y": 37,
+      "w": 24,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "B",
+      "x": 1372,
+      "y": 37,
+      "w": 25,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "C",
+      "x": 1399,
+      "y": 37,
+      "w": 25,
+      "h": 26,
+      "source": "font"
+    },
+    {
+      "char": "C",
+      "x": 1426,
+      "y": 37,
+      "w": 26,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "C",
+      "x": 1454,
+      "y": 37,
+      "w": 27,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "D",
+      "x": 1483,
+      "y": 37,
+      "w": 25,
+      "h": 26,
+      "source": "font"
+    },
+    {
+      "char": "D",
+      "x": 1510,
+      "y": 37,
+      "w": 26,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "D",
+      "x": 1538,
+      "y": 37,
+      "w": 27,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "E",
+      "x": 1567,
+      "y": 37,
+      "w": 22,
+      "h": 26,
+      "source": "font"
+    },
+    {
+      "char": "E",
+      "x": 2,
+      "y": 72,
+      "w": 22,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "E",
+      "x": 26,
+      "y": 72,
+      "w": 23,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "F",
+      "x": 51,
+      "y": 72,
+      "w": 20,
+      "h": 26,
+      "source": "font"
+    },
+    {
+      "char": "F",
+      "x": 73,
+      "y": 72,
+      "w": 20,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "F",
+      "x": 95,
+      "y": 72,
+      "w": 21,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "G",
+      "x": 118,
+      "y": 72,
+      "w": 25,
+      "h": 26,
+      "source": "font"
+    },
+    {
+      "char": "G",
+      "x": 145,
+      "y": 72,
+      "w": 26,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "G",
+      "x": 173,
+      "y": 72,
+      "w": 27,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "H",
+      "x": 202,
+      "y": 72,
+      "w": 24,
+      "h": 26,
+      "source": "font"
+    },
+    {
+      "char": "H",
+      "x": 228,
+      "y": 72,
+      "w": 25,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "H",
+      "x": 255,
+      "y": 72,
+      "w": 25,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "I",
+      "x": 282,
+      "y": 72,
+      "w": 11,
+      "h": 26,
+      "source": "font"
+    },
+    {
+      "char": "I",
+      "x": 295,
+      "y": 72,
+      "w": 11,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "I",
+      "x": 308,
+      "y": 72,
+      "w": 12,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "J",
+      "x": 322,
+      "y": 72,
+      "w": 16,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "J",
+      "x": 340,
+      "y": 72,
+      "w": 16,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "J",
+      "x": 358,
+      "y": 72,
+      "w": 17,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "K",
+      "x": 377,
+      "y": 72,
+      "w": 24,
+      "h": 26,
+      "source": "font"
+    },
+    {
+      "char": "K",
+      "x": 403,
+      "y": 72,
+      "w": 25,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "K",
+      "x": 430,
+      "y": 72,
+      "w": 26,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "L",
+      "x": 458,
+      "y": 72,
+      "w": 20,
+      "h": 26,
+      "source": "font"
+    },
+    {
+      "char": "L",
+      "x": 480,
+      "y": 72,
+      "w": 21,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "L",
+      "x": 503,
+      "y": 72,
+      "w": 22,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "M",
+      "x": 527,
+      "y": 72,
+      "w": 28,
+      "h": 26,
+      "source": "font"
+    },
+    {
+      "char": "M",
+      "x": 557,
+      "y": 72,
+      "w": 29,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "M",
+      "x": 588,
+      "y": 72,
+      "w": 30,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "N",
+      "x": 620,
+      "y": 72,
+      "w": 24,
+      "h": 26,
+      "source": "font"
+    },
+    {
+      "char": "N",
+      "x": 646,
+      "y": 72,
+      "w": 25,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "N",
+      "x": 673,
+      "y": 72,
+      "w": 25,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "O",
+      "x": 700,
+      "y": 72,
+      "w": 26,
+      "h": 26,
+      "source": "font"
+    },
+    {
+      "char": "O",
+      "x": 728,
+      "y": 72,
+      "w": 27,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "O",
+      "x": 757,
+      "y": 72,
+      "w": 28,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "P",
+      "x": 787,
+      "y": 72,
+      "w": 22,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "P",
+      "x": 811,
+      "y": 72,
+      "w": 23,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "P",
+      "x": 836,
+      "y": 72,
+      "w": 24,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "Q",
+      "x": 862,
+      "y": 72,
+      "w": 27,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "Q",
+      "x": 891,
+      "y": 72,
+      "w": 28,
+      "h": 33,
+      "source": "font"
+    },
+    {
+      "char": "Q",
+      "x": 921,
+      "y": 72,
+      "w": 29,
+      "h": 34,
+      "source": "font"
+    },
+    {
+      "char": "R",
+      "x": 952,
+      "y": 72,
+      "w": 23,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "R",
+      "x": 977,
+      "y": 72,
+      "w": 24,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "R",
+      "x": 1003,
+      "y": 72,
+      "w": 25,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "S",
+      "x": 1030,
+      "y": 72,
+      "w": 23,
+      "h": 26,
+      "source": "font"
+    },
+    {
+      "char": "S",
+      "x": 1055,
+      "y": 72,
+      "w": 24,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "S",
+      "x": 1081,
+      "y": 72,
+      "w": 24,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "T",
+      "x": 1107,
+      "y": 72,
+      "w": 22,
+      "h": 26,
+      "source": "font"
+    },
+    {
+      "char": "T",
+      "x": 1131,
+      "y": 72,
+      "w": 23,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "T",
+      "x": 1156,
+      "y": 72,
+      "w": 24,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "U",
+      "x": 1182,
+      "y": 72,
+      "w": 24,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "U",
+      "x": 1208,
+      "y": 72,
+      "w": 25,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "U",
+      "x": 1235,
+      "y": 72,
+      "w": 25,
+      "h": 29,
+      "source": "font"
+    },
+    {
+      "char": "V",
+      "x": 1262,
+      "y": 72,
+      "w": 26,
+      "h": 26,
+      "source": "font"
+    },
+    {
+      "char": "V",
+      "x": 1290,
+      "y": 72,
+      "w": 26,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "V",
+      "x": 1318,
+      "y": 72,
+      "w": 27,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "W",
+      "x": 1347,
+      "y": 72,
+      "w": 33,
+      "h": 26,
+      "source": "font"
+    },
+    {
+      "char": "W",
+      "x": 1382,
+      "y": 72,
+      "w": 34,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "W",
+      "x": 1418,
+      "y": 72,
+      "w": 35,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "X",
+      "x": 1455,
+      "y": 72,
+      "w": 25,
+      "h": 26,
+      "source": "font"
+    },
+    {
+      "char": "X",
+      "x": 1482,
+      "y": 72,
+      "w": 25,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "X",
+      "x": 1509,
+      "y": 72,
+      "w": 26,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "Y",
+      "x": 1537,
+      "y": 72,
+      "w": 24,
+      "h": 26,
+      "source": "font"
+    },
+    {
+      "char": "Y",
+      "x": 1563,
+      "y": 72,
+      "w": 26,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "Y",
+      "x": 2,
+      "y": 108,
+      "w": 27,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "Z",
+      "x": 31,
+      "y": 108,
+      "w": 22,
+      "h": 26,
+      "source": "font"
+    },
+    {
+      "char": "Z",
+      "x": 55,
+      "y": 108,
+      "w": 23,
+      "h": 27,
+      "source": "font"
+    },
+    {
+      "char": "Z",
+      "x": 80,
+      "y": 108,
+      "w": 23,
+      "h": 28,
+      "source": "font"
+    },
+    {
+      "char": "-",
+      "x": 105,
+      "y": 108,
+      "w": 15,
+      "h": 8,
+      "source": "font"
+    },
+    {
+      "char": "-",
+      "x": 122,
+      "y": 108,
+      "w": 15,
+      "h": 9,
+      "source": "font"
+    },
+    {
+      "char": "-",
+      "x": 139,
+      "y": 108,
+      "w": 16,
+      "h": 9,
+      "source": "font"
+    }
+  ]
+}
\ No newline at end of file
diff --git a/public/scanner/v1/glyphs/scoreboard-replay-code.png b/public/scanner/v1/glyphs/scoreboard-replay-code.png
new file mode 100644
index 000000000..9cf145926
Binary files /dev/null and b/public/scanner/v1/glyphs/scoreboard-replay-code.png differ
diff --git a/public/scanner/v1/glyphs/scoreboard-replay-result.json b/public/scanner/v1/glyphs/scoreboard-replay-result.json
new file mode 100644
index 000000000..5062bec50
--- /dev/null
+++ b/public/scanner/v1/glyphs/scoreboard-replay-result.json
@@ -0,0 +1,517 @@
+{
+  "height": 30,
+  "glyphs": [
+    {
+      "char": "W",
+      "x": 2,
+      "y": 2,
+      "w": 39,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "W",
+      "x": 43,
+      "y": 2,
+      "w": 40,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "I",
+      "x": 85,
+      "y": 2,
+      "w": 12,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "I",
+      "x": 99,
+      "y": 2,
+      "w": 13,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "N",
+      "x": 114,
+      "y": 2,
+      "w": 27,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "N",
+      "x": 143,
+      "y": 2,
+      "w": 28,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "L",
+      "x": 173,
+      "y": 2,
+      "w": 23,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "L",
+      "x": 198,
+      "y": 2,
+      "w": 24,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "O",
+      "x": 224,
+      "y": 2,
+      "w": 31,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "O",
+      "x": 257,
+      "y": 2,
+      "w": 32,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "S",
+      "x": 291,
+      "y": 2,
+      "w": 27,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "S",
+      "x": 320,
+      "y": 2,
+      "w": 28,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "E",
+      "x": 350,
+      "y": 2,
+      "w": 25,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "E",
+      "x": 377,
+      "y": 2,
+      "w": 25,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": ".",
+      "x": 404,
+      "y": 2,
+      "w": 11,
+      "h": 9,
+      "source": "font"
+    },
+    {
+      "char": ".",
+      "x": 417,
+      "y": 2,
+      "w": 12,
+      "h": 9,
+      "source": "font"
+    },
+    {
+      "char": "i",
+      "x": 431,
+      "y": 2,
+      "w": 11,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "i",
+      "x": 444,
+      "y": 2,
+      "w": 11,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "e",
+      "x": 457,
+      "y": 2,
+      "w": 24,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "e",
+      "x": 483,
+      "y": 2,
+      "w": 25,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "g",
+      "x": 510,
+      "y": 2,
+      "w": 24,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "g",
+      "x": 536,
+      "y": 2,
+      "w": 25,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "!",
+      "x": 563,
+      "y": 2,
+      "w": 14,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "!",
+      "x": 579,
+      "y": 2,
+      "w": 15,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "V",
+      "x": 596,
+      "y": 2,
+      "w": 30,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "V",
+      "x": 628,
+      "y": 2,
+      "w": 31,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "r",
+      "x": 661,
+      "y": 2,
+      "w": 17,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "r",
+      "x": 680,
+      "y": 2,
+      "w": 17,
+      "h": 24,
+      "source": "font"
+    },
+    {
+      "char": "l",
+      "x": 699,
+      "y": 2,
+      "w": 11,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "l",
+      "x": 712,
+      "y": 2,
+      "w": 11,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "o",
+      "x": 725,
+      "y": 2,
+      "w": 25,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "o",
+      "x": 752,
+      "y": 2,
+      "w": 26,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "n",
+      "x": 780,
+      "y": 2,
+      "w": 23,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "n",
+      "x": 805,
+      "y": 2,
+      "w": 24,
+      "h": 24,
+      "source": "font"
+    },
+    {
+      "char": "C",
+      "x": 831,
+      "y": 2,
+      "w": 30,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "C",
+      "x": 863,
+      "y": 2,
+      "w": 30,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "T",
+      "x": 895,
+      "y": 2,
+      "w": 26,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "T",
+      "x": 923,
+      "y": 2,
+      "w": 27,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "R",
+      "x": 952,
+      "y": 2,
+      "w": 27,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "R",
+      "x": 981,
+      "y": 2,
+      "w": 28,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "Y",
+      "x": 1011,
+      "y": 2,
+      "w": 29,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "Y",
+      "x": 1042,
+      "y": 2,
+      "w": 30,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "D",
+      "x": 1074,
+      "y": 2,
+      "w": 29,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "D",
+      "x": 1105,
+      "y": 2,
+      "w": 30,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "F",
+      "x": 1137,
+      "y": 2,
+      "w": 23,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "F",
+      "x": 1162,
+      "y": 2,
+      "w": 23,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "A",
+      "x": 1187,
+      "y": 2,
+      "w": 32,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "A",
+      "x": 1221,
+      "y": 2,
+      "w": 33,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "¡",
+      "x": 1256,
+      "y": 2,
+      "w": 14,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "¡",
+      "x": 1272,
+      "y": 2,
+      "w": 15,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "c",
+      "x": 1289,
+      "y": 2,
+      "w": 23,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "c",
+      "x": 1314,
+      "y": 2,
+      "w": 24,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "t",
+      "x": 1340,
+      "y": 2,
+      "w": 16,
+      "h": 30,
+      "source": "font"
+    },
+    {
+      "char": "t",
+      "x": 1358,
+      "y": 2,
+      "w": 17,
+      "h": 30,
+      "source": "font"
+    },
+    {
+      "char": "a",
+      "x": 1377,
+      "y": 2,
+      "w": 24,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "a",
+      "x": 1403,
+      "y": 2,
+      "w": 25,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "é",
+      "x": 1430,
+      "y": 2,
+      "w": 24,
+      "h": 33,
+      "source": "font"
+    },
+    {
+      "char": "é",
+      "x": 1456,
+      "y": 2,
+      "w": 25,
+      "h": 33,
+      "source": "font"
+    },
+    {
+      "char": "f",
+      "x": 1483,
+      "y": 2,
+      "w": 17,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "f",
+      "x": 1502,
+      "y": 2,
+      "w": 17,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "G",
+      "x": 1521,
+      "y": 2,
+      "w": 30,
+      "h": 31,
+      "source": "font"
+    },
+    {
+      "char": "G",
+      "x": 1553,
+      "y": 2,
+      "w": 31,
+      "h": 32,
+      "source": "font"
+    },
+    {
+      "char": "w",
+      "x": 2,
+      "y": 37,
+      "w": 34,
+      "h": 23,
+      "source": "font"
+    },
+    {
+      "char": "w",
+      "x": 38,
+      "y": 37,
+      "w": 35,
+      "h": 23,
+      "source": "font"
+    }
+  ]
+}
\ No newline at end of file
diff --git a/public/scanner/v1/glyphs/scoreboard-replay-result.png b/public/scanner/v1/glyphs/scoreboard-replay-result.png
new file mode 100644
index 000000000..975a60abb
Binary files /dev/null and b/public/scanner/v1/glyphs/scoreboard-replay-result.png differ
diff --git a/public/scanner/v1/glyphs/scoreboard-stat-digits.json b/public/scanner/v1/glyphs/scoreboard-stat-digits.json
new file mode 100644
index 000000000..a92893ccd
--- /dev/null
+++ b/public/scanner/v1/glyphs/scoreboard-stat-digits.json
@@ -0,0 +1,373 @@
+{
+  "height": 17,
+  "glyphs": [
+    {
+      "char": "0",
+      "x": 2,
+      "y": 2,
+      "w": 12,
+      "h": 19,
+      "source": "fixture"
+    },
+    {
+      "char": "0",
+      "x": 16,
+      "y": 2,
+      "w": 12,
+      "h": 19,
+      "source": "fixture"
+    },
+    {
+      "char": "0",
+      "x": 30,
+      "y": 2,
+      "w": 12,
+      "h": 19,
+      "source": "fixture"
+    },
+    {
+      "char": "0",
+      "x": 44,
+      "y": 2,
+      "w": 12,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "1",
+      "x": 58,
+      "y": 2,
+      "w": 7,
+      "h": 19,
+      "source": "fixture"
+    },
+    {
+      "char": "1",
+      "x": 67,
+      "y": 2,
+      "w": 8,
+      "h": 19,
+      "source": "fixture"
+    },
+    {
+      "char": "1",
+      "x": 77,
+      "y": 2,
+      "w": 7,
+      "h": 19,
+      "source": "fixture"
+    },
+    {
+      "char": "1",
+      "x": 86,
+      "y": 2,
+      "w": 7,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "2",
+      "x": 95,
+      "y": 2,
+      "w": 12,
+      "h": 19,
+      "source": "fixture"
+    },
+    {
+      "char": "2",
+      "x": 109,
+      "y": 2,
+      "w": 11,
+      "h": 19,
+      "source": "fixture"
+    },
+    {
+      "char": "2",
+      "x": 122,
+      "y": 2,
+      "w": 12,
+      "h": 19,
+      "source": "fixture"
+    },
+    {
+      "char": "2",
+      "x": 136,
+      "y": 2,
+      "w": 12,
+      "h": 19,
+      "source": "fixture"
+    },
+    {
+      "char": "3",
+      "x": 150,
+      "y": 2,
+      "w": 12,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "3",
+      "x": 164,
+      "y": 2,
+      "w": 11,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "3",
+      "x": 177,
+      "y": 2,
+      "w": 12,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "3",
+      "x": 191,
+      "y": 2,
+      "w": 12,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "4",
+      "x": 205,
+      "y": 2,
+      "w": 12,
+      "h": 19,
+      "source": "fixture"
+    },
+    {
+      "char": "4",
+      "x": 219,
+      "y": 2,
+      "w": 11,
+      "h": 19,
+      "source": "fixture"
+    },
+    {
+      "char": "4",
+      "x": 232,
+      "y": 2,
+      "w": 12,
+      "h": 19,
+      "source": "fixture"
+    },
+    {
+      "char": "4",
+      "x": 246,
+      "y": 2,
+      "w": 11,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "5",
+      "x": 259,
+      "y": 2,
+      "w": 11,
+      "h": 19,
+      "source": "fixture"
+    },
+    {
+      "char": "5",
+      "x": 272,
+      "y": 2,
+      "w": 10,
+      "h": 19,
+      "source": "fixture"
+    },
+    {
+      "char": "5",
+      "x": 284,
+      "y": 2,
+      "w": 11,
+      "h": 19,
+      "source": "fixture"
+    },
+    {
+      "char": "5",
+      "x": 297,
+      "y": 2,
+      "w": 11,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "6",
+      "x": 310,
+      "y": 2,
+      "w": 12,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "6",
+      "x": 324,
+      "y": 2,
+      "w": 12,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "6",
+      "x": 338,
+      "y": 2,
+      "w": 12,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "6",
+      "x": 352,
+      "y": 2,
+      "w": 11,
+      "h": 17,
+      "source": "fixture"
+    },
+    {
+      "char": "7",
+      "x": 365,
+      "y": 2,
+      "w": 11,
+      "h": 19,
+      "source": "fixture"
+    },
+    {
+      "char": "7",
+      "x": 378,
+      "y": 2,
+      "w": 10,
+      "h": 19,
+      "source": "fixture"
+    },
+    {
+      "char": "8",
+      "x": 390,
+      "y": 2,
+      "w": 12,
+      "h": 19,
+      "source": "fixture"
+    },
+    {
+      "char": "8",
+      "x": 404,
+      "y": 2,
+      "w": 11,
+      "h": 19,
+      "source": "fixture"
+    },
+    {
+      "char": "8",
+      "x": 417,
+      "y": 2,
+      "w": 12,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "8",
+      "x": 431,
+      "y": 2,
+      "w": 11,
+      "h": 19,
+      "source": "fixture"
+    },
+    {
+      "char": "9",
+      "x": 444,
+      "y": 2,
+      "w": 11,
+      "h": 19,
+      "source": "fixture"
+    },
+    {
+      "char": "9",
+      "x": 457,
+      "y": 2,
+      "w": 10,
+      "h": 18,
+      "source": "fixture"
+    },
+    {
+      "char": "0",
+      "x": 469,
+      "y": 2,
+      "w": 12,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "1",
+      "x": 483,
+      "y": 2,
+      "w": 7,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "2",
+      "x": 492,
+      "y": 2,
+      "w": 12,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "3",
+      "x": 506,
+      "y": 2,
+      "w": 13,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "4",
+      "x": 521,
+      "y": 2,
+      "w": 12,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "5",
+      "x": 535,
+      "y": 2,
+      "w": 11,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "6",
+      "x": 548,
+      "y": 2,
+      "w": 12,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "7",
+      "x": 562,
+      "y": 2,
+      "w": 12,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "8",
+      "x": 576,
+      "y": 2,
+      "w": 12,
+      "h": 19,
+      "source": "font"
+    },
+    {
+      "char": "9",
+      "x": 590,
+      "y": 2,
+      "w": 12,
+      "h": 19,
+      "source": "font"
+    }
+  ]
+}
\ No newline at end of file
diff --git a/public/scanner/v1/glyphs/scoreboard-stat-digits.png b/public/scanner/v1/glyphs/scoreboard-stat-digits.png
new file mode 100644
index 000000000..56943e3ce
Binary files /dev/null and b/public/scanner/v1/glyphs/scoreboard-stat-digits.png differ
diff --git a/public/scanner/v1/glyphs/scoreboard-team-digits.json b/public/scanner/v1/glyphs/scoreboard-team-digits.json
new file mode 100644
index 000000000..6aa2a7103
--- /dev/null
+++ b/public/scanner/v1/glyphs/scoreboard-team-digits.json
@@ -0,0 +1,149 @@
+{
+  "height": 28,
+  "glyphs": [
+    {
+      "char": "0",
+      "x": 2,
+      "y": 2,
+      "w": 24,
+      "h": 28,
+      "source": "fixture"
+    },
+    {
+      "char": "0",
+      "x": 28,
+      "y": 2,
+      "w": 24,
+      "h": 28,
+      "source": "fixture"
+    },
+    {
+      "char": "0",
+      "x": 54,
+      "y": 2,
+      "w": 24,
+      "h": 28,
+      "source": "fixture"
+    },
+    {
+      "char": "0",
+      "x": 80,
+      "y": 2,
+      "w": 24,
+      "h": 28,
+      "source": "fixture"
+    },
+    {
+      "char": "5",
+      "x": 106,
+      "y": 2,
+      "w": 24,
+      "h": 29,
+      "source": "fixture"
+    },
+    {
+      "char": "5",
+      "x": 132,
+      "y": 2,
+      "w": 23,
+      "h": 29,
+      "source": "fixture"
+    },
+    {
+      "char": "5",
+      "x": 157,
+      "y": 2,
+      "w": 24,
+      "h": 29,
+      "source": "fixture"
+    },
+    {
+      "char": "5",
+      "x": 183,
+      "y": 2,
+      "w": 24,
+      "h": 29,
+      "source": "fixture"
+    },
+    {
+      "char": "0",
+      "x": 209,
+      "y": 2,
+      "w": 25,
+      "h": 30,
+      "source": "font"
+    },
+    {
+      "char": "1",
+      "x": 236,
+      "y": 2,
+      "w": 16,
+      "h": 30,
+      "source": "font"
+    },
+    {
+      "char": "2",
+      "x": 254,
+      "y": 2,
+      "w": 25,
+      "h": 30,
+      "source": "font"
+    },
+    {
+      "char": "3",
+      "x": 281,
+      "y": 2,
+      "w": 24,
+      "h": 30,
+      "source": "font"
+    },
+    {
+      "char": "4",
+      "x": 307,
+      "y": 2,
+      "w": 25,
+      "h": 30,
+      "source": "font"
+    },
+    {
+      "char": "5",
+      "x": 334,
+      "y": 2,
+      "w": 25,
+      "h": 30,
+      "source": "font"
+    },
+    {
+      "char": "6",
+      "x": 361,
+      "y": 2,
+      "w": 26,
+      "h": 30,
+      "source": "font"
+    },
+    {
+      "char": "7",
+      "x": 389,
+      "y": 2,
+      "w": 24,
+      "h": 30,
+      "source": "font"
+    },
+    {
+      "char": "8",
+      "x": 415,
+      "y": 2,
+      "w": 24,
+      "h": 30,
+      "source": "font"
+    },
+    {
+      "char": "9",
+      "x": 441,
+      "y": 2,
+      "w": 27,
+      "h": 30,
+      "source": "font"
+    }
+  ]
+}
\ No newline at end of file
diff --git a/public/scanner/v1/glyphs/scoreboard-team-digits.png b/public/scanner/v1/glyphs/scoreboard-team-digits.png
new file mode 100644
index 000000000..ea14d67a3
Binary files /dev/null and b/public/scanner/v1/glyphs/scoreboard-team-digits.png differ
diff --git a/public/scanner/v1/planner/manifest.json b/public/scanner/v1/planner/manifest.json
new file mode 100644
index 000000000..b5d9d8595
--- /dev/null
+++ b/public/scanner/v1/planner/manifest.json
@@ -0,0 +1,132 @@
+{
+  "width": 120,
+  "height": 68,
+  "cols": 5,
+  "keys": [
+    "0-CB",
+    "0-RM",
+    "0-SZ",
+    "0-TC",
+    "0-TW",
+    "1-CB",
+    "1-RM",
+    "1-SZ",
+    "1-TC",
+    "1-TW",
+    "2-CB",
+    "2-RM",
+    "2-SZ",
+    "2-TC",
+    "2-TW",
+    "3-CB",
+    "3-RM",
+    "3-SZ",
+    "3-TC",
+    "3-TW",
+    "4-CB",
+    "4-RM",
+    "4-SZ",
+    "4-TC",
+    "4-TW",
+    "5-CB",
+    "5-RM",
+    "5-SZ",
+    "5-TC",
+    "5-TW",
+    "6-CB",
+    "6-RM",
+    "6-SZ",
+    "6-TC",
+    "6-TW",
+    "7-CB",
+    "7-RM",
+    "7-SZ",
+    "7-TC",
+    "7-TW",
+    "8-CB",
+    "8-RM",
+    "8-SZ",
+    "8-TC",
+    "8-TW",
+    "9-CB",
+    "9-RM",
+    "9-SZ",
+    "9-TC",
+    "9-TW",
+    "10-CB",
+    "10-RM",
+    "10-SZ",
+    "10-TC",
+    "10-TW",
+    "11-CB",
+    "11-RM",
+    "11-SZ",
+    "11-TC",
+    "11-TW",
+    "12-CB",
+    "12-RM",
+    "12-SZ",
+    "12-TC",
+    "12-TW",
+    "13-CB",
+    "13-RM",
+    "13-SZ",
+    "13-TC",
+    "13-TW",
+    "14-CB",
+    "14-RM",
+    "14-SZ",
+    "14-TC",
+    "14-TW",
+    "15-CB",
+    "15-RM",
+    "15-SZ",
+    "15-TC",
+    "15-TW",
+    "16-CB",
+    "16-RM",
+    "16-SZ",
+    "16-TC",
+    "16-TW",
+    "17-CB",
+    "17-RM",
+    "17-SZ",
+    "17-TC",
+    "17-TW",
+    "18-CB",
+    "18-RM",
+    "18-SZ",
+    "18-TC",
+    "18-TW",
+    "19-CB",
+    "19-RM",
+    "19-SZ",
+    "19-TC",
+    "19-TW",
+    "20-CB",
+    "20-RM",
+    "20-SZ",
+    "20-TC",
+    "20-TW",
+    "21-CB",
+    "21-RM",
+    "21-SZ",
+    "21-TC",
+    "21-TW",
+    "22-CB",
+    "22-RM",
+    "22-SZ",
+    "22-TC",
+    "22-TW",
+    "23-CB",
+    "23-RM",
+    "23-SZ",
+    "23-TC",
+    "23-TW",
+    "24-CB",
+    "24-RM",
+    "24-SZ",
+    "24-TC",
+    "24-TW"
+  ]
+}
diff --git a/public/scanner/v1/planner/signatures.png b/public/scanner/v1/planner/signatures.png
new file mode 100644
index 000000000..98554a195
Binary files /dev/null and b/public/scanner/v1/planner/signatures.png differ
diff --git a/scripts/benchmark-db/cases.ts b/scripts/benchmark-db/cases.ts
index 188dd44bc..23590df60 100644
--- a/scripts/benchmark-db/cases.ts
+++ b/scripts/benchmark-db/cases.ts
@@ -17,6 +17,7 @@ import * as SkillRepository from "~/features/mmr/SkillRepository.server";
 import * as NotificationRepository from "~/features/notifications/NotificationRepository.server";
 import * as PlusSuggestionRepository from "~/features/plus-suggestions/PlusSuggestionRepository.server";
 import * as PlusVotingRepository from "~/features/plus-voting/PlusVotingRepository.server";
+import * as ScannerIngestRepository from "~/features/scanner-ingest/ScannerIngestRepository.server";
 import * as ScrimMapListRepository from "~/features/scrims/ScrimMapListRepository.server";
 import * as ScrimMapRepository from "~/features/scrims/ScrimMapRepository.server";
 import * as ScrimPostRepository from "~/features/scrims/ScrimPostRepository.server";
@@ -417,6 +418,87 @@ export function buildCases(fx: Fixtures): {
 		}),
 	);
 
+	// ScannerIngestRepository
+	add(
+		"ScannerIngestRepository.gamesPlayedByUserInTournament",
+		fx.scannerIngest,
+		(ingest) =>
+			ScannerIngestRepository.gamesPlayedByUserInTournament({
+				userId: ingest.povUserId,
+				tournamentId: ingest.tournamentId,
+			}),
+	);
+	add(
+		"ScannerIngestRepository.gamesPlayedByUserSince",
+		fx.scannerIngest,
+		(ingest) =>
+			ScannerIngestRepository.gamesPlayedByUserSince({
+				userId: ingest.povUserId,
+				since: ingest.sinceTimestamp,
+			}),
+	);
+	add(
+		"ScannerIngestRepository.castedGamesInTournament",
+		fx.castedTournamentId,
+		(tournamentId) =>
+			ScannerIngestRepository.castedGamesInTournament(tournamentId),
+	);
+	add(
+		"ScannerIngestRepository.gamesInGroupMatch",
+		fx.heavyGroupMatchId,
+		(groupMatchId) => ScannerIngestRepository.gamesInGroupMatch(groupMatchId),
+	);
+	add(
+		"ScannerIngestRepository.sendouqGamesPlayedByUserSince",
+		fx.scannerIngestSendouq,
+		(sendouq) =>
+			ScannerIngestRepository.sendouqGamesPlayedByUserSince({
+				userId: sendouq.userId,
+				since: sendouq.sinceTimestamp,
+			}),
+	);
+	add(
+		"ScannerIngestRepository.tournamentActivityAt",
+		fx.scannerIngest,
+		(ingest) =>
+			ScannerIngestRepository.tournamentActivityAt({
+				userId: ingest.povUserId,
+				at: ingest.atMs,
+			}),
+	);
+	add(
+		"ScannerIngestRepository.groupMatchIdAt",
+		fx.scannerIngestSendouq,
+		(sendouq) =>
+			ScannerIngestRepository.groupMatchIdAt({
+				userId: sendouq.userId,
+				at: sendouq.atMs,
+			}),
+	);
+	add(
+		"ScannerIngestRepository.staffTournamentIdsAt",
+		both(fx.calendarAuthorId, fx.scannerIngest),
+		([userId, ingest]) =>
+			ScannerIngestRepository.staffTournamentIdsAt({
+				userId,
+				at: ingest.atMs,
+			}),
+	);
+	add(
+		"ScannerIngestRepository.findScoreboardsByTournamentMatchId",
+		fx.heavyTournamentMatchId,
+		(tournamentMatchId) =>
+			ScannerIngestRepository.findScoreboardsByTournamentMatchId(
+				tournamentMatchId,
+			),
+	);
+	add(
+		"ScannerIngestRepository.gamesInTournamentMatch",
+		fx.heavyTournamentMatchId,
+		(tournamentMatchId) =>
+			ScannerIngestRepository.gamesInTournamentMatch(tournamentMatchId),
+	);
+
 	// ScrimMapListRepository
 	add(
 		"ScrimMapListRepository.findMapListsByScrimPostId",
diff --git a/scripts/benchmark-db/fixtures.ts b/scripts/benchmark-db/fixtures.ts
index bbabe34a1..13828e30e 100644
--- a/scripts/benchmark-db/fixtures.ts
+++ b/scripts/benchmark-db/fixtures.ts
@@ -1,4 +1,5 @@
 import { sub } from "date-fns";
+import { sql } from "kysely";
 import { db } from "~/db/sql";
 import type { Tables } from "~/db/tables";
 import type { SkillTeamIdentifier } from "~/features/mmr/mmr-utils";
@@ -97,6 +98,18 @@ export interface Fixtures {
 	apiTokenUserId: number | null;
 	logInLinkCode: string | null;
 	modNoteId: number | null;
+	scannerIngest: {
+		povUserId: number;
+		tournamentId: number;
+		atMs: number;
+		sinceTimestamp: number;
+	} | null;
+	scannerIngestSendouq: {
+		userId: number;
+		atMs: number;
+		sinceTimestamp: number;
+	} | null;
+	castedTournamentId: number | null;
 }
 
 /**
@@ -170,6 +183,9 @@ export async function resolveFixtures(): Promise<Fixtures> {
 		apiTokenUserId: await resolveApiTokenUserId(),
 		logInLinkCode: await resolveLogInLinkCode(),
 		modNoteId: await resolveModNoteId(),
+		scannerIngest: await resolveScannerIngest(),
+		scannerIngestSendouq: await resolveScannerIngestSendouq(),
+		castedTournamentId: await resolveCastedTournamentId(),
 	};
 
 	const nullFixtures = Object.entries(fixtures)
@@ -1132,3 +1148,113 @@ async function resolveModNoteId() {
 
 	return row?.id ?? null;
 }
+
+const SCANNER_INGEST_SINCE_WINDOW_SECONDS = 365 * 24 * 60 * 60;
+
+async function resolveScannerIngest() {
+	const participantRow = await db
+		.selectFrom("TournamentMatchGameResultParticipant")
+		.select(({ fn }) => ["userId", fn.countAll<number>().as("count")])
+		.groupBy("userId")
+		.orderBy("count", "desc")
+		.limit(1)
+		.executeTakeFirst();
+	if (!participantRow) return null;
+
+	const latestGame = await db
+		.selectFrom("TournamentMatchGameResultParticipant")
+		.innerJoin(
+			"TournamentMatchGameResult",
+			"TournamentMatchGameResult.id",
+			"TournamentMatchGameResultParticipant.matchGameResultId",
+		)
+		.innerJoin(
+			"TournamentMatch",
+			"TournamentMatch.id",
+			"TournamentMatchGameResult.matchId",
+		)
+		.innerJoin(
+			"TournamentStage",
+			"TournamentStage.id",
+			"TournamentMatch.stageId",
+		)
+		.select([
+			"TournamentMatchGameResult.createdAt",
+			"TournamentStage.tournamentId",
+		])
+		.where(
+			"TournamentMatchGameResultParticipant.userId",
+			"=",
+			participantRow.userId,
+		)
+		.orderBy("TournamentMatchGameResult.createdAt", "desc")
+		.limit(1)
+		.executeTakeFirst();
+	if (!latestGame) return null;
+
+	return {
+		povUserId: participantRow.userId,
+		tournamentId: latestGame.tournamentId,
+		atMs: latestGame.createdAt * 1000,
+		sinceTimestamp: latestGame.createdAt - SCANNER_INGEST_SINCE_WINDOW_SECONDS,
+	};
+}
+
+async function resolveScannerIngestSendouq() {
+	const memberRow = await db
+		.selectFrom("GroupMember")
+		.select(({ fn }) => ["userId", fn.countAll<number>().as("count")])
+		.groupBy("userId")
+		.orderBy("count", "desc")
+		.limit(1)
+		.executeTakeFirst();
+	if (!memberRow) return null;
+
+	const latestMatch = await db
+		.selectFrom("GroupMatch")
+		.select("GroupMatch.createdAt")
+		.where((eb) =>
+			eb.exists(
+				eb
+					.selectFrom("GroupMember")
+					.select("GroupMember.userId")
+					.where("GroupMember.userId", "=", memberRow.userId)
+					.where((memberEb) =>
+						memberEb.or([
+							memberEb(
+								"GroupMember.groupId",
+								"=",
+								memberEb.ref("GroupMatch.alphaGroupId"),
+							),
+							memberEb(
+								"GroupMember.groupId",
+								"=",
+								memberEb.ref("GroupMatch.bravoGroupId"),
+							),
+						]),
+					),
+			),
+		)
+		.orderBy("GroupMatch.createdAt", "desc")
+		.limit(1)
+		.executeTakeFirst();
+	if (!latestMatch) return null;
+
+	return {
+		userId: memberRow.userId,
+		atMs: latestMatch.createdAt * 1000,
+		sinceTimestamp: latestMatch.createdAt - SCANNER_INGEST_SINCE_WINDOW_SECONDS,
+	};
+}
+
+async function resolveCastedTournamentId() {
+	const row = await db
+		.selectFrom("Tournament")
+		.select("id")
+		.where("castedMatchesInfo", "is not", null)
+		.orderBy(sql`length("castedMatchesInfo")`, "desc")
+		.limit(1)
+		.executeTakeFirst();
+
+	return row?.id ?? null;
+}
diff --git a/scripts/ensure-test-db.ts b/scripts/ensure-test-db.ts
index 6328584a6..9a1850035 100644
--- a/scripts/ensure-test-db.ts
+++ b/scripts/ensure-test-db.ts
@@ -1,4 +1,5 @@
 import { execSync } from "node:child_process";
+import { createHash } from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
 import { DatabaseSync } from "node:sqlite";
@@ -24,8 +25,13 @@ export function setup() {
 
 /**
  * Ensures the SQLite file at `dbPath` has every migration applied: creates it
- * if missing, applies pending migrations, and rebuilds it from scratch if it
- * contains a migration that no longer exists on disk.
+ * if missing, applies pending migrations, and rebuilds it from scratch if an
+ * already applied migration no longer exists on disk or its contents changed
+ * since it was applied.
+ *
+ * Rebuilding on changed contents matters because a branch edits the migration
+ * it added rather than stacking a new one, so the file name kysely tracks stays
+ * the same while the schema it produces does not.
  */
 export function ensureMigratedDb(dbPath: string) {
 	const resolvedPath = path.resolve(ROOT_DIR, dbPath);
@@ -39,7 +45,9 @@ export function ensureMigratedDb(dbPath: string) {
 	const onDisk = migrationFilesOnDisk();
 
 	const hasDrift =
-		applied === null || applied.some((name) => !onDisk.has(name));
+		applied === null ||
+		applied.some((name) => !onDisk.has(name)) ||
+		readContentsMarker(resolvedPath) !== migrationContentsHash();
 	if (hasDrift) {
 		deleteDbFiles(resolvedPath);
 		migrateUp(resolvedPath);
@@ -53,6 +61,29 @@ export function ensureMigratedDb(dbPath: string) {
 	}
 }
 
+/** Fingerprint of every migration's name and contents. */
+function migrationContentsHash() {
+	const hash = createHash("sha256");
+	for (const file of fs.readdirSync(MIGRATIONS_DIR).sort()) {
+		hash.update(file);
+		hash.update(fs.readFileSync(path.join(MIGRATIONS_DIR, file)));
+	}
+	return hash.digest("hex");
+}
+
+/** Sidecar recording the migration contents the database was built from. */
+function contentsMarkerPath(dbPath: string) {
+	return `${dbPath}.migrations`;
+}
+
+function readContentsMarker(dbPath: string) {
+	try {
+		return fs.readFileSync(contentsMarkerPath(dbPath), "utf8");
+	} catch {
+		return null;
+	}
+}
+
 function migrationFilesOnDisk() {
 	return new Set(
 		fs
@@ -90,6 +121,7 @@ function deleteDbFiles(dbPath: string) {
 	for (const suffix of ["", "-shm", "-wal"]) {
 		fs.rmSync(`${dbPath}${suffix}`, { force: true });
 	}
+	fs.rmSync(contentsMarkerPath(dbPath), { force: true });
 }
 
 function migrateUp(dbPath: string) {
@@ -98,4 +130,5 @@ function migrateUp(dbPath: string) {
 		stdio: "inherit",
 		env: { ...process.env, DB_PATH: dbPath },
 	});
+	fs.writeFileSync(contentsMarkerPath(dbPath), migrationContentsHash());
 }
diff --git a/scripts/scanner/bootstrap-atlas-from-fixture.ts b/scripts/scanner/bootstrap-atlas-from-fixture.ts
new file mode 100644
index 000000000..6f1618d68
--- /dev/null
+++ b/scripts/scanner/bootstrap-atlas-from-fixture.ts
@@ -0,0 +1,776 @@
+/** biome-ignore-all lint/suspicious/noConsole: CLI script output */
+/**
+ * Bootstrap glyph atlases from the labeled reference fixtures: slices glyph
+ * templates straight out of the reference frames, since the same scoreboard
+ * captured through different pipelines (OBS virtual camera 720p, game
+ * capture 1080p) yields subtly different pixels — every source contributes
+ * its own crop per character and recognition takes the best-scoring one.
+ * build-glyph-atlas.ts then fills in the rest of the charset from the
+ * fonts, preserving these fixture-tagged glyphs.
+ *
+ * Usage: pnpm scanner:bootstrap-atlas
+ * Writes public/assets/glyphs/scoreboard-{names,paint-digits,stat-digits}.{png,json}
+ */
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { loadOpenCV, type Mat } from "../../app/features/scanner/core/cv";
+import {
+	TAG_NAME_INNER,
+	TAG_NAME_OUTER,
+	TAG_NAME_TEXT_HEIGHT,
+	TAG_TILT_DEG,
+} from "../../app/features/scanner/core/detectors/death/rois";
+import {
+	nameRoi,
+	paintRoi,
+	ROW_CENTERS,
+	statRoi,
+	TEAM_SCORE_ROIS,
+} from "../../app/features/scanner/core/detectors/scoreboard/rois";
+import {
+	CODE_TEXT_HEIGHT,
+	REPLAY_CODE_ROI,
+} from "../../app/features/scanner/core/detectors/scoreboard-battle-log-replay/rois";
+import type { AtlasMeta } from "../../app/features/scanner/core/glyphs";
+import {
+	normalizeFrame,
+	type Roi,
+	toMat,
+} from "../../app/features/scanner/core/image";
+import { SCANNER_ASSETS_DIR } from "../../app/features/scanner/node/assets-dir";
+import { FIXTURES_DIR } from "../../app/features/scanner/node/fixtures";
+import { readImage, writePng } from "../../app/features/scanner/node/image-io";
+
+const OUT_DIR = join(SCANNER_ASSETS_DIR, "glyphs");
+const BIN_THRESHOLD = 150;
+
+/** A labeled header tag region (positions are fixture-specific: tags size to their text). */
+interface HeaderSpec {
+	roi: Roi;
+	label: string;
+	splitHints?: number[];
+	threshold?: number;
+}
+
+interface Source {
+	frame: string;
+	/** row labels, top to bottom; "" skips a row (e.g. unverifiable glyphs) */
+	names: string[];
+	paints: string[];
+	/** per row: [ka, deaths, specials], zero-padded 2 digits as rendered */
+	stats: string[][];
+	teamScores: string[];
+	/**
+	 * Split hints are absolute x positions where merged segments must be cut
+	 * (keyed by row index) — e.g. the "Te" in Teddy renders as one segment,
+	 * with the exact boundary shifting a couple of pixels between sources.
+	 */
+	nameSplitHints: Record<number, number[]>;
+	/** omit to skip header harvest for this source */
+	header?: { lobby: HeaderSpec; mode: HeaderSpec; stage: HeaderSpec };
+}
+
+/** Ground-truth labels for the reference match (captured through two pipelines). */
+const REFERENCE = {
+	names: [
+		"Pinhole",
+		"Sunshield",
+		"Headphones",
+		"Now or Never Seven",
+		"Charms",
+		"Teddy",
+		"Circle",
+		"Fleece",
+	],
+	paints: ["842", "1217", "1768", "693", "1422", "980", "1204", "1053"],
+	stats: [
+		["12", "07", "02"],
+		["07", "06", "03"],
+		["04", "04", "05"],
+		["04", "04", "02"],
+		["09", "06", "05"],
+		["07", "07", "05"],
+		["08", "06", "03"],
+		["05", "02", "04"],
+	],
+	/**
+	 * Team totals render with an outline on the colored team box, so they get
+	 * their own atlas rather than reusing paint digits. This fixture only
+	 * contributes '5' and '0' — later fixtures extend the set (harvest keeps
+	 * the first instance per char, so rerunning with more fixtures is additive).
+	 */
+	teamScores: ["500", "0"],
+	header: {
+		lobby: { roi: { x: 838, y: 44, w: 82, h: 26 }, label: "X Battle" },
+		// mode is bold, stage is regular — harvested separately so shared letters
+		// (e.g. both have an 'S') keep one template per face; bold text bridges
+		// at threshold 150, 170 separates all but "pl"
+		mode: {
+			roi: { x: 832, y: 88, w: 216, h: 40 },
+			label: "Splat Zones",
+			splitHints: [877],
+			threshold: 170,
+		},
+		stage: { roi: { x: 1078, y: 88, w: 160, h: 40 }, label: "Scorch Gorge" },
+	},
+};
+
+/** Labeled source frames; every source contributes its own crop per character. */
+const SOURCES: Source[] = [
+	{
+		frame: "scoreboard/xbattle-splat-zones-ko/frame.jpg",
+		...REFERENCE,
+		nameSplitHints: { 5: [1137] },
+	},
+	{
+		frame: "scoreboard/xbattle-splat-zones-ko-capture/frame.png",
+		...REFERENCE,
+		nameSplitHints: { 5: [1135] },
+	},
+	{
+		frame: "scoreboard/private-battle-splat-zones-ko-kera/frame.png",
+		names: [
+			"Mongering",
+			"y0s",
+			"fuzzy",
+			"kera",
+			"sigma",
+			"Reefslider",
+			"Cucumber",
+			"tomato",
+		],
+		paints: ["503", "766", "624", "323", "500", "503", "427", "414"],
+		stats: [
+			["11", "01", "02"],
+			["08", "00", "03"],
+			["05", "02", "02"],
+			["05", "03", "00"],
+			["04", "03", "02"],
+			["03", "06", "01"],
+			["02", "05", "02"],
+			["01", "06", "01"],
+		],
+		teamScores: ["500", "0"],
+		nameSplitHints: {},
+	},
+	{
+		// This capture renders names slightly smaller than the reference: its
+		// 'T' (9x15) loses to the taller reference crops, and its baseline dots
+		// are pure homoglyphs the font templates can't split — '.' renders 4px,
+		// '・' 5px, so exact crops separate them via the ink-coverage penalty.
+		// Only the dot/T rows are labeled; the rest add nothing new.
+		frame: "scoreboard/robot/frame.png",
+		names: ["R.O.B.O.T", "", "", "", "", "Rαι×ι..・", "", ""],
+		paints: ["", "", "", "", "", "", "", ""],
+		stats: [
+			["", "", ""],
+			["", "", ""],
+			["", "", ""],
+			["", "", ""],
+			["", "", ""],
+			["", "", ""],
+			["", "", ""],
+			["", "", ""],
+		],
+		teamScores: ["", ""],
+		nameSplitHints: {},
+	},
+	{
+		frame: "scoreboard/splash-sploosh/frame.png",
+		// rows 2 and 7 hold kana/symbol glyphs not yet verified char-by-char
+		names: [
+			"Bocchi",
+			"have faith",
+			"",
+			"Florescent",
+			"Elis",
+			"Jrod_14",
+			"GOLD SHIP",
+			"",
+		],
+		paints: ["1422", "1161", "993", "1046", "1662", "1105", "799", "1155"],
+		stats: [
+			["15", "10", "06"],
+			["13", "06", "04"],
+			["06", "02", "05"],
+			["13", "06", "05"],
+			["15", "02", "06"],
+			["10", "10", "03"],
+			["02", "02", "04"],
+			["08", "12", "06"],
+		],
+		teamScores: ["500", "0"],
+		nameSplitHints: {},
+	},
+];
+
+/** Team totals sit on the light team-color pattern; binarize higher. */
+const TEAM_BIN_THRESHOLD = 175;
+
+const cv = await loadOpenCV();
+
+/** Normalized grayscale of the source frame currently being harvested. */
+let gray: Mat;
+
+async function loadGray(framePath: string): Promise<Mat> {
+	const srcMat = toMat(await readImage(join(FIXTURES_DIR, framePath)));
+	const frame = normalizeFrame(srcMat);
+	srcMat.delete();
+	const out = new cv.Mat();
+	cv.cvtColor(frame, out, cv.COLOR_RGBA2GRAY);
+	frame.delete();
+	return out;
+}
+
+/** Green channel instead of luminance — the replay code is green-on-dark. */
+async function loadGreen(framePath: string): Promise<Mat> {
+	const srcMat = toMat(await readImage(join(FIXTURES_DIR, framePath)));
+	const frame = normalizeFrame(srcMat);
+	srcMat.delete();
+	const channels = new cv.MatVector();
+	cv.split(frame, channels);
+	frame.delete();
+	const g = channels.get(1);
+	const out = new cv.Mat();
+	g.copyTo(out);
+	g.delete();
+	channels.delete();
+	return out;
+}
+
+/**
+ * Death splash-tag name band, prepared the way the detector reads it
+ * (see src/core/detectors/death/index.ts): crop the tilted tag, rotate it
+ * level, crop the name band, then map each pixel to its max-channel
+ * distance from the median banner color, normalized to 0-255.
+ */
+async function loadTagBand(framePath: string): Promise<Mat> {
+	const srcMat = toMat(await readImage(join(FIXTURES_DIR, framePath)));
+	const frame = normalizeFrame(srcMat);
+	srcMat.delete();
+	const rgb = new cv.Mat();
+	cv.cvtColor(frame, rgb, cv.COLOR_RGBA2RGB);
+	frame.delete();
+
+	const outerView = rgb.roi(
+		new cv.Rect(
+			TAG_NAME_OUTER.x,
+			TAG_NAME_OUTER.y,
+			TAG_NAME_OUTER.w,
+			TAG_NAME_OUTER.h,
+		),
+	);
+	const outer = new cv.Mat();
+	outerView.copyTo(outer);
+	outerView.delete();
+	rgb.delete();
+	const center = new cv.Point(outer.cols / 2, outer.rows / 2);
+	const m = cv.getRotationMatrix2D(center, -TAG_TILT_DEG, 1);
+	const rotated = new cv.Mat();
+	cv.warpAffine(
+		outer,
+		rotated,
+		m,
+		new cv.Size(outer.cols, outer.rows),
+		cv.INTER_LINEAR,
+		cv.BORDER_REPLICATE,
+		new cv.Scalar(),
+	);
+	m.delete();
+	outer.delete();
+	const innerView = rotated.roi(
+		new cv.Rect(
+			TAG_NAME_INNER.x,
+			TAG_NAME_INNER.y,
+			TAG_NAME_INNER.w,
+			TAG_NAME_INNER.h,
+		),
+	);
+	const inner = new cv.Mat();
+	innerView.copyTo(inner);
+	innerView.delete();
+	rotated.delete();
+
+	const n = inner.rows * inner.cols;
+	const px = inner.data;
+	const background: number[] = [];
+	for (let c = 0; c < 3; c++) {
+		const hist = new Array<number>(256).fill(0);
+		for (let i = 0; i < n; i++) hist[px[i * 3 + c]!]!++;
+		let acc = 0;
+		let v = 0;
+		for (; v < 255; v++) {
+			acc += hist[v]!;
+			if (acc >= n / 2) break;
+		}
+		background.push(v);
+	}
+	const band = new cv.Mat(inner.rows, inner.cols, cv.CV_8UC1);
+	const out = band.data;
+	for (let i = 0; i < n; i++) {
+		out[i] = Math.max(
+			Math.abs(px[i * 3]! - background[0]!),
+			Math.abs(px[i * 3 + 1]! - background[1]!),
+			Math.abs(px[i * 3 + 2]! - background[2]!),
+		);
+	}
+	inner.delete();
+	cv.normalize(band, band, 0, 255, cv.NORM_MINMAX);
+	clearBorderBlobs(band, TAG_BIN_THRESHOLD);
+	return band;
+}
+
+/**
+ * Zero out ink components touching the band border, exactly as the
+ * detector does before parsing (see clearBorderBlobs in death/index.ts):
+ * banner art and title-line slivers enter at the band edges, and without
+ * this they join the column runs (mismatching the label) or push a crop's
+ * tight box past the band edge.
+ */
+function clearBorderBlobs(band: Mat, threshold: number): void {
+	const bin = new cv.Mat();
+	cv.threshold(band, bin, threshold, 255, cv.THRESH_BINARY);
+	const labels = new cv.Mat();
+	const stats = new cv.Mat();
+	const centroids = new cv.Mat();
+	const count = cv.connectedComponentsWithStats(
+		bin,
+		labels,
+		stats,
+		centroids,
+		8,
+	);
+	bin.delete();
+	centroids.delete();
+	const s = stats.data32S;
+	const touchesBorder = new Uint8Array(count);
+	for (let i = 1; i < count; i++) {
+		const left = s[i * 5 + cv.CC_STAT_LEFT]!;
+		const top = s[i * 5 + cv.CC_STAT_TOP]!;
+		const right = left + s[i * 5 + cv.CC_STAT_WIDTH]!;
+		const bottom = top + s[i * 5 + cv.CC_STAT_HEIGHT]!;
+		touchesBorder[i] =
+			left === 0 || top === 0 || right === band.cols || bottom === band.rows
+				? 1
+				: 0;
+	}
+	stats.delete();
+	const lab = labels.data32S;
+	const out = band.data;
+	for (let i = 0; i < out.length; i++) {
+		if (touchesBorder[lab[i]!]!) out[i] = 0;
+	}
+	labels.delete();
+}
+
+function columnRuns(
+	roi: Roi,
+	splitHints: number[] = [],
+	threshold = BIN_THRESHOLD,
+	mergeHints: number[] = [],
+): { x0: number; x1: number }[] {
+	let runs: { x0: number; x1: number }[] = [];
+	let start = -1;
+	for (let x = roi.x; x < roi.x + roi.w; x++) {
+		let count = 0;
+		for (let y = roi.y; y < roi.y + roi.h; y++) {
+			if (gray.ucharPtr(y, x)[0]! > threshold) count++;
+		}
+		const on = count >= 1;
+		if (on && start < 0) start = x;
+		if (!on && start >= 0) {
+			if (x - start >= 2) runs.push({ x0: start, x1: x });
+			start = -1;
+		}
+	}
+	if (start >= 0) runs.push({ x0: start, x1: roi.x + roi.w });
+	// Merge hints bridge runs that belong to one glyph (multi-stroke kana
+	// like パ segments as two strokes): a hint x inside the gap between two
+	// consecutive runs joins them into a single crop.
+	for (const hint of mergeHints) {
+		const i = runs.findIndex(
+			(r, idx) =>
+				idx + 1 < runs.length && r.x1 <= hint && runs[idx + 1]!.x0 >= hint,
+		);
+		if (i >= 0) {
+			runs = [
+				...runs.slice(0, i),
+				{ x0: runs[i]!.x0, x1: runs[i + 1]!.x1 },
+				...runs.slice(i + 2),
+			];
+		}
+	}
+	return runs.flatMap((run) => {
+		const cuts = splitHints
+			.filter((h) => h > run.x0 + 1 && h < run.x1 - 1)
+			.sort((a, b) => a - b);
+		if (cuts.length === 0) return [run];
+		const parts: { x0: number; x1: number }[] = [];
+		let x0 = run.x0;
+		for (const cut of cuts) {
+			parts.push({ x0, x1: cut });
+			x0 = cut;
+		}
+		parts.push({ x0, x1: run.x1 });
+		return parts;
+	});
+}
+
+function cropGlyph(
+	run: { x0: number; x1: number },
+	roi: Roi,
+	threshold = BIN_THRESHOLD,
+): Mat {
+	// tight vertical bounds within the run
+	let yMin = roi.y + roi.h;
+	let yMax = -1;
+	for (let y = roi.y; y < roi.y + roi.h; y++) {
+		for (let x = run.x0; x < run.x1; x++) {
+			if (gray.ucharPtr(y, x)[0]! > threshold) {
+				if (y < yMin) yMin = y;
+				if (y > yMax) yMax = y;
+			}
+		}
+	}
+	const pad = 1;
+	const rect = new cv.Rect(
+		run.x0 - pad,
+		yMin - pad,
+		run.x1 - run.x0 + 2 * pad,
+		yMax - yMin + 1 + 2 * pad,
+	);
+	const view = gray.roi(rect);
+	const out = new cv.Mat();
+	view.copyTo(out);
+	view.delete();
+	// Apply the same background masking recognizeText uses at match time, so
+	// templates harvested off colored backgrounds stay comparable.
+	const binary = new cv.Mat();
+	cv.threshold(out, binary, threshold, 255, cv.THRESH_BINARY);
+	const mask = new cv.Mat();
+	const kernel = cv.getStructuringElement(cv.MORPH_RECT, new cv.Size(3, 3));
+	cv.dilate(binary, mask, kernel, new cv.Point(-1, -1), 2);
+	kernel.delete();
+	binary.delete();
+	const masked = new cv.Mat(out.rows, out.cols, cv.CV_8UC1, new cv.Scalar(0));
+	out.copyTo(masked, mask);
+	out.delete();
+	mask.delete();
+	return masked;
+}
+
+/**
+ * Slice a labeled text ROI into per-char crops. A Map collector keeps the
+ * first instance per char (digits render identically everywhere); an array
+ * collector keeps every instance — letters land on different subpixel
+ * phases, so each occurrence is a distinct, equally-authoritative exemplar.
+ */
+function harvest(
+	roi: Roi,
+	label: string,
+	collected: Map<string, Mat> | [string, Mat][],
+	splitHints: number[] = [],
+	threshold = BIN_THRESHOLD,
+	mergeHints: number[] = [],
+): void {
+	if (label === "") return;
+	const chars = [...label.replace(/ /g, "")];
+	const runs = columnRuns(roi, splitHints, threshold, mergeHints);
+	if (runs.length !== chars.length) {
+		console.warn(
+			`segment mismatch for "${label}": ${runs.length} segments vs ${chars.length} chars — skipped`,
+		);
+		return;
+	}
+	runs.forEach((run, i) => {
+		const ch = chars[i]!;
+		if (Array.isArray(collected)) {
+			collected.push([ch, cropGlyph(run, roi, threshold)]);
+		} else if (!collected.has(ch)) {
+			collected.set(ch, cropGlyph(run, roi, threshold));
+		}
+	});
+}
+
+function writeAtlas(
+	name: string,
+	height: number,
+	collected: Map<string, Mat> | [string, Mat][],
+): void {
+	const entries =
+		collected instanceof Map ? [...collected.entries()] : collected;
+	const glyphs = entries.sort(([a], [b]) => a.localeCompare(b));
+	if (glyphs.length === 0) {
+		console.warn(`${name}: nothing harvested, atlas not written`);
+		return;
+	}
+	const spacing = 2;
+	const totalW =
+		glyphs.reduce((acc, [, m]) => acc + m.cols, 0) +
+		spacing * (glyphs.length + 1);
+	const maxH = Math.max(...glyphs.map(([, m]) => m.rows)) + 2 * spacing;
+	const atlas = new cv.Mat(maxH, totalW, cv.CV_8UC1, new cv.Scalar(0));
+
+	const meta: AtlasMeta = { height, glyphs: [] };
+	let x = spacing;
+	for (const [char, m] of glyphs) {
+		const view = atlas.roi(new cv.Rect(x, spacing, m.cols, m.rows));
+		m.copyTo(view);
+		view.delete();
+		meta.glyphs.push({
+			char,
+			x,
+			y: spacing,
+			w: m.cols,
+			h: m.rows,
+			source: "fixture",
+		});
+		x += m.cols + spacing;
+	}
+
+	const rgba = new cv.Mat();
+	cv.cvtColor(atlas, rgba, cv.COLOR_GRAY2RGBA);
+	writePng(join(OUT_DIR, `${name}.png`), {
+		width: rgba.cols,
+		height: rgba.rows,
+		data: new Uint8ClampedArray(rgba.data),
+	});
+	writeFileSync(join(OUT_DIR, `${name}.json`), JSON.stringify(meta, null, 2));
+	atlas.delete();
+	rgba.delete();
+	console.info(
+		`${name}: ${glyphs.length} glyphs -> ${OUT_DIR}/${name}.{png,json}`,
+	);
+}
+
+mkdirSync(OUT_DIR, { recursive: true });
+
+// One crop per char per source: each source keeps its own first-instance map,
+// and the atlases carry every source's crops side by side.
+const nameEntries: [string, Mat][] = [];
+const paintEntries: [string, Mat][] = [];
+const statEntries: [string, Mat][] = [];
+const teamEntries: [string, Mat][] = [];
+const lobbyEntries: [string, Mat][] = [];
+const lineEntries: [string, Mat][] = [];
+
+for (const source of SOURCES) {
+	console.info(`harvesting ${source.frame}`);
+	gray = await loadGray(source.frame);
+
+	const nameGlyphs: [string, Mat][] = [];
+	ROW_CENTERS.forEach((cy, row) => {
+		// name region may include paint digits for long names; stop where digits start
+		harvest(
+			{ ...nameRoi(cy), w: 196 },
+			source.names[row]!,
+			nameGlyphs,
+			source.nameSplitHints[row] ?? [],
+		);
+	});
+	nameEntries.push(...nameGlyphs);
+
+	const paintGlyphs = new Map<string, Mat>();
+	ROW_CENTERS.forEach((cy, row) => {
+		harvest(paintRoi(cy), source.paints[row]!, paintGlyphs);
+	});
+	paintEntries.push(...paintGlyphs.entries());
+
+	const statGlyphs = new Map<string, Mat>();
+	ROW_CENTERS.forEach((cy, row) => {
+		for (const i of [0, 1, 2] as const) {
+			harvest(statRoi(cy, i), source.stats[row]![i]!, statGlyphs);
+		}
+	});
+	statEntries.push(...statGlyphs.entries());
+
+	const teamGlyphs = new Map<string, Mat>();
+	TEAM_SCORE_ROIS.forEach((roi, i) => {
+		harvest(roi, source.teamScores[i]!, teamGlyphs, [], TEAM_BIN_THRESHOLD);
+	});
+	teamEntries.push(...teamGlyphs.entries());
+
+	// Header tags: lobby line (BlitzMain ~24px), then mode (BlitzBold ~35px) and
+	// stage (BlitzMain ~22px) side by side.
+	if (source.header) {
+		const { lobby, mode, stage } = source.header;
+		const lobbyGlyphs = new Map<string, Mat>();
+		harvest(
+			lobby.roi,
+			lobby.label,
+			lobbyGlyphs,
+			lobby.splitHints,
+			lobby.threshold,
+		);
+		lobbyEntries.push(...lobbyGlyphs.entries());
+
+		const modeGlyphs = new Map<string, Mat>();
+		harvest(mode.roi, mode.label, modeGlyphs, mode.splitHints, mode.threshold);
+		const stageGlyphs = new Map<string, Mat>();
+		harvest(
+			stage.roi,
+			stage.label,
+			stageGlyphs,
+			stage.splitHints,
+			stage.threshold,
+		);
+		lineEntries.push(...modeGlyphs.entries(), ...stageGlyphs.entries());
+	}
+
+	gray.delete();
+}
+
+// Replay-browser fixtures: the code line renders in FOT-RowdyStd, which no
+// live-scoreboard atlas covers. Letters land on different subpixel phases,
+// so keep every occurrence (array collector), like names.
+const REPLAY_SOURCES: { frame: string; code: string }[] = [
+	{
+		frame:
+			"scoreboard-battle-log-replay/private-battle-splat-zones-hagglefish/frame.jpeg",
+		code: "R6KE-D064-3CXD-XVKL",
+	},
+	{
+		frame:
+			"scoreboard-battle-log-replay/anarchy-open-rainmaker-knockout-museum/frame.png",
+		code: "RWYQ-4X37-M1EL-EGGQ",
+	},
+	{
+		frame:
+			"scoreboard-battle-log-replay/private-battle-crableg-capital/frame.png",
+		code: "R1V4-PAHW-GGM2-PD9S",
+	},
+	// Heavily compressed stream captures: font-rendered templates lose to
+	// fixture crops of lookalikes on these (E beat a real F by 0.1+), so the
+	// chars they cover (8 B F J N T U 5 among them) need crops at this
+	// fidelity. brinewater-1411/marlin stay out as generalization checks.
+	{
+		frame:
+			"scoreboard-battle-log-replay/x-battle-rainmaker-brinewater-1404/frame.png",
+		code: "R80B-00DL-WF4X-V3CA",
+	},
+	{
+		frame:
+			"scoreboard-battle-log-replay/x-battle-rainmaker-brinewater-1416/frame.png",
+		code: "RUH3-3NEF-F5FY-PAJL",
+	},
+	{
+		frame:
+			"scoreboard-battle-log-replay/x-battle-rainmaker-urchin-1434/frame.png",
+		code: "RUCT-5HNH-XWDC-J51U",
+	},
+];
+
+const codeEntries: [string, Mat][] = [];
+for (const source of REPLAY_SOURCES) {
+	console.info(`harvesting ${source.frame}`);
+	gray = await loadGreen(source.frame);
+	const codeGlyphs: [string, Mat][] = [];
+	harvest(REPLAY_CODE_ROI, source.code, codeGlyphs);
+	codeEntries.push(...codeGlyphs);
+	gray.delete();
+}
+
+// Death splash-tag names (BlitzBold + Rowdy kana at ~46px). The atlas is
+// nominal 42 with the detector upscaling to 46 at load (see the builder
+// comment in scripts/scanner/build-glyph-atlas.ts), so native-size crops shrink to
+// 42 here and come back to native after the load-time upscale.
+const TAG_BIN_THRESHOLD = 160; // TAG_NAME_BIN_THRESHOLD in death/index.ts
+const TAG_ATLAS_HEIGHT = 42;
+const DEATH_TAG_SOURCES: {
+	frame: string;
+	label: string;
+	mergeHints?: number[];
+}[] = [
+	{
+		frame: "death/fxg-supaatan-slosher/frame.png",
+		label: "FxG スパータン",
+		// パ renders as two disconnected strokes; bridge them into one crop
+		mergeHints: [340],
+	},
+	{
+		frame: "death/classic-squiffer-jp/frame.png",
+		label: "ごあんぜんに",
+		// に's bar and body never connect; bridge them into one crop
+		mergeHints: [431],
+	},
+	{
+		frame: "death/wipeout-52-gal/frame.png",
+		label: "さんだいめドパかげ",
+		// だ (1px column gap), い, ド, パ, げ all segment as disconnected
+		// strokes/marks; bridge each into one crop
+		mergeHints: [176, 236, 366, 408, 528],
+	},
+];
+
+const tagEntries: [string, Mat][] = [];
+for (const source of DEATH_TAG_SOURCES) {
+	console.info(`harvesting ${source.frame}`);
+	gray = await loadTagBand(source.frame);
+	const tagGlyphs: [string, Mat][] = [];
+	harvest(
+		{ x: 0, y: 0, w: gray.cols, h: gray.rows },
+		source.label,
+		tagGlyphs,
+		[],
+		TAG_BIN_THRESHOLD,
+		source.mergeHints ?? [],
+	);
+	gray.delete();
+	const factor = TAG_ATLAS_HEIGHT / TAG_NAME_TEXT_HEIGHT;
+	for (const [char, mat] of tagGlyphs) {
+		const scaledMat = new cv.Mat();
+		cv.resize(mat, scaledMat, new cv.Size(0, 0), factor, factor, cv.INTER_AREA);
+		mat.delete();
+		tagEntries.push([char, scaledMat]);
+	}
+}
+
+// JA death-message lines (condensed Kurokane/Rowdy blend at ~40px; the
+// atlas is native-size, matched unscaled by the detector's JA read path).
+// ROIs are fixture-specific tight boxes around each line so scene ink
+// outside the burst stays out of the runs.
+const DEATH_JA_BIN_THRESHOLD = 190; // SPLAT_TEXT_BIN_THRESHOLD in death/rois.ts
+const DEATH_JA_SOURCES: {
+	frame: string;
+	lines: { roi: Roi; label: string; mergeHints?: number[] }[];
+}[] = [
+	{
+		frame: "death/classic-squiffer-jp/frame.png",
+		lines: [
+			// ッ renders as two disconnected strokes; bridge them into one crop
+			{
+				roi: { x: 825, y: 358, w: 275, h: 58 },
+				label: "スクイックリンα で",
+				mergeHints: [917],
+			},
+			{ roi: { x: 880, y: 410, w: 155, h: 56 }, label: "やられた！" },
+		],
+	},
+];
+
+const deathJaEntries: [string, Mat][] = [];
+for (const source of DEATH_JA_SOURCES) {
+	console.info(`harvesting ${source.frame}`);
+	gray = await loadGray(source.frame);
+	for (const line of source.lines) {
+		harvest(
+			line.roi,
+			line.label,
+			deathJaEntries,
+			[],
+			DEATH_JA_BIN_THRESHOLD,
+			line.mergeHints ?? [],
+		);
+	}
+	gray.delete();
+}
+
+writeAtlas("scoreboard-names", 22, nameEntries);
+writeAtlas("scoreboard-paint-digits", 28, paintEntries);
+writeAtlas("scoreboard-stat-digits", 17, statEntries);
+writeAtlas("scoreboard-team-digits", 33, teamEntries);
+writeAtlas("scoreboard-header-lobby", 19, lobbyEntries);
+writeAtlas("scoreboard-header-line", 24, lineEntries);
+writeAtlas("scoreboard-replay-code", CODE_TEXT_HEIGHT, codeEntries);
+writeAtlas("death-tag-name", TAG_ATLAS_HEIGHT, tagEntries);
+writeAtlas("death-weapon-ja", 40, deathJaEntries);
diff --git a/scripts/scanner/build-glyph-atlas.ts b/scripts/scanner/build-glyph-atlas.ts
new file mode 100644
index 000000000..5e05745b5
--- /dev/null
+++ b/scripts/scanner/build-glyph-atlas.ts
@@ -0,0 +1,481 @@
+/** biome-ignore-all lint/suspicious/noConsole: CLI script output */
+/**
+ * Build glyph atlases by rendering the Splatoon fonts at the exact
+ * scoreboard render sizes, calibrated against the reference fixture:
+ *
+ *   paint digits  BlitzMain 34px  (tight '0' height ~29px at 1080p)
+ *   stat digits   BlitzMain 20px  (~17px)
+ *   team digits   BlitzBold 36px  (~28px — team totals use the bold face,
+ *                                  which is why they can't reuse paint glyphs)
+ *   names         BlitzMain 20px  (cap height ~17px), full charset:
+ *                 ASCII + Latin-1 + kana + common symbols (~330 glyphs)
+ *
+ * The fonts ship with the game and are not committed — drop them into
+ * assets/fonts/ (see README). Fixture-crop bootstrapping
+ * (scripts/scanner/bootstrap-atlas-from-fixture.ts) remains as a cross-check and as
+ * the fallback when the fonts are unavailable.
+ *
+ * Usage: pnpm scanner:build-glyph-atlas
+ * Writes public/assets/glyphs/scoreboard-*.{png,json}
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { createCanvas, GlobalFonts } from "@napi-rs/canvas";
+import {
+	DEATH_MESSAGE_TEMPLATES,
+	LOCALIZED_WEAPON_NAMES,
+} from "../../app/features/scanner/core/detectors/death/localized-messages";
+import { ALL_WEAPON_ENTRIES } from "../../app/features/scanner/core/detectors/death/weapon-names";
+import type { AtlasMeta } from "../../app/features/scanner/core/glyphs";
+import {
+	ALL_LOBBY_ENTRIES,
+	ALL_MODE_ENTRIES,
+	ALL_MODE_LABELS,
+	ALL_STAGE_ENTRIES,
+	RESULT_TAG_ENTRIES,
+} from "../../app/features/scanner/core/localized";
+import { SCANNER_ASSETS_DIR } from "../../app/features/scanner/node/assets-dir";
+import { readImage, writePng } from "../../app/features/scanner/node/image-io";
+import { readFontCoverage } from "./otf-cmap";
+
+/**
+ * Atlases are hybrids: glyphs harvested from labeled fixtures
+ * (scripts/scanner/bootstrap-atlas-from-fixture.ts, tagged source:"fixture") are exact
+ * in-game pixels and are preserved across rebuilds; font-rendered glyphs
+ * fill in the rest of the charset. Recognition takes the best-scoring glyph,
+ * so fixture crops dominate wherever they exist.
+ */
+
+const FONTS_DIR = new URL("../../assets/fonts", import.meta.url).pathname;
+const OUT_DIR = join(SCANNER_ASSETS_DIR, "glyphs");
+
+const FONT_FILES = {
+	BlitzMain: "BlitzMain.otf",
+	BlitzBold: "BlitzBold.otf",
+	/** replay-browser code line and VICTORY/DEFEAT panel tags */
+	Rowdy: "FOT-RowdyStd-EB.otf",
+	/** JA death message (together with Rowdy — see death-weapon-ja) */
+	Kurokane: "FOT-KurokaneStd-EB.otf",
+} as const;
+
+/**
+ * Which codepoints each font actually maps: canvas silently substitutes a
+ * system font for the rest (the Blitz cuts have no kanji/hangul/hanzi), so
+ * charsets are filtered through this before rendering — the CJK languages'
+ * ideographs drop out of the localized charsets instead of baking
+ * wrong-font glyphs into the atlases.
+ */
+const fontCoverage: Record<string, (codepoint: number) => boolean> = {};
+
+for (const [family, file] of Object.entries(FONT_FILES)) {
+	const path = join(FONTS_DIR, file);
+	if (!existsSync(path)) {
+		console.error(
+			[
+				`font not found: ${path}`,
+				"",
+				"The Splatoon fonts are proprietary and not committed. Get",
+				"Decrypted/BlitzMain.otf and Decrypted/BlitzBold.otf (e.g. from the",
+				"splatoon3-fonts repo) into assets/fonts/, or fall back to",
+				"  pnpm scanner:bootstrap-atlas",
+			].join("\n"),
+		);
+		process.exit(1);
+	}
+	GlobalFonts.registerFromPath(path, family);
+	fontCoverage[family] = readFontCoverage(path);
+}
+
+const DIGITS = "0123456789";
+
+function nameCharset(): string[] {
+	const chars: string[] = [];
+	for (let c = 33; c <= 126; c++) chars.push(String.fromCharCode(c)); // ASCII
+	for (let c = 0xa1; c <= 0xff; c++) chars.push(String.fromCharCode(c)); // Latin-1
+	for (let c = 0x3041; c <= 0x3096; c++) chars.push(String.fromCharCode(c)); // hiragana
+	for (let c = 0x30a1; c <= 0x30fa; c++) chars.push(String.fromCharCode(c)); // katakana
+	chars.push("・", "ー", "、", "。", "「", "」");
+	chars.push("★", "☆", "●", "♪"); // name decorations
+	return [...new Set(chars)];
+}
+
+/**
+ * Greek letters players stylize scoreboard names with, added per attested
+ * fixture need only ("Rιppιng_H"): most of the block are homoglyphs of latin
+ * or kana at capture fidelity (η~n, ε~c, Γ~か strokes...) and displace
+ * correct matches on ranking noise, so it is not included wholesale — and
+ * even a few extra narrow glyphs shift an atlas's median width enough to
+ * change wide-segment splitting, so it stays out of the death-tag charset
+ * until a death fixture attests it.
+ */
+const NAME_GREEK = "ια"; // ι: "Rιppιng_H", α: "◇Dαrz™" (special-symbols fixture)
+
+/**
+ * The rest of the in-game name editor's symbol pickers (sendou.ink's
+ * IN_GAME_NAME_CHARACTER_CATEGORIES: "symbols" + "cjk-symbols"), minus what
+ * nameCharset() already carries via ASCII/Latin-1/kana and minus chars the
+ * Blitz cmap doesn't map (ˊˋ𝑓⁀⚪⚫◻◼⍑ — canvas would render a system-font
+ * substitute; nameSymbols() re-checks at build time). "•" stays out too:
+ * BlitzMain's own bullet is a 4px dot, the on-screen full-size circle comes
+ * from "●" via RENDER_ALIASES. The tilde is the fullwidth "～" (U+FF5E) only
+ * — the wave dash "〜" (U+301C) is a pixel-identical homoglyph that would
+ * duel it on ranking noise, and FF5E is the form the fixture labels attest.
+ * Like NAME_GREEK, scoreboard-names only (not death-tag) until attested.
+ */
+const NAME_SYMBOLS =
+	"′‘’‚‛…″“”„←→↑↓⇒⇔˜€∞√∀⊂⊃∴∵∂№♭♀♂◎◇◆△▲▽▼†※™" + "『』【】〈〉《》〔〕々〆〇〃～";
+
+/**
+ * Render the key char's glyph but emit it as the value char: in-game names
+ * show "•" as the full-size filled circle (BlitzMain's own "•" is a 4px dot
+ * that never appears on screen), and fixture labels write it as "•".
+ */
+const RENDER_ALIASES: Record<string, string> = { "●": "•" };
+
+interface GlyphBitmap {
+	char: string;
+	w: number;
+	h: number;
+	/** grayscale, white-on-black (alpha coverage) */
+	data: Uint8Array;
+	source: "fixture" | "font";
+}
+
+/** Carry fixture-harvested glyphs over from the existing atlas, if any. */
+async function readFixtureGlyphs(name: string): Promise<GlyphBitmap[]> {
+	const pngPath = join(OUT_DIR, `${name}.png`);
+	const jsonPath = join(OUT_DIR, `${name}.json`);
+	if (!existsSync(pngPath) || !existsSync(jsonPath)) return [];
+	const meta = JSON.parse(readFileSync(jsonPath, "utf8")) as AtlasMeta;
+	const png = await readImage(pngPath);
+	return meta.glyphs
+		.filter((g) => g.source === "fixture")
+		.map((g) => {
+			const data = new Uint8Array(g.w * g.h);
+			for (let y = 0; y < g.h; y++) {
+				for (let x = 0; x < g.w; x++) {
+					data[y * g.w + x] =
+						png.data[((g.y + y) * png.width + (g.x + x)) * 4]!;
+				}
+			}
+			return { char: g.char, w: g.w, h: g.h, data, source: "fixture" as const };
+		});
+}
+
+/**
+ * Render one glyph and tight-crop it via the alpha channel. xScale < 1
+ * condenses the glyph horizontally (the JA death message renders its font
+ * squeezed to ~3/4 width in-game).
+ */
+function renderGlyph(
+	family: string,
+	px: number,
+	char: string,
+	xScale = 1,
+): GlyphBitmap | null {
+	const size = px * 4;
+	const canvas = createCanvas(size, size);
+	const ctx = canvas.getContext("2d");
+	ctx.fillStyle = "white";
+	ctx.font = `${px}px ${family}`;
+	ctx.textBaseline = "middle";
+	ctx.scale(xScale, 1);
+	ctx.fillText(char, px / xScale, size / 2);
+	const img = ctx.getImageData(0, 0, size, size);
+	let x0 = size;
+	let x1 = -1;
+	let y0 = size;
+	let y1 = -1;
+	let ink = 0;
+	for (let y = 0; y < size; y++) {
+		for (let x = 0; x < size; x++) {
+			if (img.data[(y * size + x) * 4 + 3]! > 128) {
+				if (x < x0) x0 = x;
+				if (x > x1) x1 = x;
+				if (y < y0) y0 = y;
+				if (y > y1) y1 = y;
+				ink++;
+			}
+		}
+	}
+	if (x1 < 0 || ink < 4) return null;
+	const pad = 1;
+	const w = x1 - x0 + 1 + 2 * pad;
+	const h = y1 - y0 + 1 + 2 * pad;
+	const data = new Uint8Array(w * h);
+	for (let y = 0; y < h; y++) {
+		for (let x = 0; x < w; x++) {
+			const sx = x0 - pad + x;
+			const sy = y0 - pad + y;
+			if (sx < 0 || sy < 0 || sx >= size || sy >= size) continue;
+			data[y * w + x] = img.data[(sy * size + sx) * 4 + 3]!;
+		}
+	}
+	return { char, w, h, data, source: "font" };
+}
+
+/** Pack glyphs into rows (wrapping at maxWidth) and write PNG + JSON. */
+function writeAtlas(name: string, height: number, glyphs: GlyphBitmap[]): void {
+	const spacing = 2;
+	const maxWidth = 1600;
+	const meta: AtlasMeta = { height, glyphs: [] };
+	let x = spacing;
+	let y = spacing;
+	let rowH = 0;
+	let atlasW = 0;
+	for (const g of glyphs) {
+		if (x + g.w + spacing > maxWidth) {
+			x = spacing;
+			y += rowH + spacing;
+			rowH = 0;
+		}
+		meta.glyphs.push({ char: g.char, x, y, w: g.w, h: g.h, source: g.source });
+		x += g.w + spacing;
+		rowH = Math.max(rowH, g.h);
+		atlasW = Math.max(atlasW, x);
+	}
+	const atlasH = y + rowH + spacing;
+
+	const pixels = new Uint8ClampedArray(atlasW * atlasH * 4);
+	for (let i = 3; i < pixels.length; i += 4) pixels[i] = 255;
+	meta.glyphs.forEach((m, i) => {
+		const g = glyphs[i]!;
+		for (let gy = 0; gy < g.h; gy++) {
+			for (let gx = 0; gx < g.w; gx++) {
+				const v = g.data[gy * g.w + gx]!;
+				const o = ((m.y + gy) * atlasW + (m.x + gx)) * 4;
+				pixels[o] = v;
+				pixels[o + 1] = v;
+				pixels[o + 2] = v;
+			}
+		}
+	});
+	writePng(join(OUT_DIR, `${name}.png`), {
+		width: atlasW,
+		height: atlasH,
+		data: pixels,
+	});
+	writeFileSync(join(OUT_DIR, `${name}.json`), JSON.stringify(meta, null, 2));
+	console.info(
+		`${name}: ${glyphs.length} glyphs (${atlasW}x${atlasH}) -> ${name}.{png,json}`,
+	);
+}
+
+interface AtlasPart {
+	family: string;
+	/** in-game render size varies by ±1px; multiple template sizes per char */
+	pxs: number[];
+	chars: string[];
+	/** horizontal condensation applied in-game (default 1 = none) */
+	xScale?: number;
+}
+
+async function build(
+	name: string,
+	height: number,
+	parts: AtlasPart[],
+): Promise<void> {
+	const glyphs: GlyphBitmap[] = await readFixtureGlyphs(name);
+	const fixtureCount = glyphs.length;
+	const missing: string[] = [];
+	for (const { family, pxs, chars, xScale } of parts) {
+		for (const ch of chars) {
+			let found = false;
+			for (const px of pxs) {
+				const g = renderGlyph(family, px, ch, xScale ?? 1);
+				if (g) {
+					glyphs.push({ ...g, char: RENDER_ALIASES[ch] ?? ch });
+					found = true;
+				}
+			}
+			if (!found) missing.push(ch);
+		}
+	}
+	if (missing.length > 0) {
+		console.info(
+			`${name}: ${missing.length} chars not renderable, skipped: ${missing.join("")}`,
+		);
+	}
+	console.info(
+		`${name}: carrying over ${fixtureCount} fixture-harvested glyphs`,
+	);
+	writeAtlas(name, height, glyphs);
+}
+
+/** NAME_SYMBOLS chars the font actually maps (see the constant's comment). */
+function nameSymbols(family: string): string[] {
+	const covers = fontCoverage[family]!;
+	return [...NAME_SYMBOLS].filter((ch) => covers(ch.codePointAt(0)!));
+}
+
+/** Unique non-space characters across a set of known strings. */
+function charsOf(entries: readonly string[]): string[] {
+	return [...new Set(entries.flatMap((e) => [...e.replace(/ /g, "")]))];
+}
+
+mkdirSync(OUT_DIR, { recursive: true });
+await build("scoreboard-paint-digits", 29, [
+	{ family: "BlitzMain", pxs: [34], chars: [...DIGITS] },
+]);
+await build("scoreboard-stat-digits", 17, [
+	{ family: "BlitzMain", pxs: [20], chars: [...DIGITS] },
+]);
+await build("scoreboard-team-digits", 28, [
+	{ family: "BlitzBold", pxs: [36], chars: [...DIGITS] },
+]);
+await build("scoreboard-names", 17, [
+	{
+		family: "BlitzMain",
+		pxs: [19, 20],
+		chars: [...nameCharset(), ...NAME_GREEK, ...nameSymbols("BlitzMain")],
+	},
+]);
+/**
+ * Localized closed-set charsets (all 14 game languages; the canonical
+ * English strings are included by construction), restricted to the Latin
+ * scripts (< U+0250) the fixtures attest: like the Greek block in the name
+ * charset, wholesale Cyrillic/kana/ideograph glyphs displace Latin matches
+ * on ranking noise (adding them regressed the English fixtures), so the
+ * non-Latin languages' entries stay in the closed sets — ready to snap —
+ * but their glyphs wait for fixtures to tune against. Chars the font
+ * doesn't map are dropped too: canvas would silently render a system-font
+ * substitute into the atlas.
+ */
+function localizedChars(texts: readonly string[], family: string): string[] {
+	const covers = fontCoverage[family]!;
+	return charsOf(texts).filter((ch) => {
+		const cp = ch.codePointAt(0)!;
+		return cp < 0x250 && covers(cp);
+	});
+}
+
+const lobbyTexts = ALL_LOBBY_ENTRIES.map((e) => e.text);
+const modeTexts = ALL_MODE_ENTRIES.map((e) => e.text);
+const stageTexts = ALL_STAGE_ENTRIES.map((e) => e.text);
+const resultTexts = RESULT_TAG_ENTRIES.map((e) => e.text);
+
+// header: lobby tag is BlitzMain ~24px; the mode/stage line mixes bold mode
+// text with regular stage text, so its atlas carries both faces
+await build("scoreboard-header-lobby", 19, [
+	{
+		family: "BlitzMain",
+		pxs: [23, 24],
+		chars: localizedChars(lobbyTexts, "BlitzMain"),
+	},
+]);
+await build("scoreboard-header-line", 24, [
+	{
+		family: "BlitzBold",
+		pxs: [34, 35],
+		chars: localizedChars(modeTexts, "BlitzBold"),
+	},
+	{
+		family: "BlitzMain",
+		pxs: [22, 23],
+		chars: localizedChars(stageTexts, "BlitzMain"),
+	},
+]);
+// replay browser: the code line and the VICTORY/DEFEAT panel tags render in
+// FOT-RowdyStd-EB (tight height 25px at ~32px, 30px at ~38px)
+await build("scoreboard-replay-code", 25, [
+	{
+		family: "Rowdy",
+		pxs: [31, 32, 33],
+		chars: [...DIGITS, ..."ABCDEFGHIJKLMNOPQRSTUVWXYZ", "-"],
+	},
+]);
+await build("scoreboard-replay-result", 30, [
+	{
+		family: "Rowdy",
+		pxs: [37, 38],
+		chars: localizedChars(resultTexts, "Rowdy"),
+	},
+]);
+// map-start intro splash: the big mode title on the center splat is
+// BlitzBold (~76px tight caps at 1080p; a px sweep against the fixture reads
+// best at 99-101), the stage name bottom-right is BlitzMain (~40px tight;
+// 46-48px render). The constant "MODE" label ("Kampfart", ...) is BlitzMain
+// too and is read with the stage atlas rescaled to its ~48px height, so its
+// chars ride along.
+await build("map-start-mode", 76, [
+	{
+		family: "BlitzBold",
+		pxs: [99, 100, 101],
+		chars: localizedChars(modeTexts, "BlitzBold"),
+	},
+]);
+await build("map-start-stage", 40, [
+	{
+		family: "BlitzMain",
+		pxs: [46, 47, 48],
+		chars: localizedChars([...stageTexts, ...ALL_MODE_LABELS], "BlitzMain"),
+	},
+]);
+// death screen: the localized "Splatted by <weapon>!" burst message (tight
+// caps ~28px; the face reads between the two Blitz cuts at capture
+// fidelity, so carry both and let recognition take the max) and the
+// splash-tag name, which is BlitzBold for latin but the angular Rowdy face
+// for kana
+const deathWeaponTexts = [
+	...ALL_WEAPON_ENTRIES.map((e) => e.name),
+	...Object.values(LOCALIZED_WEAPON_NAMES).flatMap((names) =>
+		names.map((n) => n.text),
+	),
+	...DEATH_MESSAGE_TEMPLATES.flatMap((t) => [
+		t.constText,
+		t.weaponPre,
+		t.weaponPost,
+	]),
+];
+await build("death-weapon", 34, [
+	{
+		family: "BlitzMain",
+		pxs: [40, 41],
+		chars: localizedChars(deathWeaponTexts, "BlitzMain"),
+	},
+	{
+		family: "BlitzBold",
+		pxs: [43, 44],
+		chars: localizedChars(deathWeaponTexts, "BlitzBold"),
+	},
+]);
+// JA death message, a separate atlas read only by the JA line ROIs: mixing
+// kana into the Latin set would shift its median width (breaking wide-
+// segment splitting) and displace Latin matches on ranking noise. The
+// in-game JP face renders horizontally condensed and sits between the two
+// FOT cuts at capture fidelity — ス/ク read as Kurokane, で as Rowdy — so
+// carry both, at the (px, xScale) pairs that peaked in an NCC sweep against
+// the classic-squiffer-jp fixture. Latin/digit chars inside JP weapon names
+// (LACT-450, .52ガロン) ride along in both faces. Attested-fixture rule as
+// everywhere: KO/ZH names stay in the closed sets without an atlas.
+const deathJaTexts = [
+	...(LOCALIZED_WEAPON_NAMES.JPja ?? []).map((n) => n.text),
+	...DEATH_MESSAGE_TEMPLATES.filter((t) =>
+		t.langs.some((l) => l.endsWith("ja")),
+	).flatMap((t) => [t.constText, t.weaponPre, t.weaponPost]),
+];
+function coveredChars(texts: readonly string[], family: string): string[] {
+	const covers = fontCoverage[family]!;
+	return charsOf(texts).filter((ch) => covers(ch.codePointAt(0)!));
+}
+await build("death-weapon-ja", 40, [
+	{
+		family: "Kurokane",
+		pxs: [44, 46],
+		xScale: 0.75,
+		chars: coveredChars(deathJaTexts, "Kurokane"),
+	},
+	{
+		family: "Rowdy",
+		pxs: [38, 40],
+		xScale: 0.8,
+		chars: coveredChars(deathJaTexts, "Rowdy"),
+	},
+]);
+// nominal 42 with the detector scaling to 46 reads strictly better than a
+// native-46 render (the cubic upscale slightly fattens strokes the way the
+// in-game compositing does; a native render splits か into two segments)
+await build("death-tag-name", 42, [
+	{ family: "BlitzBold", pxs: [53, 54], chars: nameCharset() },
+	{ family: "Rowdy", pxs: [52, 54], chars: nameCharset() },
+]);
diff --git a/scripts/scanner/build-localized-entries.ts b/scripts/scanner/build-localized-entries.ts
new file mode 100644
index 000000000..c3b26a72e
--- /dev/null
+++ b/scripts/scanner/build-localized-entries.ts
@@ -0,0 +1,436 @@
+/** biome-ignore-all lint/suspicious/noConsole: CLI script output */
+/**
+ * Generate the localized closed sets from the splat3 repo's language dumps
+ * (https://github.com/Leanny/splat3, data/language/<Lang>_full.json), so
+ * ingestion works no matter which language the player runs the game in.
+ * Detectors OCR whatever is on screen, snap it against every language's
+ * entries, and always emit the sendou.ink id (canonical English text
+ * exists only inside the snap tables).
+ *
+ * Sources per language:
+ *   CommonMsg/VS/VSRuleName          modes (+ the _2L two-line intro-splash
+ *                                    wrap variants, e.g. "Muschel-\nchaos")
+ *   CommonMsg/VS/VSStageName         stages (keyed via the USen values)
+ *   CommonMsg/MatchMode              lobby tags (XMatch / Private)
+ *   LayoutMsg/Lobby_MenuMode_00      the intro splash's "MODE" label
+ *   LayoutMsg/Mng_Result_00          replay-browser VICTORY / DEFEAT tags
+ *   LayoutMsg/VS_Beaten_00 (999)     the death-burst message; the weapon
+ *                                    placeholder sits on line 1 or 2
+ *                                    depending on language, so this becomes
+ *                                    a per-language template
+ *   CommonMsg/Weapon/WeaponName_*    weapon names, mapped to the canonical
+ *                                    entries via their USen value
+ *
+ * Usage: pnpm scanner:build-localized-entries [path-to-splat3]
+ * Writes app/features/scanner/core/localized-entries.ts
+ *    and app/features/scanner/core/detectors/death/localized-messages.ts
+ */
+import { readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { ALL_WEAPON_ENTRIES } from "../../app/features/scanner/core/detectors/death/weapon-names";
+import type { ScannerLobby } from "../../app/features/scanner/scanner-types";
+import { stageIds } from "../../app/modules/in-game-lists/stage-ids";
+import type { ModeShort, StageId } from "../../app/modules/in-game-lists/types";
+import gameMisc from "../../locales/en/game-misc.json";
+
+const SPLAT3_DIR =
+	process.argv[2] ?? new URL("../../../splat3", import.meta.url).pathname;
+const LANG_DIR = join(SPLAT3_DIR, "data", "language");
+const OUT_ENTRIES = new URL(
+	"../../app/features/scanner/core/localized-entries.ts",
+	import.meta.url,
+).pathname;
+const OUT_MESSAGES = new URL(
+	"../../app/features/scanner/core/detectors/death/localized-messages.ts",
+	import.meta.url,
+).pathname;
+
+const CANONICAL_LANG = "USen";
+const misc = gameMisc as Record<string, string>;
+
+/** VSRuleName key -> ModeShort; USen values validate against the en locale. */
+const RULE_KEYS: Record<string, ModeShort> = {
+	Pnt: "TW",
+	Var: "SZ",
+	Vlf: "TC",
+	Vgl: "RM",
+	Vcl: "CB",
+};
+
+/** MatchMode key -> lobby code; USen values validate against these names. */
+const LOBBY_KEYS: Record<string, ScannerLobby> = {
+	XMatch: "X",
+	Bankara: "SERIES",
+	BankaraOpen: "OPEN",
+	Private: "PRIVATE",
+};
+
+/** the English lobby tags as the game shows them, for USen validation */
+const LOBBY_ENGLISH: Record<ScannerLobby, string> = {
+	X: "X Battle",
+	SERIES: "Anarchy Battle (Series)",
+	OPEN: "Anarchy Battle (Open)",
+	PRIVATE: "Private Battle",
+};
+
+type LangDump = Record<string, Record<string, string>>;
+
+function loadLang(lang: string): LangDump {
+	return JSON.parse(
+		readFileSync(join(LANG_DIR, `${lang}_full.json`), "utf8"),
+	) as LangDump;
+}
+
+/** Drop [size=...]/[color=...]-style markup and collapse whitespace. */
+function clean(s: string): string {
+	return s
+		.replace(/\[[^\]]*\]/g, "")
+		.replace(/[ \t]+/g, " ")
+		.trim();
+}
+
+/** The case/space/diacritic-insensitive key entries are deduped on (mirrors text.ts). */
+function foldKey(s: string): string {
+	return s
+		.toLowerCase()
+		.normalize("NFD")
+		.replace(/[\u0300-\u036f]/g, "")
+		.replace(/\s+/g, "");
+}
+
+/** sendou.ink locales use the ASCII apostrophe; the game dumps use ’. */
+function normalizeApostrophes(s: string): string {
+	return s.replace(/[’‘]/g, "'");
+}
+
+const languages = [
+	...new Set(
+		readdirSync(LANG_DIR)
+			.filter((f) => f.endsWith("_full.json"))
+			.map((f) => f.replace("_full.json", "")),
+	),
+].sort();
+if (!languages.includes(CANONICAL_LANG)) {
+	throw new Error(
+		`canonical language ${CANONICAL_LANG} not found in ${LANG_DIR}`,
+	);
+}
+
+const dumps = new Map<string, LangDump>(languages.map((l) => [l, loadLang(l)]));
+const usen = dumps.get(CANONICAL_LANG)!;
+
+// ---- validate the canonical sets against USen ------------------------------
+
+for (const [key, mode] of Object.entries(RULE_KEYS)) {
+	const value = clean(usen["CommonMsg/VS/VSRuleName"]![key]!);
+	const expected = misc[`MODE_LONG_${mode}`]!;
+	if (value !== expected)
+		throw new Error(`USen rule ${key} is "${value}", expected "${expected}"`);
+}
+for (const [key, lobby] of Object.entries(LOBBY_KEYS)) {
+	const value = clean(usen["CommonMsg/MatchMode"]![key]!);
+	const expected = LOBBY_ENGLISH[lobby as ScannerLobby];
+	if (value !== expected)
+		throw new Error(`USen lobby ${key} is "${value}", expected "${expected}"`);
+}
+
+/** English stage name (per the sendou.ink en locale) -> StageId. */
+const stageIdByEnglishName = new Map<string, StageId>(
+	stageIds.map((stageId) => [misc[`STAGE_${stageId}`]!, stageId]),
+);
+/** VSStageName key -> StageId, via the USen values. */
+const stageKeys = new Map<string, StageId>();
+for (const [key, value] of Object.entries(usen["CommonMsg/VS/VSStageName"]!)) {
+	const stageId = stageIdByEnglishName.get(value);
+	if (stageId !== undefined) stageKeys.set(key, stageId);
+}
+for (const [name, stageId] of stageIdByEnglishName) {
+	if (![...stageKeys.values()].includes(stageId)) {
+		throw new Error(
+			`stage "${name}" (id ${stageId}) not found in USen VSStageName`,
+		);
+	}
+}
+
+// ---- per-language closed sets ----------------------------------------------
+
+interface LocalizedLobby {
+	text: string;
+	lobby: ScannerLobby;
+}
+interface LocalizedMode {
+	text: string;
+	mode: ModeShort;
+}
+interface LocalizedStage {
+	text: string;
+	stageId: StageId;
+}
+
+interface LanguageEntries {
+	lang: string;
+	modeLabel: string;
+	victory: string;
+	defeat: string;
+	lobbies: LocalizedLobby[];
+	modes: LocalizedMode[];
+	modeWraps: LocalizedMode[];
+	stages: LocalizedStage[];
+}
+
+const languageEntries: LanguageEntries[] = [];
+for (const lang of languages) {
+	const d = dumps.get(lang)!;
+	const rules = d["CommonMsg/VS/VSRuleName"]!;
+	const modes: LocalizedMode[] = [];
+	const modeWraps: LocalizedMode[] = [];
+	for (const [key, mode] of Object.entries(RULE_KEYS)) {
+		modes.push({ text: clean(rules[key]!), mode });
+		// the intro splash renders the _2L wrap variant, hyphens included
+		const wrap = clean(rules[`${key}_2L`]!.replace(/\n/g, " "));
+		if (foldKey(wrap) !== foldKey(rules[key]!))
+			modeWraps.push({ text: wrap, mode });
+	}
+	languageEntries.push({
+		lang,
+		modeLabel: clean(d["LayoutMsg/Lobby_MenuMode_00"]!.T_Rule_00!),
+		victory: clean(d["LayoutMsg/Mng_Result_00"]!.T_Win_00!),
+		defeat: clean(d["LayoutMsg/Mng_Result_00"]!.T_Lose_00!),
+		lobbies: Object.entries(LOBBY_KEYS).map(([key, lobby]) => ({
+			text: clean(d["CommonMsg/MatchMode"]![key]!),
+			lobby,
+		})),
+		modes,
+		modeWraps,
+		stages: [...stageKeys.entries()].map(([key, stageId]) => ({
+			text: clean(d["CommonMsg/VS/VSStageName"]![key]!),
+			stageId,
+		})),
+	});
+}
+
+// A localized string that means one thing in language A and another in
+// language B would snap ambiguously in the flattened unions — reject.
+for (const category of ["lobbies", "modes", "modeWraps", "stages"] as const) {
+	const seen = new Map<string, string | number>();
+	for (const entries of languageEntries) {
+		for (const entry of entries[category]) {
+			const value =
+				"lobby" in entry
+					? entry.lobby
+					: "mode" in entry
+						? entry.mode
+						: entry.stageId;
+			const k = foldKey(entry.text);
+			const prior = seen.get(k);
+			if (prior !== undefined && prior !== value) {
+				throw new Error(
+					`${category}: "${entry.text}" maps to both "${prior}" and "${value}" across languages`,
+				);
+			}
+			seen.set(k, value);
+		}
+	}
+}
+
+// ---- death message templates -----------------------------------------------
+
+const PLACEHOLDER = /\[group=[^\]]*\]/;
+/** stands in for the weapon placeholder while splitting the message */
+const SENTINEL = "\u0000";
+
+interface DeathTemplate {
+	langs: string[];
+	weaponLine: 1 | 2;
+	constText: string;
+	weaponPre: string;
+	weaponPost: string;
+}
+
+const templates: DeathTemplate[] = [];
+for (const lang of languages) {
+	const raw = dumps.get(lang)!["LayoutMsg/VS_Beaten_00"]!["999"]!;
+	const lines = raw
+		.split("\n")
+		.map((l) => clean(l.replace(PLACEHOLDER, SENTINEL)));
+	if (lines.length !== 2)
+		throw new Error(`${lang}: death message is not two lines: ${raw}`);
+	const weaponIndex = lines.findIndex((l) => l.includes(SENTINEL));
+	if (weaponIndex < 0)
+		throw new Error(`${lang}: no weapon placeholder: ${raw}`);
+	const weaponLine = (weaponIndex + 1) as 1 | 2;
+	const [pre, post] = lines[weaponLine - 1]!.split(SENTINEL) as [
+		string,
+		string,
+	];
+	const constText = lines[weaponLine % 2]!;
+	const existing = templates.find(
+		(t) =>
+			t.weaponLine === weaponLine &&
+			t.constText === constText &&
+			t.weaponPre === pre &&
+			t.weaponPost === post,
+	);
+	if (existing) existing.langs.push(lang);
+	else
+		templates.push({
+			langs: [lang],
+			weaponLine,
+			constText,
+			weaponPre: pre,
+			weaponPost: post,
+		});
+}
+
+// ---- localized weapon names --------------------------------------------------
+
+const WEAPON_MSGS = [
+	"CommonMsg/Weapon/WeaponName_Main",
+	"CommonMsg/Weapon/WeaponName_Sub",
+	"CommonMsg/Weapon/WeaponName_Special",
+];
+
+const canonicalWeaponNames = new Set(ALL_WEAPON_ENTRIES.map((e) => e.name));
+/** codename -> canonical entry name, via the USen value. */
+const weaponCodenames = new Map<string, string>();
+for (const msg of WEAPON_MSGS) {
+	for (const [codename, value] of Object.entries(usen[msg]!)) {
+		const name = normalizeApostrophes(value);
+		if (canonicalWeaponNames.has(name))
+			weaponCodenames.set(`${msg} ${codename}`, name);
+	}
+}
+const unmapped = [...canonicalWeaponNames].filter(
+	(n) => ![...weaponCodenames.values()].includes(n),
+);
+if (unmapped.length > 0) {
+	console.warn(
+		`WARNING: ${unmapped.length} weapon entries have no splat3 codename: ${unmapped.join(", ")}`,
+	);
+}
+
+/** lang -> localized names that differ from the canonical English name. */
+const localizedWeaponNames: Record<string, { text: string; name: string }[]> =
+	{};
+for (const lang of languages) {
+	const d = dumps.get(lang)!;
+	const seen = new Set<string>();
+	const entries: { text: string; name: string }[] = [];
+	for (const [key, name] of weaponCodenames) {
+		const [msg, codename] = key.split(" ") as [string, string];
+		const text = clean(d[msg]![codename] ?? "");
+		if (!text || text === "-") continue;
+		const k = foldKey(text);
+		if (seen.has(k) || k === foldKey(name)) continue;
+		seen.add(k);
+		entries.push({ text, name });
+	}
+	if (entries.length > 0) localizedWeaponNames[lang] = entries;
+}
+
+// ---- emit --------------------------------------------------------------------
+
+const banner = (extra: string) =>
+	`/**
+ * GENERATED by scripts/scanner/build-localized-entries.ts from the splat3 repo's
+ * language dumps — do not edit by hand; regenerate when the game adds
+ * content. ${extra}
+ */`;
+
+writeFileSync(
+	OUT_ENTRIES,
+	`${banner(
+		`Localized versus-UI strings for every game language, each
+ * mapped to the sendou.ink id it means (core/localized.ts derives the
+ * flattened match sets detectors snap OCR output against).`,
+	)}
+import type { ModeShort, StageId } from "~/modules/in-game-lists/types";
+import type { ScannerLobby } from "../scanner-types";
+
+export interface LocalizedLobby {
+  text: string;
+  lobby: ScannerLobby;
+}
+
+export interface LocalizedMode {
+  text: string;
+  mode: ModeShort;
+}
+
+export interface LocalizedStage {
+  text: string;
+  stageId: StageId;
+}
+
+export interface LanguageEntries {
+  lang: string;
+  /** the intro splash's constant "MODE" label */
+  modeLabel: string;
+  /** replay-browser winner/loser panel tags */
+  victory: string;
+  defeat: string;
+  lobbies: LocalizedLobby[];
+  modes: LocalizedMode[];
+  /** two-line intro-splash wrap variants ("Muschel-\\nchaos"), space-joined */
+  modeWraps: LocalizedMode[];
+  stages: LocalizedStage[];
+}
+
+export const LANGUAGE_ENTRIES: readonly LanguageEntries[] = ${JSON.stringify(
+		languageEntries,
+		null,
+		2,
+	)};
+`,
+);
+
+writeFileSync(
+	OUT_MESSAGES,
+	`${banner(
+		`Per-language death-burst message templates and localized
+ * weapon names: the "Splatted by\\n<weapon>!" burst puts the weapon on line
+ * 1 or 2 depending on language, with language-specific text around it.`,
+	)}
+
+export interface DeathMessageTemplate {
+  /** languages sharing this exact template */
+  langs: readonly string[];
+  /** which burst line carries the weapon name */
+  weaponLine: 1 | 2;
+  /** the constant text on the other line (parse-time confirmation) */
+  constText: string;
+  /** constant text around the weapon name on its own line */
+  weaponPre: string;
+  weaponPost: string;
+}
+
+export const DEATH_MESSAGE_TEMPLATES: readonly DeathMessageTemplate[] = ${JSON.stringify(
+		templates,
+		null,
+		2,
+	)};
+
+export interface LocalizedWeaponName {
+  text: string;
+  /** canonical English entry name (weapon-names.ts) */
+  name: string;
+}
+
+/**
+ * Per-language weapon names that differ from the canonical English name
+ * (identical ones are omitted; match against the canonical set too).
+ */
+export const LOCALIZED_WEAPON_NAMES: Readonly<
+  Record<string, readonly LocalizedWeaponName[]>
+> = ${JSON.stringify(localizedWeaponNames, null, 2)};
+`,
+);
+
+console.info(
+	`localized-entries: ${languages.length} languages, ` +
+		`${languageEntries.reduce((n, l) => n + l.stages.length, 0)} stage strings`,
+);
+console.info(
+	`localized-messages: ${templates.length} death templates, ` +
+		`${Object.values(localizedWeaponNames).reduce((n, e) => n + e.length, 0)} localized weapon names`,
+);
diff --git a/scripts/scanner/build-planner-signatures.ts b/scripts/scanner/build-planner-signatures.ts
new file mode 100644
index 000000000..217274bf3
--- /dev/null
+++ b/scripts/scanner/build-planner-signatures.ts
@@ -0,0 +1,111 @@
+/** biome-ignore-all lint/suspicious/noConsole: CLI script output */
+/**
+ * Build the planner signature atlas from the assets repo's planner renders.
+ *
+ * The sendou-ink/assets checkout's assets/planner-maps/ holds the full
+ * planner PNGs (~340MB), named "<stageId>-<MODE>-<TYPE>.png" (MODE in
+ * CB/RM/SZ/TC/TW; TYPE in OVER/MINI/ITEMS). This tool reduces each
+ * PLANNER_TYPE render to the ink-invariant structural signature
+ * (app/features/scanner/core/detectors/minimap/stage.ts) and packs all of them,
+ * quantized to uint8, into a single grayscale atlas PNG plus a manifest
+ * (keys "<stageId>-<MODE>") — a few hundred KB the minimap detector loads
+ * to identify the stage. Output goes to the assets checkout
+ * (SCANNER_ASSETS_DIR/planner); shipping a regen means pushing the assets repo.
+ *
+ *   pnpm scanner:build-planner-signatures
+ */
+import { mkdirSync, readdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { loadOpenCV } from "../../app/features/scanner/core/cv";
+import {
+	PLANNER_SIG_H,
+	PLANNER_SIG_W,
+	type PlannerManifest,
+	plannerSignature,
+} from "../../app/features/scanner/core/detectors/minimap/stage";
+import {
+	type FrameData,
+	normalizeFrame,
+	toMat,
+} from "../../app/features/scanner/core/image";
+import { SCANNER_ASSETS_DIR } from "../../app/features/scanner/node/assets-dir";
+import { readImage, writePng } from "../../app/features/scanner/node/image-io";
+
+/** which render variant the signatures are built from */
+const PLANNER_TYPE = process.env.SCANNER_PLANNER_TYPE ?? "MINI";
+const SRC_DIR =
+	process.env.SCANNER_PLANNER_MAPS_DIR ??
+	new URL("../../../assets/assets/planner-maps", import.meta.url).pathname;
+const OUT_DIR =
+	process.env.SCANNER_PLANNER_OUT_DIR ?? join(SCANNER_ASSETS_DIR, "planner");
+const COLS = 5;
+
+await loadOpenCV();
+
+const files = readdirSync(SRC_DIR)
+	.filter((f) => f.endsWith(`-${PLANNER_TYPE}.png`))
+	.sort((a, b) => {
+		const [sa, ma] = a.split("-");
+		const [sb, mb] = b.split("-");
+		return Number(sa) - Number(sb) || ma!.localeCompare(mb!);
+	});
+if (files.length === 0) {
+	throw new Error(`no ${PLANNER_TYPE} planner PNGs in ${SRC_DIR}`);
+}
+
+const rows = Math.ceil(files.length / COLS);
+const atlasW = COLS * PLANNER_SIG_W;
+const atlasH = rows * PLANNER_SIG_H;
+const atlas: FrameData = {
+	width: atlasW,
+	height: atlasH,
+	data: new Uint8ClampedArray(atlasW * atlasH * 4),
+};
+const keys: string[] = [];
+
+for (let i = 0; i < files.length; i++) {
+	const file = files[i]!;
+	const key = file.replace(`-${PLANNER_TYPE}.png`, "");
+	keys.push(key);
+
+	const img = toMat(await readImage(join(SRC_DIR, file)));
+	const norm = normalizeFrame(img);
+	const sig = plannerSignature(norm);
+	img.delete();
+	norm.delete();
+
+	// quantize to uint8 (load re-normalizes to unit L2, so the scale is free)
+	let max = 0;
+	for (const v of sig) if (v > max) max = v;
+	const scale = max > 0 ? 255 / max : 0;
+
+	const tx = (i % COLS) * PLANNER_SIG_W;
+	const ty = Math.floor(i / COLS) * PLANNER_SIG_H;
+	for (let y = 0; y < PLANNER_SIG_H; y++) {
+		for (let x = 0; x < PLANNER_SIG_W; x++) {
+			const v = Math.round(sig[y * PLANNER_SIG_W + x]! * scale);
+			const o = ((ty + y) * atlasW + (tx + x)) * 4;
+			atlas.data[o] = v;
+			atlas.data[o + 1] = v;
+			atlas.data[o + 2] = v;
+			atlas.data[o + 3] = 255;
+		}
+	}
+}
+
+mkdirSync(OUT_DIR, { recursive: true });
+writePng(join(OUT_DIR, "signatures.png"), atlas);
+const manifest: PlannerManifest = {
+	width: PLANNER_SIG_W,
+	height: PLANNER_SIG_H,
+	cols: COLS,
+	keys,
+};
+writeFileSync(
+	join(OUT_DIR, "manifest.json"),
+	`${JSON.stringify(manifest, null, 2)}\n`,
+);
+
+console.info(
+	`packed ${files.length} signatures into ${atlasW}x${atlasH} atlas -> ${OUT_DIR}`,
+);
diff --git a/scripts/scanner/dump-crops.ts b/scripts/scanner/dump-crops.ts
new file mode 100644
index 000000000..0f1c8fc7b
--- /dev/null
+++ b/scripts/scanner/dump-crops.ts
@@ -0,0 +1,93 @@
+/** biome-ignore-all lint/suspicious/noConsole: CLI script output */
+/**
+ * ROI calibration helper: normalize a frame to 1080p, then dump crops
+ * (optionally scaled up) and/or a grid overlay for visual inspection.
+ *
+ * Usage:
+ *   vite-node -c scripts/scanner/vite-node.config.ts scripts/scanner/dump-crops.ts <image> <outdir> grid
+ *   vite-node -c scripts/scanner/vite-node.config.ts scripts/scanner/dump-crops.ts <image> <outdir> x,y,w,h[,scale][:label] ...
+ */
+import { mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { loadOpenCV } from "../../app/features/scanner/core/cv";
+import {
+	cropRoi,
+	matToFrameData,
+	normalizeFrame,
+	toMat,
+} from "../../app/features/scanner/core/image";
+import { readImage, writePng } from "../../app/features/scanner/node/image-io";
+
+const [imagePath, outDir, ...specs] = process.argv.slice(2);
+if (!imagePath || !outDir || specs.length === 0) {
+	console.error(
+		"usage: vite-node -c scripts/scanner/vite-node.config.ts scripts/scanner/dump-crops.ts <image> <outdir> (grid | x,y,w,h[,scale][:label])...",
+	);
+	process.exit(1);
+}
+
+const cv = await loadOpenCV();
+mkdirSync(outDir, { recursive: true });
+
+const src = toMat(await readImage(imagePath));
+const frame = normalizeFrame(src);
+src.delete();
+
+for (const spec of specs) {
+	if (spec === "grid") {
+		const overlay = frame.clone();
+		for (let x = 0; x < overlay.cols; x += 20) {
+			const major = x % 100 === 0;
+			cv.line(
+				overlay,
+				new cv.Point(x, 0),
+				new cv.Point(x, overlay.rows),
+				new cv.Scalar(255, 0, major ? 0 : 255, 255),
+				major ? 2 : 1,
+			);
+		}
+		for (let y = 0; y < overlay.rows; y += 20) {
+			const major = y % 100 === 0;
+			cv.line(
+				overlay,
+				new cv.Point(0, y),
+				new cv.Point(overlay.cols, y),
+				new cv.Scalar(255, 0, major ? 0 : 255, 255),
+				major ? 2 : 1,
+			);
+		}
+		writePng(join(outDir, "grid.png"), matToFrameData(overlay));
+		overlay.delete();
+		continue;
+	}
+	const [rect = "", label] = spec.split(":");
+	const [x, y, w, h, scale = 1] = rect.split(",").map(Number);
+	if ([x, y, w, h].some((v) => !Number.isFinite(v))) {
+		console.error(`bad spec: ${spec}`);
+		continue;
+	}
+	const cx = Math.max(0, Math.min(x!, frame.cols - 1));
+	const cy = Math.max(0, Math.min(y!, frame.rows - 1));
+	const crop = cropRoi(frame, {
+		x: cx,
+		y: cy,
+		w: Math.min(w!, frame.cols - cx),
+		h: Math.min(h!, frame.rows - cy),
+	});
+	const out = new cv.Mat();
+	cv.resize(
+		crop,
+		out,
+		new cv.Size(0, 0),
+		Number(scale),
+		Number(scale),
+		cv.INTER_NEAREST,
+	);
+	const name = label ?? `crop-${x}-${y}-${w}x${h}`;
+	writePng(join(outDir, `${name}.png`), matToFrameData(out));
+	crop.delete();
+	out.delete();
+}
+
+frame.delete();
+console.info(`wrote crops to ${outDir}`);
diff --git a/scripts/scanner/otf-cmap.ts b/scripts/scanner/otf-cmap.ts
new file mode 100644
index 000000000..606c45382
--- /dev/null
+++ b/scripts/scanner/otf-cmap.ts
@@ -0,0 +1,61 @@
+/** biome-ignore-all lint/suspicious/noConsole: CLI script output */
+/**
+ * Minimal OpenType cmap reader: which codepoints does a font actually map?
+ *
+ * @napi-rs/canvas silently falls back to a system font for characters the
+ * requested family lacks (the Blitz cuts carry Latin/Greek/Cyrillic/kana
+ * but no kanji, hangul or hanzi), which would bake wrong-font glyphs into
+ * the atlases. The builder filters every charset through this before
+ * rendering. Supports the two subtable formats the game fonts use:
+ * format 4 (BMP segments) and format 12 (grouped full-range).
+ */
+import { readFileSync } from "node:fs";
+
+export function readFontCoverage(path: string): (codepoint: number) => boolean {
+	const buf = readFileSync(path);
+	const numTables = buf.readUInt16BE(4);
+	let cmapOffset = -1;
+	for (let i = 0; i < numTables; i++) {
+		const rec = 12 + i * 16;
+		if (buf.toString("latin1", rec, rec + 4) === "cmap") {
+			cmapOffset = buf.readUInt32BE(rec + 8);
+			break;
+		}
+	}
+	if (cmapOffset < 0) throw new Error(`${path}: no cmap table`);
+
+	// prefer a full-repertoire format-12 subtable, else the BMP format 4
+	const encodingCount = buf.readUInt16BE(cmapOffset + 2);
+	let best = -1;
+	let bestFormat = -1;
+	for (let i = 0; i < encodingCount; i++) {
+		const rec = cmapOffset + 4 + i * 8;
+		const subtable = cmapOffset + buf.readUInt32BE(rec + 4);
+		const format = buf.readUInt16BE(subtable);
+		if (format === 12 || (format === 4 && bestFormat !== 12)) {
+			best = subtable;
+			bestFormat = format;
+		}
+	}
+	if (best < 0) throw new Error(`${path}: no format 4/12 cmap subtable`);
+
+	const ranges: [number, number][] = [];
+	if (bestFormat === 12) {
+		const nGroups = buf.readUInt32BE(best + 12);
+		for (let g = 0; g < nGroups; g++) {
+			const rec = best + 16 + g * 12;
+			ranges.push([buf.readUInt32BE(rec), buf.readUInt32BE(rec + 4)]);
+		}
+	} else {
+		const segCount = buf.readUInt16BE(best + 6) / 2;
+		const endCodes = best + 14;
+		const startCodes = endCodes + segCount * 2 + 2;
+		for (let s = 0; s < segCount; s++) {
+			const start = buf.readUInt16BE(startCodes + s * 2);
+			const end = buf.readUInt16BE(endCodes + s * 2);
+			if (start !== 0xffff) ranges.push([start, end]);
+		}
+	}
+	return (codepoint) =>
+		ranges.some(([start, end]) => codepoint >= start && codepoint <= end);
+}
diff --git a/scripts/scanner/overlay-rois.ts b/scripts/scanner/overlay-rois.ts
new file mode 100644
index 000000000..67da3ea5e
--- /dev/null
+++ b/scripts/scanner/overlay-rois.ts
@@ -0,0 +1,145 @@
+/** biome-ignore-all lint/suspicious/noConsole: CLI script output */
+/**
+ * Draw all scoreboard ROIs on a (normalized) frame for visual calibration.
+ * Usage: vite-node -c scripts/scanner/vite-node.config.ts scripts/scanner/overlay-rois.ts <image> [out.png] [scoreboard|scoreboard-battle-log-replay|scoreboard-battle-log]
+ */
+import { loadOpenCV, type Mat } from "../../app/features/scanner/core/cv";
+import * as death from "../../app/features/scanner/core/detectors/death/rois";
+import * as mapStart from "../../app/features/scanner/core/detectors/map-start/rois";
+import * as minimap from "../../app/features/scanner/core/detectors/minimap/rois";
+import * as sb from "../../app/features/scanner/core/detectors/scoreboard/rois";
+import * as bl from "../../app/features/scanner/core/detectors/scoreboard-battle-log/rois";
+import * as replay from "../../app/features/scanner/core/detectors/scoreboard-battle-log-replay/rois";
+import {
+	matToFrameData,
+	normalizeFrame,
+	type Roi,
+	toMat,
+} from "../../app/features/scanner/core/image";
+import { readImage, writePng } from "../../app/features/scanner/node/image-io";
+
+const [imagePath, outPath = "roi-overlay.png", detector = "scoreboard"] =
+	process.argv.slice(2);
+if (!imagePath) {
+	console.error(
+		"usage: vite-node -c scripts/scanner/vite-node.config.ts scripts/scanner/overlay-rois.ts <image> [out.png] [scoreboard|scoreboard-battle-log-replay|scoreboard-battle-log|death|map-start|minimap]",
+	);
+	process.exit(1);
+}
+
+const cv = await loadOpenCV();
+const src = toMat(await readImage(imagePath));
+const frame = normalizeFrame(src);
+src.delete();
+
+function rect(m: Mat, roi: Roi, color: [number, number, number]) {
+	cv.rectangle(
+		m,
+		new cv.Point(roi.x, roi.y),
+		new cv.Point(roi.x + roi.w, roi.y + roi.h),
+		new cv.Scalar(...color, 255),
+		1,
+	);
+}
+
+if (detector === "scoreboard") {
+	for (const cy of sb.ROW_CENTERS) {
+		rect(frame, sb.weaponRoi(cy), [255, 0, 0]);
+		rect(frame, sb.nameRoi(cy), [0, 255, 0]);
+		rect(frame, sb.paintRoi(cy), [0, 128, 255]);
+		for (const i of [0, 1, 2] as const)
+			rect(frame, sb.statRoi(cy, i), [255, 0, 255]);
+		rect(frame, sb.gateDarkProbe(cy), [255, 255, 0]);
+	}
+	for (const roi of sb.TEAM_SCORE_ROIS) rect(frame, roi, [0, 128, 255]);
+	for (const roi of sb.GATE_PANEL_PROBES) rect(frame, roi, [255, 255, 0]);
+} else if (detector === "scoreboard-battle-log-replay") {
+	for (const dx of replay.PANEL_XS) {
+		for (const cy of replay.ROW_CENTERS) {
+			rect(frame, replay.weaponRoi(cy, dx), [255, 0, 0]);
+			rect(frame, replay.nameRoi(cy, dx), [0, 255, 0]);
+			rect(frame, replay.paintRoi(cy, dx), [0, 128, 255]);
+			rect(frame, replay.paintSuffixRoi(cy, dx), [0, 255, 255]);
+			for (const i of [0, 1, 2] as const)
+				rect(frame, replay.statRoi(cy, dx, i), [255, 0, 255]);
+			rect(frame, replay.gateFlatProbe(cy, dx), [255, 255, 0]);
+		}
+		rect(frame, replay.teamScoreRoi(dx), [0, 128, 255]);
+		rect(frame, replay.resultTagRoi(dx), [255, 128, 0]);
+	}
+	for (const roi of replay.MATCH_SCORE_ROIS) rect(frame, roi, [0, 128, 255]);
+	for (const roi of replay.GATE_GAP_PROBES) rect(frame, roi, [255, 255, 0]);
+	rect(frame, replay.HEADER_TOP_BAND, [0, 255, 0]);
+	rect(frame, replay.HEADER_BOTTOM_BAND, [0, 255, 0]);
+	rect(frame, replay.REPLAY_CODE_ROI, [0, 255, 0]);
+} else if (detector === "scoreboard-battle-log") {
+	for (const dy of bl.PANEL_DYS) {
+		for (const base of bl.ROW_CENTERS) {
+			const cy = base + dy;
+			rect(frame, bl.weaponRoi(cy), [255, 0, 0]);
+			rect(frame, bl.nameRoi(cy), [0, 255, 0]);
+			rect(frame, bl.paintRoi(cy), [0, 128, 255]);
+			rect(frame, bl.paintSuffixRoi(cy), [0, 255, 255]);
+			for (const i of [0, 1, 2] as const)
+				rect(frame, bl.statRoi(cy, i), [255, 0, 255]);
+			rect(frame, bl.gateDarkProbe(cy), [255, 255, 0]);
+			rect(frame, bl.povArrowRoi(cy), [255, 128, 0]);
+			rect(frame, bl.specialIconRoi(cy), [255, 0, 0]);
+		}
+		rect(frame, bl.teamScoreRoi(dy), [0, 128, 255]);
+		rect(frame, bl.resultTagRoi(dy), [255, 128, 0]);
+	}
+	for (const roi of bl.MATCH_SCORE_ROIS) rect(frame, roi, [0, 128, 255]);
+	for (const roi of bl.GATE_COLOR_PROBES) rect(frame, roi, [255, 255, 0]);
+	rect(frame, bl.HEADER_TOP_BAND, [0, 255, 0]);
+	rect(frame, bl.HEADER_BOTTOM_BAND, [0, 255, 0]);
+} else if (detector === "death") {
+	rect(frame, death.SPLAT_LINE1_ROI, [0, 255, 0]);
+	rect(frame, death.WEAPON_LINE_ROI, [255, 0, 0]);
+	for (let row = 0; row < death.ABILITY_ROWS; row++) {
+		rect(frame, death.abilityMainRoi(row), [0, 128, 255]);
+		for (const slot of [0, 1, 2])
+			rect(frame, death.abilitySubRoi(row, slot), [255, 0, 255]);
+	}
+	rect(frame, death.TAG_NAME_OUTER, [0, 255, 0]);
+	for (const roi of [...death.GATE_BURST_PROBES, ...death.GATE_PANEL_PROBES]) {
+		rect(frame, roi, [255, 255, 0]);
+	}
+} else if (detector === "map-start") {
+	rect(frame, mapStart.MODE_LABEL_ROI, [0, 255, 0]);
+	rect(frame, mapStart.MODE_BLOCK_ROI, [255, 0, 0]);
+	rect(frame, mapStart.STAGE_ROI, [0, 128, 255]);
+	rect(frame, mapStart.GATE_INK_BAND, [0, 255, 255]);
+	for (const roi of mapStart.GATE_DARK_PROBES) rect(frame, roi, [255, 255, 0]);
+} else if (detector === "minimap") {
+	for (const card of minimap.CARD_LAYOUTS) {
+		rect(frame, card.name, [0, 255, 0]);
+		rect(frame, card.weapon, [255, 0, 0]);
+		rect(frame, card.subTile, [0, 255, 255]);
+		for (const [cx, cy] of card.badges)
+			rect(frame, minimap.badgeRoi(cx, cy), [0, 128, 255]);
+		rect(frame, card.cross, [255, 0, 255]);
+	}
+	for (const cy of minimap.ENEMY_ROW_CYS) {
+		rect(frame, minimap.enemyWeaponRoi(cy), [255, 0, 0]);
+		rect(frame, minimap.enemySubTileRoi(cy), [0, 255, 255]);
+		for (const cx of minimap.ENEMY_BADGE_XS)
+			rect(frame, minimap.badgeRoi(cx, cy), [0, 128, 255]);
+		rect(frame, minimap.enemyCrossRoi(cy), [255, 0, 255]);
+	}
+	for (const roi of [
+		minimap.GATE_CLOSE_BRIGHT,
+		minimap.GATE_SPAWN_BRIGHT,
+		...minimap.GATE_CLOSE_DARK_PROBES,
+		...minimap.GATE_SPAWN_DARK_PROBES,
+	]) {
+		rect(frame, roi, [255, 255, 0]);
+	}
+} else {
+	console.error(`unknown detector "${detector}"`);
+	process.exit(1);
+}
+
+writePng(outPath, matToFrameData(frame));
+frame.delete();
+console.info(`wrote ${outPath}`);
diff --git a/scripts/scanner/replay-frames.ts b/scripts/scanner/replay-frames.ts
new file mode 100644
index 000000000..db0338cc4
--- /dev/null
+++ b/scripts/scanner/replay-frames.ts
@@ -0,0 +1,82 @@
+/** biome-ignore-all lint/suspicious/noConsole: CLI script output */
+/**
+ * CLI harness: replay a directory of extracted VoD frames through the full
+ * detector registry driven by a DetectorScheduler, mirroring the analyzer
+ * worker's chunk scan — to reproduce scheduling-dependent misses offline.
+ * This is the tool for "the browser scan missed an event that a fixture
+ * parses fine": extract the surrounding footage with
+ *   ffmpeg -ss <startT> -i vod.mkv -t 30 -vf fps=6 frames/f%04d.png
+ * then replay it and watch which checks the scheduler ran and what they saw.
+ *
+ * Usage: pnpm scanner:replay <framesDir> <startT> <fps>
+ * (frames are ffmpeg-numbered f0001.png..; t = startT + (n-1)/fps)
+ */
+import { readdirSync } from "node:fs";
+import { join } from "node:path";
+import { loadOpenCV } from "../../app/features/scanner/core/cv";
+import { MAP_START_EVENT_TYPE } from "../../app/features/scanner/core/detectors/map-start/index";
+import {
+	createAllDetectors,
+	SCOREBOARD_EVENT_TYPES,
+} from "../../app/features/scanner/core/detectors/registry";
+import { DetectorScheduler } from "../../app/features/scanner/core/detectors/scheduler";
+import { normalizeFrame, toMat } from "../../app/features/scanner/core/image";
+import { readImage } from "../../app/features/scanner/node/image-io";
+import { loadScoreboardResources } from "../../app/features/scanner/node/resources";
+
+const [framesDir, startTArg, fpsArg] = process.argv.slice(2);
+if (!framesDir || !startTArg || !fpsArg) {
+	console.error("usage: pnpm scanner:replay <framesDir> <startT> <fps>");
+	process.exit(1);
+}
+const startT = Number(startTArg);
+const fps = Number(fpsArg);
+
+await loadOpenCV();
+const detectors = createAllDetectors(await loadScoreboardResources());
+const scheduler = new DetectorScheduler(detectors, {
+	matchOpeningTypes: [MAP_START_EVENT_TYPE],
+	matchClosingTypes: SCOREBOARD_EVENT_TYPES,
+});
+scheduler.reset(startT);
+
+const files = readdirSync(framesDir)
+	.filter((f) => f.endsWith(".png"))
+	.sort();
+
+for (const [i, file] of files.entries()) {
+	const t = startT + i / fps;
+	const due = scheduler.dueDetectors(t);
+	if (due.length === 0) continue;
+	const image = await readImage(join(framesDir, file));
+	const src = toMat(image);
+	const frame = normalizeFrame(src);
+	src.delete();
+	for (const detector of detectors) {
+		if (!due.includes(detector.id)) continue;
+		const gate = detector.gate(frame);
+		scheduler.recordGate(detector.id, t, gate.pass, gate.signature);
+		if (!gate.pass) {
+			if (process.env.LOG_GATES?.includes(detector.id)) {
+				console.log(
+					`${t.toFixed(2)} ${file} ${detector.id} gate=${gate.score.toFixed(3)} FAIL`,
+				);
+			}
+			continue;
+		}
+		if (!scheduler.shouldParse(detector.id, t)) {
+			console.log(
+				`${t.toFixed(2)} ${file} ${detector.id} gate=${gate.score.toFixed(3)} PARSE-SUPPRESSED`,
+			);
+			continue;
+		}
+		const events = detector.parse(frame, t, gate);
+		scheduler.recordParse(detector.id, t, events);
+		console.log(
+			`${t.toFixed(2)} ${file} ${detector.id} gate=${gate.score.toFixed(3)} events=[${events
+				.map((e) => `${e.type}@${e.confidence.toFixed(3)}`)
+				.join(", ")}]`,
+		);
+	}
+	frame.delete();
+}
diff --git a/scripts/scanner/report.ts b/scripts/scanner/report.ts
new file mode 100644
index 000000000..2b8158e2d
--- /dev/null
+++ b/scripts/scanner/report.ts
@@ -0,0 +1,513 @@
+/** biome-ignore-all lint/suspicious/noConsole: CLI script output */
+/**
+ * Accuracy report across all fixtures — separate from pass/fail testing.
+ * Runs each detector over its own fixture directory and prints aggregate
+ * per-field accuracy plus character error rate (CER) for names, the metric
+ * that drives glyph atlas expansion.
+ *
+ * Usage: pnpm scanner:report
+ */
+import { loadOpenCV } from "../../app/features/scanner/core/cv";
+import {
+	createDeathDetector,
+	type DeathData,
+} from "../../app/features/scanner/core/detectors/death/index";
+import {
+	createMapStartDetector,
+	type MapStartData,
+} from "../../app/features/scanner/core/detectors/map-start/index";
+import {
+	createMinimapDetector,
+	type MinimapData,
+} from "../../app/features/scanner/core/detectors/minimap/index";
+import { createScoreboardDetector } from "../../app/features/scanner/core/detectors/scoreboard/index";
+import { createScoreboardBattleLogDetector } from "../../app/features/scanner/core/detectors/scoreboard-battle-log/index";
+import {
+	createScoreboardBattleLogReplayDetector,
+	type ScoreboardBattleLogReplayData,
+} from "../../app/features/scanner/core/detectors/scoreboard-battle-log-replay/index";
+import {
+	createScoreboardOwnDetector,
+	type ScoreboardOwnData,
+} from "../../app/features/scanner/core/detectors/scoreboard-own/index";
+import type { Detector } from "../../app/features/scanner/core/detectors/types";
+import {
+	loadFixtures,
+	runDetectorOnFixture,
+} from "../../app/features/scanner/node/fixtures";
+import { loadScoreboardResources } from "../../app/features/scanner/node/resources";
+
+await loadOpenCV();
+const resources = await loadScoreboardResources();
+
+interface Config {
+	label: string;
+	detector: Detector<Partial<ScoreboardBattleLogReplayData>>;
+	fixturesDir: string;
+	event: string;
+}
+
+const configs: Config[] = [
+	{
+		label: "scoreboard",
+		detector: createScoreboardDetector(resources),
+		fixturesDir: "scoreboard",
+		event: "Scoreboard",
+	},
+	{
+		label: "scoreboard-battle-log-replay",
+		detector: createScoreboardBattleLogReplayDetector(resources),
+		fixturesDir: "scoreboard-battle-log-replay",
+		event: "ScoreboardBattleLogReplay",
+	},
+	{
+		label: "scoreboard-battle-log",
+		detector: createScoreboardBattleLogDetector(resources),
+		fixturesDir: "scoreboard-battle-log",
+		event: "ScoreboardBattleLog",
+	},
+];
+
+interface Tally {
+	ok: number;
+	total: number;
+}
+
+/** Levenshtein distance for CER. */
+function editDistance(a: string, b: string): number {
+	const dp = Array.from({ length: a.length + 1 }, (_, i) => {
+		const row = new Array<number>(b.length + 1).fill(0);
+		row[0] = i;
+		return row;
+	});
+	for (let j = 0; j <= b.length; j++) dp[0]![j] = j;
+	for (let i = 1; i <= a.length; i++) {
+		for (let j = 1; j <= b.length; j++) {
+			dp[i]![j] = Math.min(
+				dp[i - 1]![j]! + 1,
+				dp[i]![j - 1]! + 1,
+				dp[i - 1]![j - 1]! + (a[i - 1] === b[j - 1] ? 0 : 1),
+			);
+		}
+	}
+	return dp[a.length]![b.length]!;
+}
+
+function pct(t: Tally): string {
+	if (t.total === 0) return "     n/a";
+	return `${((100 * t.ok) / t.total).toFixed(1).padStart(5)}% (${t.ok}/${t.total})`;
+}
+
+for (const config of configs) {
+	// Shared negatives count toward gate accuracy (expectPositive is false).
+	const fixtures = [
+		...loadFixtures(config.fixturesDir),
+		...loadFixtures("negative"),
+	];
+
+	const tally = {
+		gate: { ok: 0, total: 0 } as Tally,
+		header: { ok: 0, total: 0 } as Tally,
+		timestamp: { ok: 0, total: 0 } as Tally,
+		replayCode: { ok: 0, total: 0 } as Tally,
+		matchScores: { ok: 0, total: 0 } as Tally,
+		weapons: { ok: 0, total: 0 } as Tally,
+		names: { ok: 0, total: 0 } as Tally,
+		paint: { ok: 0, total: 0 } as Tally,
+		stats: { ok: 0, total: 0 } as Tally,
+	};
+	let charEdits = 0;
+	let charTotal = 0;
+	const nameMisses: string[] = [];
+
+	for (const fixture of fixtures) {
+		const { gate, events } = await runDetectorOnFixture(
+			config.detector,
+			fixture,
+		);
+		const expectPositive = fixture.expected.event === config.event;
+		tally.gate.total++;
+		if (gate.pass === expectPositive) tally.gate.ok++;
+		if (!expectPositive || !events[0]) continue;
+
+		const event = events[0];
+		const expected = fixture.expected.data ?? {};
+		if (expected.mode !== undefined) {
+			tally.header.total++;
+			if (
+				event.data.lobby === (expected.lobby ?? null) &&
+				event.data.mode === (expected.mode ?? null) &&
+				event.data.stage === (expected.stage ?? null)
+			) {
+				tally.header.ok++;
+			}
+		}
+		if (expected.timestamp !== undefined) {
+			tally.timestamp.total++;
+			if (event.data.timestamp === expected.timestamp) tally.timestamp.ok++;
+		}
+		if (expected.replayCode !== undefined) {
+			tally.replayCode.total++;
+			if (event.data.replayCode === expected.replayCode) tally.replayCode.ok++;
+		}
+		if (expected.matchScores) {
+			tally.matchScores.total++;
+			if (
+				JSON.stringify(event.data.matchScores) ===
+				JSON.stringify(expected.matchScores)
+			) {
+				tally.matchScores.ok++;
+			}
+		}
+		(expected.players ?? []).forEach((want, i) => {
+			const got = event.data.players?.[i];
+			if (!got) return;
+			if (want.weaponId !== undefined) {
+				tally.weapons.total++;
+				if (got.weaponId === want.weaponId) tally.weapons.ok++;
+			}
+			if (want.name !== undefined) {
+				tally.names.total++;
+				const dist = editDistance(got.name, want.name);
+				charEdits += dist;
+				charTotal += want.name.length;
+				if (dist === 0) tally.names.ok++;
+				else
+					nameMisses.push(
+						`${fixture.name} row${i}: "${got.name}" != "${want.name}"`,
+					);
+			}
+			if (want.paint !== undefined) {
+				tally.paint.total++;
+				if (got.paint === want.paint) tally.paint.ok++;
+			}
+			if (want.ka !== undefined) {
+				tally.stats.total++;
+				if (
+					got.ka === want.ka &&
+					got.d === (want.d ?? null) &&
+					got.s === (want.s ?? null)
+				) {
+					tally.stats.ok++;
+				}
+			}
+		});
+	}
+
+	console.info(`\n=== ${config.label} (${fixtures.length} fixtures) ===`);
+	console.info(`gate        ${pct(tally.gate)}`);
+	console.info(`header      ${pct(tally.header)}`);
+	if (tally.timestamp.total > 0) {
+		console.info(`timestamp   ${pct(tally.timestamp)}`);
+	}
+	if (tally.replayCode.total > 0) {
+		console.info(`replayCode  ${pct(tally.replayCode)}`);
+	}
+	console.info(`matchScores ${pct(tally.matchScores)}`);
+	console.info(`weapons     ${pct(tally.weapons)}`);
+	console.info(`names       ${pct(tally.names)}`);
+	console.info(`paint       ${pct(tally.paint)}`);
+	console.info(`stats       ${pct(tally.stats)}`);
+	console.info(
+		`name CER    ${charTotal ? ((100 * charEdits) / charTotal).toFixed(2) : "n/a"}% (${charEdits} edits / ${charTotal} chars)`,
+	);
+	if (nameMisses.length > 0) {
+		console.info("name misses:");
+		for (const m of nameMisses) console.info(`  ${m}`);
+	}
+}
+
+// Map-start fixtures only carry mode + stage, so they get their own pass.
+{
+	const detector = createMapStartDetector(resources);
+	const fixtures = loadFixtures("map-start");
+	const tally = {
+		gate: { ok: 0, total: 0 } as Tally,
+		mode: { ok: 0, total: 0 } as Tally,
+		stage: { ok: 0, total: 0 } as Tally,
+	};
+	const misses: string[] = [];
+
+	for (const fixture of fixtures) {
+		const { gate, events } = await runDetectorOnFixture<MapStartData>(
+			detector,
+			fixture,
+		);
+		const expectPositive = fixture.expected.event === "MapStart";
+		tally.gate.total++;
+		if (gate.pass === expectPositive) tally.gate.ok++;
+		if (!expectPositive || !events[0]) continue;
+		const event = events[0];
+		const expected = fixture.expected.data ?? {};
+		if (expected.mode !== undefined) {
+			tally.mode.total++;
+			if (event.data.mode === expected.mode) tally.mode.ok++;
+			else
+				misses.push(
+					`${fixture.name}: mode "${event.data.mode}" != "${expected.mode}"`,
+				);
+		}
+		if (expected.stage !== undefined) {
+			tally.stage.total++;
+			if (event.data.stage === expected.stage) tally.stage.ok++;
+			else
+				misses.push(
+					`${fixture.name}: stage "${event.data.stage}" != "${expected.stage}"`,
+				);
+		}
+	}
+
+	console.info(`\n=== map-start (${fixtures.length} fixtures) ===`);
+	console.info(`gate        ${pct(tally.gate)}`);
+	console.info(`mode        ${pct(tally.mode)}`);
+	console.info(`stage       ${pct(tally.stage)}`);
+	if (misses.length > 0) {
+		console.info("misses:");
+		for (const m of misses) console.info(`  ${m}`);
+	}
+}
+
+// Scoreboard-own fixtures carry header + own weapon + ability grid.
+{
+	const detector = createScoreboardOwnDetector(resources);
+	const fixtures = [
+		...loadFixtures("scoreboard-own"),
+		...loadFixtures("negative"),
+	];
+	const tally = {
+		gate: { ok: 0, total: 0 } as Tally,
+		header: { ok: 0, total: 0 } as Tally,
+		weapon: { ok: 0, total: 0 } as Tally,
+		abilities: { ok: 0, total: 0 } as Tally,
+	};
+	const misses: string[] = [];
+
+	for (const fixture of fixtures) {
+		const { gate, events } = await runDetectorOnFixture<ScoreboardOwnData>(
+			detector,
+			fixture,
+		);
+		const expectPositive = fixture.expected.event === "ScoreboardOwn";
+		tally.gate.total++;
+		if (gate.pass === expectPositive) tally.gate.ok++;
+		if (!expectPositive || !events[0]) continue;
+		const event = events[0];
+		const expected = fixture.expected.data ?? {};
+		if (expected.mode !== undefined) {
+			tally.header.total++;
+			if (
+				event.data.lobby === (expected.lobby ?? null) &&
+				event.data.mode === (expected.mode ?? null) &&
+				event.data.stage === (expected.stage ?? null)
+			) {
+				tally.header.ok++;
+			} else {
+				misses.push(
+					`${fixture.name}: header "${event.data.lobby}/${event.data.mode}/${event.data.stage}"`,
+				);
+			}
+		}
+		if (expected.weaponId !== undefined) {
+			tally.weapon.total++;
+			if (event.data.weaponId === expected.weaponId) tally.weapon.ok++;
+			else
+				misses.push(
+					`${fixture.name}: weapon ${event.data.weaponId} != ${expected.weaponId} ("${expected.weaponLabel ?? ""}")`,
+				);
+		}
+		(expected.abilities ?? []).forEach((wantRow, row) => {
+			wantRow.forEach((want, slot) => {
+				tally.abilities.total++;
+				const got = event.data.abilities[row]?.[slot];
+				if (got === want) tally.abilities.ok++;
+				else
+					misses.push(
+						`${fixture.name}: ability [${row}][${slot}] "${got}" != "${want}"`,
+					);
+			});
+		});
+	}
+
+	console.info(`\n=== scoreboard-own (${fixtures.length} fixtures) ===`);
+	console.info(`gate        ${pct(tally.gate)}`);
+	console.info(`header      ${pct(tally.header)}`);
+	console.info(`weapon      ${pct(tally.weapon)}`);
+	console.info(`abilities   ${pct(tally.abilities)}`);
+	if (misses.length > 0) {
+		console.info("misses:");
+		for (const m of misses) console.info(`  ${m}`);
+	}
+}
+
+// Minimap fixtures carry teammates/enemies, so they get their own pass.
+{
+	const detector = createMinimapDetector(resources);
+	const fixtures = [...loadFixtures("minimap"), ...loadFixtures("negative")];
+	const tally = {
+		gate: { ok: 0, total: 0 } as Tally,
+		weapons: { ok: 0, total: 0 } as Tally,
+		names: { ok: 0, total: 0 } as Tally,
+		abilities: { ok: 0, total: 0 } as Tally,
+		stage: { ok: 0, total: 0 } as Tally,
+	};
+	let charEdits = 0;
+	let charTotal = 0;
+	const misses: string[] = [];
+
+	for (const fixture of fixtures) {
+		const { gate, events } = await runDetectorOnFixture<MinimapData>(
+			detector,
+			fixture,
+		);
+		const expectPositive = fixture.expected.event === "Minimap";
+		tally.gate.total++;
+		if (gate.pass === expectPositive) tally.gate.ok++;
+		if (!expectPositive || !events[0]) continue;
+		const event = events[0];
+		const expected = fixture.expected.data ?? {};
+
+		const sides: [
+			string,
+			{
+				name?: string | null;
+				weaponId?: number | null;
+				abilities?: (string | null)[];
+			}[],
+			{
+				name?: string | null;
+				weaponId: number | null;
+				abilities: (string | null)[];
+			}[],
+		][] = [
+			["teammate", expected.teammates ?? [], event.data.teammates],
+			["enemy", expected.enemies ?? [], event.data.enemies],
+		];
+		for (const [side, wants, gots] of sides) {
+			wants.forEach((want, i) => {
+				const got = gots[i];
+				if (!got) return;
+				if (want.weaponId !== undefined) {
+					tally.weapons.total++;
+					if (got.weaponId === want.weaponId) tally.weapons.ok++;
+					else
+						misses.push(
+							`${fixture.name} ${side}${i}: weapon ${got.weaponId} != ${want.weaponId}`,
+						);
+				}
+				if (want.name !== undefined && want.name !== null) {
+					tally.names.total++;
+					const gotName = got.name ?? "";
+					const dist = editDistance(gotName, want.name);
+					charEdits += dist;
+					charTotal += want.name.length;
+					if (dist === 0) tally.names.ok++;
+					else
+						misses.push(
+							`${fixture.name} ${side}${i}: name "${gotName}" != "${want.name}"`,
+						);
+				}
+				(want.abilities ?? []).forEach((wantId, slot) => {
+					tally.abilities.total++;
+					const gotId = got.abilities[slot] ?? null;
+					if (gotId === wantId) tally.abilities.ok++;
+					else
+						misses.push(
+							`${fixture.name} ${side}${i}: ability [${slot}] "${gotId}" != "${wantId}"`,
+						);
+				});
+			});
+		}
+		if (expected.stage !== undefined) {
+			tally.stage.total++;
+			if (event.data.stage === expected.stage) tally.stage.ok++;
+			else
+				misses.push(
+					`${fixture.name}: stage "${event.data.stage}" != "${expected.stage}"`,
+				);
+		}
+	}
+
+	console.info(`\n=== minimap (${fixtures.length} fixtures) ===`);
+	console.info(`gate        ${pct(tally.gate)}`);
+	console.info(`weapons     ${pct(tally.weapons)}`);
+	console.info(`names       ${pct(tally.names)}`);
+	console.info(`abilities   ${pct(tally.abilities)}`);
+	console.info(`stage       ${pct(tally.stage)}`);
+	console.info(
+		`name CER    ${charTotal ? ((100 * charEdits) / charTotal).toFixed(2) : "n/a"}% (${charEdits} edits / ${charTotal} chars)`,
+	);
+	if (misses.length > 0) {
+		console.info("misses:");
+		for (const m of misses) console.info(`  ${m}`);
+	}
+}
+
+// Death fixtures carry a different data shape (weapon text, ability grid,
+// splash-tag name), so they get their own pass instead of a Config entry.
+{
+	const detector = createDeathDetector(resources);
+	const fixtures = loadFixtures("death");
+	const tally = {
+		gate: { ok: 0, total: 0 } as Tally,
+		weapon: { ok: 0, total: 0 } as Tally,
+		abilities: { ok: 0, total: 0 } as Tally,
+		names: { ok: 0, total: 0 } as Tally,
+	};
+	let charEdits = 0;
+	let charTotal = 0;
+	const misses: string[] = [];
+
+	for (const fixture of fixtures) {
+		const { gate, events } = await runDetectorOnFixture<DeathData>(
+			detector,
+			fixture,
+		);
+		const expectPositive = fixture.expected.event === "Death";
+		tally.gate.total++;
+		if (gate.pass === expectPositive) tally.gate.ok++;
+		if (!expectPositive || !events[0]) continue;
+		const event = events[0];
+		const expected = fixture.expected.data ?? {};
+		if (expected.weaponId !== undefined) {
+			tally.weapon.total++;
+			if (event.data.weaponId === expected.weaponId) tally.weapon.ok++;
+			else
+				misses.push(
+					`${fixture.name}: weapon ${event.data.weaponId} != ${expected.weaponId} ("${expected.weaponLabel ?? ""}")`,
+				);
+		}
+		(expected.abilities ?? []).forEach((wantRow, row) => {
+			wantRow.forEach((want, slot) => {
+				tally.abilities.total++;
+				const got = event.data.abilities[row]?.[slot];
+				if (got === want) tally.abilities.ok++;
+				else
+					misses.push(
+						`${fixture.name}: ability [${row}][${slot}] "${got}" != "${want}"`,
+					);
+			});
+		});
+		if (expected.name !== undefined) {
+			tally.names.total++;
+			const got = event.data.name ?? "";
+			const dist = editDistance(got, expected.name);
+			charEdits += dist;
+			charTotal += expected.name.length;
+			if (dist === 0) tally.names.ok++;
+			else misses.push(`${fixture.name}: name "${got}" != "${expected.name}"`);
+		}
+	}
+
+	console.info(`\n=== death (${fixtures.length} fixtures) ===`);
+	console.info(`gate        ${pct(tally.gate)}`);
+	console.info(`weapon      ${pct(tally.weapon)}`);
+	console.info(`abilities   ${pct(tally.abilities)}`);
+	console.info(`names       ${pct(tally.names)}`);
+	console.info(
+		`name CER    ${charTotal ? ((100 * charEdits) / charTotal).toFixed(2) : "n/a"}% (${charEdits} edits / ${charTotal} chars)`,
+	);
+	if (misses.length > 0) {
+		console.info("misses:");
+		for (const m of misses) console.info(`  ${m}`);
+	}
+}
diff --git a/scripts/scanner/run-fixtures.ts b/scripts/scanner/run-fixtures.ts
new file mode 100644
index 000000000..9cafb9222
--- /dev/null
+++ b/scripts/scanner/run-fixtures.ts
@@ -0,0 +1,52 @@
+/** biome-ignore-all lint/suspicious/noConsole: CLI script output */
+/**
+ * CLI harness: run the ScoreboardDetector over fixtures and print everything
+ * it saw — gate result, parsed fields, per-field scores, top weapon candidates.
+ *
+ * Usage: pnpm scanner:fixtures [case-name-substring]
+ */
+import { loadOpenCV } from "../../app/features/scanner/core/cv";
+import {
+	createScoreboardDetector,
+	type ScoreboardRowDebug,
+} from "../../app/features/scanner/core/detectors/scoreboard/index";
+import {
+	loadFixtures,
+	runDetectorOnFixture,
+} from "../../app/features/scanner/node/fixtures";
+import { loadScoreboardResources } from "../../app/features/scanner/node/resources";
+
+const filter = process.argv[2];
+
+await loadOpenCV();
+const detector = createScoreboardDetector(await loadScoreboardResources());
+
+const fixtures = loadFixtures("scoreboard").filter(
+	(f) => !filter || f.name.includes(filter),
+);
+if (fixtures.length === 0) {
+	console.error("no fixtures matched");
+	process.exit(1);
+}
+
+for (const fixture of fixtures) {
+	const { gate, events } = await runDetectorOnFixture(detector, fixture);
+	console.info(`\n=== ${fixture.name}`);
+	console.info(`gate: pass=${gate.pass} score=${gate.score.toFixed(3)}`);
+	for (const event of events) {
+		console.info(`event confidence=${event.confidence.toFixed(3)}`);
+		console.info(`matchScores: ${JSON.stringify(event.data.matchScores)}`);
+		const rows = (event.debug?.rows ?? []) as ScoreboardRowDebug[];
+		event.data.players.forEach((p, i) => {
+			const dbg = rows[i];
+			const top = dbg?.weapon?.top
+				.map((t) => `${t.id}:${t.score.toFixed(2)}`)
+				.join(" ");
+			console.info(
+				`  row${i}: name="${p.name}"(${dbg?.nameScore.toFixed(2)}) ` +
+					`weapon=${p.weaponId} [${top}] paint=${p.paint}(${dbg?.paintScore.toFixed(2)}) ` +
+					`ka=${p.ka} d=${p.d} s=${p.s} statScores=${dbg?.statScores.map((s) => s.toFixed(2)).join(",")}`,
+			);
+		});
+	}
+}
diff --git a/scripts/scanner/vite-node.config.ts b/scripts/scanner/vite-node.config.ts
new file mode 100644
index 000000000..c795a609a
--- /dev/null
+++ b/scripts/scanner/vite-node.config.ts
@@ -0,0 +1,18 @@
+/**
+ * Config for running the scanner scripts with vite-node. Deliberately minimal:
+ * the root vite.config.ts pre-bundles @techstark/opencv-js for the browser
+ * worker, and vite-node would resolve that browser prebundle (which
+ * crashes on __dirname in Node). Without the include, vite-node
+ * externalizes the dep to a plain require of the (patched) CJS bundle.
+ */
+import { defineConfig } from "vite";
+
+export default defineConfig({
+	resolve: {
+		tsconfigPaths: true,
+	},
+	optimizeDeps: {
+		noDiscovery: true,
+		exclude: ["@techstark/opencv-js"],
+	},
+});
diff --git a/vite.config.ts b/vite.config.ts
index 51f3addf1..94275933d 100644
--- a/vite.config.ts
+++ b/vite.config.ts
@@ -79,7 +79,11 @@ export default defineConfig((config) => {
 
 		test: {
 			globalSetup: ["./scripts/ensure-test-db.ts"],
-			projects: ["./vitest.unit.config.ts", "./vitest.browser.config.ts"],
+			projects: [
+				"./vitest.unit.config.ts",
+				"./vitest.browser.config.ts",
+				"./vitest.scanner.config.ts",
+			],
 		},
 		define: {
 			__GIT_COMMIT__: JSON.stringify(process.env.RENDER_GIT_COMMIT ?? ""),
@@ -102,6 +106,7 @@ export default defineConfig((config) => {
 			// and full page reloads on first navigations.
 			include: [
 				"@date-fns/tz",
+				"@techstark/opencv-js",
 				"@dnd-kit/core",
 				"@dnd-kit/modifiers",
 				"@dnd-kit/sortable",
@@ -133,6 +138,7 @@ export default defineConfig((config) => {
 				"kysely",
 				"kysely/helpers/sqlite",
 				"markdown-to-jsx",
+				"mediabunny",
 				"nanoid",
 				"openskill",
 				"pako",
diff --git a/vitest.scanner.config.ts b/vitest.scanner.config.ts
new file mode 100644
index 000000000..416e4c3f1
--- /dev/null
+++ b/vitest.scanner.config.ts
@@ -0,0 +1,18 @@
+import { configDefaults, defineConfig } from "vitest/config";
+
+// Scanner golden-file suite: Node-side (OpenCV.js WASM + @napi-rs/canvas image
+// IO), sweeping every fixture under app/features/scanner/tests/fixtures. Kept
+// out of the unit project so `--project unit` stays fast.
+export default defineConfig({
+	test: {
+		name: "scanner",
+		include: ["app/features/scanner/**/*.test.{ts,tsx}"],
+		exclude: [...configDefaults.exclude, "**/*.browser.test.{ts,tsx}"],
+		// OpenCV WASM init takes seconds and the fixture sweeps are heavy
+		testTimeout: 120_000,
+		hookTimeout: 120_000,
+	},
+	resolve: {
+		tsconfigPaths: true,
+	},
+});
diff --git a/vitest.unit.config.ts b/vitest.unit.config.ts
index 2124e3843..a1d594f31 100644
--- a/vitest.unit.config.ts
+++ b/vitest.unit.config.ts
@@ -8,6 +8,8 @@ export default defineConfig({
 			...configDefaults.exclude,
 			"e2e/**",
 			"**/*.browser.test.{ts,tsx}",
+			// the scanner golden-file suite has its own heavy project (vitest.scanner.config.ts)
+			"app/features/scanner/**",
 		],
 		setupFiles: ["./app/test-setup.ts"],
 	},