@cs2dak/contract 1.0.0 → 1.1.0

package/src/map-role.ts

@@ -0,0 +1,317 @@
+import { z } from "zod";
+import { evidenceRefSchema } from "./evidence.js";
+
+/** Bump when aggregation or role-selection semantics change. */
+export const MAP_ROLE_EVIDENCE_VERSION = 4;
+export const T_RESPONSIBILITY_RESEARCH_PROJECTION_VERSION = "cs2-demo-analysis-kit/t-responsibility-research-projection-1.0";
+
+/** The supported active-duty pool. Unknown maps are deliberately not generalized. */
+export const supportedMapNameSchema = z.enum([
+  "de_ancient", "de_anubis", "de_dust2", "de_inferno", "de_mirage", "de_nuke", "de_overpass"
+]);
+export const mapRoleStatusSchema = z.enum(["ready", "mixed", "insufficient", "unknown"]);
+export const inferredMapRoleSchema = z.enum(["awper", "anchor", "opener", "closer"]);
+export const declaredRoleSchema = z.enum(["igl", "awper", "anchor", "opener", "closer"]);
+export const weaponDutySchema = z.enum(["primary_awper", "secondary_awper", "situational_awper", "rifler"]);
+export const teamResponsibilitySchema = z.enum([
+  "pack", "extremity", "late_joining", "stable_default",
+  "anchor_tendency", "component_mobile", "independent_mobile", "stable_position",
+  "mixed", "unknown",
+]);
+export const roleModifierSchema = z.enum(["utility_supportive", "positionally_stable", "spatially_isolated", "component_mobile"]);
+export const tResponsibilityResearchCandidateSchema = z.enum(["pack", "lurker", "flexible"]);
+
+export const tResponsibilityResearchFeaturesSchema = z.object({
+  dominantGroupStability: z.number().min(0).max(1).nullable(),
+  teamRelativeGroupShare: z.number().min(-1).max(1).nullable(),
+  openingIsolatedShare: z.number().min(0).max(1).nullable(),
+  isolationShare: z.number().min(0).max(1).nullable(),
+  delayedConvergenceShare: z.number().min(0).max(1).nullable(),
+  movementSync: z.number().min(-1).max(1).nullable(),
+  positionTopShare: z.number().min(0).max(1).nullable(),
+  openingLargestShare: z.number().min(0).max(1).nullable(),
+  fullLargestShare: z.number().min(0).max(1).nullable(),
+  meanTeamCentroidDistance: z.number().nonnegative().nullable(),
+  openingPathDisplacement: z.number().nonnegative().nullable(),
+  openingPathTransitions: z.number().nonnegative().nullable(),
+  openingPositionEntropy: z.number().min(0).max(1).nullable(),
+  fullPositionEntropy: z.number().min(0).max(1).nullable(),
+  rejoinsPerMinute: z.number().nonnegative().nullable(),
+});
+
+/** Product-neutral declaration scope. Storage ids, namespaces and timestamps intentionally do not belong here. */
+const declarationScopeSchema = z.object({
+  playerKey: z.string().min(1),
+  source: z.enum(["user", "self_report", "organizer", "event_package", "trusted_metadata"]),
+  mapName: supportedMapNameSchema.optional(),
+  teamKey: z.string().min(1).optional(),
+  validFrom: z.string().datetime().optional(),
+  validTo: z.string().datetime().optional(),
+  provenance: z.string().min(1),
+}).strict();
+
+/** A declared tactical role. priority belongs only to this kind of declaration. */
+export const mainRoleDeclarationSchema = declarationScopeSchema.extend({
+  kind: z.literal("main_role"),
+  role: declaredRoleSchema,
+  priority: z.enum(["primary", "secondary"]),
+});
+
+/** A declared weapon duty. It is deliberately independent from tactical-role priority. */
+export const weaponDutyDeclarationSchema = declarationScopeSchema.extend({
+  kind: z.literal("weapon_duty"),
+  weaponDuty: weaponDutySchema,
+});
+
+export const roleDeclarationSchema = z.discriminatedUnion("kind", [mainRoleDeclarationSchema, weaponDutyDeclarationSchema]).superRefine((value, context) => {
+  if (value.validFrom != null && value.validTo != null && value.validFrom > value.validTo) context.addIssue({ code: z.ZodIssueCode.custom, message: "validFrom must not be after validTo" });
+});
+
+export const roleEvidenceLocatorSchema = z.object({
+  matchId: z.string().min(1),
+  roundNumber: z.number().int().positive(),
+  positionGroupId: z.string().min(1).optional(),
+});
+
+/**
+ * Same-event research projection. It is intentionally separate from
+ * PlayerMapRoleEvidence.responsibility and is not a production role conclusion.
+ */
+export const tResponsibilityResearchProjectionSchema = z.object({
+  version: z.literal(T_RESPONSIBILITY_RESEARCH_PROJECTION_VERSION),
+  modelId: z.literal("cologne-major-2026/parsimonious-v1-full-fit"),
+  playerKey: z.string().min(1),
+  teamKey: z.string().min(1),
+  side: z.literal("t"),
+  status: mapRoleStatusSchema,
+  candidate: tResponsibilityResearchCandidateSchema.nullable(),
+  packScore: z.number().min(0).max(1).nullable(),
+  lurkerScore: z.number().min(0).max(1).nullable(),
+  confidence: z.number().min(0).max(1).nullable(),
+  sample: z.object({
+    observedRounds: z.number().int().nonnegative(),
+    eligibleRounds: z.number().int().nonnegative(),
+    eligibleSeconds: z.number().nonnegative(),
+    matchCount: z.number().int().nonnegative(),
+    mapCount: z.number().int().nonnegative(),
+    dataQuality: z.number().min(0).max(1).nullable(),
+  }),
+  features: tResponsibilityResearchFeaturesSchema,
+  matchIds: z.array(z.string().min(1)),
+  representativeRounds: z.array(roleEvidenceLocatorSchema).max(8),
+  basis: z.array(z.string()),
+  limitations: z.array(z.string()),
+});
+
+export const mapPositionGroupEvidenceSchema = z.object({
+  positionGroupId: z.string().min(1),
+  seconds: z.number().nonnegative(),
+  share: z.number().min(0).max(1),
+  roundCount: z.number().int().nonnegative(),
+});
+
+export const awpResponsibilityEvidenceSchema = z.object({
+  duty: weaponDutySchema,
+  eligibleRounds: z.number().int().nonnegative(),
+  freezeOwnershipRounds: z.number().int().nonnegative(),
+  activeSeconds: z.number().nonnegative().nullable(),
+  shots: z.number().int().nonnegative().nullable(),
+  kills: z.number().int().nonnegative().nullable(),
+  teamActiveShare: z.number().min(0).max(1).nullable(),
+  /** Concentration/exclusivity of observed AWP active time inside this team/map/side cell. */
+  usageConcentration: z.number().min(0).max(1).nullable(),
+  matchConsistency: z.number().min(0).max(1).nullable(),
+  qualifiedLongGunRounds: z.number().int().nonnegative(),
+});
+
+/** One identity × canonical team × map × side evidence cell. No role conclusion is stored here. */
+export const playerMapRoleEvidenceSchema = z.object({
+  version: z.literal(MAP_ROLE_EVIDENCE_VERSION),
+  playerKey: z.string().min(1),
+  teamKey: z.string().min(1),
+  mapName: supportedMapNameSchema,
+  side: z.enum(["t", "ct"]),
+  status: mapRoleStatusSchema,
+  confidence: z.number().min(0).max(1),
+  sample: z.object({
+    observedRounds: z.number().int().nonnegative(),
+    eligibleRounds: z.number().int().nonnegative(),
+    eligibleSeconds: z.number().nonnegative(),
+    matchCount: z.number().int().nonnegative(),
+    dataQuality: z.number().min(0).max(1),
+    coverage: z.number().min(0).max(1).nullable(),
+  }),
+  /** Complete compact match coverage for aggregation and declaration time scope; not an evidence sample. */
+  matchIds: z.array(z.string().min(1)),
+  positionGroups: z.array(mapPositionGroupEvidenceSchema),
+  spatial: z.object({
+    dominantGroupStability: z.number().min(0).max(1).nullable(),
+    teamRelativeGroupShare: z.number().min(-1).max(1).nullable(),
+    isolationSeconds: z.number().nonnegative().nullable(),
+    isolationShare: z.number().min(0).max(1).nullable(),
+    rejoinCount: z.number().int().nonnegative().nullable(),
+    delayedConvergenceRoundShare: z.number().min(0).max(1).nullable(),
+    movementSync: z.number().min(-1).max(1).nullable(),
+    openingMainComponentShare: z.number().min(0).max(1).nullable(),
+    openingNoUniqueCoreShare: z.number().min(0).max(1).nullable(),
+    openingIsolatedShare: z.number().min(0).max(1).nullable(),
+    formationShares: z.record(z.number().min(0).max(1)),
+  }),
+  support: z.object({
+    utilityUses: z.number().int().nonnegative(),
+    openingUtilityUses: z.number().int().nonnegative(),
+    utilityUsePerRound: z.number().nonnegative(),
+    openingUtilityUsePerRound: z.number().nonnegative(),
+  }),
+  responsibility: teamResponsibilitySchema,
+  modifiers: z.array(roleModifierSchema),
+  awp: awpResponsibilityEvidenceSchema,
+  representativeRounds: z.array(roleEvidenceLocatorSchema).max(5),
+  basis: z.array(z.string()),
+  limitations: z.array(z.string()),
+});
+
+export const teamMapResponsibilityEvidenceSchema = z.object({
+  version: z.literal(MAP_ROLE_EVIDENCE_VERSION),
+  teamKey: z.string().min(1),
+  mapName: supportedMapNameSchema,
+  side: z.enum(["t", "ct"]),
+  status: mapRoleStatusSchema,
+  confidence: z.number().min(0).max(1),
+  players: z.array(playerMapRoleEvidenceSchema),
+  positionOverlap: z.array(z.object({ positionGroupId: z.string().min(1), playerKeys: z.array(z.string().min(1)).min(2), share: z.number().min(0).max(1) })),
+  positionConcentration: z.number().min(0).max(1).nullable(),
+  unstableCoverage: z.boolean(),
+  representativeRounds: z.array(roleEvidenceLocatorSchema).max(5),
+  basis: z.array(z.string()),
+  limitations: z.array(z.string()),
+});
+
+export const playerMapRoleProfileSchema = z.object({
+  version: z.literal("cs2-demo-analysis-kit/player-map-role-profile-5.0"),
+  playerKey: z.string().min(1),
+  teamKey: z.string().min(1),
+  declaredRoles: z.array(mainRoleDeclarationSchema),
+  declaredWeaponDuties: z.array(weaponDutyDeclarationSchema),
+  inferredPrimaryRole: inferredMapRoleSchema.nullable(),
+  runnerUpRole: inferredMapRoleSchema.nullable(),
+  separationMargin: z.number().min(0).max(1).nullable(),
+  roleEvidenceScores: z.object({ awper: z.number().min(0).max(1), anchor: z.number().min(0).max(1), opener: z.number().min(0).max(1), closer: z.number().min(0).max(1) }),
+  headlineRole: z.union([inferredMapRoleSchema, z.literal("IGL"), z.literal("IGL / AWPer")]).nullable(),
+  status: mapRoleStatusSchema,
+  confidence: z.number().min(0).max(1),
+  weaponDuty: weaponDutySchema.nullable(),
+  positionGroupDisplay: z.array(z.object({
+    mapName: supportedMapNameSchema,
+    side: z.enum(["t", "ct"]),
+    positionGroupId: z.string().min(1),
+    displayName: z.string().min(1),
+    officialName: z.string().nullable(),
+    resolved: z.boolean(),
+  })),
+  roleAlignments: z.array(z.object({
+    declaration: mainRoleDeclarationSchema,
+    declaredPrimary: declaredRoleSchema.nullable(),
+    declaredSecondary: z.array(declaredRoleSchema),
+    inferredPrimary: inferredMapRoleSchema.nullable(),
+    overall: z.enum(["aligned", "partially_aligned", "different_observation", "not_comparable"]),
+    tSide: z.string(),
+    ctSide: z.string(),
+    disagreementReasons: z.array(z.string()),
+    sampleLimitations: z.array(z.string()),
+  })),
+  weaponDutyAlignments: z.array(z.object({
+    declaration: weaponDutyDeclarationSchema,
+    observedWeaponDuty: weaponDutySchema.nullable(),
+    overall: z.enum(["aligned", "different_observation", "not_comparable"]),
+    sampleLimitations: z.array(z.string()),
+  })),
+  perMapEvidence: z.array(playerMapRoleEvidenceSchema),
+  evidence: z.array(evidenceRefSchema),
+  basis: z.array(z.string()),
+  limitations: z.array(z.string()),
+});
+
+export const teamMapRoleMatrixSchema = z.object({
+  version: z.literal("cs2-demo-analysis-kit/team-map-role-matrix-4.0"),
+  teamKey: z.string().min(1),
+  mapName: supportedMapNameSchema,
+  side: z.enum(["t", "ct"]),
+  status: mapRoleStatusSchema,
+  confidence: z.number().min(0).max(1),
+  players: z.array(z.object({
+    playerKey: z.string().min(1),
+    primaryPositionGroups: z.array(mapPositionGroupEvidenceSchema.extend({ displayName: z.string().min(1), officialName: z.string().nullable(), resolved: z.boolean() })),
+    responsibility: teamResponsibilitySchema,
+    modifiers: z.array(roleModifierSchema),
+    sampleRounds: z.number().int().nonnegative(),
+    confidence: z.number().min(0).max(1),
+    weaponDuty: weaponDutySchema.nullable(),
+    evidence: z.array(evidenceRefSchema),
+  })),
+  positionOverlap: teamMapResponsibilityEvidenceSchema.shape.positionOverlap,
+  positionConcentration: z.number().min(0).max(1).nullable(),
+  unstableCoverage: z.boolean(),
+  representativeRounds: z.array(evidenceRefSchema),
+  basis: z.array(z.string()),
+  limitations: z.array(z.string()),
+});
+
+const countBreakdownSchema = z.object({ key: z.string().min(1), rounds: z.number().int().nonnegative() });
+export const doubleAwpAnalysisSchema = z.object({
+  version: z.literal("cs2-demo-analysis-kit/double-awp-analysis-2.0"),
+  teamKey: z.string().min(1),
+  side: z.enum(["t", "ct"]),
+  status: mapRoleStatusSchema,
+  qualifiedRoundCount: z.number().int().nonnegative(),
+  doubleAwpRoundCount: z.number().int().nonnegative(),
+  eligibleRoundShare: z.number().min(0).max(1).nullable(),
+  combinations: z.array(z.object({ playerKeys: z.array(z.string().min(1)).min(2), rounds: z.number().int().positive() })),
+  mapDistribution: z.array(countBreakdownSchema),
+  scorePhaseDistribution: z.array(countBreakdownSchema),
+  economyDistribution: z.array(countBreakdownSchema),
+  opponentEconomyDistribution: z.array(countBreakdownSchema),
+  wins: z.number().int().nonnegative(),
+  winRate: z.number().min(0).max(1).nullable(),
+  openingKills: z.number().int().nonnegative(),
+  openingDeaths: z.number().int().nonnegative(),
+  roundStartAwpOwnerships: z.number().int().nonnegative(),
+  activeAwpSeconds: z.number().nonnegative().nullable(),
+  doubleAwpActiveSeconds: z.number().nonnegative().nullable(),
+  awpKills: z.number().int().nonnegative().nullable(),
+  awpDamage: z.number().nonnegative().nullable(),
+  evidence: z.array(evidenceRefSchema),
+  basis: z.array(z.string()),
+  limitations: z.array(z.string()),
+});
+
+export const playerMapPoolRowSchema = z.object({
+  mapName: supportedMapNameSchema,
+  matchCount: z.number().int().nonnegative(), roundCount: z.number().int().nonnegative(), wins: z.number().int().nonnegative(), losses: z.number().int().nonnegative(), winRate: z.number().min(0).max(1).nullable(),
+  rr: z.number().nonnegative().nullable(), adr: z.number().nonnegative().nullable(), kast: z.number().min(0).max(100).nullable(),
+  openingKills: z.number().int().nonnegative(), openingDeaths: z.number().int().nonnegative(),
+  mainWeapon: z.string().nullable(), globalWeaponDuty: weaponDutySchema.nullable(), mapSideAwpUsage: z.array(z.object({ side: z.enum(["t", "ct"]), duty: weaponDutySchema, qualifiedRounds: z.number().int().nonnegative(), activeSeconds: z.number().nonnegative().nullable() })),
+  tPositionGroup: z.string().nullable(), ctPositionGroup: z.string().nullable(), tResponsibility: teamResponsibilitySchema, ctResponsibility: teamResponsibilitySchema,
+  sampleQuality: z.number().min(0).max(1), confidence: z.number().min(0).max(1), evidence: z.array(evidenceRefSchema),
+});
+
+export type SupportedMapName = z.infer<typeof supportedMapNameSchema>;
+export type MapRoleStatus = z.infer<typeof mapRoleStatusSchema>;
+export type InferredMapRole = z.infer<typeof inferredMapRoleSchema>;
+export type DeclaredRole = z.infer<typeof declaredRoleSchema>;
+export type WeaponDuty = z.infer<typeof weaponDutySchema>;
+export type TeamResponsibility = z.infer<typeof teamResponsibilitySchema>;
+export type RoleModifier = z.infer<typeof roleModifierSchema>;
+export type TResponsibilityResearchCandidate = z.infer<typeof tResponsibilityResearchCandidateSchema>;
+export type TResponsibilityResearchFeatures = z.infer<typeof tResponsibilityResearchFeaturesSchema>;
+export type TResponsibilityResearchProjection = z.infer<typeof tResponsibilityResearchProjectionSchema>;
+export type RoleDeclaration = z.infer<typeof roleDeclarationSchema>;
+export type MainRoleDeclaration = z.infer<typeof mainRoleDeclarationSchema>;
+export type WeaponDutyDeclaration = z.infer<typeof weaponDutyDeclarationSchema>;
+export type RoleEvidenceLocator = z.infer<typeof roleEvidenceLocatorSchema>;
+export type PlayerMapRoleEvidence = z.infer<typeof playerMapRoleEvidenceSchema>;
+export type TeamMapResponsibilityEvidence = z.infer<typeof teamMapResponsibilityEvidenceSchema>;
+export type PlayerMapRoleProfile = z.infer<typeof playerMapRoleProfileSchema>;
+export type TeamMapRoleMatrix = z.infer<typeof teamMapRoleMatrixSchema>;
+export type DoubleAwpAnalysis = z.infer<typeof doubleAwpAnalysisSchema>;
+export type PlayerMapPoolRow = z.infer<typeof playerMapPoolRowSchema>;

