volleyballsimtypes 0.0.359 → 0.0.361

package/dist/cjs/src/service/match/match-set.test.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+const uuid_1 = require("uuid");
+const match_set_1 = require("./match-set");
+const match_team_1 = require("./match-team");
+// ─── helpers ─────────────────────────────────────────────────────────────────
+function makeSet(homeScore, awayScore, isTieBreak = false, order) {
+    return match_set_1.MatchSet.create({
+        id: (0, uuid_1.v4)(),
+        order: order ?? (isTieBreak ? 4 : 0),
+        isTieBreak,
+        homePlayerPosition: [],
+        awayPlayerPosition: [],
+        homeScore,
+        awayScore,
+        boxScores: [],
+        rallies: []
+    });
+}
+// ─── scoreThreshold ───────────────────────────────────────────────────────────
+(0, globals_1.describe)('MatchSet', () => {
+    (0, globals_1.describe)('scoreThreshold', () => {
+        (0, globals_1.it)('is 25 for a regular set', () => {
+            (0, globals_1.expect)(makeSet(0, 0).scoreThreshold).toBe(25);
+        });
+        (0, globals_1.it)('is 15 for a tie-break set', () => {
+            (0, globals_1.expect)(makeSet(0, 0, true).scoreThreshold).toBe(15);
+        });
+    });
+    // ─── isOver ──────────────────────────────────────────────────────────────────
+    (0, globals_1.describe)('isOver()', () => {
+        (0, globals_1.it)('returns false at 0-0', () => {
+            (0, globals_1.expect)(makeSet(0, 0).isOver()).toBe(false);
+        });
+        (0, globals_1.it)('returns false when home has 25 but lead is only 1 (25-24)', () => {
+            (0, globals_1.expect)(makeSet(25, 24).isOver()).toBe(false);
+        });
+        (0, globals_1.it)('returns false when away has 25 but lead is only 1 (24-25)', () => {
+            (0, globals_1.expect)(makeSet(24, 25).isOver()).toBe(false);
+        });
+        (0, globals_1.it)('returns true when home reaches 25 with a 2-point lead (25-23)', () => {
+            (0, globals_1.expect)(makeSet(25, 23).isOver()).toBe(true);
+        });
+        (0, globals_1.it)('returns true when away reaches 25 with a 2-point lead (23-25)', () => {
+            (0, globals_1.expect)(makeSet(23, 25).isOver()).toBe(true);
+        });
+        (0, globals_1.it)('returns true in overtime with 2-point lead (27-25)', () => {
+            (0, globals_1.expect)(makeSet(27, 25).isOver()).toBe(true);
+        });
+        (0, globals_1.it)('returns false in overtime deuce (26-25)', () => {
+            (0, globals_1.expect)(makeSet(26, 25).isOver()).toBe(false);
+        });
+        (0, globals_1.it)('returns false when neither team has reached 25 (20-18 via increaseScore)', () => {
+            // MatchSet.create() validates finished-set scores, so build mid-game state
+            // by starting at 0-0 and driving scores up with increaseScore().
+            const set = makeSet(0, 0);
+            for (let i = 0; i < 20; i++)
+                set.increaseScore(match_team_1.MatchTeam.HOME);
+            for (let i = 0; i < 18; i++)
+                set.increaseScore(match_team_1.MatchTeam.AWAY);
+            (0, globals_1.expect)(set.isOver()).toBe(false);
+        });
+        (0, globals_1.it)('returns false for tie-break at 0-0', () => {
+            (0, globals_1.expect)(makeSet(0, 0, true).isOver()).toBe(false);
+        });
+        (0, globals_1.it)('returns true for tie-break at 15-13 (2-point lead)', () => {
+            (0, globals_1.expect)(makeSet(15, 13, true).isOver()).toBe(true);
+        });
+        (0, globals_1.it)('returns false for tie-break at 15-14 (only 1 ahead)', () => {
+            (0, globals_1.expect)(makeSet(15, 14, true).isOver()).toBe(false);
+        });
+        (0, globals_1.it)('returns true for tie-break in overtime (17-15)', () => {
+            (0, globals_1.expect)(makeSet(17, 15, true).isOver()).toBe(true);
+        });
+    });
+    // ─── getWinner ────────────────────────────────────────────────────────────────
+    (0, globals_1.describe)('getWinner()', () => {
+        (0, globals_1.it)('throws UNFINISHED_SET when set is not over', () => {
+            (0, globals_1.expect)(() => makeSet(0, 0).getWinner()).toThrow('UNFINISHED_SET');
+        });
+        (0, globals_1.it)('throws UNFINISHED_SET when score is tied at threshold (25-25)', () => {
+            // 25-25: diff is 0, not > 1
+            (0, globals_1.expect)(() => makeSet(25, 25).getWinner()).toThrow('UNFINISHED_SET');
+        });
+        (0, globals_1.it)('returns HOME when home score is higher', () => {
+            (0, globals_1.expect)(makeSet(25, 20).getWinner()).toBe(match_team_1.MatchTeam.HOME);
+        });
+        (0, globals_1.it)('returns AWAY when away score is higher', () => {
+            (0, globals_1.expect)(makeSet(20, 25).getWinner()).toBe(match_team_1.MatchTeam.AWAY);
+        });
+        (0, globals_1.it)('returns HOME for a tie-break win (15-13)', () => {
+            (0, globals_1.expect)(makeSet(15, 13, true).getWinner()).toBe(match_team_1.MatchTeam.HOME);
+        });
+    });
+    // ─── increaseScore ────────────────────────────────────────────────────────────
+    (0, globals_1.describe)('increaseScore()', () => {
+        (0, globals_1.it)('increments home score by 1', () => {
+            const set = makeSet(0, 0);
+            set.increaseScore(match_team_1.MatchTeam.HOME);
+            (0, globals_1.expect)(set.homeScore).toBe(1);
+            (0, globals_1.expect)(set.awayScore).toBe(0);
+        });
+        (0, globals_1.it)('increments away score by 1', () => {
+            const set = makeSet(0, 0);
+            set.increaseScore(match_team_1.MatchTeam.AWAY);
+            (0, globals_1.expect)(set.awayScore).toBe(1);
+            (0, globals_1.expect)(set.homeScore).toBe(0);
+        });
+        (0, globals_1.it)('can be called multiple times', () => {
+            const set = makeSet(0, 0);
+            set.increaseScore(match_team_1.MatchTeam.HOME);
+            set.increaseScore(match_team_1.MatchTeam.HOME);
+            set.increaseScore(match_team_1.MatchTeam.AWAY);
+            (0, globals_1.expect)(set.homeScore).toBe(2);
+            (0, globals_1.expect)(set.awayScore).toBe(1);
+        });
+        (0, globals_1.it)('throws UNKNOWN_TEAM for an invalid team value', () => {
+            const set = makeSet(0, 0);
+            (0, globals_1.expect)(() => set.increaseScore('INVALID')).toThrow('UNKNOWN_TEAM');
+        });
+    });
+});

