wows-compute 0.0.0-stage → 1.1.0

package/dist/match-J2T9QiGg.mjs

@@ -0,0 +1,441 @@
+//#region src/time/index.ts
+const GAME_DATE_PATTERN = /^(\d{2})\.(\d{2})\.(\d{4}) (\d{2}):(\d{2}):(\d{2})$/;
+const SECOND_MS = 1e3;
+const DAY_MS = 864e5;
+const formatters = /* @__PURE__ */ new Map();
+function formatterFor(timeZone) {
+	const cached = formatters.get(timeZone);
+	if (cached) return cached;
+	const formatter = new Intl.DateTimeFormat("en-US", {
+		timeZone,
+		hourCycle: "h23",
+		year: "numeric",
+		month: "2-digit",
+		day: "2-digit",
+		hour: "2-digit",
+		minute: "2-digit",
+		second: "2-digit"
+	});
+	formatters.set(timeZone, formatter);
+	return formatter;
+}
+function localParts(timestamp, timeZone) {
+	const parts = formatterFor(timeZone).formatToParts(new Date(timestamp));
+	const values = {};
+	for (const part of parts) if (part.type !== "literal") values[part.type] = part.value;
+	return {
+		year: Number(values.year),
+		month: Number(values.month),
+		day: Number(values.day),
+		hour: Number(values.hour),
+		minute: Number(values.minute),
+		second: Number(values.second)
+	};
+}
+function utcFromParts(parts) {
+	return Date.UTC(parts.year, parts.month - 1, parts.day, parts.hour, parts.minute, parts.second);
+}
+function offsetAt(timestamp, timeZone) {
+	return utcFromParts(localParts(timestamp, timeZone)) - timestamp;
+}
+function localToUtc(parts, timeZone) {
+	const guess = utcFromParts(parts);
+	const firstOffset = offsetAt(guess, timeZone);
+	const firstCandidate = guess - firstOffset;
+	const secondOffset = offsetAt(firstCandidate, timeZone);
+	return secondOffset === firstOffset ? firstCandidate : guess - secondOffset;
+}
+function pad(value, length = 2) {
+	return String(value).padStart(length, "0");
+}
+function isValidParts(parts) {
+	if (parts.month < 1 || parts.month > 12 || parts.day < 1 || parts.day > 31 || parts.hour < 0 || parts.hour > 23 || parts.minute < 0 || parts.minute > 59 || parts.second < 0 || parts.second > 59) return false;
+	const date = new Date(Date.UTC(parts.year, parts.month - 1, parts.day));
+	return date.getUTCFullYear() === parts.year && date.getUTCMonth() === parts.month - 1 && date.getUTCDate() === parts.day;
+}
+/**
+* Parses the game's `DD.MM.YYYY HH:mm:ss` format in an explicit time zone.
+*
+* The value itself carries no time zone: it is the recorder's local time, so
+* the caller must decide which zone the replay belongs to. Returns `null` for
+* malformed or impossible dates.
+*/
+function parseBattleTime(value, timeZone) {
+	const match = GAME_DATE_PATTERN.exec(value);
+	if (match === null) return null;
+	const parts = {
+		day: Number(match[1]),
+		month: Number(match[2]),
+		year: Number(match[3]),
+		hour: Number(match[4]),
+		minute: Number(match[5]),
+		second: Number(match[6])
+	};
+	if (!isValidParts(parts)) return null;
+	return localToUtc(parts, timeZone);
+}
+/**
+* Local "game day" label (`YYYY-MM-DD`).
+*
+* Days roll over at `boundaryHour` instead of midnight, so a battle at 02:00
+* still belongs to the previous game day.
+*/
+function gameDay(timestamp, timeZone, boundaryHour = 4) {
+	const parts = localParts(timestamp - boundaryHour * 60 * 60 * SECOND_MS, timeZone);
+	return `${pad(parts.year, 4)}-${pad(parts.month)}-${pad(parts.day)}`;
+}
+/** Start of the game week (Monday at `boundaryHour`, local time) containing `timestamp`. */
+function weekBoundary(timestamp, timeZone, boundaryHour = 4) {
+	const parts = localParts(timestamp - boundaryHour * 60 * 60 * SECOND_MS, timeZone);
+	const daysSinceMonday = (new Date(Date.UTC(parts.year, parts.month - 1, parts.day)).getUTCDay() + 6) % 7;
+	const monday = /* @__PURE__ */ new Date(Date.UTC(parts.year, parts.month - 1, parts.day) - daysSinceMonday * DAY_MS);
+	return localToUtc({
+		year: monday.getUTCFullYear(),
+		month: monday.getUTCMonth() + 1,
+		day: monday.getUTCDate(),
+		hour: boundaryHour,
+		minute: 0,
+		second: 0
+	}, timeZone);
+}
+/** Inclusive range check; omitted bounds are open. */
+function inRange(timestamp, from, to) {
+	if (from !== void 0 && timestamp < from) return false;
+	if (to !== void 0 && timestamp > to) return false;
+	return true;
+}
+//#endregion
+//#region src/match/index.ts
+const QUALITY_RANK = {
+	"meta-only": 0,
+	partial: 1,
+	complete: 2
+};
+const DEFAULT_TIME_ZONE = "Asia/Shanghai";
+/** Roster `dateTime` and results `startDt` differ by roughly 30–45 seconds in practice. */
+const ROSTER_TIME_TOLERANCE_MS = 12e4;
+/** Draw counts as a loss for both teams in every statistical view. */
+function statOutcome(outcome) {
+	if (outcome === "win") return "win";
+	if (outcome === "loss" || outcome === "draw") return "loss";
+	return null;
+}
+/**
+* Resolves a team's outcome.
+*
+* `winnerTeamId` is a real team id (`0` included). Negative values mean a
+* draw; `null` means the result packet carried no verdict.
+*/
+function outcomeOf(teamId, winnerTeamId) {
+	if (teamId === null || winnerTeamId === null) return "unknown";
+	if (winnerTeamId < 0) return "draw";
+	return teamId === winnerTeamId ? "win" : "loss";
+}
+function matchGroupOf(value) {
+	if (typeof value !== "string") return "unknown";
+	switch (value.trim().toLowerCase()) {
+		case "pvp":
+		case "random":
+		case "randombattle": return "pvp";
+		case "ranked":
+		case "rank": return "ranked";
+		case "coop":
+		case "cooperative":
+		case "pve": return "coop";
+		case "clan":
+		case "clanbattle": return "clan";
+		case "brawl": return "brawl";
+		case "event": return "event";
+		default: return "unknown";
+	}
+}
+function isBot(accountId, name) {
+	if (name !== null && name.startsWith(":")) return true;
+	return accountId !== null && accountId <= 0;
+}
+function relationOf(value) {
+	if (value === 0) return "self";
+	if (value === 1) return "ally";
+	if (value === 2) return "enemy";
+	return "unknown";
+}
+function finiteNumber(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function positiveInteger(value) {
+	const number = finiteNumber(value);
+	return number !== null && number > 0 ? Math.trunc(number) : null;
+}
+function hashString(value) {
+	let hash = 2166136261;
+	for (let index = 0; index < value.length; index += 1) {
+		hash ^= value.charCodeAt(index);
+		hash = Math.imul(hash, 16777619);
+	}
+	return (hash >>> 0).toString(16).padStart(8, "0");
+}
+function provisionalId(battleTime, mapId, accountIds) {
+	const ids = [...new Set(accountIds.filter((id) => id !== null && id > 0))].sort((a, b) => a - b);
+	return `roster:${battleTime ?? "?"}:${mapId ?? "?"}:${ids.join(",")}`;
+}
+/**
+* Stable match key. Prefers the numeric arena id, then a deterministic derived
+* key, then an opaque unknown marker.
+*/
+function arenaKeyOf(input) {
+	if (input.arenaId !== void 0 && input.arenaId !== null) return `arena:${input.arenaId}`;
+	const ids = [...new Set(input.accountIds.filter((id) => id !== null && id > 0))].sort((a, b) => a - b);
+	const derived = `${input.battleTime ?? "?"}:${input.mapId ?? "?"}:${ids.join(",")}`;
+	if (input.battleTime !== null || input.mapId !== null || ids.length > 0) return `derived:${derived}`;
+	return `unknown:${hashString(derived)}`;
+}
+function fromArenaInfo(input, options = {}) {
+	const timeZone = options.timeZone ?? DEFAULT_TIME_ZONE;
+	const battleTime = typeof input.dateTime === "string" ? parseBattleTime(input.dateTime, timeZone) : null;
+	const participants = (input.vehicles ?? []).map((vehicle) => {
+		const accountId = positiveInteger(vehicle.id);
+		return {
+			accountId,
+			name: typeof vehicle.name === "string" ? vehicle.name : null,
+			clanId: null,
+			clanTag: null,
+			shipId: finiteNumber(vehicle.shipId),
+			relation: relationOf(vehicle.relation),
+			isBot: isBot(accountId, typeof vehicle.name === "string" ? vehicle.name : null)
+		};
+	});
+	return {
+		provisionalId: provisionalId(battleTime, finiteNumber(input.mapId), participants.map((participant) => participant.accountId)),
+		battleTime,
+		gameMode: finiteNumber(input.gameMode),
+		matchGroup: matchGroupOf(input.matchGroup),
+		mapId: finiteNumber(input.mapId),
+		mapName: typeof input.mapName === "string" ? input.mapName : null,
+		clientVersion: typeof input.clientVersionFromExe === "string" ? input.clientVersionFromExe : null,
+		durationSec: finiteNumber(input.battleDuration) ?? finiteNumber(input.duration),
+		playersPerTeam: finiteNumber(input.playersPerTeam),
+		participants,
+		raw: input
+	};
+}
+function selfPlayerOf(facts) {
+	const results = facts.battleResults;
+	if (results === null) return null;
+	const playerId = facts.meta.playerID;
+	if (typeof playerId === "number" && playerId > 0) {
+		const byId = results.players.find((player) => player.accountId === playerId);
+		if (byId) return byId;
+	}
+	const name = facts.meta.playerName;
+	if (typeof name !== "string" || name.length === 0) return null;
+	const matches = results.players.filter((player) => player.name === name);
+	return matches.length === 1 ? matches[0] : null;
+}
+function resultOf(player) {
+	return {
+		damage: player.damage,
+		frags: player.frags,
+		exp: player.exp,
+		rawExp: player.rawExp,
+		isAlive: player.isAlive,
+		lifeTimeSec: player.lifeTimeSec,
+		scoutingDamage: player.scoutingDamage,
+		killerAccountId: player.killerAccountId,
+		interactions: player.interactions,
+		fields: player.fields
+	};
+}
+function divisionIdOf(fields) {
+	return positiveInteger(fields.prebattle_id);
+}
+function metaParticipants(vehicles) {
+	return (vehicles ?? []).map((vehicle) => {
+		const accountId = positiveInteger(vehicle.id);
+		const name = typeof vehicle.name === "string" ? vehicle.name : null;
+		return {
+			accountId,
+			name,
+			clanId: null,
+			clanTag: null,
+			shipId: finiteNumber(vehicle.shipId),
+			teamId: null,
+			relation: relationOf(vehicle.relation),
+			isBot: isBot(accountId, name),
+			divisionId: null,
+			result: null
+		};
+	});
+}
+function fromReplay(facts, options = {}) {
+	const timeZone = options.timeZone ?? DEFAULT_TIME_ZONE;
+	const results = facts.battleResults;
+	const common = results?.common ?? null;
+	const meta = facts.meta;
+	const self = selfPlayerOf(facts);
+	const selfTeamId = self?.teamId ?? null;
+	const participants = results !== null ? results.players.map((player) => {
+		const name = player.name;
+		return {
+			accountId: player.accountId,
+			name,
+			clanId: player.clanId,
+			clanTag: player.clanTag,
+			shipId: player.shipId,
+			teamId: player.teamId,
+			relation: self !== null && player.accountId !== null && player.accountId === self.accountId ? "self" : selfTeamId !== null && player.teamId !== null ? player.teamId === selfTeamId ? "ally" : "enemy" : "unknown",
+			isBot: isBot(player.accountId, name),
+			divisionId: divisionIdOf(player.fields),
+			result: resultOf(player)
+		};
+	}) : metaParticipants(meta.vehicles);
+	const winnerTeamId = finiteNumber(common?.winnerTeamId);
+	const arenaId = results === null ? null : finiteNumber(results.arenaId);
+	const startDt = finiteNumber(common?.startDt);
+	const metaTime = typeof meta.dateTime === "string" ? parseBattleTime(meta.dateTime, timeZone) : null;
+	const battleTime = startDt !== null && startDt > 0 ? startDt * 1e3 : metaTime;
+	const mapId = finiteNumber(meta.mapId);
+	let quality = "meta-only";
+	if (results !== null) quality = participants.length > 0 && winnerTeamId !== null ? "complete" : "partial";
+	const record = {
+		arenaId: arenaId !== null ? String(arenaId) : arenaKeyOf({
+			battleTime,
+			mapId,
+			accountIds: participants.map((participant) => participant.accountId)
+		}),
+		provisionalIds: [],
+		battleTime,
+		gameMode: finiteNumber(common?.gameMode) ?? finiteNumber(meta.gameMode),
+		matchGroup: matchGroupOf(meta.matchGroup ?? meta.gameType),
+		mapId,
+		mapName: typeof meta.mapName === "string" ? meta.mapName : null,
+		clientVersion: typeof meta.clientVersionFromExe === "string" ? meta.clientVersionFromExe : null,
+		durationSec: finiteNumber(common?.durationSec) ?? finiteNumber(meta.battleDuration) ?? finiteNumber(meta.duration),
+		winnerTeamId,
+		outcome: outcomeOf(selfTeamId, winnerTeamId),
+		participants,
+		quality,
+		ingestedAt: options.ingestedAt ?? Date.now(),
+		parsedAt: options.parsedAt ?? Date.now(),
+		mappingVersion: results?.mappingVersion ?? null,
+		source: options.source ?? { kind: "replay" }
+	};
+	if (options.includeRaw && results?.raw !== void 0) record.raw = results.raw;
+	return record;
+}
+function participantKey(participant) {
+	if (participant.accountId !== null) return `account:${participant.accountId}`;
+	return `name:${participant.name ?? "?"}:${participant.shipId ?? "?"}`;
+}
+function mergeResult(base, fallback) {
+	if (base === null) return fallback;
+	if (fallback === null) return base;
+	return {
+		damage: base.damage ?? fallback.damage,
+		frags: base.frags ?? fallback.frags,
+		exp: base.exp ?? fallback.exp,
+		rawExp: base.rawExp ?? fallback.rawExp,
+		isAlive: base.isAlive ?? fallback.isAlive,
+		lifeTimeSec: base.lifeTimeSec ?? fallback.lifeTimeSec,
+		scoutingDamage: base.scoutingDamage ?? fallback.scoutingDamage,
+		killerAccountId: base.killerAccountId ?? fallback.killerAccountId,
+		interactions: {
+			...fallback.interactions,
+			...base.interactions
+		},
+		fields: {
+			...fallback.fields,
+			...base.fields
+		}
+	};
+}
+function mergeParticipant(base, fallback) {
+	return {
+		accountId: base.accountId ?? fallback.accountId,
+		name: base.name ?? fallback.name,
+		clanId: base.clanId ?? fallback.clanId,
+		clanTag: base.clanTag ?? fallback.clanTag,
+		shipId: base.shipId ?? fallback.shipId,
+		teamId: base.teamId ?? fallback.teamId,
+		relation: base.relation !== "unknown" ? base.relation : fallback.relation,
+		isBot: base.isBot,
+		divisionId: base.divisionId ?? fallback.divisionId,
+		result: mergeResult(base.result, fallback.result)
+	};
+}
+/**
+* Combines two parses of the same match.
+*
+* Higher quality wins; within the same quality the newer parse wins. Fields
+* missing from the winner are filled from the other record.
+*/
+function mergeMatchRecords(a, b) {
+	const aRank = QUALITY_RANK[a.quality];
+	const bRank = QUALITY_RANK[b.quality];
+	const base = bRank > aRank || aRank === bRank && b.parsedAt > a.parsedAt ? b : a;
+	const fallback = base === a ? b : a;
+	const byKey = /* @__PURE__ */ new Map();
+	for (const participant of fallback.participants) byKey.set(participantKey(participant), participant);
+	const participants = base.participants.map((participant) => {
+		const key = participantKey(participant);
+		const other = byKey.get(key);
+		if (other === void 0) return participant;
+		byKey.delete(key);
+		return mergeParticipant(participant, other);
+	});
+	participants.push(...byKey.values());
+	const merged = {
+		arenaId: base.arenaId.startsWith("unknown:") ? fallback.arenaId : base.arenaId,
+		provisionalIds: [.../* @__PURE__ */ new Set([...base.provisionalIds, ...fallback.provisionalIds])],
+		battleTime: base.battleTime ?? fallback.battleTime,
+		gameMode: base.gameMode ?? fallback.gameMode,
+		matchGroup: base.matchGroup !== "unknown" ? base.matchGroup : fallback.matchGroup,
+		mapId: base.mapId ?? fallback.mapId,
+		mapName: base.mapName ?? fallback.mapName,
+		clientVersion: base.clientVersion ?? fallback.clientVersion,
+		durationSec: base.durationSec ?? fallback.durationSec,
+		winnerTeamId: base.winnerTeamId ?? fallback.winnerTeamId,
+		outcome: base.outcome !== "unknown" ? base.outcome : fallback.outcome,
+		participants,
+		quality: QUALITY_RANK[base.quality] >= QUALITY_RANK[fallback.quality] ? base.quality : fallback.quality,
+		ingestedAt: Math.min(base.ingestedAt, fallback.ingestedAt),
+		parsedAt: Math.max(base.parsedAt, fallback.parsedAt),
+		mappingVersion: base.mappingVersion ?? fallback.mappingVersion,
+		source: base.source
+	};
+	const raw = base.raw ?? fallback.raw;
+	if (raw !== void 0) merged.raw = raw;
+	return merged;
+}
+/**
+* Links a pre-battle roster to a finished record.
+*
+* Returns `null` unless exactly one roster matches; ambiguity is never guessed.
+*/
+function matchRosterToRecord(rosters, record) {
+	const known = rosters.filter((roster) => record.provisionalIds.includes(roster.provisionalId));
+	if (known.length > 0) return known.length === 1 ? known[0] : null;
+	if (record.battleTime === null || record.mapId === null) return null;
+	const candidates = rosters.filter((roster) => {
+		if (roster.battleTime === null || roster.mapId !== record.mapId) return false;
+		return Math.abs(roster.battleTime - record.battleTime) <= ROSTER_TIME_TOLERANCE_MS;
+	});
+	return candidates.length === 1 ? candidates[0] : null;
+}
+/** Groups participants by `teamId + prebattle_id`; solo players are omitted. */
+function groupDivisions(participants) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const participant of participants) {
+		if (participant.divisionId === null || participant.divisionId <= 0) continue;
+		const key = `${participant.teamId ?? "?"}:${participant.divisionId}`;
+		const group = groups.get(key);
+		if (group === void 0) groups.set(key, {
+			teamId: participant.teamId,
+			divisionId: participant.divisionId,
+			participants: [participant]
+		});
+		else group.participants.push(participant);
+	}
+	return [...groups.values()].filter((group) => group.participants.length >= 2);
+}
+//#endregion
+export { isBot as a, mergeMatchRecords as c, gameDay as d, inRange as f, groupDivisions as i, outcomeOf as l, weekBoundary as m, fromArenaInfo as n, matchGroupOf as o, parseBattleTime as p, fromReplay as r, matchRosterToRecord as s, arenaKeyOf as t, statOutcome as u };

