wows-compute 0.0.0-stage → 1.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 wows-devkit contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,128 @@
-# Temporary Holding Version
+# wows-compute
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+《战舰世界》对局数据的纯计算内核。无文件 IO、无网络、无运行时状态：输入是已经解析好的赛前名单或赛后回放结果，输出是可直接持久化或展示的 `MatchRecord`、评级与统计。
+
+已提供：`./match`、评级、时间、`./recent`、`./aggregate`、`./metrics`、`./strength`（含概览归纳）。
+
+## 安装
+
+```bash
+pnpm add wows-compute wows-number-api-sdk
+```
+
+ESM-only，Node.js 22.18+。
+
+## 入口
+
+| 入口 | 内容 |
+| --- | --- |
+| `wows-compute` | PR / PR*、等级、近期统计、聚合、概览归纳、游戏日与周界 |
+| `wows-compute/match` | `ArenaRoster`、`MatchRecord`、合并、赛前赛后关联、组队 |
+| `wows-compute/metrics` | 字段字典与派生指标 |
+| `wows-compute/strength` | 散点原料、概览归纳、参考线、角色配对 |
+
+## 快速上手
+
+```ts
+import { fromReplay, groupDivisions } from 'wows-compute/match'
+
+const record = fromReplay(parsedReplay)
+// record.arenaId、record.outcome、record.quality、record.participants
+
+const divisions = groupDivisions(record.participants)
+```
+
+`fromReplay` 接受 `wows-replay-parser` 的 `ParsedReplay` 结构，不依赖它的包，只有类型层面的结构兼容。
+
+### 平局
+
+事实层保留 `outcome: 'draw'`；统计层用 `statOutcome('draw')` 映射为 `loss`，即平局双输。`winnerTeamId` 为负数表示平局，`0` 是合法队伍。
+
+### 时间
+
+`battleTime` 优先取结果包的 `startDt`（UTC）。回放元数据的 `dateTime` 是录制者本机时间，跨区不可靠，只在没有结果包时作为回退。
+
+### 评级
+
+```ts
+import { accountPrEstimated, accountPrPooled, levelOf, shipPr } from 'wows-compute'
+
+const ship = shipPr(stats, expected)          // 精确，exact: true
+const account = accountPrEstimated(totals, expected) // PR*，exact: false
+const pooled = accountPrPooled(ships, expected, sample) // 精确加权，exact: true
+
+levelOf('pr', 1200) // { levelKey: 'average', floor: 1100, ... }
+```
+
+`exact: false` 是产品承诺：调用方必须把它显示为 `PR*`，不能与精确 PR 不加区分地混排。偏差方向通过 `bias` 输出；没有 `shipMix` 时是 `unknown`，不猜。
+
+PR 公式、预期值和分档阈值全部复用 `wows-number-api-sdk`，本包不复制常量。
+
+### 近期与聚合
+
+```ts
+import { aggregateTeam, recentMatches } from 'wows-compute'
+
+const recent = recentMatches(records, { subject: { kind: 'self' }, last: 20 }, expected)
+const team = aggregateTeam(records, teamId, {
+  weighting: 'equal',          // 监控页：每个席位一票
+  prAggregation: 'mean',
+  expected,
+})
+```
+
+- 近期只统计“已解析并入库”的对局，不扫描历史回放、不补缺口。
+- `winRate` 是百分数，例如 `54.3`。
+- 平局计入 `battles`，胜率为 `wins / battles`；`losses` 只计实际失败。
+- 记录总览用 `weighting: 'battles'` + `prAggregation: 'pooled'`；监控页用 `equal` + `mean`。
+- 分母为 0 返回 `null`；`coverage` 的 `resolved + hidden + bot + failed` 恒等于 `total`。
+
+### 指标字典
+
+```ts
+import { METRICS, deriveMetrics } from 'wows-compute/metrics'
+
+deriveMetrics(player.result.fields) // { damage, frags, potentialDamage, ... }
+```
+
+指标只做字段语义包装，不复制原始数据。新增字段必须能在回放字段映射中找到，测试会先失败。
+
+### 对局强度原料
+
+```ts
+import { buildPlayerPoints, pairByRole, referenceLines } from 'wows-compute/strength'
+
+const points = buildPlayerPoints(roster, ratings, catalog)
+const reference = referenceLines(points)
+const matchups = pairByRole(allyPoints, enemyPoints)
+```
+
+只输出散点原料、参考线和逐角色差值，不输出综合强度分或预测。
+
+### 队伍概览
+
+`summarizePlayers` / `summarizeRoster` 对已经标准化的 `PlayerPoint` 做加权归纳，输入不是对局记录：
+
+```ts
+import { buildPlayerPoints, summarizeRoster } from 'wows-compute/strength'
+
+const points = buildPlayerPoints(roster, ratings, catalog)
+const { ally, enemy, unassigned } = summarizeRoster(points)
+// ally.players、ally.battles、ally.winRate / avgDamage / avgFrags / pr、ally.coverage
+```
+
+- 与 `aggregate*` 的分工：`aggregate*` 从逐局 `MatchRecord` 推导统计；overview 只归纳已算好的值，赛前赛后可复用。
+- 默认 `weighting: 'equal'`（一人一票），可改为 `'battles'` 按生涯场次加权。
+- 每项均值只使用非 null 值，`0` 是合法值，分母为 0 返回 `null`。
+- `coverage` 的单位是席位：`total` 含 Bot，`players` 只算真人，且 `resolved + hidden + bot + failed === total`。
+- 概览 PR 是对账号 PR 的均值，`prExact` 恒为 `false`，展示时必须标 `PR*`。
+
+## 约束
+
+- 不读写文件、不访问网络、不 import `node:*`。
+- 不扫描历史回放、不推断缺失对局、不做存储假设。
+- 只读已解析的数据；需要回放解析时使用 `wows-replay-parser`。
+
+## License
+
+MIT