package/dist/cjs/src/service/match/match-team.d.ts

@@ -0,0 +1,7 @@
+export declare enum MatchTeam {
+    HOME = "homeTeam",
+    AWAY = "awayTeam"
+}
+export declare namespace MatchTeam {
+    function otherTeam(team: MatchTeam): MatchTeam;
+}

package/dist/cjs/src/service/match/match-team.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MatchTeam = void 0;
+var MatchTeam;
+(function (MatchTeam) {
+    MatchTeam["HOME"] = "homeTeam";
+    MatchTeam["AWAY"] = "awayTeam";
+})(MatchTeam || (exports.MatchTeam = MatchTeam = {}));
+// eslint-disable-next-line @typescript-eslint/no-namespace
+(function (MatchTeam) {
+    function otherTeam(team) {
+        if (team === MatchTeam.HOME)
+            return MatchTeam.AWAY;
+        else if (team === MatchTeam.AWAY)
+            return MatchTeam.HOME;
+        else
+            throw new Error('UNKNOWN_MATCH_TEAM');
+    }
+    MatchTeam.otherTeam = otherTeam;
+})(MatchTeam || (exports.MatchTeam = MatchTeam = {}));

package/dist/cjs/src/service/match/match.d.ts

@@ -0,0 +1,26 @@
+import { MatchSet } from './match-set';
+import { Team } from '../team';
+import { MatchTeam } from './match-team';
+import { StatusEnum } from '../../data';
+import { VPER } from './vper';
+export type MatchScore = '3-0' | '3-1' | '3-2' | '2-3' | '1-3' | '0-3';
+export type SetScore = 0 | 1 | 2 | 3;
+export declare class Match {
+    readonly id: string;
+    readonly homeTeam: Team;
+    readonly awayTeam: Team;
+    readonly sets: MatchSet[];
+    readonly scheduledDate: Date;
+    readonly VPERs: VPER[];
+    status: StatusEnum;
+    homeScore?: number;
+    awayScore?: number;
+    winner?: Team;
+    static create(input: unknown): Match;
+    private constructor();
+    addSet(set: MatchSet): void;
+    getTeamSets(team: MatchTeam): SetScore;
+    getScore(): MatchScore;
+    isOver(): boolean;
+    getWinner(): Team;
+}

