volleyballsimtypes 0.0.390 → 0.0.393

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

@@ -18,8 +18,8 @@ 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),
+    homePlayerPosition: zod_1.z.array(PlayerPositionSchema).max(14),
+    awayPlayerPosition: zod_1.z.array(PlayerPositionSchema).max(14),
     homeScore: nonNegInt,
     awayScore: nonNegInt,
     boxScores: zod_1.z.array(zod_1.z.custom((v) => v instanceof box_score_1.BoxScore, {

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

@@ -1,4 +1,5 @@
 import { BoxScore } from './box-score';
+export declare const MIN_POINTS_PLAYED_FOR_VPER = 35;
 export interface VPERParams {
     readonly playerId: string;
     readonly matchId: string;
@@ -11,4 +12,6 @@ export declare class VPER {
     static create(input: unknown): VPER;
     private constructor();
     static computeVPERForMatch(boxScores: BoxScore[]): number;
+    static totalPointsPlayed(boxScores: BoxScore[]): number;
+    static qualifiesForVPER(boxScores: BoxScore[]): boolean;
 }

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VPER = void 0;
+exports.VPER = exports.MIN_POINTS_PLAYED_FOR_VPER = void 0;
 const vper_z_1 = require("./schemas/vper.z");
 const WEIGHTS = {
     // terminal positive
@@ -20,6 +20,10 @@ const WEIGHTS = {
     // terminal errors (always point against)
     TERMINAL_ERROR: -1.0
 };
+// Minimum points a player must be on court for in a match to receive a VPER. VPER is a per-100-points rate,
+// so below a meaningful sample one good touch is extrapolated into a wildly inflated value. Players under this
+// threshold get no VPER for the match.
+exports.MIN_POINTS_PLAYED_FOR_VPER = 35;
 class VPER {
     static create(input) {
         const result = vper_z_1.VPERInputSchema.safeParse(input);
@@ -65,5 +69,11 @@ class VPER {
         }
         return 100 * rawSum / Math.max(1, pointsPlayedSum);
     }
+    static totalPointsPlayed(boxScores) {
+        return boxScores.reduce((sum, box) => sum + box.misc.pointsPlayed, 0);
+    }
+    static qualifiesForVPER(boxScores) {
+        return VPER.totalPointsPlayed(boxScores) >= exports.MIN_POINTS_PLAYED_FOR_VPER;
+    }
 }
 exports.VPER = VPER;

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

@@ -106,3 +106,37 @@ function makeBox() {
         (0, globals_1.expect)(vper_1.VPER.computeVPERForMatch([box])).toBeCloseTo(14, 5);
     });
 });
+// ─── VPER eligibility threshold ───────────────────────────────────────────────
+(0, globals_1.describe)('VPER.qualifiesForVPER()', () => {
+    function boxWithPoints(points) {
+        const box = makeBox();
+        box.misc.pointsPlayed = points;
+        return box;
+    }
+    (0, globals_1.it)('uses a 35-point threshold', () => {
+        (0, globals_1.expect)(vper_1.MIN_POINTS_PLAYED_FOR_VPER).toBe(35);
+    });
+    (0, globals_1.it)('sums points played across box scores', () => {
+        (0, globals_1.expect)(vper_1.VPER.totalPointsPlayed([boxWithPoints(20), boxWithPoints(15)])).toBe(35);
+    });
+    (0, globals_1.it)('does not qualify an empty box score list', () => {
+        (0, globals_1.expect)(vper_1.VPER.qualifiesForVPER([])).toBe(false);
+    });
+    (0, globals_1.it)('does not qualify below the threshold', () => {
+        (0, globals_1.expect)(vper_1.VPER.qualifiesForVPER([boxWithPoints(34)])).toBe(false);
+    });
+    (0, globals_1.it)('qualifies exactly at the threshold (inclusive)', () => {
+        (0, globals_1.expect)(vper_1.VPER.qualifiesForVPER([boxWithPoints(35)])).toBe(true);
+    });
+    (0, globals_1.it)('qualifies above the threshold across multiple sets', () => {
+        (0, globals_1.expect)(vper_1.VPER.qualifiesForVPER([boxWithPoints(20), boxWithPoints(20)])).toBe(true);
+    });
+    (0, globals_1.it)('rejects the inflated-cameo case (one good touch in a single point)', () => {
+        const box = makeBox();
+        box.setting.assists = 1;
+        box.setting.pass = 1;
+        box.misc.pointsPlayed = 1;
+        // Pre-fix this produced a VPER of 85; now the player is simply ineligible.
+        (0, globals_1.expect)(vper_1.VPER.qualifiesForVPER([box])).toBe(false);
+    });
+});

package/dist/cjs/src/service/team/schemas/designated-sub.z.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/src/service/team/schemas/designated-sub.z.test.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+const designated_sub_z_1 = require("./designated-sub.z");
+const energy_band_1 = require("../energy-band");
+const pinch_condition_1 = require("../pinch-condition");
+const test_helpers_1 = require("../../test-helpers");
+(0, globals_1.describe)('SubBandSchema', () => {
+    (0, globals_1.it)('accepts every energy band and NEVER', () => {
+        const bands = [energy_band_1.EnergyBand.ENERGETIC, energy_band_1.EnergyBand.WORN, energy_band_1.EnergyBand.TIRED, energy_band_1.EnergyBand.EXHAUSTED, 'NEVER'];
+        for (const band of bands) {
+            (0, globals_1.expect)(designated_sub_z_1.SubBandSchema.safeParse(band).success).toBe(true);
+        }
+    });
+    (0, globals_1.it)('rejects an unknown band', () => {
+        (0, globals_1.expect)(designated_sub_z_1.SubBandSchema.safeParse('SLEEPY').success).toBe(false);
+    });
+});
+(0, globals_1.describe)('ConditionLogicSchema', () => {
+    (0, globals_1.it)('accepts ALL and ANY', () => {
+        (0, globals_1.expect)(designated_sub_z_1.ConditionLogicSchema.safeParse('ALL').success).toBe(true);
+        (0, globals_1.expect)(designated_sub_z_1.ConditionLogicSchema.safeParse('ANY').success).toBe(true);
+    });
+    (0, globals_1.it)('rejects anything else', () => {
+        (0, globals_1.expect)(designated_sub_z_1.ConditionLogicSchema.safeParse('SOMETIMES').success).toBe(false);
+    });
+});
+(0, globals_1.describe)('PinchConditionSchema', () => {
+    const valid = [
+        { type: pinch_condition_1.PinchConditionType.ASAP },
+        { type: pinch_condition_1.PinchConditionType.TEAM_SET_POINT, margin: 2, opponent: pinch_condition_1.OpponentRelation.EITHER },
+        { type: pinch_condition_1.PinchConditionType.OPPONENT_SET_POINT, margin: 1 },
+        { type: pinch_condition_1.PinchConditionType.SCORE_DIFF, direction: pinch_condition_1.ScoreDirection.TRAILING, points: 3 },
+        { type: pinch_condition_1.PinchConditionType.AFTER_ROTATIONS, rotations: 1 },
+        { type: pinch_condition_1.PinchConditionType.FROM_SET, set: 5 },
+        { type: pinch_condition_1.PinchConditionType.MIN_OWN_SCORE, score: 20 }
+    ];
+    (0, globals_1.it)('accepts a valid instance of every condition type', () => {
+        for (const condition of valid) {
+            (0, globals_1.expect)(designated_sub_z_1.PinchConditionSchema.safeParse(condition).success).toBe(true);
+        }
+    });
+    (0, globals_1.it)('rejects an unknown condition type', () => {
+        (0, globals_1.expect)(designated_sub_z_1.PinchConditionSchema.safeParse({ type: 'WHENEVER' }).success).toBe(false);
+    });
+    (0, globals_1.it)('rejects a condition missing its required field', () => {
+        (0, globals_1.expect)(designated_sub_z_1.PinchConditionSchema.safeParse({ type: pinch_condition_1.PinchConditionType.TEAM_SET_POINT, opponent: pinch_condition_1.OpponentRelation.EITHER }).success).toBe(false);
+        (0, globals_1.expect)(designated_sub_z_1.PinchConditionSchema.safeParse({ type: pinch_condition_1.PinchConditionType.SCORE_DIFF, direction: pinch_condition_1.ScoreDirection.LEADING }).success).toBe(false);
+    });
+    (0, globals_1.it)('enforces numeric bounds', () => {
+        (0, globals_1.expect)(designated_sub_z_1.PinchConditionSchema.safeParse({ type: pinch_condition_1.PinchConditionType.TEAM_SET_POINT, margin: 0, opponent: pinch_condition_1.OpponentRelation.AHEAD }).success).toBe(false);
+        (0, globals_1.expect)(designated_sub_z_1.PinchConditionSchema.safeParse({ type: pinch_condition_1.PinchConditionType.TEAM_SET_POINT, margin: 26, opponent: pinch_condition_1.OpponentRelation.AHEAD }).success).toBe(false);
+        (0, globals_1.expect)(designated_sub_z_1.PinchConditionSchema.safeParse({ type: pinch_condition_1.PinchConditionType.AFTER_ROTATIONS, rotations: 7 }).success).toBe(false);
+        (0, globals_1.expect)(designated_sub_z_1.PinchConditionSchema.safeParse({ type: pinch_condition_1.PinchConditionType.FROM_SET, set: 6 }).success).toBe(false);
+        (0, globals_1.expect)(designated_sub_z_1.PinchConditionSchema.safeParse({ type: pinch_condition_1.PinchConditionType.MIN_OWN_SCORE, score: 41 }).success).toBe(false);
+        (0, globals_1.expect)(designated_sub_z_1.PinchConditionSchema.safeParse({ type: pinch_condition_1.PinchConditionType.SCORE_DIFF, direction: pinch_condition_1.ScoreDirection.TRAILING, points: 0 }).success).toBe(false);
+    });
+    (0, globals_1.it)('rejects a non-integer numeric field', () => {
+        (0, globals_1.expect)(designated_sub_z_1.PinchConditionSchema.safeParse({ type: pinch_condition_1.PinchConditionType.FROM_SET, set: 2.5 }).success).toBe(false);
+    });
+});
+(0, globals_1.describe)('DesignatedSubSchema', () => {
+    const country = (0, test_helpers_1.makeCountry)();
+    const starter = (0, test_helpers_1.makePlayer)(country);
+    const bench = (0, test_helpers_1.makePlayer)(country);
+    (0, globals_1.it)('accepts a fatigue-mode entry with a band and bench', () => {
+        const res = designated_sub_z_1.DesignatedSubSchema.safeParse({
+            starter,
+            bench,
+            isPinchServer: false,
+            fatigueBand: energy_band_1.EnergyBand.TIRED
+        });
+        (0, globals_1.expect)(res.success).toBe(true);
+    });
+    (0, globals_1.it)('accepts a fatigue-mode entry with no bench (falls back to closest sub)', () => {
+        const res = designated_sub_z_1.DesignatedSubSchema.safeParse({
+            starter,
+            isPinchServer: false
+        });
+        (0, globals_1.expect)(res.success).toBe(true);
+    });
+    (0, globals_1.it)('accepts a pinch-mode entry with a bench server and conditions', () => {
+        const res = designated_sub_z_1.DesignatedSubSchema.safeParse({
+            starter,
+            bench,
+            isPinchServer: true,
+            conditions: [{ type: pinch_condition_1.PinchConditionType.ASAP }],
+            conditionLogic: 'ALL'
+        });
+        (0, globals_1.expect)(res.success).toBe(true);
+    });
+    (0, globals_1.it)('rejects a pinch-mode entry without a bench server', () => {
+        const res = designated_sub_z_1.DesignatedSubSchema.safeParse({
+            starter,
+            isPinchServer: true,
+            conditions: [{ type: pinch_condition_1.PinchConditionType.ASAP }]
+        });
+        (0, globals_1.expect)(res.success).toBe(false);
+        if (!res.success) {
+            (0, globals_1.expect)(res.error.issues.some(issue => issue.message === 'PINCH_SERVER_REQUIRES_BENCH')).toBe(true);
+        }
+    });
+    (0, globals_1.it)('rejects a pinch-mode entry with no conditions', () => {
+        const res = designated_sub_z_1.DesignatedSubSchema.safeParse({
+            starter,
+            bench,
+            isPinchServer: true,
+            conditions: []
+        });
+        (0, globals_1.expect)(res.success).toBe(false);
+        if (!res.success) {
+            (0, globals_1.expect)(res.error.issues.some(issue => issue.message === 'PINCH_SERVER_REQUIRES_CONDITIONS')).toBe(true);
+        }
+    });
+    (0, globals_1.it)('rejects a starter that is not a Player instance', () => {
+        const res = designated_sub_z_1.DesignatedSubSchema.safeParse({
+            starter: { id: 'not-a-player' },
+            isPinchServer: false
+        });
+        (0, globals_1.expect)(res.success).toBe(false);
+    });
+});

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

@@ -15,8 +15,8 @@ export const MatchSetInputSchema = z.object({
     id: z.uuid(),
     order: orderSchema,
     isTieBreak: z.boolean(),
-    homePlayerPosition: z.array(PlayerPositionSchema).max(12),
-    awayPlayerPosition: z.array(PlayerPositionSchema).max(12),
+    homePlayerPosition: z.array(PlayerPositionSchema).max(14),
+    awayPlayerPosition: z.array(PlayerPositionSchema).max(14),
     homeScore: nonNegInt,
     awayScore: nonNegInt,
     boxScores: z.array(z.custom((v) => v instanceof BoxScore, {

package/dist/esm/src/service/match/vper.d.ts

@@ -1,4 +1,5 @@
 import { BoxScore } from './box-score';
+export declare const MIN_POINTS_PLAYED_FOR_VPER = 35;
 export interface VPERParams {
     readonly playerId: string;
     readonly matchId: string;
@@ -11,4 +12,6 @@ export declare class VPER {
     static create(input: unknown): VPER;
     private constructor();
     static computeVPERForMatch(boxScores: BoxScore[]): number;
+    static totalPointsPlayed(boxScores: BoxScore[]): number;
+    static qualifiesForVPER(boxScores: BoxScore[]): boolean;
 }

package/dist/esm/src/service/match/vper.js

@@ -17,6 +17,10 @@ const WEIGHTS = {
     // terminal errors (always point against)
     TERMINAL_ERROR: -1.0
 };
+// Minimum points a player must be on court for in a match to receive a VPER. VPER is a per-100-points rate,
+// so below a meaningful sample one good touch is extrapolated into a wildly inflated value. Players under this
+// threshold get no VPER for the match.
+export const MIN_POINTS_PLAYED_FOR_VPER = 35;
 export class VPER {
     static create(input) {
         const result = VPERInputSchema.safeParse(input);
@@ -62,4 +66,10 @@ export class VPER {
         }
         return 100 * rawSum / Math.max(1, pointsPlayedSum);
     }
+    static totalPointsPlayed(boxScores) {
+        return boxScores.reduce((sum, box) => sum + box.misc.pointsPlayed, 0);
+    }
+    static qualifiesForVPER(boxScores) {
+        return VPER.totalPointsPlayed(boxScores) >= MIN_POINTS_PLAYED_FOR_VPER;
+    }
 }

package/dist/esm/src/service/match/vper.test.js

@@ -1,6 +1,6 @@
 import { describe, it, expect } from '@jest/globals';
 import { v4 as uuidv4 } from 'uuid';
-import { VPER } from './vper';
+import { MIN_POINTS_PLAYED_FOR_VPER, VPER } from './vper';
 import { BoxScore } from './box-score';
 // ─── helpers ─────────────────────────────────────────────────────────────────
 function makeBox() {
@@ -104,3 +104,37 @@ describe('VPER.computeVPERForMatch()', () => {
         expect(VPER.computeVPERForMatch([box])).toBeCloseTo(14, 5);
     });
 });
+// ─── VPER eligibility threshold ───────────────────────────────────────────────
+describe('VPER.qualifiesForVPER()', () => {
+    function boxWithPoints(points) {
+        const box = makeBox();
+        box.misc.pointsPlayed = points;
+        return box;
+    }
+    it('uses a 35-point threshold', () => {
+        expect(MIN_POINTS_PLAYED_FOR_VPER).toBe(35);
+    });
+    it('sums points played across box scores', () => {
+        expect(VPER.totalPointsPlayed([boxWithPoints(20), boxWithPoints(15)])).toBe(35);
+    });
+    it('does not qualify an empty box score list', () => {
+        expect(VPER.qualifiesForVPER([])).toBe(false);
+    });
+    it('does not qualify below the threshold', () => {
+        expect(VPER.qualifiesForVPER([boxWithPoints(34)])).toBe(false);
+    });
+    it('qualifies exactly at the threshold (inclusive)', () => {
+        expect(VPER.qualifiesForVPER([boxWithPoints(35)])).toBe(true);
+    });
+    it('qualifies above the threshold across multiple sets', () => {
+        expect(VPER.qualifiesForVPER([boxWithPoints(20), boxWithPoints(20)])).toBe(true);
+    });
+    it('rejects the inflated-cameo case (one good touch in a single point)', () => {
+        const box = makeBox();
+        box.setting.assists = 1;
+        box.setting.pass = 1;
+        box.misc.pointsPlayed = 1;
+        // Pre-fix this produced a VPER of 85; now the player is simply ineligible.
+        expect(VPER.qualifiesForVPER([box])).toBe(false);
+    });
+});

package/dist/esm/src/service/team/schemas/designated-sub.z.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/src/service/team/schemas/designated-sub.z.test.js

@@ -0,0 +1,120 @@
+import { describe, it, expect } from '@jest/globals';
+import { ConditionLogicSchema, DesignatedSubSchema, PinchConditionSchema, SubBandSchema } from './designated-sub.z';
+import { EnergyBand } from '../energy-band';
+import { OpponentRelation, PinchConditionType, ScoreDirection } from '../pinch-condition';
+import { makeCountry, makePlayer } from '../../test-helpers';
+describe('SubBandSchema', () => {
+    it('accepts every energy band and NEVER', () => {
+        const bands = [EnergyBand.ENERGETIC, EnergyBand.WORN, EnergyBand.TIRED, EnergyBand.EXHAUSTED, 'NEVER'];
+        for (const band of bands) {
+            expect(SubBandSchema.safeParse(band).success).toBe(true);
+        }
+    });
+    it('rejects an unknown band', () => {
+        expect(SubBandSchema.safeParse('SLEEPY').success).toBe(false);
+    });
+});
+describe('ConditionLogicSchema', () => {
+    it('accepts ALL and ANY', () => {
+        expect(ConditionLogicSchema.safeParse('ALL').success).toBe(true);
+        expect(ConditionLogicSchema.safeParse('ANY').success).toBe(true);
+    });
+    it('rejects anything else', () => {
+        expect(ConditionLogicSchema.safeParse('SOMETIMES').success).toBe(false);
+    });
+});
+describe('PinchConditionSchema', () => {
+    const valid = [
+        { type: PinchConditionType.ASAP },
+        { type: PinchConditionType.TEAM_SET_POINT, margin: 2, opponent: OpponentRelation.EITHER },
+        { type: PinchConditionType.OPPONENT_SET_POINT, margin: 1 },
+        { type: PinchConditionType.SCORE_DIFF, direction: ScoreDirection.TRAILING, points: 3 },
+        { type: PinchConditionType.AFTER_ROTATIONS, rotations: 1 },
+        { type: PinchConditionType.FROM_SET, set: 5 },
+        { type: PinchConditionType.MIN_OWN_SCORE, score: 20 }
+    ];
+    it('accepts a valid instance of every condition type', () => {
+        for (const condition of valid) {
+            expect(PinchConditionSchema.safeParse(condition).success).toBe(true);
+        }
+    });
+    it('rejects an unknown condition type', () => {
+        expect(PinchConditionSchema.safeParse({ type: 'WHENEVER' }).success).toBe(false);
+    });
+    it('rejects a condition missing its required field', () => {
+        expect(PinchConditionSchema.safeParse({ type: PinchConditionType.TEAM_SET_POINT, opponent: OpponentRelation.EITHER }).success).toBe(false);
+        expect(PinchConditionSchema.safeParse({ type: PinchConditionType.SCORE_DIFF, direction: ScoreDirection.LEADING }).success).toBe(false);
+    });
+    it('enforces numeric bounds', () => {
+        expect(PinchConditionSchema.safeParse({ type: PinchConditionType.TEAM_SET_POINT, margin: 0, opponent: OpponentRelation.AHEAD }).success).toBe(false);
+        expect(PinchConditionSchema.safeParse({ type: PinchConditionType.TEAM_SET_POINT, margin: 26, opponent: OpponentRelation.AHEAD }).success).toBe(false);
+        expect(PinchConditionSchema.safeParse({ type: PinchConditionType.AFTER_ROTATIONS, rotations: 7 }).success).toBe(false);
+        expect(PinchConditionSchema.safeParse({ type: PinchConditionType.FROM_SET, set: 6 }).success).toBe(false);
+        expect(PinchConditionSchema.safeParse({ type: PinchConditionType.MIN_OWN_SCORE, score: 41 }).success).toBe(false);
+        expect(PinchConditionSchema.safeParse({ type: PinchConditionType.SCORE_DIFF, direction: ScoreDirection.TRAILING, points: 0 }).success).toBe(false);
+    });
+    it('rejects a non-integer numeric field', () => {
+        expect(PinchConditionSchema.safeParse({ type: PinchConditionType.FROM_SET, set: 2.5 }).success).toBe(false);
+    });
+});
+describe('DesignatedSubSchema', () => {
+    const country = makeCountry();
+    const starter = makePlayer(country);
+    const bench = makePlayer(country);
+    it('accepts a fatigue-mode entry with a band and bench', () => {
+        const res = DesignatedSubSchema.safeParse({
+            starter,
+            bench,
+            isPinchServer: false,
+            fatigueBand: EnergyBand.TIRED
+        });
+        expect(res.success).toBe(true);
+    });
+    it('accepts a fatigue-mode entry with no bench (falls back to closest sub)', () => {
+        const res = DesignatedSubSchema.safeParse({
+            starter,
+            isPinchServer: false
+        });
+        expect(res.success).toBe(true);
+    });
+    it('accepts a pinch-mode entry with a bench server and conditions', () => {
+        const res = DesignatedSubSchema.safeParse({
+            starter,
+            bench,
+            isPinchServer: true,
+            conditions: [{ type: PinchConditionType.ASAP }],
+            conditionLogic: 'ALL'
+        });
+        expect(res.success).toBe(true);
+    });
+    it('rejects a pinch-mode entry without a bench server', () => {
+        const res = DesignatedSubSchema.safeParse({
+            starter,
+            isPinchServer: true,
+            conditions: [{ type: PinchConditionType.ASAP }]
+        });
+        expect(res.success).toBe(false);
+        if (!res.success) {
+            expect(res.error.issues.some(issue => issue.message === 'PINCH_SERVER_REQUIRES_BENCH')).toBe(true);
+        }
+    });
+    it('rejects a pinch-mode entry with no conditions', () => {
+        const res = DesignatedSubSchema.safeParse({
+            starter,
+            bench,
+            isPinchServer: true,
+            conditions: []
+        });
+        expect(res.success).toBe(false);
+        if (!res.success) {
+            expect(res.error.issues.some(issue => issue.message === 'PINCH_SERVER_REQUIRES_CONDITIONS')).toBe(true);
+        }
+    });
+    it('rejects a starter that is not a Player instance', () => {
+        const res = DesignatedSubSchema.safeParse({
+            starter: { id: 'not-a-player' },
+            isPinchServer: false
+        });
+        expect(res.success).toBe(false);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "volleyballsimtypes",
-  "version": "0.0.390",
+  "version": "0.0.393",
   "description": "vbsim types",
   "main": "./dist/cjs/src/index.js",
   "module": "./dist/esm/src/index.js",