@cs2dak/contract 1.0.0 → 1.1.0

package/LICENSE

@@ -1,3 +1,10 @@
+Licensing note / 适用范围
+-------------------------
+The MIT License below applies to this repository EXCEPT apps/dak-studio/,
+which is licensed under the GNU AGPL-3.0-only (see apps/dak-studio/LICENSE).
+Ecosystem packages (@cs2dak/*, python exporter) are MIT; the DAK Studio
+product is AGPL. Third-party attributions: THIRD-PARTY-NOTICES.md.
+
 MIT License
 
 Copyright (c) 2026 Starfie1d

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@cs2dak/contract",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "type": "module",
   "license": "MIT",
   "exports": {
     ".": "./src/index.ts"
   },
   "dependencies": {
-    "@rivalhub/rival-rating": "^0.1.0",
-    "cs2-demo-format": "^2.2.0",
+    "@rivalhub/rival-rating": "^0.3.0",
+    "cs2-demo-format": "^3.1.0",
     "zod": "^3.25.0"
   },
   "files": [

package/src/analysis.ts

@@ -39,6 +39,7 @@ export const playerScoreboardRowSchema = z.object({
   steamId64: z.string(),
   name: z.string(),
   teamKey: teamKeySchema,
+  indicators: rrIndicatorsSchema,
   kills: z.number().int().nonnegative(),
   deaths: z.number().int().nonnegative(),
   assists: z.number().int().nonnegative(),
@@ -66,19 +67,22 @@ export const playerScoreboardRowSchema = z.object({
     damages: z.enum(["available", "missing"]),
     bombs: z.enum(["available", "missing"])
   }),
-  ratingSeed: z.number().nonnegative(),
+  // rrBase（clamp 前的基础分）：被碾压方 KAST/KPR 低、死亡惩罚大时可为负，
+  // 不能强制非负，否则一边倒的真实比赛整场导入失败。最终 rr 才被 clamp 到非负。
+  ratingSeed: z.number(),
   rr: z.number().nonnegative(),
   rrPercentile: z.number().min(0).max(100),
-  /** RR v2 账户分。锚定后：1.00 = 本场联赛均值（per-match league mean）。 */
+  /** RR v2 账户分。单场为 frozen pro baseline：1.00 = 职业基线。 */
   accountRR: z.number().nonnegative(),
   /** 锚定/clamp 前的原始账户分（调试用）。 */
   accountRRRaw: z.number(),
   /** Combat 击杀项的 context 乘子（1.0 = context 未生效 / 已降级）。 */
   accountCombatContextFactor: z.number(),
-  /** 五账户对 RR 的加权贡献（解释面板用；和为 accountRRRaw − intercept）。 */
+  /** 六账户对 RR 的加权贡献（解释面板用）。 */
   accountBreakdown: z.object({
     combat: z.number(),
     trade: z.number(),
+    mapControl: z.number(),
     clutch: z.number(),
     objective: z.number(),
     utility: z.number()
@@ -157,12 +161,14 @@ export const heatmapPointSchema = z.object({
 export const mapViewSchema = z.object({
   name: z.string(),
   radarImageUrl: z.string().nullable(),
+  /** 双层地图（de_nuke / de_vertigo）的下层底图；单层地图为 null。 */
+  lowerRadarImageUrl: z.string().nullable().optional().default(null),
   calibrated: z.boolean()
 });
 
 export const analysisProvenanceSchema = z.object({
   analysisVersion: z.string(),
-  sourceSchemaVersion: z.literal("cs2-demo-format/2.0"),
+  sourceSchemaVersion: z.literal("cs2-demo-format/3.0"),
   sourceDemoHash: z.string().nullable(),
   exporter: z.object({ name: z.string(), version: z.string() }),
   parser: z.object({ name: z.string(), version: z.string() }),
@@ -174,7 +180,7 @@ export const analysisProvenanceSchema = z.object({
 
 export const analysisBundleSchema = z.object({
   version: z.literal("cs2-demo-analysis-kit/1.0"),
-  sourceSchemaVersion: z.literal("cs2-demo-format/2.0"),
+  sourceSchemaVersion: z.literal("cs2-demo-format/3.0"),
   provenance: analysisProvenanceSchema,
   mapName: z.string(),
   tickrate: z.number().int().positive(),

package/src/bracket.ts

@@ -0,0 +1,68 @@
+/**
+ * 赛事 bracket 的中性数据模型 —— 观看侧（从比赛结果推算）与制作器（从框架槽位）共用同一套
+ * 渲染。瑞士轮按战绩组（Buchholz）成列 + 晋级/淘汰终列；淘汰赛按晋级轮次成列。
+ */
+
+export interface BracketCell {
+  key: string;
+  teamA: string | null;
+  teamB: string | null;
+  scoreA: number | null;
+  scoreB: number | null;
+  winner: "A" | "B" | null;
+  date: string | null;
+  /** 观看侧：点开该场的 demo entry。 */
+  entryIds?: string[];
+  /** 制作器：待填槽位（点击附加 demo）。 */
+  empty?: boolean;
+}
+
+export interface SwissGroup {
+  /** 战绩组标签，如 "1-0"。 */
+  record: string;
+  matches: BracketCell[];
+  /** 制作器：该战绩组可继续添加比赛（携带 slot id）。 */
+  addSlotId?: string;
+}
+
+export interface SwissColumn {
+  round: number;
+  groups: SwissGroup[];
+}
+
+export interface SwissModel {
+  columns: SwissColumn[];
+  advanced: { team: string; record: string }[];
+  eliminated: { team: string; record: string }[];
+  winsTarget: number;
+  lossTarget: number;
+}
+
+export interface ElimColumn {
+  round: number;
+  label: string;
+  matches: BracketCell[];
+}
+
+/** 淘汰赛 bracket 中单个节点的元数据（双败 / GSL lane-aware 布局用）。 */
+export interface ElimNode {
+  id: string;
+  round: number;
+  lane: "winner" | "loser" | "grand" | "single";
+  label: string;
+  nextWinNodeId?: string | null;
+  nextLossNodeId?: string | null;
+}
+
+export interface ElimModel {
+  columns: ElimColumn[];
+  /**
+   * Lane-aware 节点元数据（可选）。**存在性决定渲染模式**：
+   * - 非空 → SVG lane-aware 布局（双败 / GSL），含晋级连线与 lane 分隔
+   * - undefined / [] → DOM 列布局（单败 / 旧资产 / 制作器），以 MatchBox 列展示
+   *
+   * 未来考虑改为显式 `renderMode?: "dom" | "svg-lane"` 以消除隐式联合类型。
+   */
+  nodes?: ElimNode[];
+}
+

package/src/cohort.ts

@@ -22,6 +22,7 @@ export const seasonPlayerRowSchema = z.object({
   accountBreakdown: z.object({
     combat: z.number(),
     trade: z.number(),
+    mapControl: z.number(),
     clutch: z.number(),
     objective: z.number(),
     utility: z.number()
@@ -47,7 +48,7 @@ export const seasonCohortBundleSchema = z.object({
   weightsVersion: z.string(),
   provenance: z.object({
     cohortVersion: z.literal("cs2-demo-analysis-kit/cohort-1.0"),
-    sourceSchemaVersion: z.literal("cs2-demo-format/2.0"),
+    sourceSchemaVersion: z.literal("cs2-demo-format/3.0"),
     matches: z.array(z.object({
       matchId: z.string(),
       sourceDemoHash: z.string().nullable()

package/src/contract.test.ts

@@ -24,6 +24,9 @@ import {
   mapViewSchema,
   analysisProvenanceSchema,
   analysisBundleSchema,
+  evidenceRefSchema,
+  matchMapIntelligenceFactsSchema,
+  roleDeclarationSchema,
   // cohort
   seasonCohortBundleSchema,
   // workspace
@@ -35,6 +38,65 @@ import {
 // 复用 fixtures
 // ─────────────────────────────────────────────────────────────────────────────
 
+describe("evidenceRefSchema", () => {
+  it("requires a human-readable reason", () => {
+    expect(evidenceRefSchema.safeParse({ matchId: "m1", roundNumber: 12, reason: "复核该回合的首死" }).success).toBe(true);
+    expect(evidenceRefSchema.safeParse({ matchId: "m1", roundNumber: 12 }).success).toBe(false);
+  });
+});
+
+describe("roleDeclarationSchema", () => {
+  it("accepts portable declarations and excludes storage-only fields", () => {
+    expect(roleDeclarationSchema.safeParse({ kind: "main_role", playerKey: "p1", role: "igl", priority: "primary", source: "trusted_metadata", mapName: "de_ancient", provenance: "team roster" }).success).toBe(true);
+    expect(roleDeclarationSchema.safeParse({ kind: "weapon_duty", playerKey: "p1", weaponDuty: "secondary_awper", source: "user", provenance: "self report" }).success).toBe(true);
+    expect(roleDeclarationSchema.safeParse({ kind: "weapon_duty", playerKey: "p1", weaponDuty: "secondary_awper", priority: "primary", source: "user", provenance: "self report" }).success).toBe(false);
+    expect(roleDeclarationSchema.safeParse({ kind: "main_role", playerKey: "p1", role: "igl", priority: "primary", source: "user", provenance: "" }).success).toBe(false);
+  });
+});
+
+describe("matchMapIntelligenceFactsSchema", () => {
+  const base = {
+    analysisVersion: 6 as const,
+    matchId: "m1",
+    mapName: "de_anubis",
+    playerPositionRounds: [{
+      analysisVersion: 6 as const,
+      matchId: "m1", mapName: "de_anubis", roundNumber: 1, teamKey: "teamA" as const, side: "t" as const,
+      playerIndex: 0, steamId64: "76561198000000001", economyType: null, openingWindow: null,
+      openingEligibleSeconds: null, openingPositionGroupDwell: [], openingMeanComponentSize: null, openingIsolationSeconds: null,
+      openingUtilityUseCount: 0,
+      openingPath: [],
+      eligibleSeconds: null, positionGroupDwell: [],
+      unresolvedCalloutSeconds: null, calloutCoverage: null, meanNearestTeammateDistance: null,
+      meanTeamCentroidDistance: null, meanComponentSize: null, isolationSegments: [], rejoinTicks: [], delayedConvergences: [],
+      movementSync: null, utilityUseCount: 0, freezeAwpOwnership: null, activeAwpSeconds: null, awpShots: null, awpKills: null,
+      availability: { replay: "missing" as const, nav: "missing" as const, callouts: "missing" as const, shots: "missing" as const },
+    }],
+    teamShapeRounds: [{
+      analysisVersion: 6 as const,
+      matchId: "m1", mapName: "de_anubis", roundNumber: 1, teamKey: "teamA" as const, side: "t" as const,
+      openingWindow: null, openingWindows: [], coverageSeconds: null, windows: [],
+      availability: { replay: "missing" as const, nav: "missing" as const, callouts: "missing" as const, shots: "missing" as const },
+    }],
+    teamAwpRounds: [],
+    ctRotationRounds: [],
+  };
+
+  it("keeps missing replay facts explicitly null rather than inventing zero", () => {
+    expect(matchMapIntelligenceFactsSchema.parse(base).playerPositionRounds[0]?.activeAwpSeconds).toBeNull();
+  });
+
+  it("rejects invalid coverage and malformed shape windows", () => {
+    expect(matchMapIntelligenceFactsSchema.safeParse({ ...base, playerPositionRounds: [{ ...base.playerPositionRounds[0], calloutCoverage: 2 }] }).success).toBe(false);
+    expect(matchMapIntelligenceFactsSchema.safeParse({ ...base, teamShapeRounds: [{ ...base.teamShapeRounds[0], windows: [{ startTick: 1, endTick: 2, coverageSeconds: 1, componentSizes: [], partition: "", componentPlayerIndices: [] }] }] }).success).toBe(false);
+  });
+
+  it("rejects pre-v6 map facts that omit CT rotation rows instead of defaulting them", () => {
+    const { ctRotationRounds: _, ...historic } = base;
+    expect(matchMapIntelligenceFactsSchema.safeParse(historic).success).toBe(false);
+  });
+});
+
 const qaReport = {
   ok: true,
   summary: { issueCount: 0, errorCount: 0, warningCount: 0 },
@@ -77,7 +139,7 @@ const minimalIndicators = {
 
 const minimalProvenance = {
   analysisVersion: "cs2-demo-analysis-kit/1.0",
-  sourceSchemaVersion: "cs2-demo-format/2.0" as const,
+  sourceSchemaVersion: "cs2-demo-format/3.0" as const,
   sourceDemoHash: null,
   exporter: { name: "cs2dak", version: "0.2.1" },
   parser: { name: "demoparser2", version: "0.1.0" },
@@ -88,6 +150,7 @@ const minimalScoreboardRow = {
   steamId64: "76561198000000001",
   name: "Player A",
   teamKey: "teamA" as const,
+  indicators: minimalIndicators,
   kills: 10, deaths: 8, assists: 2,
   adr: 72.5, kast: 66.7, headshotPercent: 40,
   entryKills: 2, tradeKills: 1, awpKills: 2, utilityDamage: 150,
@@ -108,13 +171,13 @@ const minimalScoreboardRow = {
   rr: 1.05, rrPercentile: 55,
   accountRR: 1.1, accountRRRaw: 1.08,
   accountCombatContextFactor: 1.0,
-  accountBreakdown: { combat: 0.4, trade: 0.1, clutch: 0.05, objective: 0.05, utility: 0.1 },
+  accountBreakdown: { combat: 0.4, trade: 0.1, mapControl: 0, clutch: 0.05, objective: 0.05, utility: 0.1 },
   accountContextStatus: { buyDelta: "available" as const, manState: "available" as const },
 };
 
 const minimalBundle = {
   version: "cs2-demo-analysis-kit/1.0" as const,
-  sourceSchemaVersion: "cs2-demo-format/2.0" as const,
+  sourceSchemaVersion: "cs2-demo-format/3.0" as const,
   provenance: minimalProvenance,
   mapName: "de_ancient",
   tickrate: 64,
@@ -134,7 +197,7 @@ const minimalBundle = {
 
 const minimalWorkspaceModel = {
   version: "cs2-demo-analysis-kit/workspace-0.1" as const,
-  sourceSchemaVersion: "cs2-demo-format/2.0" as const,
+  sourceSchemaVersion: "cs2-demo-format/3.0" as const,
   title: "Team A vs Team B",
   subtitle: "de_ancient · 10 名选手 · 21 回合",
   scoreline: "13:8",
@@ -146,6 +209,8 @@ const minimalWorkspaceModel = {
   rounds: [],
   players: [],
   economy: [],
+  weapons: [],
+  duels: { players: [], matrix: [], openings: [] },
   map: {
     view: { name: "de_ancient", radarImageUrl: null, calibrated: false },
     modes: [],
@@ -157,7 +222,7 @@ const minimalWorkspaceModel = {
     sampleRate: null,
     tickrate: null,
     rounds: [],
-    capabilities: { hasDefuseKit: false, hasBombPosition: false },
+    capabilities: { hasDefuseKit: false },
   },
   adminQa: qaReport,
 };
@@ -250,7 +315,7 @@ describe("demoPackageSchema", () => {
   it("applies defaults for optional array fields", () => {
     const pkg = demoPackageSchema.parse({
       manifest: {
-        schemaVersion: "cs2-demo-format/2.0",
+        schemaVersion: "cs2-demo-format/3.0",
         exporter: { name: "cs2dak", version: "0.2.1" },
         parser: { name: "demoparser2", version: "0.1.0" },
         demo: { hash: null, sourceFileName: null },
@@ -292,8 +357,8 @@ describe("demoPackageSchema", () => {
     expect(pkg.grenades).toEqual([]);
     expect(pkg.clutches).toEqual([]);
     expect(pkg.shots).toBeUndefined();
-    expect(pkg.positions1s).toBeUndefined();
     expect(pkg.replay).toBeUndefined();
+    expect(pkg.duels).toBeUndefined();
   });
 });
 
@@ -494,10 +559,10 @@ describe("seasonCohortBundleSchema", () => {
     version: "cs2-demo-analysis-kit/cohort-1.0" as const,
     matchCount: 3,
     players: [],
-    weightsVersion: "value-accounts-v2-lite@0.1.0",
+    weightsVersion: "rr-six-accounts-1.0",
     provenance: {
       cohortVersion: "cs2-demo-analysis-kit/cohort-1.0" as const,
-      sourceSchemaVersion: "cs2-demo-format/2.0" as const,
+      sourceSchemaVersion: "cs2-demo-format/3.0" as const,
       matches: [{ matchId: "abc123", sourceDemoHash: null }],
     },
   };
@@ -542,7 +607,7 @@ describe("matchWorkspaceModelSchema", () => {
 
   it("enforces sourceSchemaVersion literal", () => {
     expect(
-      matchWorkspaceModelSchema.safeParse({ ...minimalWorkspaceModel, sourceSchemaVersion: "cs2-demo-format/3.0" }).success
+      matchWorkspaceModelSchema.safeParse({ ...minimalWorkspaceModel, sourceSchemaVersion: "cs2-demo-format/2.0" }).success
     ).toBe(false);
   });
 

package/src/demo-package.ts

@@ -13,8 +13,8 @@ import {
   grenadesSchema,
   clutchesSchema,
   shotsSchema,
-  positionsSchema,
   replaySchema,
+  duelsSchema,
 } from "cs2-demo-format";
 
 export const demoPackageSchema = z.object({
@@ -31,8 +31,8 @@ export const demoPackageSchema = z.object({
   grenades: grenadesSchema.default([]),
   clutches: clutchesSchema.default([]),
   shots: shotsSchema.optional(),
-  positions1s: positionsSchema.optional(),
   replay: replaySchema.optional(),
+  duels: duelsSchema.optional(),
 });
 
 export type DemoPackage = z.infer<typeof demoPackageSchema>;

package/src/dependency-boundaries.test.ts

@@ -0,0 +1,27 @@
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { describe, expect, it } from "vitest";
+
+function readPackageJson(relativePath: string) {
+  return JSON.parse(readFileSync(fileURLToPath(new URL(relativePath, import.meta.url)), "utf8")) as {
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+  };
+}
+
+describe("package dependency boundaries", () => {
+  it("keeps shared contract dependencies on the current upstream versions", () => {
+    const root = readPackageJson("../../../package.json");
+    const contract = readPackageJson("../package.json");
+
+    expect(contract.dependencies?.["cs2-demo-format"]).toBe("^3.1.0");
+    expect(contract.dependencies?.["@rivalhub/rival-rating"]).toBe(root.dependencies?.["@rivalhub/rival-rating"]);
+  });
+
+  it("declares runtime workspace imports as dependencies, not dev-only edges", () => {
+    const presentation = readPackageJson("../../presentation/package.json");
+
+    expect(presentation.dependencies?.["@cs2dak/cohort"]).toBe("workspace:*");
+    expect(presentation.devDependencies?.["@cs2dak/cohort"]).toBeUndefined();
+  });
+});

package/src/duel.ts

@@ -0,0 +1,105 @@
+import { z } from "zod";
+import { evidenceRefSchema } from "./evidence.js";
+
+export const duelEvidenceSchema = evidenceRefSchema;
+
+export const duelPointSchema = z.object({
+  x: z.number(),
+  y: z.number(),
+  z: z.number()
+}).nullable();
+
+export const duelFinderRowSchema = z.object({
+  id: z.string(),
+  matchId: z.string(),
+  mapName: z.string(),
+  roundNumber: z.number().int().positive(),
+  tick: z.number().int().positive(),
+  killerSteamId64: z.string(),
+  victimSteamId64: z.string(),
+  killerName: z.string(),
+  victimName: z.string(),
+  weapon: z.string(),
+  classification: z.enum(["contested_duel", "suppressed_kill", "caught_off_guard"]),
+  hpBucket: z.enum(["full_hp", "low_hp"]),
+  thirdParty: z.boolean(),
+  fullHealth: z.boolean(),
+  victimHealthBefore: z.number().min(0).max(100),
+  killerHealthBefore: z.number().min(0).max(100).nullable(),
+  ttkMs: z.number().nonnegative().nullable(),
+  oneShotKill: z.boolean(),
+  evidenceTicks: z.object({
+    engagementStartTick: z.number().int().positive(),
+    engagementEndTick: z.number().int().positive(),
+    killerFirstShotTick: z.number().int().positive().nullable(),
+    victimResponseTick: z.number().int().positive().nullable(),
+    killTick: z.number().int().positive(),
+    windowStartTick: z.number().int().positive().optional(),
+    windowEndTick: z.number().int().positive().optional()
+  }),
+  killerPosition: duelPointSchema,
+  victimPosition: duelPointSchema,
+  /** 对枪发生时的回合剩余时间标签（"1:23"），无 freezeEnd 时为 null。 */
+  roundTimeLabel: z.string().nullable(),
+  evidence: duelEvidenceSchema
+});
+
+export const openingDuelRowSchema = duelFinderRowSchema.extend({
+  attackerCallout: z.string().nullable(),
+  victimCallout: z.string().nullable()
+});
+
+export const mechanicsMetricSchema = z.object({
+  key: z.string(),
+  label: z.string(),
+  /** 主数值；无有效样本时为 null（UI 显示 —）。 */
+  value: z.number().nullable(),
+  unit: z.string().optional(),
+  /** 证据分子/分母（命中率类指标）。 */
+  successes: z.number().int().nonnegative().optional(),
+  attempts: z.number().int().nonnegative().optional(),
+  /** 中位类指标的样本数。 */
+  sampleSize: z.number().int().nonnegative().optional(),
+  /** 次级证据行，如「27/44 ≤5°」。 */
+  detail: z.string().optional(),
+  percentileLabel: z.string().nullable()
+});
+
+export const playerMechanicsRowSchema = z.object({
+  steamId64: z.string(),
+  playerName: z.string(),
+  teamName: z.string(),
+  weapon: z.string(),
+  killCount: z.number().int().nonnegative(),
+  shotCount: z.number().int().nonnegative(),
+  burstCount: z.number().int().nonnegative(),
+  metrics: z.array(mechanicsMetricSchema),
+  burstLengthBuckets: z.object({
+    single: z.number().int().nonnegative(),
+    short: z.number().int().nonnegative(),
+    medium: z.number().int().nonnegative(),
+    long: z.number().int().nonnegative()
+  }),
+  firingPatternRatio: z.object({
+    tap: z.number().min(0).max(100),
+    burst: z.number().min(0).max(100),
+    spray: z.number().min(0).max(100)
+  })
+});
+
+export const duelInsightsModelSchema = z.object({
+  version: z.literal("cs2-demo-analysis-kit/duel-insights-0.1"),
+  matchCount: z.number().int().nonnegative(),
+  duelRows: z.array(duelFinderRowSchema),
+  openingRows: z.array(openingDuelRowSchema),
+  mechanicsRows: z.array(playerMechanicsRowSchema),
+  notes: z.array(z.string())
+});
+
+export type DuelEvidence = z.infer<typeof duelEvidenceSchema>;
+export type DuelPoint = z.infer<typeof duelPointSchema>;
+export type DuelFinderRow = z.infer<typeof duelFinderRowSchema>;
+export type OpeningDuelRow = z.infer<typeof openingDuelRowSchema>;
+export type MechanicsMetric = z.infer<typeof mechanicsMetricSchema>;
+export type PlayerMechanicsRow = z.infer<typeof playerMechanicsRowSchema>;
+export type DuelInsightsModel = z.infer<typeof duelInsightsModelSchema>;

package/src/event-package.test.ts

@@ -0,0 +1,48 @@
+import { describe, expect, it } from "vitest";
+import { eventPackageSchema } from "./event-package.js";
+
+const valid = {
+  version: "cs2-demo-analysis-kit/event-package-1.0",
+  source: "manual",
+  exportedAt: "2026-06-20T00:00:00Z",
+  event: { slug: "cologne-major-2026", name: "IEM Cologne Major 2026", kind: "major", stages: [{ key: "playoffs", name: "淘汰赛", type: "single_elim", teamCount: 8, advanceCount: 1 }] },
+  teams: [{ key: "a", name: "Team A", players: [] }, { key: "b", name: "Team B", players: [] }],
+  series: [{ key: "final", stage: "playoffs", round: 1, format: "bo5", teamAKey: "a", teamBKey: "b", maps: [] }],
+} as const;
+
+describe("eventPackageSchema", () => {
+  it("accepts a valid event package", () => {
+    expect(eventPackageSchema.parse(valid).event.slug).toBe("cologne-major-2026");
+  });
+
+  it("rejects unknown team and stage references", () => {
+    const result = eventPackageSchema.safeParse({ ...valid, series: [{ ...valid.series[0], teamBKey: "missing", stage: "missing" }] });
+    expect(result.success).toBe(false);
+  });
+
+  it("rejects duplicate keys and same-team series", () => {
+    expect(eventPackageSchema.safeParse({ ...valid, teams: [valid.teams[0], valid.teams[0]] }).success).toBe(false);
+    expect(eventPackageSchema.safeParse({ ...valid, series: [{ ...valid.series[0], teamBKey: "a" }] }).success).toBe(false);
+  });
+
+  it("validates bracket nodes and series node references", () => {
+    const bracket = {
+      ...valid,
+      event: { ...valid.event, stages: [{ ...valid.event.stages[0], bracketNodes: [
+        { id: "semi", label: "半决赛", round: 1, lane: "single", nextWinNodeId: "final" },
+        { id: "final", label: "决赛", round: 2, lane: "single", nextWinNodeId: null },
+      ] }] },
+      series: [{ ...valid.series[0], bracketNodeId: "final" }],
+    };
+    expect(eventPackageSchema.safeParse(bracket).success).toBe(true);
+    expect(eventPackageSchema.safeParse({ ...bracket, series: [{ ...bracket.series[0], bracketNodeId: "missing" }] }).success).toBe(false);
+    expect(eventPackageSchema.safeParse({ ...bracket, event: { ...bracket.event, stages: [{ ...bracket.event.stages[0], bracketNodes: [{ id: "semi", label: "半决赛", round: 1, nextWinNodeId: "missing" }] }] } }).success).toBe(false);
+    expect(eventPackageSchema.safeParse({ ...bracket, event: { ...bracket.event, stages: [{ ...bracket.event.stages[0], bracketNodes: [{ id: "self", label: "自环", round: 1, nextWinNodeId: "self" }] }] } }).success).toBe(false);
+    expect(eventPackageSchema.safeParse({ ...bracket, event: { ...bracket.event, stages: [{ ...bracket.event.stages[0], bracketNodes: [
+      { id: "later", label: "后轮", round: 2, nextWinNodeId: "early" }, { id: "early", label: "前轮", round: 1 },
+    ] }] } }).success).toBe(false);
+    expect(eventPackageSchema.safeParse({ ...bracket, event: { ...bracket.event, stages: [{ ...bracket.event.stages[0], bracketNodes: [
+      { id: "a", label: "A", round: 1, nextWinNodeId: "b" }, { id: "b", label: "B", round: 2, nextWinNodeId: "a" },
+    ] }] } }).success).toBe(false);
+  });
+});