package/dist/match.d.mts

@@ -0,0 +1,3 @@
+import { S as StatOutcome, _ as ReplayPlayerLike, a as Division, b as ResultValue, c as MatchRecord, d as PlayerResult, f as RecordQuality, g as ReplayMetaLike, h as ReplayFacts, i as ArenaRoster, l as MatchSource, m as ReplayCommonLike, n as ArenaInfoVehicle, o as MatchGroup, p as Relation, r as ArenaKeyInput, s as MatchParticipant, t as ArenaInfoLike, u as Outcome, v as ReplayResultsLike, x as RosterParticipant, y as ReplayVehicleLike } from "./types-DwmuyfXs.mjs";
+import { a as fromReplay, c as matchGroupOf, d as outcomeOf, f as statOutcome, i as fromArenaInfo, l as matchRosterToRecord, n as FromReplayOptions, o as groupDivisions, r as arenaKeyOf, s as isBot, t as FromArenaInfoOptions, u as mergeMatchRecords } from "./index-_QacyXDj.mjs";
+export { type ArenaInfoLike, type ArenaInfoVehicle, type ArenaKeyInput, type ArenaRoster, type Division, FromArenaInfoOptions, FromReplayOptions, type MatchGroup, type MatchParticipant, type MatchRecord, type MatchSource, type Outcome, type PlayerResult, type RecordQuality, type Relation, type ReplayCommonLike, type ReplayFacts, type ReplayMetaLike, type ReplayPlayerLike, type ReplayResultsLike, type ReplayVehicleLike, type ResultValue, type RosterParticipant, type StatOutcome, arenaKeyOf, fromArenaInfo, fromReplay, groupDivisions, isBot, matchGroupOf, matchRosterToRecord, mergeMatchRecords, outcomeOf, statOutcome };