package/dist/cjs/src/service/match/match.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Match = void 0;
+const match_team_1 = require("./match-team");
+const data_1 = require("../../data");
+const match_z_1 = require("./schemas/match.z");
+class Match {
+    static create(input) {
+        const result = match_z_1.MatchInputSchema.safeParse(input);
+        if (!result.success) {
+            throw new Error(`INVALID_MATCH: ${result.error.message}. RECEIVED=${(() => { try {
+                return JSON.stringify(input);
+            }
+            catch {
+                return String(input);
+            } })()}`);
+        }
+        return new Match(result.data);
+    }
+    constructor({ id, homeTeam, awayTeam, scheduledDate, sets, status, homeScore, awayScore, winner, VPERs }) {
+        if (homeTeam.id === awayTeam.id)
+            throw new Error(`FAILED_TO_CREATE_MATCH. TEAMS_WITH_SAME_ID: ${homeTeam.id}`);
+        this.id = id;
+        this.homeTeam = homeTeam;
+        this.awayTeam = awayTeam;
+        this.scheduledDate = scheduledDate;
+        this.sets = sets ?? [];
+        this.status = status;
+        this.homeScore = homeScore;
+        this.awayScore = awayScore;
+        this.winner = winner;
+        this.VPERs = VPERs ?? [];
+    }
+    addSet(set) {
+        if (this.sets.length >= 5)
+            throw new Error('SET_AMOUNT_EXCEEDED');
+        this.sets.push(set);
+    }
+    getTeamSets(team) {
+        const sets = this.sets.reduce((sets, set) => sets + (!set.isOver() ? 0 : set.getWinner() === team ? 1 : 0), 0);
+        if (sets > 3 || sets < 0)
+            throw new Error(`INCORRECT_SET_VALUE: ${sets}`);
+        return sets;
+    }
+    getScore() {
+        return `${this.getTeamSets(match_team_1.MatchTeam.HOME)}-${this.getTeamSets(match_team_1.MatchTeam.AWAY)}`;
+    }
+    isOver() {
+        if (this.status === data_1.StatusEnum.COMPLETE)
+            return true;
+        const setsToWin = 3;
+        const homeSets = this.getTeamSets(match_team_1.MatchTeam.HOME);
+        const awaySets = this.getTeamSets(match_team_1.MatchTeam.AWAY);
+        return !(homeSets < setsToWin && awaySets < setsToWin);
+    }
+    getWinner() {
+        if (!this.isOver()) {
+            throw new Error(`UNFINISHED_MATCH: ${this.id}, homeSets=[${this.sets.map(s => s.homeScore).join(', ')}], awaySets=[${this.sets.map(s => s.awayScore).join(', ')}], status=${this.status}`);
+        }
+        const homeSets = this.getTeamSets(match_team_1.MatchTeam.HOME);
+        const awaySets = this.getTeamSets(match_team_1.MatchTeam.AWAY);
+        return homeSets > awaySets ? this.homeTeam : this.awayTeam;
+    }
+}
+exports.Match = Match;

package/dist/cjs/src/service/match/rally.d.ts

@@ -0,0 +1,15 @@
+import { CourtPosition } from './court-position';
+import { RallyEvent } from '../event';
+export interface PlayerPosition {
+    position: CourtPosition;
+    playerId: string;
+}
+export declare class Rally {
+    readonly id: string;
+    readonly servingTeamId: string;
+    readonly events: RallyEvent[];
+    readonly order: number;
+    static create(input: unknown): Rally;
+    private constructor();
+    addEvent(event: RallyEvent): void;
+}