package/dist/index-CkKx_Wtz.d.mts

@@ -0,0 +1,286 @@
+import { c as MatchRecord, i as ArenaRoster, o as MatchGroup, p as Relation } from "./types-DwmuyfXs.mjs";
+import { ExpectedValuesDocument, ShipBattleStats, SingleBattleInput } from "wows-number-api-sdk";
+//#region src/rating/index.d.ts
+interface SampleDescriptor {
+  kind: 'ingested' | 'lifetime' | 'match';
+  matches: number;
+  /** ISO timestamps; present for date windows. */
+  from?: string;
+  to?: string;
+  /** When querying another player: matches shared with the local player. */
+  sharedWith?: number;
+  players?: number;
+}
+interface EstimateBias {
+  direction: 'underestimate' | 'overestimate' | 'mixed' | 'unknown';
+  reason: 'ship-mix' | 'insufficient-data';
+  /** Relative baseline difference: pooled baseline / global average - 1. */
+  delta?: {
+    damage?: number;
+    frags?: number;
+    wins?: number;
+  };
+}
+interface RatedValue {
+  value: number;
+  basis: 'ship' | 'account';
+  exact: boolean;
+  sample: SampleDescriptor;
+  /** Expected-values version, taken from `expected.time`. */
+  baselineVersion: string;
+  /** Only present when `exact === false`. */
+  bias?: EstimateBias;
+}
+interface AccountTotals {
+  battles: number;
+  damage: number;
+  frags: number;
+  wins: number;
+}
+interface ShipMixEntry {
+  shipId: number | string;
+  battles: number;
+}
+interface AccountPrOptions {
+  shipMix?: readonly ShipMixEntry[];
+}
+/** Personal Rating for one ship, using that ship's own expected values. */
+declare function shipPr(stats: ShipBattleStats, expected: ExpectedValuesDocument, sample?: SampleDescriptor): RatedValue | null;
+/** Personal Rating for a single battle. */
+declare function battlePr(battle: SingleBattleInput, expected: ExpectedValuesDocument, sample?: SampleDescriptor): RatedValue | null;
+/**
+ * Fast account PR*: account totals against the unweighted average of all
+ * expected values.
+ *
+ * This is an estimate, not a different formula: the account is treated as one
+ * synthetic ship. `exact: false` is a product promise — UI must mark it `PR*`.
+ */
+declare function accountPrEstimated(account: AccountTotals, expected: ExpectedValuesDocument, options?: AccountPrOptions): RatedValue | null;
+/**
+ * Exact weighted account PR: pools per-ship totals and per-ship baselines.
+ *
+ * Ships without expected values are skipped by `calculatePR`, not counted
+ * as zero.
+ */
+declare function accountPrPooled(ships: readonly ShipBattleStats[], expected: ExpectedValuesDocument, sample: SampleDescriptor): RatedValue | null;
+//#endregion
+//#region src/aggregate/index.d.ts
+type Weighting = 'equal' | 'battles';
+type PrAggregation = 'mean' | 'pooled';
+interface Coverage {
+  total: number;
+  resolved: number;
+  hidden: number;
+  bot: number;
+  failed: number;
+}
+interface AggregatedValue {
+  value: number | null;
+  sample: SampleDescriptor;
+  coverage: Coverage;
+}
+interface AggregateOptions {
+  weighting: Weighting;
+  prAggregation: PrAggregation;
+  expected?: ExpectedValuesDocument;
+  matchGroups?: readonly MatchGroup[];
+  from?: number;
+  to?: number;
+}
+interface PlayerAggregate {
+  accountId: number;
+  name: string | null;
+  battles: number;
+  wins: number;
+  losses: number;
+  draws: number;
+  damage: number;
+  frags: number;
+  winRate: AggregatedValue;
+  avgDamage: AggregatedValue;
+  avgFrags: AggregatedValue;
+  pr: AggregatedValue;
+}
+interface TeamAggregate {
+  teamId: number | null;
+  players: number;
+  coverage: Coverage;
+  values: {
+    winRate: AggregatedValue;
+    avgDamage: AggregatedValue;
+    avgFrags: AggregatedValue;
+    pr: AggregatedValue;
+  };
+}
+interface ShipAggregate {
+  shipId: number;
+  battles: number;
+  wins: number;
+  losses: number;
+  draws: number;
+  damage: number;
+  frags: number;
+  winRate: AggregatedValue;
+  avgDamage: AggregatedValue;
+  avgFrags: AggregatedValue;
+  pr: AggregatedValue;
+}
+interface DailyPoint {
+  day: string;
+  matches: number;
+  battles: number;
+  wins: number;
+  losses: number;
+  draws: number;
+  winRate: number | null;
+  avgDamage: number | null;
+  avgFrags: number | null;
+  pr: AggregatedValue;
+}
+interface DailyOptions {
+  timeZone: string;
+  boundaryHour?: number;
+  expected?: ExpectedValuesDocument;
+  matchGroups?: readonly MatchGroup[];
+  from?: number;
+  to?: number;
+}
+/** Per-player aggregates over the selected records. Ordered by battles, then account id. */
+declare function aggregatePlayers(records: readonly MatchRecord[], options: AggregateOptions): PlayerAggregate[];
+/** One team's aggregate; coverage only counts that team's participants. */
+declare function aggregateTeam(records: readonly MatchRecord[], teamId: number | null, options: AggregateOptions): TeamAggregate;
+/** Per-ship aggregates over the selected records. Ordered by battles, then ship id. */
+declare function aggregateShips(records: readonly MatchRecord[], options: AggregateOptions): ShipAggregate[];
+/** Self performance per game day, ordered oldest first. */
+declare function dailySeries(records: readonly MatchRecord[], options: DailyOptions): DailyPoint[];
+//#endregion
+//#region src/strength/index.d.ts
+type ShipRole = 'submarine' | 'aircraft-carrier' | 'destroyer' | 'battleship' | 'cruiser-functional' | 'cruiser-firepower' | 'cruiser' | 'unknown';
+/** Display / analysis order; not a composite score. */
+declare const ROLE_ORDER: readonly ShipRole[];
+interface ShipCatalogLike {
+  role?: (shipId: number) => ShipRole | null;
+  tier?: (shipId: number) => number | null;
+}
+interface PlayerRatingSnapshot {
+  pr?: RatedValue | null;
+  /** Lifetime win rate in percent, e.g. `54.3`. */
+  winRate?: number | null;
+  battles?: number | null;
+  /** Lifetime average damage; `null` when unavailable. */
+  avgDamage?: number | null;
+  /** Lifetime average frags; `null` when unavailable. */
+  avgFrags?: number | null;
+  /** Platform-flagged hidden profile, distinct from "no data". */
+  hidden?: boolean;
+}
+type PlayerRatingValue = RatedValue | PlayerRatingSnapshot;
+type PlayerRatings = ReadonlyMap<number, PlayerRatingValue>;
+interface PlayerPoint {
+  accountId: number | null;
+  name: string | null;
+  /** `null` for pre-battle rosters; relations are known, team ids are not. */
+  teamId: number | null;
+  shipId: number | null;
+  shipRole: ShipRole;
+  tier: number | null;
+  divisionId: number | null;
+  /** Percentage, e.g. `54.3`. */
+  winRate: number | null;
+  pr: number | null;
+  prExact: boolean;
+  battles: number | null;
+  isBot: boolean;
+  /** Roster relation; used to group points into sides. */
+  relation: Relation;
+  avgDamage: number | null;
+  avgFrags: number | null;
+  hidden: boolean;
+}
+interface ReferenceLines {
+  winRateMedian: number | null;
+  prMedian: number | null;
+}
+type Quadrant = 'q1' | 'q2' | 'q3' | 'q4' | 'unknown';
+interface RoleWeightProfile {
+  weights?: Partial<Record<ShipRole, number>>;
+}
+interface RoleMatchup {
+  role: ShipRole;
+  allyCount: number;
+  enemyCount: number;
+  allyMedianPr: number | null;
+  enemyMedianPr: number | null;
+  allyMedianWinRate: number | null;
+  enemyMedianWinRate: number | null;
+  /** Ally median minus enemy median; `null` when either side lacks values. */
+  prDiff: number | null;
+  winRateDiff: number | null;
+  weight: number | null;
+  sample: {
+    ally: number;
+    enemy: number;
+  };
+  coverage: Coverage;
+}
+/** Maps a roster to scatter-plot points. Bots and hidden players stay in the list. */
+declare function buildPlayerPoints(roster: ArenaRoster, ratings: PlayerRatings, catalog?: ShipCatalogLike): PlayerPoint[];
+declare function median(values: readonly number[]): number | null;
+declare function referenceLines(points: readonly PlayerPoint[]): ReferenceLines;
+/**
+ * Quadrants relative to the reference lines.
+ *
+ * q1 high win rate + high PR, q2 low win rate + high PR,
+ * q3 low + low, q4 high win rate + low PR.
+ */
+declare function quadrantOf(point: PlayerPoint, reference: ReferenceLines): Quadrant;
+/**
+ * Per-role ally/enemy comparison.
+ *
+ * Returns differences and samples only; no composite score and no prediction.
+ */
+declare function pairByRole(ally: readonly PlayerPoint[], enemy: readonly PlayerPoint[], profile?: RoleWeightProfile): RoleMatchup[];
+interface SummaryOptions {
+  /**
+   * `equal` (default): one player, one vote.
+   * `battles`: weight by the player's lifetime battles.
+   */
+  weighting?: Weighting;
+}
+interface PlayerSummary {
+  /** All slots on the side, including bots. */
+  total: number;
+  /** Non-bot slots. */
+  players: number;
+  /** Sum of non-null lifetime battles for non-bot players. */
+  battles: number;
+  /** Counts slots, not participant-match samples. */
+  coverage: Coverage;
+  /** Percentage, e.g. `54.3`. */
+  winRate: number | null;
+  avgDamage: number | null;
+  avgFrags: number | null;
+  pr: number | null;
+  /**
+   * Always false: a mean of account PR values is not an official team PR.
+   * UI must mark it `PR*`.
+   */
+  prExact: false;
+}
+interface RosterSummary {
+  ally: PlayerSummary;
+  enemy: PlayerSummary;
+  /** Slots that cannot be assigned to a side (`relation === 'unknown'`). */
+  unassigned: number;
+}
+/**
+ * Reduces normalized player points into one side's overview.
+ *
+ * Averages only over non-null values; `0` is a valid value. Empty input
+ * returns an all-zero summary rather than throwing.
+ */
+declare function summarizePlayers(points: readonly PlayerPoint[], options?: SummaryOptions): PlayerSummary;
+/** Groups points by `relation` and summarizes both sides. */
+declare function summarizeRoster(points: readonly PlayerPoint[], options?: SummaryOptions): RosterSummary;
+//#endregion
+export { TeamAggregate as A, SampleDescriptor as B, AggregatedValue as C, PlayerAggregate as D, DailyPoint as E, dailySeries as F, shipPr as G, accountPrEstimated as H, AccountPrOptions as I, AccountTotals as L, aggregatePlayers as M, aggregateShips as N, PrAggregation as O, aggregateTeam as P, EstimateBias as R, AggregateOptions as S, DailyOptions as T, accountPrPooled as U, ShipMixEntry as V, battlePr as W, pairByRole as _, PlayerSummary as a, summarizePlayers as b, ReferenceLines as c, RosterSummary as d, ShipCatalogLike as f, median as g, buildPlayerPoints as h, PlayerRatings as i, Weighting as j, ShipAggregate as k, RoleMatchup as l, SummaryOptions as m, PlayerRatingSnapshot as n, Quadrant as o, ShipRole as p, PlayerRatingValue as r, ROLE_ORDER as s, PlayerPoint as t, RoleWeightProfile as u, quadrantOf as v, Coverage as w, summarizeRoster as x, referenceLines as y, RatedValue as z };

