volleyballsimtypes 0.0.463 → 0.0.464

package/dist/cjs/src/data/transformers/tactics.js

@@ -87,7 +87,12 @@ function transformToAttributes(tactics, teamId) {
         offensive_preference_sets: tactics.offensivePreferenceSets?.map(prefs => prefs.map(p => ({
             rotation: p.rotation,
             order: p.order.map((a) => a.id)
-        })))
+        }))),
+        replace_injured_immediately: tactics.replaceInjuredImmediately,
+        reserve_priorities: tactics.reservePriorities.map(rp => ({
+            position: rp.position,
+            reserves: rp.reserves.map((p) => p.id)
+        }))
     };
 }
 // Accepts TacticsAttributes (not just TacticsModel) so a per-match preset's config, shaped as column data by
@@ -164,7 +169,39 @@ function transformToObject(model, roster) {
         offensivePreferenceSets: model.offensive_preference_sets?.map(prefs => prefs.map(p => ({
             rotation: p.rotation,
             order: p.order.map((id) => findPlayer(id, roster))
-        })))
+        }))),
+        replaceInjuredImmediately: model.replace_injured_immediately ?? true,
+        // LENIENT (roster.find, not findPlayer): a dismissed/retired reserve, one that has since moved INTO the
+        // lineup, one that doubles as the resolved second libero, or a duplicate (player in two lists, repeated
+        // position) is DROPPED rather than crashing the sim batch (reserves are depth, not structure); now-empty
+        // entries are pruned. First occurrence wins on duplicates; the next tactics save rewrites cleanly.
+        reservePriorities: (() => {
+            const seenIds = new Set();
+            const seenPositions = new Set();
+            return (model.reserve_priorities ?? [])
+                .filter(rp => {
+                // Court slots only (1-6): jsonb has no constraint, and an out-of-range position would pass the
+                // heal only to be rejected by the schema, crashing the very sim batch this heal protects.
+                if (!Number.isInteger(rp.position) || rp.position < 1 || rp.position > 6)
+                    return false;
+                if (seenPositions.has(rp.position))
+                    return false;
+                seenPositions.add(rp.position);
+                return true;
+            })
+                .map(rp => ({
+                position: rp.position,
+                reserves: rp.reserves
+                    .map((id) => roster.find((p) => p.id === id))
+                    .filter((p) => {
+                    if (p == null || inLineupIds.has(p.id) || p.id === secondLibero?.id || seenIds.has(p.id))
+                        return false;
+                    seenIds.add(p.id);
+                    return true;
+                })
+            }))
+                .filter(rp => rp.reserves.length > 0);
+        })()
     });
 }
 // Serialize a Tactics ROW (db columns) straight to the API Tactics DTO (player references stay as ids; no
@@ -224,7 +261,35 @@ function tacticsColumnsToApiDto(model) {
         designatedSetters: model.designated_setters,
         offensivePreferences: model.offensive_preferences,
         systemSets: model.system_sets,
-        offensivePreferenceSets: model.offensive_preference_sets
+        offensivePreferenceSets: model.offensive_preference_sets,
+        replaceInjuredImmediately: model.replace_injured_immediately ?? true,
+        // Same stale-data policy as validSecondLibero above: don't surface reserve entries the service load
+        // would drop (bad position, id now in the lineup, the L2, duplicates), or the UI reloads and re-emits
+        // them forever. Roster membership can't be checked here (ids only); the service heal covers that.
+        reservePriorities: (() => {
+            const seenIds = new Set();
+            const seenPositions = new Set();
+            const healed = (model.reserve_priorities ?? [])
+                .filter(rp => {
+                if (!Number.isInteger(rp.position) || rp.position < 1 || rp.position > 6)
+                    return false;
+                if (seenPositions.has(rp.position))
+                    return false;
+                seenPositions.add(rp.position);
+                return true;
+            })
+                .map(rp => ({
+                position: rp.position,
+                reserves: rp.reserves.filter(id => {
+                    if (lineupIds.has(id) || id === validSecondLibero || seenIds.has(id))
+                        return false;
+                    seenIds.add(id);
+                    return true;
+                })
+            }))
+                .filter(rp => rp.reserves.length > 0);
+            return healed.length > 0 ? healed : undefined;
+        })()
     };
 }
 // Inverse of tacticsColumnsToApiDto: shape a preset's stored API config (camelCase, player ids) as