package/dist/cjs/src/service/match/rally.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Rally = void 0;
+const rally_z_1 = require("./schemas/rally.z");
+class Rally {
+    static create(input) {
+        const result = rally_z_1.RallyInputSchema.safeParse(input);
+        if (!result.success) {
+            throw new Error(`INVALID_RALLY: ${result.error.message}. RECEIVED=${(() => { try {
+                return JSON.stringify(input);
+            }
+            catch {
+                return String(input);
+            } })()}`);
+        }
+        return new Rally(result.data);
+    }
+    constructor({ id, order, servingTeamId, events }) {
+        this.id = id;
+        this.order = order;
+        this.servingTeamId = servingTeamId;
+        this.events = events;
+    }
+    addEvent(event) {
+        this.events.push(event);
+    }
+}
+exports.Rally = Rally;

package/dist/cjs/src/service/match/schemas/box-score.z.d.ts

@@ -0,0 +1,90 @@
+import { z } from 'zod';
+/**
+ * Leaf stat schemas
+ */
+export declare const AttackStatsSchema: z.ZodObject<{
+    attempts: z.ZodNumber;
+    kills: z.ZodNumber;
+    errors: z.ZodNumber;
+}, z.core.$strip>;
+export declare const ServeStatsSchema: z.ZodObject<{
+    attempts: z.ZodNumber;
+    aces: z.ZodNumber;
+    errors: z.ZodNumber;
+}, z.core.$strip>;
+export declare const ReceptionStatsSchema: z.ZodObject<{
+    attempts: z.ZodNumber;
+    perfect: z.ZodNumber;
+    positive: z.ZodNumber;
+    overpasses: z.ZodNumber;
+    errors: z.ZodNumber;
+}, z.core.$strip>;
+export declare const BlockStatsSchema: z.ZodObject<{
+    solo: z.ZodNumber;
+    assists: z.ZodNumber;
+    errors: z.ZodNumber;
+    touches: z.ZodNumber;
+}, z.core.$strip>;
+export declare const SettingStatsSchema: z.ZodObject<{
+    assists: z.ZodNumber;
+    errors: z.ZodNumber;
+    pass: z.ZodNumber;
+}, z.core.$strip>;
+export declare const DefenseStatsSchema: z.ZodObject<{
+    digs: z.ZodNumber;
+    errors: z.ZodNumber;
+}, z.core.$strip>;
+export declare const MiscStatsSchema: z.ZodObject<{
+    pointsPlayed: z.ZodNumber;
+    pointsWonOnCourt: z.ZodNumber;
+    serveTurns: z.ZodNumber;
+    sideoutOpportunities: z.ZodNumber;
+    successfulSideouts: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * BoxScore input schema
+ */
+export declare const BoxScoreInputSchema: z.ZodObject<{
+    playerId: z.ZodUUID;
+    matchSetId: z.ZodUUID;
+    attack: z.ZodObject<{
+        attempts: z.ZodNumber;
+        kills: z.ZodNumber;
+        errors: z.ZodNumber;
+    }, z.core.$strip>;
+    serve: z.ZodObject<{
+        attempts: z.ZodNumber;
+        aces: z.ZodNumber;
+        errors: z.ZodNumber;
+    }, z.core.$strip>;
+    reception: z.ZodObject<{
+        attempts: z.ZodNumber;
+        perfect: z.ZodNumber;
+        positive: z.ZodNumber;
+        overpasses: z.ZodNumber;
+        errors: z.ZodNumber;
+    }, z.core.$strip>;
+    block: z.ZodObject<{
+        solo: z.ZodNumber;
+        assists: z.ZodNumber;
+        errors: z.ZodNumber;
+        touches: z.ZodNumber;
+    }, z.core.$strip>;
+    setting: z.ZodObject<{
+        assists: z.ZodNumber;
+        errors: z.ZodNumber;
+        pass: z.ZodNumber;
+    }, z.core.$strip>;
+    defense: z.ZodObject<{
+        digs: z.ZodNumber;
+        errors: z.ZodNumber;
+    }, z.core.$strip>;
+    misc: z.ZodObject<{
+        pointsPlayed: z.ZodNumber;
+        pointsWonOnCourt: z.ZodNumber;
+        serveTurns: z.ZodNumber;
+        sideoutOpportunities: z.ZodNumber;
+        successfulSideouts: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type BoxScoreInput = z.infer<typeof BoxScoreInputSchema>;

package/dist/cjs/src/service/match/schemas/box-score.z.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BoxScoreInputSchema = exports.MiscStatsSchema = exports.DefenseStatsSchema = exports.SettingStatsSchema = exports.BlockStatsSchema = exports.ReceptionStatsSchema = exports.ServeStatsSchema = exports.AttackStatsSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Helpers
+ */
+const nonNegInt = zod_1.z.number().int().min(0);
+/**
+ * Leaf stat schemas
+ */
+exports.AttackStatsSchema = zod_1.z.object({
+    attempts: nonNegInt,
+    kills: nonNegInt,
+    errors: nonNegInt
+}).superRefine((v, ctx) => {
+    if (v.errors > v.attempts) {
+        ctx.addIssue({ code: 'custom', message: 'ATTACK_ERRORS_EXCEEDS_ATTEMPTS', path: ['kills'] });
+    }
+});
+exports.ServeStatsSchema = zod_1.z.object({
+    attempts: nonNegInt,
+    aces: nonNegInt,
+    errors: nonNegInt
+}).superRefine((v, ctx) => {
+    if (v.aces + v.errors > v.attempts) {
+        ctx.addIssue({ code: 'custom', message: 'SERVE_ACES_PLUS_ERRORS_EXCEEDS_ATTEMPTS', path: ['aces'] });
+    }
+});
+exports.ReceptionStatsSchema = zod_1.z.object({
+    attempts: nonNegInt,
+    perfect: nonNegInt,
+    positive: nonNegInt,
+    overpasses: nonNegInt,
+    errors: nonNegInt
+}).superRefine((v, ctx) => {
+    const sum = v.perfect + v.positive + v.overpasses + v.errors;
+    if (sum > v.attempts) {
+        ctx.addIssue({ code: 'custom', message: 'RECEPTION_COMPONENTS_EXCEED_ATTEMPTS', path: ['attempts'] });
+    }
+});
+exports.BlockStatsSchema = zod_1.z.object({
+    solo: nonNegInt,
+    assists: nonNegInt,
+    errors: nonNegInt,
+    touches: nonNegInt
+}).superRefine((v, ctx) => {
+    // If you interpret touches as "block touches total", then point-scoring blocks can't exceed touches.
+    if (v.solo + v.assists > v.touches) {
+        ctx.addIssue({ code: 'custom', message: 'BLOCK_SOLO_PLUS_ASSISTS_EXCEEDS_TOUCHES', path: ['touches'] });
+    }
+});
+exports.SettingStatsSchema = zod_1.z.object({
+    assists: nonNegInt,
+    errors: nonNegInt,
+    pass: nonNegInt
+});
+exports.DefenseStatsSchema = zod_1.z.object({
+    digs: nonNegInt,
+    errors: nonNegInt
+});
+exports.MiscStatsSchema = zod_1.z.object({
+    pointsPlayed: nonNegInt,
+    pointsWonOnCourt: nonNegInt,
+    serveTurns: nonNegInt,
+    sideoutOpportunities: nonNegInt,
+    successfulSideouts: nonNegInt
+}).superRefine((v, ctx) => {
+    if (v.pointsWonOnCourt > v.pointsPlayed) {
+        ctx.addIssue({ code: 'custom', message: 'POINTS_WON_ON_COURT_EXCEEDS_POINTS_PLAYED', path: ['pointsWonOnCourt'] });
+    }
+    if (v.successfulSideouts > v.sideoutOpportunities) {
+        ctx.addIssue({ code: 'custom', message: 'SUCCESSFUL_SIDEOUTS_EXCEED_OPPORTUNITIES', path: ['successfulSideouts'] });
+    }
+});
+/**
+ * BoxScore input schema
+ */
+exports.BoxScoreInputSchema = zod_1.z.object({
+    playerId: zod_1.z.uuid(),
+    matchSetId: zod_1.z.uuid(),
+    attack: exports.AttackStatsSchema,
+    serve: exports.ServeStatsSchema,
+    reception: exports.ReceptionStatsSchema,
+    block: exports.BlockStatsSchema,
+    setting: exports.SettingStatsSchema,
+    defense: exports.DefenseStatsSchema,
+    misc: exports.MiscStatsSchema
+});

package/dist/cjs/src/service/match/schemas/match-rating.z.d.ts

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+import { Match } from '../match';
+export declare const MatchContextSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"LEAGUE">;
+    tier: z.ZodNumber;
+    homeIsBot: z.ZodBoolean;
+    awayIsBot: z.ZodBoolean;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"PROMOTION">;
+    upperTier: z.ZodNumber;
+    lowerTier: z.ZodNumber;
+    homeIsBot: z.ZodBoolean;
+    awayIsBot: z.ZodBoolean;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"QUALIFIER">;
+    homeIsBot: z.ZodBoolean;
+    awayIsBot: z.ZodBoolean;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"TOURNAMENT">;
+    homeIsBot: z.ZodBoolean;
+    awayIsBot: z.ZodBoolean;
+}, z.core.$strip>], "kind">;
+export declare const MatchRatingInputSchema: z.ZodObject<{
+    match: z.ZodCustom<Match, Match>;
+    context: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"LEAGUE">;
+        tier: z.ZodNumber;
+        homeIsBot: z.ZodBoolean;
+        awayIsBot: z.ZodBoolean;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"PROMOTION">;
+        upperTier: z.ZodNumber;
+        lowerTier: z.ZodNumber;
+        homeIsBot: z.ZodBoolean;
+        awayIsBot: z.ZodBoolean;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"QUALIFIER">;
+        homeIsBot: z.ZodBoolean;
+        awayIsBot: z.ZodBoolean;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"TOURNAMENT">;
+        homeIsBot: z.ZodBoolean;
+        awayIsBot: z.ZodBoolean;
+    }, z.core.$strip>], "kind">;
+}, z.core.$strip>;
+export type MatchContext = z.infer<typeof MatchContextSchema>;
+export type MatchRatingInput = z.infer<typeof MatchRatingInputSchema>;