package/dist/index-_QacyXDj.d.mts

@@ -0,0 +1,48 @@
+import { S as StatOutcome, a as Division, c as MatchRecord, h as ReplayFacts, i as ArenaRoster, o as MatchGroup, r as ArenaKeyInput, s as MatchParticipant, t as ArenaInfoLike, u as Outcome } from "./types-DwmuyfXs.mjs";
+//#region src/match/index.d.ts
+interface FromArenaInfoOptions {
+  timeZone?: string;
+}
+interface FromReplayOptions {
+  timeZone?: string;
+  ingestedAt?: number;
+  parsedAt?: number;
+  source?: MatchRecord['source'];
+  /** Include the raw battle-results payload for later remapping. */
+  includeRaw?: boolean;
+}
+/** Draw counts as a loss for both teams in every statistical view. */
+declare function statOutcome(outcome: Outcome): StatOutcome | 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.
+ */
+declare function outcomeOf(teamId: number | null, winnerTeamId: number | null): Outcome;
+declare function matchGroupOf(value: unknown): MatchGroup;
+declare function isBot(accountId: number | null, name: string | null): boolean;
+/**
+ * Stable match key. Prefers the numeric arena id, then a deterministic derived
+ * key, then an opaque unknown marker.
+ */
+declare function arenaKeyOf(input: ArenaKeyInput): string;
+declare function fromArenaInfo(input: ArenaInfoLike, options?: FromArenaInfoOptions): ArenaRoster;
+declare function fromReplay(facts: ReplayFacts, options?: FromReplayOptions): MatchRecord;
+/**
+ * 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.
+ */
+declare function mergeMatchRecords(a: MatchRecord, b: MatchRecord): MatchRecord;
+/**
+ * Links a pre-battle roster to a finished record.
+ *
+ * Returns `null` unless exactly one roster matches; ambiguity is never guessed.
+ */
+declare function matchRosterToRecord(rosters: readonly ArenaRoster[], record: MatchRecord): ArenaRoster | null;
+/** Groups participants by `teamId + prebattle_id`; solo players are omitted. */
+declare function groupDivisions(participants: readonly MatchParticipant[]): Division[];
+//#endregion
+export { fromReplay as a, matchGroupOf as c, outcomeOf as d, statOutcome as f, fromArenaInfo as i, matchRosterToRecord as l, FromReplayOptions as n, groupDivisions as o, arenaKeyOf as r, isBot as s, FromArenaInfoOptions as t, mergeMatchRecords as u };