@@ -257,6 +322,8 @@ function apiTacticsConfigToAttributes(config, teamId) {
         designated_setters: config.designatedSetters,
         offensive_preferences: config.offensivePreferences,
         system_sets: config.systemSets,
-        offensive_preference_sets: config.offensivePreferenceSets
+        offensive_preference_sets: config.offensivePreferenceSets,
+        replace_injured_immediately: config.replaceInjuredImmediately,
+        reserve_priorities: config.reservePriorities
     };
 }

package/dist/cjs/src/service/event/schemas/substitution.z.d.ts

@@ -2,5 +2,6 @@ import { z } from 'zod';
 export declare const SubstitutionInputSchema: z.ZodObject<{
     playerId: z.ZodUUID;
     playerOut: z.ZodUUID;
+    injury: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export type SubstitutionInput = z.infer<typeof SubstitutionInputSchema>;

package/dist/cjs/src/service/event/schemas/substitution.z.js

@@ -4,7 +4,8 @@ exports.SubstitutionInputSchema = void 0;
 const zod_1 = require("zod");
 exports.SubstitutionInputSchema = zod_1.z.object({
     playerId: zod_1.z.uuid(),
-    playerOut: zod_1.z.uuid()
+    playerOut: zod_1.z.uuid(),
+    injury: zod_1.z.boolean().optional()
 }).superRefine((data, ctx) => {
     if (data.playerId === data.playerOut) {
         ctx.addIssue({

package/dist/cjs/src/service/event/substitution.d.ts

@@ -1,6 +1,7 @@
 import { RallyEvent } from './rally-event';
 export declare class Substitution extends RallyEvent {
     readonly playerOut: string;
+    readonly injury?: boolean;
     static create(input: unknown): Substitution;
     private constructor();
     toString(): string;

package/dist/cjs/src/service/event/substitution.js

@@ -17,15 +17,17 @@ class Substitution extends rally_event_1.RallyEvent {
         }
         return new Substitution(result.data);
     }
-    constructor({ playerOut, playerId }) {
+    constructor({ playerOut, playerId, injury }) {
         super({ eventType, playerId });
         this.playerOut = playerOut;
+        this.injury = injury;
     }
     toString() {
         const playerId = `"playerId":"${this.playerId}"`;
         const playerOut = `"playerOut":"${this.playerOut}"`;
         const eventType = `"eventType":${this.eventType}`;
-        return `{${playerId},${playerOut},${eventType}}`;
+        const injury = this.injury === true ? ',"injury":true' : '';
+        return `{${playerId},${playerOut},${eventType}${injury}}`;
     }
 }
 exports.Substitution = Substitution;

package/dist/cjs/src/service/match/match-set-forfeit.test.d.ts

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

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

@@ -0,0 +1,76 @@
+"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");
+function makeSet(homeScore, awayScore, isTieBreak = false, forfeited) {
+    return match_set_1.MatchSet.create({
+        id: (0, uuid_1.v4)(),
+        order: isTieBreak ? 4 : 0,
+        isTieBreak,
+        homePlayerPosition: [],
+        awayPlayerPosition: [],
+        homeScore,
+        awayScore,
+        boxScores: [],
+        rallies: [],
+        ...(forfeited != null ? { forfeited } : {})
+    });
+}
+// Mid-set states are not valid CREATION states (the schema wants 0-0 or a finished score), so build them the
+// way the sim does: create at 0-0 and play to the score.
+function playedTo(homeScore, awayScore, isTieBreak = false) {
+    const set = makeSet(0, 0, isTieBreak);
+    for (let i = 0; i < homeScore; i++)
+        set.increaseScore(match_team_1.MatchTeam.HOME);
+    for (let i = 0; i < awayScore; i++)
+        set.increaseScore(match_team_1.MatchTeam.AWAY);
+    return set;
+}
+(0, globals_1.describe)('MatchSet — forfeit (FIVB 6.4.3)', () => {
+    (0, globals_1.it)('defaults forfeited to false', () => {
+        (0, globals_1.expect)(makeSet(25, 20).forfeited).toBe(false);
+    });
+    (0, globals_1.it)('accepts a persisted forfeited set with an awarded score', () => {
+        const set = makeSet(25, 13, false, true);
+        (0, globals_1.expect)(set.forfeited).toBe(true);
+        (0, globals_1.expect)(set.isOver()).toBe(true);
+        (0, globals_1.expect)(set.getWinner()).toBe(match_team_1.MatchTeam.HOME);
+    });
+    (0, globals_1.it)('awards the threshold when the loser is below deuce (18-23, home granted)', () => {
+        const set = playedTo(18, 23);
+        // Score order in makeSet is home, away; away leads 23-18 but HOME is granted the forfeit win.
+        set.forfeit(match_team_1.MatchTeam.HOME);
+        (0, globals_1.expect)(set.homeScore).toBe(25);
+        (0, globals_1.expect)(set.awayScore).toBe(23);
+        (0, globals_1.expect)(set.forfeited).toBe(true);
+        (0, globals_1.expect)(set.isOver()).toBe(true);
+        (0, globals_1.expect)(set.getWinner()).toBe(match_team_1.MatchTeam.HOME);
+    });
+    (0, globals_1.it)('awards loser + 2 beyond deuce (24-24, away granted -> 24-26)', () => {
+        const set = playedTo(24, 24);
+        set.forfeit(match_team_1.MatchTeam.AWAY);
+        (0, globals_1.expect)(set.homeScore).toBe(24);
+        (0, globals_1.expect)(set.awayScore).toBe(26);
+        (0, globals_1.expect)(set.isOver()).toBe(true);
+        (0, globals_1.expect)(set.getWinner()).toBe(match_team_1.MatchTeam.AWAY);
+    });
+    (0, globals_1.it)('keeps the forfeiting side points (0-0 fully-awarded set -> 25-0)', () => {
+        const set = makeSet(0, 0);
+        set.forfeit(match_team_1.MatchTeam.HOME);
+        (0, globals_1.expect)(set.homeScore).toBe(25);
+        (0, globals_1.expect)(set.awayScore).toBe(0);
+        (0, globals_1.expect)(set.isOver()).toBe(true);
+    });
+    (0, globals_1.it)('awards 15 on a tie break', () => {
+        const set = playedTo(10, 13, true);
+        set.forfeit(match_team_1.MatchTeam.HOME);
+        (0, globals_1.expect)(set.homeScore).toBe(15);
+        (0, globals_1.expect)(set.awayScore).toBe(13);
+        (0, globals_1.expect)(set.isOver()).toBe(true);
+    });
+    (0, globals_1.it)('rejects a forfeited set whose score never reached the awarding rule (below threshold)', () => {
+        (0, globals_1.expect)(() => makeSet(18, 12, false, true)).toThrow(/INVALID_MATCH_SET/);
+    });
+});

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

@@ -13,10 +13,18 @@ export declare class MatchSet {
     readonly scoreThreshold: ScoreThreshold;
     private _homeScore;
     private _awayScore;
+    private _forfeited;
     static create(input: unknown): MatchSet;
     private constructor();
     get homeScore(): number;
     get awayScore(): number;
+    get forfeited(): boolean;
+    /**
+     * End the set by forfeit (FIVB 6.4.3, incomplete team). The forfeiting side keeps its points; the winner
+     * is granted exactly the points needed to win the set (the threshold, or loser + 2 beyond deuce), so the
+     * final score always satisfies the normal reached-threshold and win-by-2 rules. Marks the set forfeited.
+     */
+    forfeit(winner: MatchTeam): void;
     increaseScore(team: MatchTeam): void;
     addRally(rally: Rally): void;
     /**

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

@@ -16,11 +16,12 @@ class MatchSet {
         }
         return new MatchSet(result.data);
     }
-    constructor({ id, order, isTieBreak, homePlayerPosition, awayPlayerPosition, boxScores, rallies, homeScore, awayScore }) {
+    constructor({ id, order, isTieBreak, homePlayerPosition, awayPlayerPosition, boxScores, rallies, homeScore, awayScore, forfeited = false }) {
         this.id = id;
         this.order = order;
         this._homeScore = homeScore;
         this._awayScore = awayScore;
+        this._forfeited = forfeited;
         this.homePlayerPosition = homePlayerPosition;
         this.awayPlayerPosition = awayPlayerPosition;
         this.boxScores = boxScores;
@@ -34,6 +35,27 @@ class MatchSet {
     get awayScore() {
         return this._awayScore;
     }
+    get forfeited() {
+        return this._forfeited;
+    }
+    /**
+     * End the set by forfeit (FIVB 6.4.3, incomplete team). The forfeiting side keeps its points; the winner
+     * is granted exactly the points needed to win the set (the threshold, or loser + 2 beyond deuce), so the
+     * final score always satisfies the normal reached-threshold and win-by-2 rules. Marks the set forfeited.
+     */
+    forfeit(winner) {
+        // Forfeiting an already-decided (or already-forfeited) set would silently rewrite the winner with a
+        // schema-legal score: surface the caller bug instead (e.g. both teams forfeited in the same rally).
+        if (this._forfeited || this.isOver())
+            throw new Error('SET_ALREADY_DECIDED');
+        if (winner === match_team_1.MatchTeam.HOME)
+            this._homeScore = Math.max(this.scoreThreshold, this._awayScore + 2);
+        else if (winner === match_team_1.MatchTeam.AWAY)
+            this._awayScore = Math.max(this.scoreThreshold, this._homeScore + 2);
+        else
+            throw new Error('UNKNOWN_TEAM');
+        this._forfeited = true;
+    }
     increaseScore(team) {
         if (team === match_team_1.MatchTeam.HOME)
             this._homeScore++;

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

@@ -3,6 +3,7 @@ import { Team } from '../team';
 import { MatchTeam } from './match-team';
 import { StatusEnum } from '../../data';
 import { VPER } from './vper';
+export type MatchForfeitType = 'INCOMPLETE' | 'DEFAULT';
 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 {
@@ -16,6 +17,7 @@ export declare class Match {
     homeScore?: number;
     awayScore?: number;
     winner?: Team;
+    forfeitType?: MatchForfeitType;
     static create(input: unknown): Match;
     private constructor();
     addSet(set: MatchSet): void;

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

@@ -17,7 +17,7 @@ class Match {
         }
         return new Match(result.data);
     }
-    constructor({ id, homeTeam, awayTeam, scheduledDate, sets, status, homeScore, awayScore, winner, VPERs }) {
+    constructor({ id, homeTeam, awayTeam, scheduledDate, sets, status, homeScore, awayScore, winner, VPERs, forfeitType }) {
         if (homeTeam.id === awayTeam.id)
             throw new Error(`FAILED_TO_CREATE_MATCH. TEAMS_WITH_SAME_ID: ${homeTeam.id}`);
         this.id = id;
@@ -30,6 +30,7 @@ class Match {
         this.awayScore = awayScore;
         this.winner = winner;
         this.VPERs = VPERs ?? [];
+        this.forfeitType = forfeitType;
     }
     addSet(set) {
         if (this.sets.length >= 5)

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

@@ -11,5 +11,6 @@ export declare const MatchSetInputSchema: z.ZodObject<{
     awayScore: z.ZodNumber;
     boxScores: z.ZodArray<z.ZodCustom<BoxScore, BoxScore>>;
     rallies: z.ZodArray<z.ZodCustom<Rally, Rally>>;
+    forfeited: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strip>;
 export type MatchSetInput = z.infer<typeof MatchSetInputSchema>;

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

@@ -27,7 +27,10 @@ exports.MatchSetInputSchema = zod_1.z.object({
     })),
     rallies: zod_1.z.array(zod_1.z.custom((v) => v instanceof rally_1.Rally, {
         message: 'INVALID_RALLY_INSTANCE'
-    }))
+    })),
+    // FIVB 6.4.3 set forfeit (injuries: team could not field six). The awarding rule (winner granted the points
+    // needed to win) keeps the threshold rule below satisfied; only the rallies-vs-score equality is relaxed.
+    forfeited: zod_1.z.boolean().default(false)
 }).superRefine((data, ctx) => {
     const { order, isTieBreak, rallies, homeScore, awayScore } = data;
     // isTieBreak <-> order === 4
@@ -56,6 +59,20 @@ exports.MatchSetInputSchema = zod_1.z.object({
             path: ['homeScore']
         });
     }
+    // A forfeited score must be exactly what forfeit() awards: winner = max(threshold, loser + 2). This rejects
+    // over-awarded scores (30-10), missing-award states (0-0 or 25-24 forfeited) and any hand-rolled corruption
+    // at the validation boundary instead of letting it flip winners downstream.
+    if (data.forfeited) {
+        const winner = Math.max(homeScore, awayScore);
+        const loser = Math.min(homeScore, awayScore);
+        if (winner !== Math.max(scoreThreshold, loser + 2)) {
+            ctx.addIssue({
+                code: 'custom',
+                message: 'FORFEITED_SCORE_MUST_MATCH_AWARDING_RULE',
+                path: ['homeScore']
+            });
+        }
+    }
     // If rallies exist, score cannot be 0-0 and must match the number of rallies.
     if (hasRallies) {
         if (isZeroZero) {
@@ -65,12 +82,23 @@ exports.MatchSetInputSchema = zod_1.z.object({
                 path: ['rallies']
             });
         }
-        if (homeScore + awayScore !== rallies.length) {
+        // A forfeited set keeps the rallies actually played and is topped up with awarded points, so the sum
+        // exceeds the rally count; anything else (more rallies than points) is still invalid. The loser's points
+        // were all EARNED, so when rallies are present they must at least cover them (rally-less persisted sets,
+        // the bot-vs-bot path, skip this whole block).
+        if (data.forfeited ? rallies.length > homeScore + awayScore : homeScore + awayScore !== rallies.length) {
             ctx.addIssue({
                 code: 'custom',
                 message: 'RALLIES_LENGTH_MUST_EQUAL_SCORE_SUM',
                 path: ['rallies']
             });
         }
+        if (data.forfeited && rallies.length < Math.min(homeScore, awayScore)) {
+            ctx.addIssue({
+                code: 'custom',
+                message: 'FORFEITED_LOSER_POINTS_REQUIRE_RALLIES',
+                path: ['rallies']
+            });
+        }
     }
 });

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

@@ -18,5 +18,9 @@ export declare const MatchInputSchema: z.ZodObject<{
     homeScore: z.ZodOptional<z.ZodNumber>;
     awayScore: z.ZodOptional<z.ZodNumber>;
     winner: z.ZodOptional<z.ZodCustom<Team, Team>>;
+    forfeitType: z.ZodOptional<z.ZodEnum<{
+        INCOMPLETE: "INCOMPLETE";
+        DEFAULT: "DEFAULT";
+    }>>;
 }, z.core.$strip>;
 export type MatchInput = z.infer<typeof MatchInputSchema>;

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

@@ -23,7 +23,10 @@ exports.MatchInputSchema = zod_1.z.object({
     })).optional(),
     homeScore: zod_1.z.number().int().optional(),
     awayScore: zod_1.z.number().int().optional(),
-    winner: teamSchema.optional()
+    winner: teamSchema.optional(),
+    // Abnormal ending marker (see MatchForfeitType). The match still validates as a normal COMPLETE result
+    // because forfeited sets carry FIVB-awarded scores.
+    forfeitType: zod_1.z.enum(['INCOMPLETE', 'DEFAULT']).optional()
 }).superRefine((data, ctx) => {
     if (data.homeTeam.id === data.awayTeam.id) {
         ctx.addIssue({

package/dist/cjs/src/service/player/index.d.ts

@@ -1,6 +1,7 @@
 export * from './player';
 export * from './improvement';
 export * from './decline';
+export * from './injury';
 export * from './player-generator';
 export * from './performance-stats';
 export * from './trait';

package/dist/cjs/src/service/player/index.js

@@ -17,6 +17,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./player"), exports);
 __exportStar(require("./improvement"), exports);
 __exportStar(require("./decline"), exports);
+__exportStar(require("./injury"), exports);
 __exportStar(require("./player-generator"), exports);
 __exportStar(require("./performance-stats"), exports);
 __exportStar(require("./trait"), exports);

package/dist/cjs/src/service/player/injury.d.ts

@@ -0,0 +1,14 @@
+import { Rarity } from './rarity';
+export declare enum InjurySeverityEnum {
+    MINOR = 1,
+    MODERATE = 2,
+    SEVERE = 3
+}
+export interface PlayerInjury {
+    readonly severity: number;
+    readonly injuredUntil: Date;
+    readonly debuff?: number;
+}
+export declare function hasActiveInjury(injury: PlayerInjury | undefined, at: Date): boolean;
+export declare function getPhysiotherapistRiskMultiplier(rarity: Rarity): number;
+export declare function getPhysicianRecoveryMultiplier(rarity: Rarity): number;

package/dist/cjs/src/service/player/injury.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InjurySeverityEnum = void 0;
+exports.hasActiveInjury = hasActiveInjury;
+exports.getPhysiotherapistRiskMultiplier = getPhysiotherapistRiskMultiplier;
+exports.getPhysicianRecoveryMultiplier = getPhysicianRecoveryMultiplier;
+const rarity_1 = require("./rarity");
+var InjurySeverityEnum;
+(function (InjurySeverityEnum) {
+    InjurySeverityEnum[InjurySeverityEnum["MINOR"] = 1] = "MINOR";
+    InjurySeverityEnum[InjurySeverityEnum["MODERATE"] = 2] = "MODERATE";
+    InjurySeverityEnum[InjurySeverityEnum["SEVERE"] = 3] = "SEVERE";
+})(InjurySeverityEnum || (exports.InjurySeverityEnum = InjurySeverityEnum = {}));
+// A long-term injury is active while `at` is before injuredUntil.
+function hasActiveInjury(injury, at) {
+    return injury != null && injury.injuredUntil.getTime() > at.getTime();
+}
+// Staff effect curves (same Record-plus-accessor shape as getCoachMultiplier). COMMON = neutral baseline.
+// Physiotherapist scales the per-action injury CHANCE; physician scales long-term recovery TIME.
+const PHYSIOTHERAPIST_RISK_MULTIPLIERS = {
+    [rarity_1.RarityEnum.COMMON]: 1.0,
+    [rarity_1.RarityEnum.RARE]: 0.92,
+    [rarity_1.RarityEnum.LEGENDARY]: 0.84,
+    [rarity_1.RarityEnum.MYTHIC]: 0.75,
+    [rarity_1.RarityEnum.SPECIAL]: 0.65
+};
+const PHYSICIAN_RECOVERY_MULTIPLIERS = {
+    [rarity_1.RarityEnum.COMMON]: 1.0,
+    [rarity_1.RarityEnum.RARE]: 0.9,
+    [rarity_1.RarityEnum.LEGENDARY]: 0.8,
+    [rarity_1.RarityEnum.MYTHIC]: 0.65,
+    [rarity_1.RarityEnum.SPECIAL]: 0.5
+};
+function getPhysiotherapistRiskMultiplier(rarity) {
+    return PHYSIOTHERAPIST_RISK_MULTIPLIERS[rarity] ?? 1.0;
+}
+function getPhysicianRecoveryMultiplier(rarity) {
+    return PHYSICIAN_RECOVERY_MULTIPLIERS[rarity] ?? 1.0;
+}

package/dist/cjs/src/service/player/injury.test.d.ts

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

package/dist/cjs/src/service/player/injury.test.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+const rarity_1 = require("./rarity");
+const injury_1 = require("./injury");
+const player_z_1 = require("./schemas/player.z");
+const test_helpers_1 = require("../test-helpers");
+(0, globals_1.describe)('Player injury fields', () => {
+    const country = (0, test_helpers_1.makeCountry)();
+    (0, globals_1.it)('defaults injuryProneProfile to 0.5 for legacy Player.create callers', () => {
+        const player = (0, test_helpers_1.makePlayer)(country);
+        (0, globals_1.expect)(player.injuryProneProfile).toBe(0.5);
+        (0, globals_1.expect)(player.injury).toBeUndefined();
+    });
+    (0, globals_1.it)('accepts an injury object and coerces injuredUntil from an ISO string', () => {
+        const base = player_z_1.PlayerInputSchema.safeParse({
+            ...validInput(),
+            injuryProneProfile: 0.8,
+            injury: { severity: 2, injuredUntil: '2026-07-04T10:00:00.000Z', debuff: 0.75 }
+        });
+        (0, globals_1.expect)(base.success).toBe(true);
+        if (base.success) {
+            (0, globals_1.expect)(base.data.injuryProneProfile).toBe(0.8);
+            (0, globals_1.expect)(base.data.injury?.injuredUntil).toBeInstanceOf(Date);
+            (0, globals_1.expect)(base.data.injury?.severity).toBe(2);
+        }
+    });
+    (0, globals_1.it)('rejects out-of-range severity and profile', () => {
+        (0, globals_1.expect)(player_z_1.PlayerInputSchema.safeParse({ ...validInput(), injury: { severity: 4, injuredUntil: new Date() } }).success).toBe(false);
+        (0, globals_1.expect)(player_z_1.PlayerInputSchema.safeParse({ ...validInput(), injury: { severity: 0, injuredUntil: new Date() } }).success).toBe(false);
+        (0, globals_1.expect)(player_z_1.PlayerInputSchema.safeParse({ ...validInput(), injuryProneProfile: 1.2 }).success).toBe(false);
+        (0, globals_1.expect)(player_z_1.PlayerInputSchema.safeParse({ ...validInput(), injuryProneProfile: -0.1 }).success).toBe(false);
+    });
+    function validInput() {
+        const p = (0, test_helpers_1.makePlayer)(country);
+        return {
+            id: p.id,
+            name: { first: p.name.first, last: p.name.last },
+            country,
+            stats: p.stats,
+            roles: p.roles,
+            traits: p.traits,
+            rarity: p.rarity,
+            age: p.age,
+            birthAge: p.birthAge,
+            birthIteration: p.birthIteration,
+            declineProfile: p.declineProfile
+        };
+    }
+});
+(0, globals_1.describe)('hasActiveInjury', () => {
+    const at = new Date('2026-07-03T12:00:00.000Z');
+    (0, globals_1.it)('is false for a healthy player', () => {
+        (0, globals_1.expect)((0, injury_1.hasActiveInjury)(undefined, at)).toBe(false);
+    });
+    (0, globals_1.it)('is true while injuredUntil is in the future', () => {
+        (0, globals_1.expect)((0, injury_1.hasActiveInjury)({ severity: 1, injuredUntil: new Date('2026-07-03T18:00:00.000Z') }, at)).toBe(true);
+    });
+    (0, globals_1.it)('is false once injuredUntil has passed (lazy expiry)', () => {
+        (0, globals_1.expect)((0, injury_1.hasActiveInjury)({ severity: 3, injuredUntil: new Date('2026-07-03T11:59:59.000Z') }, at)).toBe(false);
+    });
+});
+(0, globals_1.describe)('staff multipliers', () => {
+    (0, globals_1.it)('physiotherapist reduces risk monotonically from COMMON to SPECIAL', () => {
+        (0, globals_1.expect)((0, injury_1.getPhysiotherapistRiskMultiplier)(rarity_1.RarityEnum.COMMON)).toBe(1.0);
+        (0, globals_1.expect)((0, injury_1.getPhysiotherapistRiskMultiplier)(rarity_1.RarityEnum.SPECIAL)).toBe(0.65);
+        const ladder = [rarity_1.RarityEnum.COMMON, rarity_1.RarityEnum.RARE, rarity_1.RarityEnum.LEGENDARY, rarity_1.RarityEnum.MYTHIC, rarity_1.RarityEnum.SPECIAL];
+        const values = ladder.map(injury_1.getPhysiotherapistRiskMultiplier);
+        (0, globals_1.expect)([...values].sort((a, b) => b - a)).toEqual(values);
+    });
+    (0, globals_1.it)('physician reduces recovery monotonically and halves it at SPECIAL', () => {
+        (0, globals_1.expect)((0, injury_1.getPhysicianRecoveryMultiplier)(rarity_1.RarityEnum.COMMON)).toBe(1.0);
+        (0, globals_1.expect)((0, injury_1.getPhysicianRecoveryMultiplier)(rarity_1.RarityEnum.SPECIAL)).toBe(0.5);
+        const ladder = [rarity_1.RarityEnum.COMMON, rarity_1.RarityEnum.RARE, rarity_1.RarityEnum.LEGENDARY, rarity_1.RarityEnum.MYTHIC, rarity_1.RarityEnum.SPECIAL];
+        const values = ladder.map(injury_1.getPhysicianRecoveryMultiplier);
+        (0, globals_1.expect)([...values].sort((a, b) => b - a)).toEqual(values);
+    });
+});

package/dist/cjs/src/service/player/player-generator.js

@@ -308,7 +308,9 @@ class PlayerGenerator {
         const traits = (0, trait_1.assignTraits)(roles, rarity, maxTraits);
         const birthAge = (0, node_crypto_1.randomInt)(15, 21);
         const declineProfile = decline_1.declineProfiles[(0, node_crypto_1.randomInt)(0, decline_1.declineProfiles.length)];
-        return player_1.Player.create({ id: (0, uuid_1.v4)(), name, country, stats, roles, traits, rarity, age: birthAge, birthAge, birthIteration, declineProfile });
+        // Uniform 0-1 (mean-neutral: the sim maps it to a 0.6-1.4 risk factor centered on 1.0).
+        const injuryProneProfile = (0, node_crypto_1.randomInt)(0, 101) / 100;
+        return player_1.Player.create({ id: (0, uuid_1.v4)(), name, country, stats, roles, traits, rarity, age: birthAge, birthAge, birthIteration, declineProfile, injuryProneProfile });
     }
     static generatePlayers(count, countries) {
         const players = [];

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

@@ -6,6 +6,7 @@ import { Stats } from './stats';
 import { Role } from './role';
 import { BoxScore, BoxScoreTotals } from '../match';
 import { DeclineProfile } from './decline';
+import { PlayerInjury } from './injury';
 export declare class Stat {
     readonly name: Stats;
     readonly value: number;
@@ -36,6 +37,8 @@ export declare class Player {
     readonly birthAge: number;
     readonly birthIteration: number;
     readonly declineProfile: DeclineProfile;
+    readonly injuryProneProfile: number;
+    readonly injury?: PlayerInjury;
     readonly boxScores?: BoxScore[];
     readonly boxScoreTotals?: BoxScoreTotals;
     static create(input: unknown): Player;

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

@@ -54,7 +54,7 @@ class Player {
             stats: performance_stats_1.PerformanceStats.create(result.data.stats)
         });
     }
-    constructor({ id, name, nickname, country, stats, roles, traits, rarity, age, birthAge, birthIteration, declineProfile, boxScores, boxScoreTotals }) {
+    constructor({ id, name, nickname, country, stats, roles, traits, rarity, age, birthAge, birthIteration, declineProfile, injuryProneProfile, injury, boxScores, boxScoreTotals }) {
         this.id = id;
         this.name = name;
         this.nickname = nickname;
@@ -67,6 +67,8 @@ class Player {
         this.birthAge = birthAge;
         this.birthIteration = birthIteration;
         this.declineProfile = declineProfile;
+        this.injuryProneProfile = injuryProneProfile;
+        this.injury = injury;
         this.boxScores = boxScores;
         this.boxScoreTotals = boxScoreTotals;
         this.generalStats = Object.values(stats_1.StatsEnum).map((stat) => ({

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

@@ -79,6 +79,12 @@ export declare const PlayerInputSchema: z.ZodObject<{
         VETERAN: DeclineProfileEnum.VETERAN;
         IRONMAN: DeclineProfileEnum.IRONMAN;
     }>;
+    injuryProneProfile: z.ZodDefault<z.ZodNumber>;
+    injury: z.ZodOptional<z.ZodObject<{
+        severity: z.ZodNumber;
+        injuredUntil: z.ZodCoercedDate<unknown>;
+        debuff: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
     boxScores: z.ZodOptional<z.ZodArray<z.ZodObject<{
         playerId: z.ZodUUID;
         matchSetId: z.ZodUUID;

package/dist/cjs/src/service/player/schemas/player.z.js

@@ -38,6 +38,13 @@ exports.PlayerInputSchema = zod_1.z.object({
     birthAge: zod_1.z.number().int().min(0),
     birthIteration: zod_1.z.number().int().min(1),
     declineProfile: zod_1.z.enum(Object.values(decline_1.DeclineProfileEnum)),
+    // Defaulted so every existing Player.create caller (generator, transformers, test helpers) stays valid.
+    injuryProneProfile: zod_1.z.number().min(0).max(1).default(0.5),
+    injury: zod_1.z.object({
+        severity: zod_1.z.number().int().min(1).max(3),
+        injuredUntil: zod_1.z.coerce.date(),
+        debuff: zod_1.z.number().min(0).max(1).optional()
+    }).optional(),
     boxScores: zod_1.z.array(box_score_z_1.BoxScoreInputSchema).optional(),
     boxScoreTotals: BoxScoreTotalsInputSchema.optional()
 });