package/dist/cjs/src/service/match/schemas/match-rating.z.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MatchRatingInputSchema = exports.MatchContextSchema = void 0;
+const zod_1 = require("zod");
+const match_1 = require("../match");
+exports.MatchContextSchema = zod_1.z.discriminatedUnion('kind', [
+    zod_1.z.object({
+        kind: zod_1.z.literal('LEAGUE'),
+        tier: zod_1.z.number().int().positive(),
+        homeIsBot: zod_1.z.boolean(),
+        awayIsBot: zod_1.z.boolean()
+    }),
+    zod_1.z.object({
+        kind: zod_1.z.literal('PROMOTION'),
+        upperTier: zod_1.z.number().int().positive(),
+        lowerTier: zod_1.z.number().int().positive(),
+        homeIsBot: zod_1.z.boolean(),
+        awayIsBot: zod_1.z.boolean()
+    }),
+    zod_1.z.object({
+        kind: zod_1.z.literal('QUALIFIER'),
+        homeIsBot: zod_1.z.boolean(),
+        awayIsBot: zod_1.z.boolean()
+    }),
+    zod_1.z.object({
+        kind: zod_1.z.literal('TOURNAMENT'),
+        homeIsBot: zod_1.z.boolean(),
+        awayIsBot: zod_1.z.boolean()
+    })
+]);
+exports.MatchRatingInputSchema = zod_1.z.object({
+    match: zod_1.z.custom((v) => v instanceof match_1.Match, { message: 'INVALID_MATCH_INSTANCE' }),
+    context: exports.MatchContextSchema
+});