package/dist/match.mjs

@@ -0,0 +1 @@
+export { t as arenaKeyOf, n as fromArenaInfo, r as fromReplay, i as groupDivisions, a as isBot, o as matchGroupOf, s as matchRosterToRecord, c as mergeMatchRecords, l as outcomeOf, u as statOutcome } from "./match-J2T9QiGg.mjs";

package/dist/metrics.d.mts

@@ -0,0 +1,31 @@
+//#region src/metrics/index.d.ts
+export type MetricUnit = 'damage' | 'count' | 'percent' | 'seconds' | 'score';
+export type MetricDirection = 'higher-is-better' | 'lower-is-better' | 'neutral';
+export type MetricAggregation = 'sum' | 'mean' | 'ratio' | 'max';
+export interface MetricSource {
+  field?: string;
+  sum?: readonly string[];
+  ratio?: readonly [string, string];
+}
+export interface MetricDefinition {
+  key: string;
+  labelKey: string;
+  unit: MetricUnit;
+  direction: MetricDirection;
+  aggregation: MetricAggregation;
+  source: MetricSource;
+  sinceMappingVersion?: string;
+}
+/**
+ * v1 field dictionary.
+ *
+ * Only semantic wrappers over raw result fields live here; values are not
+ * copied into new storage. Every source field must exist in the replay field
+ * mapping, which the test suite asserts.
+ */
+export declare const METRICS: readonly MetricDefinition[];
+/** Derives metric values from one player's raw result fields. */
+export declare function deriveMetrics(fields: Record<string, unknown>, metrics?: readonly MetricDefinition[]): Record<string, number | null>;
+/** Field names referenced by a set of metric definitions. */
+export declare function metricSourceFields(metrics?: readonly MetricDefinition[]): string[];
+//#endregion