package/dist/index.d.mts

@@ -0,0 +1,82 @@
+import { A as TeamAggregate, B as SampleDescriptor, C as AggregatedValue, D as PlayerAggregate, E as DailyPoint, F as dailySeries, G as shipPr, H as accountPrEstimated, I as AccountPrOptions, L as AccountTotals, M as aggregatePlayers, N as aggregateShips, O as PrAggregation, P as aggregateTeam, R as EstimateBias, S as AggregateOptions, T as DailyOptions, U as accountPrPooled, V as ShipMixEntry, W as battlePr, a as PlayerSummary, b as summarizePlayers, d as RosterSummary, j as Weighting, k as ShipAggregate, m as SummaryOptions, w as Coverage, x as summarizeRoster, z as RatedValue } from "./index-CkKx_Wtz.mjs";
+import { c as MatchRecord, o as MatchGroup } from "./types-DwmuyfXs.mjs";
+import { ExpectedValuesDocument, ExpectedValuesDocument as ExpectedValuesDocument$1, PR_BANDS, PR_CATEGORY_LABELS, PersonalRatingCategory, PersonalRatingCategory as PersonalRatingCategory$1, ShipBattleStats, ShipExpectedValues, SingleBattleInput, WIN_RATE_BANDS, prCategory, winRateCategory } from "wows-number-api-sdk";
+//#region src/levels/index.d.ts
+export type LevelKind = 'pr' | 'win-rate';
+export interface LevelResult {
+  levelKey: PersonalRatingCategory$1;
+  /** Inclusive lower bound of the hit band; `null` for the lowest band. */
+  floor: number | null;
+  /** Lower bound of the next band; `null` for the highest band. */
+  nextFloor: number | null;
+  deltaToFloor: number | null;
+  deltaToNext: number | null;
+}
+/** Level key plus thresholds. Labels and colors belong to the application. */
+export declare function levelOf(kind: LevelKind, value: number): LevelResult | null;
+//#endregion
+//#region src/recent/index.d.ts
+export type RecentSubject = {
+  kind: 'self';
+} | {
+  kind: 'participant';
+  accountId: number;
+};
+export interface RecentQuery {
+  subject: RecentSubject;
+  /** Window size in matches; defaults to 20. */
+  last?: number;
+  from?: number;
+  to?: number;
+  matchGroups?: readonly MatchGroup[];
+  /** `loss` (default) counts a draw as a loss; `exclude` drops draws entirely. */
+  drawPolicy?: 'loss' | 'exclude';
+}
+export interface RecentStats {
+  battles: number;
+  wins: number;
+  losses: number;
+  draws: number;
+  /** Percentage, e.g. `54.3`; `null` when there are no battles. */
+  winRate: number | null;
+  damage: number;
+  frags: number;
+  avgDamage: number | null;
+  avgFrags: number | null;
+  pr: RatedValue | null;
+}
+export interface RecentResult {
+  matches: MatchRecord[];
+  sample: SampleDescriptor;
+  stats: RecentStats;
+}
+/**
+ * Statistics over ingested matches only.
+ *
+ * No gap filling, no lifetime totals, no historical replay scan: a match is in
+ * the window only when it was successfully parsed and stored by the caller.
+ */
+export declare function recentMatches(records: readonly MatchRecord[], query: RecentQuery, expected?: ExpectedValuesDocument$1): RecentResult;
+//#endregion
+//#region src/time/index.d.ts
+/**
+ * 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.
+ */
+export declare function parseBattleTime(value: string, timeZone: string): number | null;
+/**
+ * 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.
+ */
+export declare function gameDay(timestamp: number, timeZone: string, boundaryHour?: number): string;
+/** Start of the game week (Monday at `boundaryHour`, local time) containing `timestamp`. */
+export declare function weekBoundary(timestamp: number, timeZone: string, boundaryHour?: number): number;
+/** Inclusive range check; omitted bounds are open. */
+export declare function inRange(timestamp: number, from?: number, to?: number): boolean;
+//#endregion
+export { AccountPrOptions, AccountTotals, AggregateOptions, AggregatedValue, Coverage, DailyOptions, DailyPoint, EstimateBias, type ExpectedValuesDocument, PR_BANDS, PR_CATEGORY_LABELS, type PersonalRatingCategory, PlayerAggregate, type PlayerSummary, PrAggregation, RatedValue, type RosterSummary, SampleDescriptor, ShipAggregate, type ShipBattleStats, type ShipExpectedValues, ShipMixEntry, type SingleBattleInput, type SummaryOptions, TeamAggregate, WIN_RATE_BANDS, Weighting, accountPrEstimated, accountPrPooled, aggregatePlayers, aggregateShips, aggregateTeam, battlePr, dailySeries, prCategory, shipPr, summarizePlayers, summarizeRoster, winRateCategory };