package/dist/cjs/src/service/match/schemas/match-set.z.d.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import { PlayerPosition, Rally } from '../rally';
+import { BoxScore } from '../box-score';
+export declare const MatchSetInputSchema: z.ZodObject<{
+    id: z.ZodUUID;
+    order: z.ZodNumber;
+    isTieBreak: z.ZodBoolean;
+    homePlayerPosition: z.ZodArray<z.ZodCustom<PlayerPosition, PlayerPosition>>;
+    awayPlayerPosition: z.ZodArray<z.ZodCustom<PlayerPosition, PlayerPosition>>;
+    homeScore: z.ZodNumber;
+    awayScore: z.ZodNumber;
+    boxScores: z.ZodArray<z.ZodCustom<BoxScore, BoxScore>>;
+    rallies: z.ZodArray<z.ZodCustom<Rally, Rally>>;
+}, z.core.$strip>;
+export type MatchSetInput = z.infer<typeof MatchSetInputSchema>;

package/dist/cjs/src/service/match/schemas/match-set.z.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MatchSetInputSchema = void 0;
+const zod_1 = require("zod");
+const rally_1 = require("../rally");
+const box_score_1 = require("../box-score");
+const nonNegInt = zod_1.z.number().int().min(0);
+const orderSchema = zod_1.z.number().int().min(0).max(4);
+/**
+ * NOTE:
+ * This validates that the input contains actual instances of Rally / BoxScore.
+ * If you're validating plain JSON (e.g. from DB/API), swap these for object schemas.
+ */
+const PlayerPositionSchema = zod_1.z.custom((v) => v != null, {
+    message: 'INVALID_PLAYER_POSITION'
+});
+exports.MatchSetInputSchema = zod_1.z.object({
+    id: zod_1.z.uuid(),
+    order: orderSchema,
+    isTieBreak: zod_1.z.boolean(),
+    homePlayerPosition: zod_1.z.array(PlayerPositionSchema).max(12),
+    awayPlayerPosition: zod_1.z.array(PlayerPositionSchema).max(12),
+    homeScore: nonNegInt,
+    awayScore: nonNegInt,
+    boxScores: zod_1.z.array(zod_1.z.custom((v) => v instanceof box_score_1.BoxScore, {
+        message: 'INVALID_BOX_SCORE_INSTANCE'
+    })),
+    rallies: zod_1.z.array(zod_1.z.custom((v) => v instanceof rally_1.Rally, {
+        message: 'INVALID_RALLY_INSTANCE'
+    }))
+}).superRefine((data, ctx) => {
+    const { order, isTieBreak, rallies, homeScore, awayScore } = data;
+    // isTieBreak <-> order === 4
+    if (isTieBreak && order !== 4) {
+        ctx.addIssue({
+            code: 'custom',
+            message: 'TIEBREAK_REQUIRES_ORDER_4',
+            path: ['order']
+        });
+    }
+    if (!isTieBreak && order === 4) {
+        ctx.addIssue({
+            code: 'custom',
+            message: 'ORDER_4_REQUIRES_TIEBREAK',
+            path: ['isTieBreak']
+        });
+    }
+    const hasRallies = rallies.length > 0;
+    const isZeroZero = homeScore === 0 && awayScore === 0;
+    const scoreThreshold = isTieBreak ? 15 : 25;
+    // Score rule: one side must reach threshold, unless this is an empty-rallies 0-0 set.
+    if (!isZeroZero && homeScore < scoreThreshold && awayScore < scoreThreshold) {
+        ctx.addIssue({
+            code: 'custom',
+            message: isTieBreak ? 'SCORE_REQUIRES_SIDE_AT_LEAST_15' : 'SCORE_REQUIRES_SIDE_AT_LEAST_25',
+            path: ['homeScore']
+        });
+    }
+    // If rallies exist, score cannot be 0-0 and must match the number of rallies.
+    if (hasRallies) {
+        if (isZeroZero) {
+            ctx.addIssue({
+                code: 'custom',
+                message: 'NON_EMPTY_RALLIES_CANNOT_HAVE_0_0_SCORE',
+                path: ['rallies']
+            });
+        }
+        if (homeScore + awayScore !== rallies.length) {
+            ctx.addIssue({
+                code: 'custom',
+                message: 'RALLIES_LENGTH_MUST_EQUAL_SCORE_SUM',
+                path: ['rallies']
+            });
+        }
+    }
+});