package/src/player.ts

@@ -11,16 +11,26 @@ import { leaderboardMetricKeySchema } from "./leaderboard.js";
  */
 
 export const rrBreakdownEntrySchema = z.object({
-  key: z.enum(["combat", "trade", "clutch", "objective", "utility"]),
+  key: z.enum(["combat", "trade", "mapControl", "clutch", "objective", "utility"]),
   label: z.string(),
   value: z.number()
 });
 
-/** PRISM 单根轴的展示项（八维风格雷达）。 */
+/** PRISM 单根轴的展示项：行为倾向与执行效率分离，避免把角色、频率和效果混成一个分数。 */
 export const playerStyleAxisSchema = z.object({
   key: z.string(), // PrismAxisKey
   label: z.string(),
-  percentile: z.number().min(0).max(100)
+  /** 该轴在当前 cohort 内的行为参与度相对位置。 */
+  involvementPercentile: z.number().min(0).max(100).nullable(),
+  /** 该轴在当前 cohort 内的执行效率相对位置。 */
+  efficiencyPercentile: z.number().min(0).max(100).nullable(),
+  /** 上游融合值，仅供解释/导出，不再用作雷达形状。 */
+  combinedPercentile: z.number().min(0).max(100).nullable(),
+  /** 上游配置中可用信号权重占比，0–1。 */
+  signalCoverage: z.number().min(0).max(1),
+  /** 可供当前 cohort 排名的有效选手数；不足 5 人时不展示精确 P 值。 */
+  comparisonCount: z.number().int().nonnegative(),
+  status: z.enum(["ready", "partial", "unavailable", "insufficient"])
 });
 
 export const playerStyleSchema = z.object({
@@ -51,7 +61,8 @@ export const playerWeaponProfileEntrySchema = z.object({
 });
 
 export const playerSeasonProfileSchema = z.object({
-  version: z.literal("cs2-demo-analysis-kit/player-profile-0.1"),
+  /** 0.2：PRISM 轴拆分为行为倾向、执行效率，并附带信号/样本可用性。 */
+  version: z.literal("cs2-demo-analysis-kit/player-profile-0.2"),
   weightsVersion: z.string(),
   playerKey: z.string(),
   name: z.string(),

package/src/radar-field.ts

@@ -0,0 +1,79 @@
+/**
+ * RadarField —— 雷达覆盖场合同（描述性地图控制原语）。
+ *
+ * 「基础场」逐秒 × 逐格存原始计数（不存概率、不存合成视图），因为原始计数是
+ * 加性的：合并两个 scope = 四场逐元素相加 + denom 相加。这一条承重墙撑起 per-match
+ * 缓存、scope 聚合、队伍−联赛差分、未来价值学习——全是廉价派生。
+ *
+ * 归一化（count / denom = 该秒该格被看到/占据/听到的采样占比）、信息差分（tVis−ctVis）、
+ * 对拼线（min(tVis,ctVis)）、推进波前都在渲染期合成，底层场不污染。
+ *
+ * 这是 TS 侧计算产物，不跨 Python↔TS 的 v3 ZIP seam，故用手写 interface（非 Zod）。
+ * 字段列用 Int32Array：结构化克隆（worker postMessage / IndexedDB）下紧凑且无损。
+ */
+
+/**
+ * 基础场名。
+ * Vis = 4:3 屏幕可见（矩形视锥 ∩ LOS ∩ 烟）；Aim = 准星/注意力覆盖（30°圆锥 ∩ LOS ∩ 烟）；
+ * Pres = 位置占据（最近 nav 格，无 LOS）；Sound = 在该格发声会被对面听到的风险（800u 半径）。
+ */
+export type RadarFieldBase =
+  | "ctVis" | "tVis"
+  | "ctAim" | "tAim"
+  | "ctPres" | "tPres"
+  | "ctSound" | "tSound";
+
+export const RADAR_FIELD_BASES: readonly RadarFieldBase[] = [
+  "ctVis", "tVis",
+  "ctAim", "tAim",
+  "ctPres", "tPres",
+  "ctSound", "tSound",
+] as const;
+
+export interface RadarFieldGrid {
+  /** 规则栅格边长（世界单位）。 */
+  cellSize: number;
+  /** 每格代表世界坐标 [x, y, z]（z 已含靶高），与 fields 列同序。 */
+  cells: Array<[number, number, number]>;
+}
+
+export interface RadarFieldScope {
+  /** league = 赛事/当前范围基线；team = 单队（identity 归并后的显示名）。 */
+  kind: "league" | "team";
+  team: string | null;
+  /** gun = 长枪局（双方 full/conversion）；all = 全部回合。 */
+  economy: "gun" | "all";
+  /** 贡献的回合总数（含全部采样秒之前的回合计数）。 */
+  roundCount: number;
+  matchIds: string[];
+}
+
+export interface RadarField {
+  /** 合同结构版本。 */
+  schemaVersion: number;
+  /** 算法参数指纹（锥角/采样率/格大小/眼高变了即 +1）；驱动缓存失效。 */
+  computeVersion: number;
+  mapName: string;
+  /** world→radar 标定版本；变了不可与旧场合并/差分。 */
+  calibrationVersion: string;
+  /** full = 这批 LOS 射线可信（有 .tri）；none = 只有锥+烟，无墙体遮挡，不可与 full 互比。 */
+  triAvailability: "full" | "none";
+  scope: RadarFieldScope;
+  grid: RadarFieldGrid;
+  /** 采样秒上界（一回合 1:55 = 115s）。 */
+  maxSec: number;
+  /**
+   * 归一化分母，按 source side 分。当前计算每秒采样一次：
+   * denomCt[sec] = scope 内、CT 侧、到达该秒的 side-frame 数；ct* 基础场除以它。
+   * denomT 同理给 t* 基础场。
+   */
+  denomCt: Int32Array;
+  denomT: Int32Array;
+  /** fields[base][sec] = Int32Array(cells.length) 原始计数。 */
+  fields: Record<RadarFieldBase, Int32Array[]>;
+}
+
+export const RADAR_FIELD_SCHEMA_VERSION = 1;
+
+/** 一回合 1:55 = 115s（freeze 后逐秒采样窗，含残局/换防段；已实证）。 */
+export const RADAR_FIELD_MAX_SEC = 115;

package/src/scoring.ts

@@ -76,4 +76,12 @@ export const rrIndicatorsSchema: z.ZodType<RRIndicators> = z.object({
   roundSwingPerKill: z.number().nullable()
 });
 
-export type { AccountSignalsV2, RRIndicators, RRResult, RRResultV2, PrismResult, ValueAccountsWeights } from "@rivalhub/rival-rating";
+export type {
+  CohortAccountResult,
+  PrismResult,
+  RRIndicators,
+  RRResult,
+  RRSignals,
+  RRSixAccountResult,
+  RRSixAccountWeights
+} from "@rivalhub/rival-rating";

package/src/trails.ts

@@ -0,0 +1,56 @@
+import { z } from "zod";
+import { sideSchema, teamEconomySchema, grenadeTypeSchema } from "cs2-demo-format";
+
+/**
+ * 开局动线：单选手在指定经济类型回合（默认长枪局）开局窗口内的
+ * 走位轨迹 + 道具投掷。由 @cs2dak/presentation 从 replay/rounds/grenades 派生，
+ * 坐标保持 world 坐标系，radar 投影由渲染端（@cs2dak/maps）完成。
+ */
+
+export const trailPointSchema = z.object({
+  /** 距 freeze 结束的秒数。 */
+  t: z.number().nonnegative(),
+  x: z.number(),
+  y: z.number()
+});
+
+export const trailGrenadeSchema = z.object({
+  /** 投掷时刻（距 freeze 结束的秒数）。 */
+  t: z.number().nonnegative(),
+  x: z.number(),
+  y: z.number(),
+  grenade: grenadeTypeSchema,
+  /** 生效时刻（距 freeze 结束的秒数）。 */
+  effectT: z.number().nonnegative(),
+  /** 效果消失时刻；导出包缺失时 null，渲染端按道具类型取默认时长。 */
+  destroyT: z.number().nonnegative().nullable(),
+  /** 落点（world 坐标）。 */
+  effectX: z.number(),
+  effectY: z.number()
+});
+
+export const openingTrailRoundSchema = z.object({
+  matchId: z.string(),
+  roundNumber: z.number().int().positive(),
+  side: sideSchema,
+  economyType: teamEconomySchema,
+  points: z.array(trailPointSchema),
+  grenades: z.array(trailGrenadeSchema)
+});
+
+export const openingTrailsModelSchema = z.object({
+  version: z.literal("cs2-demo-analysis-kit/opening-trails-0.2"),
+  matchId: z.string(),
+  mapName: z.string(),
+  steamId64: z.string(),
+  playerName: z.string(),
+  /** 该导出包是否含回放流；false 时 rounds 为空。 */
+  available: z.boolean(),
+  windowSeconds: z.number().positive(),
+  rounds: z.array(openingTrailRoundSchema)
+});
+
+export type TrailPoint = z.infer<typeof trailPointSchema>;
+export type TrailGrenade = z.infer<typeof trailGrenadeSchema>;
+export type OpeningTrailRound = z.infer<typeof openingTrailRoundSchema>;
+export type OpeningTrailsModel = z.infer<typeof openingTrailsModelSchema>;

package/src/upstream.ts

@@ -5,6 +5,7 @@ import {
   economyTypeSchema,
   teamEconomySchema,
   vec3Schema,
+  playerIndexSchema,
   playerRowSchema,
   roundRowSchema,
   killRowSchema,
@@ -15,11 +16,16 @@ import {
   bombRowSchema,
   grenadeRowSchema,
   clutchRowSchema,
-  shotRowSchema,
-  positionRowSchema,
+  shotTrackSchema,
+  shotsSchema,
   replaySchema,
   replayRoundSchema,
   replayPlayerTrackSchema,
+  replayProjectileSchema,
+  duelsSchema,
+  duelWindowSchema,
+  duelPlayerTrackSchema,
+  duelAnchorSchema,
 } from "cs2-demo-format";
 
 export {
@@ -33,8 +39,16 @@ export {
   clutchesSchema,
   damageRowSchema,
   damagesSchema,
+  decodeDelta,
+  duelAnchorSchema,
+  duelPlayerTrackSchema,
+  duelsSchema,
+  duelWindowSchema,
   economyTypeSchema,
   endReasonSchema,
+  FLAG_ALIVE,
+  FLAG_HAS_BOMB,
+  FLAG_HAS_DEFUSE_KIT,
   grenadeRowSchema,
   grenadeTypeSchema,
   grenadesSchema,
@@ -45,18 +59,18 @@ export {
   matchSchema,
   playerEconomiesSchema,
   playerEconomyRowSchema,
+  playerIndexSchema,
   playerRowSchema,
   playersSchema,
   playerStatsRowSchema,
   playerStatsSchema,
-  positionRowSchema,
-  positionsSchema,
   replaySchema,
   replayPlayerTrackSchema,
+  replayProjectileSchema,
   replayRoundSchema,
   roundRowSchema,
   roundsSchema,
-  shotRowSchema,
+  shotTrackSchema,
   shotsSchema,
   sideSchema,
   steamId64Schema,
@@ -72,6 +86,7 @@ export type TeamKey = z.infer<typeof teamKeySchema>;
 export type EconomyType = z.infer<typeof economyTypeSchema>;
 export type TeamEconomyType = z.infer<typeof teamEconomySchema>;
 export type Vec3 = z.infer<typeof vec3Schema>;
+export type PlayerIndex = z.infer<typeof playerIndexSchema>;
 
 export type PackagePlayer = z.infer<typeof playerRowSchema>;
 export type PackageRound = z.infer<typeof roundRowSchema>;
@@ -83,8 +98,13 @@ export type PackageBlind = z.infer<typeof blindRowSchema>;
 export type PackageBomb = z.infer<typeof bombRowSchema>;
 export type PackageGrenade = z.infer<typeof grenadeRowSchema>;
 export type PackageClutch = z.infer<typeof clutchRowSchema>;
-export type PackageShot = z.infer<typeof shotRowSchema>;
-export type PackagePosition = z.infer<typeof positionRowSchema>;
+export type PackageShots = z.infer<typeof shotsSchema>;
+export type PackageShotTrack = z.infer<typeof shotTrackSchema>;
 export type Replay = z.infer<typeof replaySchema>;
 export type ReplayRound = z.infer<typeof replayRoundSchema>;
 export type ReplayPlayerTrack = z.infer<typeof replayPlayerTrackSchema>;
+export type ReplayProjectile = z.infer<typeof replayProjectileSchema>;
+export type Duels = z.infer<typeof duelsSchema>;
+export type DuelWindow = z.infer<typeof duelWindowSchema>;
+export type DuelPlayerTrack = z.infer<typeof duelPlayerTrackSchema>;
+export type DuelAnchor = z.infer<typeof duelAnchorSchema>;

package/src/veto.ts

@@ -0,0 +1,44 @@
+import { z } from "zod";
+
+export const seriesFormatSchema = z.enum(["bo1", "bo3", "bo5"]);
+export const vetoActionTypeSchema = z.enum(["ban", "pick", "decider"]);
+export const vetoTeamRefSchema = z.enum(["teamA", "teamB"]).nullable();
+
+export const seriesVetoStepSchema = z.object({
+  stepOrder: z.number().int().positive(),
+  actionType: vetoActionTypeSchema,
+  mapName: z.string().min(1),
+  teamKey: vetoTeamRefSchema,
+  side: z.enum(["t", "ct"]).nullable()
+});
+
+export const seriesVetoSchema = z.object({
+  version: z.literal("cs2-demo-analysis-kit/series-veto-0.1"),
+  seriesId: z.string(),
+  format: seriesFormatSchema,
+  teamAName: z.string(),
+  teamBName: z.string(),
+  mapPool: z.array(z.string().min(1)),
+  maps: z.object({
+    picked: z.array(z.object({
+      mapName: z.string().min(1),
+      teamKey: z.enum(["teamA", "teamB"]).nullable()
+    })),
+    banned: z.array(z.object({
+      mapName: z.string().min(1),
+      teamKey: z.enum(["teamA", "teamB"]).nullable()
+    })),
+    decider: z.string().min(1).nullable()
+  }),
+  sideChoices: z.array(z.object({
+    mapName: z.string().min(1),
+    teamKey: z.enum(["teamA", "teamB"]).nullable(),
+    side: z.enum(["t", "ct"])
+  })),
+  steps: z.array(seriesVetoStepSchema)
+});
+
+export type SeriesFormat = z.infer<typeof seriesFormatSchema>;
+export type VetoActionType = z.infer<typeof vetoActionTypeSchema>;
+export type SeriesVetoStep = z.infer<typeof seriesVetoStepSchema>;
+export type SeriesVeto = z.infer<typeof seriesVetoSchema>;