volleyballsimtypes 0.0.463 → 0.0.465

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

@@ -14,7 +14,7 @@ export 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;
@@ -27,6 +27,7 @@ export class Match {
         this.awayScore = awayScore;
         this.winner = winner;
         this.VPERs = VPERs ?? [];
+        this.forfeitType = forfeitType;
     }
     addSet(set) {
         if (this.sets.length >= 5)

package/dist/esm/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/esm/src/service/match/schemas/match-set.z.js

@@ -24,7 +24,10 @@ export const MatchSetInputSchema = z.object({
     })),
     rallies: z.array(z.custom((v) => v instanceof 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: z.boolean().default(false)
 }).superRefine((data, ctx) => {
     const { order, isTieBreak, rallies, homeScore, awayScore } = data;
     // isTieBreak <-> order === 4
@@ -53,6 +56,20 @@ export const MatchSetInputSchema = 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) {
@@ -62,12 +79,23 @@ export const MatchSetInputSchema = 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/esm/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/esm/src/service/match/schemas/match.z.js

@@ -20,7 +20,10 @@ export const MatchInputSchema = z.object({
     })).optional(),
     homeScore: z.number().int().optional(),
     awayScore: 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: z.enum(['INCOMPLETE', 'DEFAULT']).optional()
 }).superRefine((data, ctx) => {
     if (data.homeTeam.id === data.awayTeam.id) {
         ctx.addIssue({

package/dist/esm/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/esm/src/service/player/index.js

@@ -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/esm/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/esm/src/service/player/injury.js

@@ -0,0 +1,33 @@
+import { RarityEnum } from './rarity';
+export var InjurySeverityEnum;
+(function (InjurySeverityEnum) {
+    InjurySeverityEnum[InjurySeverityEnum["MINOR"] = 1] = "MINOR";
+    InjurySeverityEnum[InjurySeverityEnum["MODERATE"] = 2] = "MODERATE";
+    InjurySeverityEnum[InjurySeverityEnum["SEVERE"] = 3] = "SEVERE";
+})(InjurySeverityEnum || (InjurySeverityEnum = {}));
+// A long-term injury is active while `at` is before injuredUntil.
+export 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 = {
+    [RarityEnum.COMMON]: 1.0,
+    [RarityEnum.RARE]: 0.92,
+    [RarityEnum.LEGENDARY]: 0.84,
+    [RarityEnum.MYTHIC]: 0.75,
+    [RarityEnum.SPECIAL]: 0.65
+};
+const PHYSICIAN_RECOVERY_MULTIPLIERS = {
+    [RarityEnum.COMMON]: 1.0,
+    [RarityEnum.RARE]: 0.9,
+    [RarityEnum.LEGENDARY]: 0.8,
+    [RarityEnum.MYTHIC]: 0.65,
+    [RarityEnum.SPECIAL]: 0.5
+};
+export function getPhysiotherapistRiskMultiplier(rarity) {
+    return PHYSIOTHERAPIST_RISK_MULTIPLIERS[rarity] ?? 1.0;
+}
+export function getPhysicianRecoveryMultiplier(rarity) {
+    return PHYSICIAN_RECOVERY_MULTIPLIERS[rarity] ?? 1.0;
+}

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

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

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

@@ -0,0 +1,76 @@
+import { describe, it, expect } from '@jest/globals';
+import { RarityEnum } from './rarity';
+import { getPhysicianRecoveryMultiplier, getPhysiotherapistRiskMultiplier, hasActiveInjury } from './injury';
+import { PlayerInputSchema } from './schemas/player.z';
+import { makeCountry, makePlayer } from '../test-helpers';
+describe('Player injury fields', () => {
+    const country = makeCountry();
+    it('defaults injuryProneProfile to 0.5 for legacy Player.create callers', () => {
+        const player = makePlayer(country);
+        expect(player.injuryProneProfile).toBe(0.5);
+        expect(player.injury).toBeUndefined();
+    });
+    it('accepts an injury object and coerces injuredUntil from an ISO string', () => {
+        const base = PlayerInputSchema.safeParse({
+            ...validInput(),
+            injuryProneProfile: 0.8,
+            injury: { severity: 2, injuredUntil: '2026-07-04T10:00:00.000Z', debuff: 0.75 }
+        });
+        expect(base.success).toBe(true);
+        if (base.success) {
+            expect(base.data.injuryProneProfile).toBe(0.8);
+            expect(base.data.injury?.injuredUntil).toBeInstanceOf(Date);
+            expect(base.data.injury?.severity).toBe(2);
+        }
+    });
+    it('rejects out-of-range severity and profile', () => {
+        expect(PlayerInputSchema.safeParse({ ...validInput(), injury: { severity: 4, injuredUntil: new Date() } }).success).toBe(false);
+        expect(PlayerInputSchema.safeParse({ ...validInput(), injury: { severity: 0, injuredUntil: new Date() } }).success).toBe(false);
+        expect(PlayerInputSchema.safeParse({ ...validInput(), injuryProneProfile: 1.2 }).success).toBe(false);
+        expect(PlayerInputSchema.safeParse({ ...validInput(), injuryProneProfile: -0.1 }).success).toBe(false);
+    });
+    function validInput() {
+        const p = 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
+        };
+    }
+});
+describe('hasActiveInjury', () => {
+    const at = new Date('2026-07-03T12:00:00.000Z');
+    it('is false for a healthy player', () => {
+        expect(hasActiveInjury(undefined, at)).toBe(false);
+    });
+    it('is true while injuredUntil is in the future', () => {
+        expect(hasActiveInjury({ severity: 1, injuredUntil: new Date('2026-07-03T18:00:00.000Z') }, at)).toBe(true);
+    });
+    it('is false once injuredUntil has passed (lazy expiry)', () => {
+        expect(hasActiveInjury({ severity: 3, injuredUntil: new Date('2026-07-03T11:59:59.000Z') }, at)).toBe(false);
+    });
+});
+describe('staff multipliers', () => {
+    it('physiotherapist reduces risk monotonically from COMMON to SPECIAL', () => {
+        expect(getPhysiotherapistRiskMultiplier(RarityEnum.COMMON)).toBe(1.0);
+        expect(getPhysiotherapistRiskMultiplier(RarityEnum.SPECIAL)).toBe(0.65);
+        const ladder = [RarityEnum.COMMON, RarityEnum.RARE, RarityEnum.LEGENDARY, RarityEnum.MYTHIC, RarityEnum.SPECIAL];
+        const values = ladder.map(getPhysiotherapistRiskMultiplier);
+        expect([...values].sort((a, b) => b - a)).toEqual(values);
+    });
+    it('physician reduces recovery monotonically and halves it at SPECIAL', () => {
+        expect(getPhysicianRecoveryMultiplier(RarityEnum.COMMON)).toBe(1.0);
+        expect(getPhysicianRecoveryMultiplier(RarityEnum.SPECIAL)).toBe(0.5);
+        const ladder = [RarityEnum.COMMON, RarityEnum.RARE, RarityEnum.LEGENDARY, RarityEnum.MYTHIC, RarityEnum.SPECIAL];
+        const values = ladder.map(getPhysicianRecoveryMultiplier);
+        expect([...values].sort((a, b) => b - a)).toEqual(values);
+    });
+});

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

@@ -302,7 +302,9 @@ export class PlayerGenerator {
         const traits = assignTraits(roles, rarity, maxTraits);
         const birthAge = randomInt(15, 21);
         const declineProfile = declineProfiles[randomInt(0, declineProfiles.length)];
-        return Player.create({ id: uuidv4(), 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 = randomInt(0, 101) / 100;
+        return Player.create({ id: uuidv4(), name, country, stats, roles, traits, rarity, age: birthAge, birthAge, birthIteration, declineProfile, injuryProneProfile });
     }
     static generatePlayers(count, countries) {
         const players = [];

package/dist/esm/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/esm/src/service/player/player.js

@@ -49,7 +49,7 @@ export class Player {
             stats: 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;
@@ -62,6 +62,8 @@ export 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(StatsEnum).map((stat) => ({

package/dist/esm/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/esm/src/service/player/schemas/player.z.js

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

package/dist/esm/src/service/team/index.d.ts

@@ -11,3 +11,4 @@ export * from './rotation-system';
 export * from './lineup-function';
 export * from './base-position';
 export * from './offensive-preference';
+export * from './injury-replacement';

package/dist/esm/src/service/team/index.js

@@ -11,3 +11,4 @@ export * from './rotation-system';
 export * from './lineup-function';
 export * from './base-position';
 export * from './offensive-preference';
+export * from './injury-replacement';

package/dist/esm/src/service/team/injury-replacement.d.ts

@@ -0,0 +1,6 @@
+import { Player } from '../player';
+export interface InjuryReplacement {
+    readonly starter: Player;
+    readonly replacement: Player;
+    readonly benchBackfill?: Player;
+}

package/dist/esm/src/service/team/injury-replacement.js

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

package/dist/esm/src/service/team/schemas/injury-replacement.z.test.d.ts

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

package/dist/esm/src/service/team/schemas/injury-replacement.z.test.js

@@ -0,0 +1,140 @@
+import { describe, it, expect } from '@jest/globals';
+import { TacticsInputSchema } from './tactics.z';
+import { makeCountry, makePlayer } from '../../test-helpers';
+describe('TacticsInputSchema — injuryReplacements (owner rules 2026-07-03)', () => {
+    const country = makeCountry();
+    const p1 = makePlayer(country);
+    const p2 = makePlayer(country);
+    const p3 = makePlayer(country);
+    const p4 = makePlayer(country);
+    const p5 = makePlayer(country);
+    const p6 = makePlayer(country);
+    const benchA = makePlayer(country);
+    const benchB = makePlayer(country);
+    const libero = makePlayer(country);
+    const reserveA = makePlayer(country);
+    const reserveB = makePlayer(country);
+    function baseInput(overrides = {}) {
+        return {
+            lineup: {
+                4: p4,
+                3: p3,
+                2: p2,
+                5: p5,
+                6: p6,
+                1: p1,
+                0: libero,
+                bench: [benchA, benchB]
+            },
+            liberoReplacements: [],
+            ...overrides
+        };
+    }
+    it('defaults to true / empty', () => {
+        const res = TacticsInputSchema.safeParse(baseInput());
+        expect(res.success).toBe(true);
+        if (res.success) {
+            expect(res.data.replaceInjuredImmediately).toBe(true);
+            expect(res.data.injuryReplacements).toEqual([]);
+        }
+    });
+    it('accepts a bench replacement with a reserve backfill', () => {
+        const res = TacticsInputSchema.safeParse(baseInput({
+            injuryReplacements: [{ starter: p1, replacement: benchA, benchBackfill: reserveA }]
+        }));
+        expect(res.success).toBe(true);
+    });
+    it('accepts a bench replacement WITHOUT a backfill (empty bench seat is allowed by design)', () => {
+        const res = TacticsInputSchema.safeParse(baseInput({
+            injuryReplacements: [{ starter: p1, replacement: benchA }]
+        }));
+        expect(res.success).toBe(true);
+    });
+    it('accepts a reserve replacement (no backfill possible)', () => {
+        const res = TacticsInputSchema.safeParse(baseInput({
+            injuryReplacements: [{ starter: p1, replacement: reserveA }]
+        }));
+        expect(res.success).toBe(true);
+    });
+    it('rejects a starter as replacement', () => {
+        const res = TacticsInputSchema.safeParse(baseInput({
+            injuryReplacements: [{ starter: p1, replacement: p2 }]
+        }));
+        expect(res.success).toBe(false);
+        if (!res.success) {
+            expect(res.error.issues.some(issue => issue.message === 'INJURY_REPLACEMENT_MUST_BE_BENCH_OR_RESERVE')).toBe(true);
+        }
+    });
+    it('rejects the libero as replacement', () => {
+        const res = TacticsInputSchema.safeParse(baseInput({
+            injuryReplacements: [{ starter: p1, replacement: libero }]
+        }));
+        expect(res.success).toBe(false);
+        if (!res.success) {
+            expect(res.error.issues.some(issue => issue.message === 'INJURY_REPLACEMENT_MUST_BE_BENCH_OR_RESERVE')).toBe(true);
+        }
+    });
+    it('rejects a non-starter as the starter side', () => {
+        const res = TacticsInputSchema.safeParse(baseInput({
+            injuryReplacements: [{ starter: benchA, replacement: reserveA }]
+        }));
+        expect(res.success).toBe(false);
+        if (!res.success) {
+            expect(res.error.issues.some(issue => issue.message === 'INJURY_REPLACEMENT_STARTER_NOT_A_STARTER')).toBe(true);
+        }
+    });
+    it('rejects a backfill when the replacement is a reserve', () => {
+        const res = TacticsInputSchema.safeParse(baseInput({
+            injuryReplacements: [{ starter: p1, replacement: reserveA, benchBackfill: reserveB }]
+        }));
+        expect(res.success).toBe(false);
+        if (!res.success) {
+            expect(res.error.issues.some(issue => issue.message === 'BENCH_BACKFILL_REQUIRES_BENCH_REPLACEMENT')).toBe(true);
+        }
+    });
+    it('rejects a bench player as backfill (must be a reserve)', () => {
+        const res = TacticsInputSchema.safeParse(baseInput({
+            injuryReplacements: [{ starter: p1, replacement: benchA, benchBackfill: benchB }]
+        }));
+        expect(res.success).toBe(false);
+        if (!res.success) {
+            expect(res.error.issues.some(issue => issue.message === 'BENCH_BACKFILL_MUST_BE_RESERVE')).toBe(true);
+        }
+    });
+    it('rejects duplicate starter entries', () => {
+        const res = TacticsInputSchema.safeParse(baseInput({
+            injuryReplacements: [
+                { starter: p1, replacement: benchA },
+                { starter: p1, replacement: reserveA }
+            ]
+        }));
+        expect(res.success).toBe(false);
+        if (!res.success) {
+            expect(res.error.issues.some(issue => issue.message === 'INJURY_REPLACEMENT_DUPLICATE_STARTER')).toBe(true);
+        }
+    });
+    it('rejects the same incoming player used twice', () => {
+        const res = TacticsInputSchema.safeParse(baseInput({
+            injuryReplacements: [
+                { starter: p1, replacement: reserveA },
+                { starter: p2, replacement: reserveA }
+            ]
+        }));
+        expect(res.success).toBe(false);
+        if (!res.success) {
+            expect(res.error.issues.some(issue => issue.message === 'INJURY_REPLACEMENT_PLAYER_USED_TWICE')).toBe(true);
+        }
+    });
+    it('rejects a player used as replacement in one entry and backfill in another', () => {
+        const res = TacticsInputSchema.safeParse(baseInput({
+            injuryReplacements: [
+                { starter: p1, replacement: reserveA },
+                { starter: p2, replacement: benchA, benchBackfill: reserveA }
+            ]
+        }));
+        expect(res.success).toBe(false);
+        if (!res.success) {
+            expect(res.error.issues.some(issue => issue.message === 'INJURY_REPLACEMENT_PLAYER_USED_TWICE')).toBe(true);
+        }
+    });
+});

package/dist/esm/src/service/team/schemas/tactics.z.d.ts

@@ -123,5 +123,11 @@ export declare const TacticsInputSchema: z.ZodObject<{
         rotation: z.ZodNumber;
         order: z.ZodArray<z.ZodCustom<Player, Player>>;
     }, z.core.$strip>>>>;
+    replaceInjuredImmediately: z.ZodDefault<z.ZodBoolean>;
+    injuryReplacements: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        starter: z.ZodCustom<Player, Player>;
+        replacement: z.ZodCustom<Player, Player>;
+        benchBackfill: z.ZodOptional<z.ZodCustom<Player, Player>>;
+    }, z.core.$strip>>>;
 }, z.core.$strip>;
 export type TacticsInput = z.infer<typeof TacticsInputSchema>;

package/dist/esm/src/service/team/schemas/tactics.z.js

@@ -77,7 +77,16 @@ export const TacticsInputSchema = z.object({
     // Per-set overrides (5 entries, index 0 = set 1; absent => the flat fields apply to all sets). Each entry is
     // validated with the same cross-field rules as the flat fields (see superRefine below).
     systemSets: z.array(systemSetSchema).max(5).optional(),
-    offensivePreferenceSets: z.array(z.array(offensivePreferenceSchema)).max(5).optional()
+    offensivePreferenceSets: z.array(z.array(offensivePreferenceSchema)).max(5).optional(),
+    // Injuries. Defaults keep every existing Tactics.create({...}) call valid. injuryReplacements is the
+    // per-starter explicit replacement mapping (owner rules: followed verbatim, bench-only auto fallback,
+    // reserves never auto-promoted); cross-field rules in the superRefine below.
+    replaceInjuredImmediately: z.boolean().default(true),
+    injuryReplacements: z.array(z.object({
+        starter: playerInstanceSchema,
+        replacement: playerInstanceSchema,
+        benchBackfill: playerInstanceSchema.optional()
+    })).default([])
 }).superRefine((data, ctx) => {
     // Cross-field rules for the rotation system. These keep an invalid config from ever reaching the sim (the
     // pinch-server outage was caused by an unvalidated tactics payload).
@@ -175,4 +184,41 @@ export const TacticsInputSchema = z.object({
             }
         }
     }
+    // Injury replacements (owner rules 2026-07-03). starter = a court starter, at most one entry each.
+    // replacement = a bench player or a reserve (never another starter, the libero, or the L2). benchBackfill
+    // only when the replacement came from the bench, and must be a RESERVE (outside the whole lineup, not the
+    // L2). No player appears as a replacement or backfill more than once across all entries.
+    const benchIds = new Set(data.lineup.bench.map((p) => p.id));
+    const liberoId = data.lineup[LIBERO_ZONE]?.id;
+    const seenInjuryStarters = new Set();
+    const seenIncoming = new Set();
+    for (const ir of data.injuryReplacements) {
+        if (!starterIds.has(ir.starter.id)) {
+            ctx.addIssue({ code: 'custom', message: 'INJURY_REPLACEMENT_STARTER_NOT_A_STARTER', path: ['injuryReplacements'] });
+        }
+        if (seenInjuryStarters.has(ir.starter.id)) {
+            ctx.addIssue({ code: 'custom', message: 'INJURY_REPLACEMENT_DUPLICATE_STARTER', path: ['injuryReplacements'] });
+        }
+        seenInjuryStarters.add(ir.starter.id);
+        const isReplacementBench = benchIds.has(ir.replacement.id);
+        if (starterIds.has(ir.replacement.id) || ir.replacement.id === liberoId || ir.replacement.id === data.secondLibero?.id) {
+            ctx.addIssue({ code: 'custom', message: 'INJURY_REPLACEMENT_MUST_BE_BENCH_OR_RESERVE', path: ['injuryReplacements'] });
+        }
+        if (seenIncoming.has(ir.replacement.id)) {
+            ctx.addIssue({ code: 'custom', message: 'INJURY_REPLACEMENT_PLAYER_USED_TWICE', path: ['injuryReplacements'] });
+        }
+        seenIncoming.add(ir.replacement.id);
+        if (ir.benchBackfill != null) {
+            if (!isReplacementBench) {
+                ctx.addIssue({ code: 'custom', message: 'BENCH_BACKFILL_REQUIRES_BENCH_REPLACEMENT', path: ['injuryReplacements'] });
+            }
+            if (inLineupIds.has(ir.benchBackfill.id) || ir.benchBackfill.id === data.secondLibero?.id) {
+                ctx.addIssue({ code: 'custom', message: 'BENCH_BACKFILL_MUST_BE_RESERVE', path: ['injuryReplacements'] });
+            }
+            if (seenIncoming.has(ir.benchBackfill.id)) {
+                ctx.addIssue({ code: 'custom', message: 'INJURY_REPLACEMENT_PLAYER_USED_TWICE', path: ['injuryReplacements'] });
+            }
+            seenIncoming.add(ir.benchBackfill.id);
+        }
+    }
 });

package/dist/esm/src/service/team/schemas/team.z.d.ts

@@ -131,6 +131,12 @@ export declare const TeamInputSchema: z.ZodObject<{
             rotation: z.ZodNumber;
             order: z.ZodArray<z.ZodCustom<Player, Player>>;
         }, z.core.$strip>>>>;
+        replaceInjuredImmediately: z.ZodDefault<z.ZodBoolean>;
+        injuryReplacements: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            starter: z.ZodCustom<Player, Player>;
+            replacement: z.ZodCustom<Player, Player>;
+            benchBackfill: z.ZodOptional<z.ZodCustom<Player, Player>>;
+        }, z.core.$strip>>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type TeamInput = z.infer<typeof TeamInputSchema>;

package/dist/esm/src/service/team/tactics.d.ts

@@ -5,6 +5,7 @@ import { LiberoSubConfig } from './libero-sub';
 import { SubBand } from './energy-band';
 import { RotationSystemEnum } from './rotation-system';
 import { OffensivePreference } from './offensive-preference';
+import { InjuryReplacement } from './injury-replacement';
 export interface StartingLineup {
     readonly [CourtPosition.LEFT_FRONT]: Player;
     readonly [CourtPosition.MIDDLE_FRONT]: Player;
@@ -33,6 +34,8 @@ export interface TacticsOpts {
     readonly offensivePreferences: OffensivePreference[];
     readonly systemSets?: SystemSet[];
     readonly offensivePreferenceSets?: OffensivePreference[][];
+    readonly replaceInjuredImmediately: boolean;
+    readonly injuryReplacements: InjuryReplacement[];
 }
 export declare class Tactics {
     readonly lineup: StartingLineup;
@@ -48,6 +51,8 @@ export declare class Tactics {
     readonly offensivePreferences: OffensivePreference[];
     readonly systemSets?: SystemSet[];
     readonly offensivePreferenceSets?: OffensivePreference[][];
+    readonly replaceInjuredImmediately: boolean;
+    readonly injuryReplacements: InjuryReplacement[];
     static create(input: unknown): Tactics;
     private constructor();
     findPlayerInLineup(id: string): CourtPosition | undefined;

package/dist/esm/src/service/team/tactics.js

@@ -15,7 +15,7 @@ export class Tactics {
         }
         return new Tactics(result.data);
     }
-    constructor({ lineup, liberoReplacements, receiveRotationOffset = false, designatedSubs = [], substitutionBand = EnergyBand.TIRED, secondLibero, liberoSub, liberoReplacementSets, rotationSystem = RotationSystemEnum.SIX_ZERO, designatedSetters = [], offensivePreferences = [], systemSets, offensivePreferenceSets }) {
+    constructor({ lineup, liberoReplacements, receiveRotationOffset = false, designatedSubs = [], substitutionBand = EnergyBand.TIRED, secondLibero, liberoSub, liberoReplacementSets, rotationSystem = RotationSystemEnum.SIX_ZERO, designatedSetters = [], offensivePreferences = [], systemSets, offensivePreferenceSets, replaceInjuredImmediately = true, injuryReplacements = [] }) {
         this.lineup = lineup;
         this.liberoReplacements = liberoReplacements;
         this.receiveRotationOffset = receiveRotationOffset;
@@ -29,6 +29,8 @@ export class Tactics {
         this.offensivePreferences = offensivePreferences;
         this.systemSets = systemSets;
         this.offensivePreferenceSets = offensivePreferenceSets;
+        this.replaceInjuredImmediately = replaceInjuredImmediately;
+        this.injuryReplacements = injuryReplacements;
     }
     findPlayerInLineup(id) {
         if (this.lineup.bench.some(p => p.id === id))

package/package.json

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