package/dist/cjs/src/service/match/schemas/match.z.d.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { Team } from '../../team';
+import { StatusEnum } from '../../../data/common';
+import { MatchSet } from '../match-set';
+import { VPER } from '../vper';
+export declare const MatchInputSchema: z.ZodObject<{
+    id: z.ZodUUID;
+    homeTeam: z.ZodCustom<Team, Team>;
+    awayTeam: z.ZodCustom<Team, Team>;
+    scheduledDate: z.ZodCoercedDate<unknown>;
+    status: z.ZodEnum<{
+        PENDING: StatusEnum.PENDING;
+        IN_PROGRESS: StatusEnum.IN_PROGRESS;
+        COMPLETE: StatusEnum.COMPLETE;
+    }>;
+    sets: z.ZodOptional<z.ZodArray<z.ZodCustom<MatchSet, MatchSet>>>;
+    VPERs: z.ZodOptional<z.ZodArray<z.ZodCustom<VPER, VPER>>>;
+    homeScore: z.ZodOptional<z.ZodNumber>;
+    awayScore: z.ZodOptional<z.ZodNumber>;
+    winner: z.ZodOptional<z.ZodCustom<Team, Team>>;
+}, z.core.$strip>;
+export type MatchInput = z.infer<typeof MatchInputSchema>;