package/dist/metrics.mjs

@@ -0,0 +1,159 @@
+//#region src/metrics/index.ts
+/**
+* v1 field dictionary.
+*
+* Only semantic wrappers over raw result fields live here; values are not
+* copied into new storage. Every source field must exist in the replay field
+* mapping, which the test suite asserts.
+*/
+const METRICS = [
+	{
+		key: "damage",
+		labelKey: "metric.damage",
+		unit: "damage",
+		direction: "higher-is-better",
+		aggregation: "sum",
+		source: { field: "damage" }
+	},
+	{
+		key: "frags",
+		labelKey: "metric.frags",
+		unit: "count",
+		direction: "higher-is-better",
+		aggregation: "sum",
+		source: { field: "ships_killed" }
+	},
+	{
+		key: "scoutingDamage",
+		labelKey: "metric.scoutingDamage",
+		unit: "damage",
+		direction: "higher-is-better",
+		aggregation: "sum",
+		source: { field: "scouting_damage" }
+	},
+	{
+		key: "potentialDamage",
+		labelKey: "metric.potentialDamage",
+		unit: "damage",
+		direction: "neutral",
+		aggregation: "sum",
+		source: { sum: [
+			"agro_air",
+			"agro_art",
+			"agro_dbomb",
+			"agro_tpd"
+		] }
+	},
+	{
+		key: "lifeTimeSec",
+		labelKey: "metric.lifeTimeSec",
+		unit: "seconds",
+		direction: "neutral",
+		aggregation: "mean",
+		source: { field: "life_time_sec" }
+	},
+	{
+		key: "capturePoints",
+		labelKey: "metric.capturePoints",
+		unit: "score",
+		direction: "higher-is-better",
+		aggregation: "sum",
+		source: { field: "capture_points" }
+	},
+	{
+		key: "droppedCapturePoints",
+		labelKey: "metric.droppedCapturePoints",
+		unit: "score",
+		direction: "lower-is-better",
+		aggregation: "sum",
+		source: { field: "dropped_capture_points" }
+	},
+	{
+		key: "exp",
+		labelKey: "metric.exp",
+		unit: "score",
+		direction: "higher-is-better",
+		aggregation: "sum",
+		source: { field: "exp" }
+	},
+	{
+		key: "rawExp",
+		labelKey: "metric.rawExp",
+		unit: "score",
+		direction: "higher-is-better",
+		aggregation: "sum",
+		source: { field: "raw_exp" }
+	},
+	{
+		key: "planesKilled",
+		labelKey: "metric.planesKilled",
+		unit: "count",
+		direction: "higher-is-better",
+		aggregation: "sum",
+		source: { field: "planes_killed_by_ship" }
+	},
+	{
+		key: "mainBatteryHits",
+		labelKey: "metric.mainBatteryHits",
+		unit: "count",
+		direction: "higher-is-better",
+		aggregation: "sum",
+		source: { sum: [
+			"hits_main_he",
+			"hits_main_ap",
+			"hits_main_cs"
+		] }
+	},
+	{
+		key: "torpedoHits",
+		labelKey: "metric.torpedoHits",
+		unit: "count",
+		direction: "higher-is-better",
+		aggregation: "sum",
+		source: { field: "hits_tpd" }
+	}
+];
+function numeric(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function resolveMetric(fields, definition) {
+	const { source } = definition;
+	if (source.field !== void 0) return numeric(fields[source.field]);
+	if (source.sum !== void 0) {
+		let total = 0;
+		let found = false;
+		for (const field of source.sum) {
+			const value = numeric(fields[field]);
+			if (value === null) continue;
+			total += value;
+			found = true;
+		}
+		return found ? total : null;
+	}
+	if (source.ratio !== void 0) {
+		const numerator = numeric(fields[source.ratio[0]]);
+		const denominator = numeric(fields[source.ratio[1]]);
+		if (numerator === null || denominator === null || denominator === 0) return null;
+		return numerator / denominator;
+	}
+	return null;
+}
+/** Derives metric values from one player's raw result fields. */
+function deriveMetrics(fields, metrics = METRICS) {
+	const result = {};
+	for (const definition of metrics) result[definition.key] = resolveMetric(fields, definition);
+	return result;
+}
+/** Field names referenced by a set of metric definitions. */
+function metricSourceFields(metrics = METRICS) {
+	const fields = /* @__PURE__ */ new Set();
+	for (const definition of metrics) {
+		const { source } = definition;
+		if (source.field !== void 0) fields.add(source.field);
+		if (source.sum !== void 0) for (const field of source.sum) fields.add(field);
+		if (source.ratio !== void 0) for (const field of source.ratio) fields.add(field);
+	}
+	return [...fields];
+}
+//#endregion
+export { METRICS, deriveMetrics, metricSourceFields };