volleyballsimtypes 0.0.473 → 0.0.475

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

@@ -3,9 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const globals_1 = require("@jest/globals");
 const libero_sub_z_1 = require("./libero-sub.z");
 const energy_band_1 = require("../energy-band");
+const pinch_condition_1 = require("../pinch-condition");
 (0, globals_1.describe)('LiberoSubModeSchema', () => {
-    (0, globals_1.it)('accepts NEVER, FATIGUE and ALWAYS', () => {
-        for (const mode of ['NEVER', 'FATIGUE', 'ALWAYS']) {
+    (0, globals_1.it)('accepts NEVER, FATIGUE, ALWAYS and CONDITIONS', () => {
+        for (const mode of ['NEVER', 'FATIGUE', 'ALWAYS', 'CONDITIONS']) {
             (0, globals_1.expect)(libero_sub_z_1.LiberoSubModeSchema.safeParse(mode).success).toBe(true);
         }
     });
@@ -23,6 +24,36 @@ const energy_band_1 = require("../energy-band");
     (0, globals_1.it)('rejects an unknown band', () => {
         (0, globals_1.expect)(libero_sub_z_1.LiberoSetSubConfigSchema.safeParse({ mode: 'FATIGUE', fatigueBand: 'SLEEPY' }).success).toBe(false);
     });
+    (0, globals_1.it)('accepts CONDITIONS with a PHASE condition (serve/receive split)', () => {
+        const res = libero_sub_z_1.LiberoSetSubConfigSchema.safeParse({
+            mode: 'CONDITIONS',
+            conditionLogic: 'ALL',
+            conditions: [{ type: pinch_condition_1.PinchConditionType.PHASE, phase: pinch_condition_1.MatchPhase.RECEIVING }]
+        });
+        (0, globals_1.expect)(res.success).toBe(true);
+    });
+    (0, globals_1.it)('accepts CONDITIONS mixing a pinch condition and a PHASE condition', () => {
+        const res = libero_sub_z_1.LiberoSetSubConfigSchema.safeParse({
+            mode: 'CONDITIONS',
+            conditionLogic: 'ANY',
+            conditions: [
+                { type: pinch_condition_1.PinchConditionType.MIN_OWN_SCORE, score: 20 },
+                { type: pinch_condition_1.PinchConditionType.PHASE, phase: pinch_condition_1.MatchPhase.SERVING }
+            ]
+        });
+        (0, globals_1.expect)(res.success).toBe(true);
+    });
+    (0, globals_1.it)('rejects CONDITIONS mode with no conditions', () => {
+        (0, globals_1.expect)(libero_sub_z_1.LiberoSetSubConfigSchema.safeParse({ mode: 'CONDITIONS' }).success).toBe(false);
+        (0, globals_1.expect)(libero_sub_z_1.LiberoSetSubConfigSchema.safeParse({ mode: 'CONDITIONS', conditions: [] }).success).toBe(false);
+    });
+    (0, globals_1.it)('rejects an invalid PHASE value', () => {
+        const res = libero_sub_z_1.LiberoSetSubConfigSchema.safeParse({
+            mode: 'CONDITIONS',
+            conditions: [{ type: pinch_condition_1.PinchConditionType.PHASE, phase: 'ATTACKING' }]
+        });
+        (0, globals_1.expect)(res.success).toBe(false);
+    });
 });
 (0, globals_1.describe)('LiberoSubConfigSchema', () => {
     (0, globals_1.it)('accepts a flat config with no per-set overrides', () => {

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

@@ -50,6 +50,9 @@ export declare const TacticsInputSchema: z.ZodObject<{
             }, z.core.$strip>, z.ZodObject<{
                 type: z.ZodLiteral<import("..").PinchConditionType.MIN_OPPONENT_SCORE>;
                 score: z.ZodNumber;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<import("..").PinchConditionType.PHASE>;
+                phase: z.ZodEnum<typeof import("..").MatchPhase>;
             }, z.core.$strip>], "type">>>;
             conditionLogic: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodLiteral<"ANY">]>>;
         }, z.core.$strip>>>;
@@ -86,6 +89,9 @@ export declare const TacticsInputSchema: z.ZodObject<{
         }, z.core.$strip>, z.ZodObject<{
             type: z.ZodLiteral<import("..").PinchConditionType.MIN_OPPONENT_SCORE>;
             score: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<import("..").PinchConditionType.PHASE>;
+            phase: z.ZodEnum<typeof import("..").MatchPhase>;
         }, z.core.$strip>], "type">>>;
         conditionLogic: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodLiteral<"ANY">]>>;
         starter: z.ZodCustom<Player, Player>;
@@ -98,15 +104,77 @@ export declare const TacticsInputSchema: z.ZodObject<{
                 NEVER: "NEVER";
                 FATIGUE: "FATIGUE";
                 ALWAYS: "ALWAYS";
+                CONDITIONS: "CONDITIONS";
             }>;
             fatigueBand: z.ZodOptional<z.ZodEnum<typeof EnergyBand>>;
+            conditions: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<import("..").PinchConditionType.ASAP>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<import("..").PinchConditionType.TEAM_SET_POINT>;
+                margin: z.ZodNumber;
+                opponent: z.ZodEnum<typeof import("..").OpponentRelation>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<import("..").PinchConditionType.OPPONENT_SET_POINT>;
+                margin: z.ZodNumber;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<import("..").PinchConditionType.SCORE_DIFF>;
+                direction: z.ZodEnum<typeof import("..").ScoreDirection>;
+                points: z.ZodNumber;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<import("..").PinchConditionType.AFTER_ROTATIONS>;
+                rotations: z.ZodNumber;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<import("..").PinchConditionType.FROM_SET>;
+                set: z.ZodNumber;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<import("..").PinchConditionType.MIN_OWN_SCORE>;
+                score: z.ZodNumber;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<import("..").PinchConditionType.MIN_OPPONENT_SCORE>;
+                score: z.ZodNumber;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<import("..").PinchConditionType.PHASE>;
+                phase: z.ZodEnum<typeof import("..").MatchPhase>;
+            }, z.core.$strip>], "type">>>;
+            conditionLogic: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodLiteral<"ANY">]>>;
         }, z.core.$strip>>>;
         mode: z.ZodEnum<{
             NEVER: "NEVER";
             FATIGUE: "FATIGUE";
             ALWAYS: "ALWAYS";
+            CONDITIONS: "CONDITIONS";
         }>;
         fatigueBand: z.ZodOptional<z.ZodEnum<typeof EnergyBand>>;
+        conditions: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<import("..").PinchConditionType.ASAP>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<import("..").PinchConditionType.TEAM_SET_POINT>;
+            margin: z.ZodNumber;
+            opponent: z.ZodEnum<typeof import("..").OpponentRelation>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<import("..").PinchConditionType.OPPONENT_SET_POINT>;
+            margin: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<import("..").PinchConditionType.SCORE_DIFF>;
+            direction: z.ZodEnum<typeof import("..").ScoreDirection>;
+            points: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<import("..").PinchConditionType.AFTER_ROTATIONS>;
+            rotations: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<import("..").PinchConditionType.FROM_SET>;
+            set: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<import("..").PinchConditionType.MIN_OWN_SCORE>;
+            score: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<import("..").PinchConditionType.MIN_OPPONENT_SCORE>;
+            score: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<import("..").PinchConditionType.PHASE>;
+            phase: z.ZodEnum<typeof import("..").MatchPhase>;
+        }, z.core.$strip>], "type">>>;
+        conditionLogic: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodLiteral<"ANY">]>>;
     }, z.core.$strip>>;
     liberoReplacementSets: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodCustom<Player, Player>>>>;
     rotationSystem: z.ZodDefault<z.ZodEnum<typeof RotationSystemEnum>>;
@@ -129,5 +197,10 @@ export declare const TacticsInputSchema: z.ZodObject<{
         replacement: z.ZodCustom<Player, Player>;
         benchBackfill: z.ZodOptional<z.ZodCustom<Player, Player>>;
     }, z.core.$strip>>>;
+    liberoInjury: z.ZodOptional<z.ZodObject<{
+        preMatchReplacement: z.ZodOptional<z.ZodCustom<Player, Player>>;
+        secondLiberoBackfill: z.ZodOptional<z.ZodCustom<Player, Player>>;
+        inMatchDesignate: z.ZodOptional<z.ZodCustom<Player, Player>>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type TacticsInput = z.infer<typeof TacticsInputSchema>;

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

@@ -90,7 +90,17 @@ exports.TacticsInputSchema = zod_1.z.object({
         starter: playerInstanceSchema,
         replacement: playerInstanceSchema,
         benchBackfill: playerInstanceSchema.optional()
-    })).default([])
+    })).default([]),
+    // Libero injuries (owner 2026-07-06). All optional => an unconfigured team behaves exactly as before.
+    // preMatchReplacement: the reserve or the L2 that takes an already-injured starting libero's zone at match
+    // load; secondLiberoBackfill: the reserve that becomes the new L2 (only when the L2 is the replacement);
+    // inMatchDesignate: a bench/reserve player re-designated as a full libero if the sole libero goes down
+    // in-match with no L2. Cross-field pool rules are in the superRefine below.
+    liberoInjury: zod_1.z.object({
+        preMatchReplacement: playerInstanceSchema.optional(),
+        secondLiberoBackfill: playerInstanceSchema.optional(),
+        inMatchDesignate: playerInstanceSchema.optional()
+    }).optional()
 }).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).
@@ -232,4 +242,34 @@ exports.TacticsInputSchema = zod_1.z.object({
             seenIncoming.add(ir.benchBackfill.id);
         }
     }
+    // Libero injuries (owner 2026-07-06). preMatchReplacement is a RESERVE or the L2 (never a court starter, the
+    // libero, or a bench player) and needs a starting libero to replace. secondLiberoBackfill (the new L2) is a
+    // RESERVE, valid ONLY when the L2 itself is the replacement. inMatchDesignate is a bench or reserve player NOT
+    // on court (never a court starter, the libero, or the L2).
+    const liberoInjury = data.liberoInjury;
+    if (liberoInjury != null) {
+        const preMatch = liberoInjury.preMatchReplacement;
+        const backfill = liberoInjury.secondLiberoBackfill;
+        const designate = liberoInjury.inMatchDesignate;
+        const secondLiberoId = data.secondLibero?.id;
+        if (preMatch != null) {
+            if (libero == null) {
+                ctx.addIssue({ code: 'custom', message: 'LIBERO_INJURY_REQUIRES_LIBERO', path: ['liberoInjury', 'preMatchReplacement'] });
+            }
+            if (inLineupIds.has(preMatch.id)) {
+                ctx.addIssue({ code: 'custom', message: 'LIBERO_INJURY_REPLACEMENT_MUST_BE_RESERVE_OR_L2', path: ['liberoInjury', 'preMatchReplacement'] });
+            }
+        }
+        if (backfill != null) {
+            if (preMatch == null || preMatch.id !== secondLiberoId) {
+                ctx.addIssue({ code: 'custom', message: 'LIBERO_BACKFILL_REQUIRES_L2_REPLACEMENT', path: ['liberoInjury', 'secondLiberoBackfill'] });
+            }
+            if (inLineupIds.has(backfill.id) || backfill.id === secondLiberoId) {
+                ctx.addIssue({ code: 'custom', message: 'LIBERO_BACKFILL_MUST_BE_RESERVE', path: ['liberoInjury', 'secondLiberoBackfill'] });
+            }
+        }
+        if (designate != null && (starterIds.has(designate.id) || designate.id === liberoId || designate.id === secondLiberoId)) {
+            ctx.addIssue({ code: 'custom', message: 'LIBERO_DESIGNATE_MUST_BE_BENCH_OR_RESERVE', path: ['liberoInjury', 'inMatchDesignate'] });
+        }
+    }
 });

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

@@ -58,6 +58,9 @@ export declare const TeamInputSchema: z.ZodObject<{
                 }, z.core.$strip>, z.ZodObject<{
                     type: z.ZodLiteral<import("..").PinchConditionType.MIN_OPPONENT_SCORE>;
                     score: z.ZodNumber;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<import("..").PinchConditionType.PHASE>;
+                    phase: z.ZodEnum<typeof import("..").MatchPhase>;
                 }, z.core.$strip>], "type">>>;
                 conditionLogic: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodLiteral<"ANY">]>>;
             }, z.core.$strip>>>;
@@ -94,6 +97,9 @@ export declare const TeamInputSchema: z.ZodObject<{
             }, z.core.$strip>, z.ZodObject<{
                 type: z.ZodLiteral<import("..").PinchConditionType.MIN_OPPONENT_SCORE>;
                 score: z.ZodNumber;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<import("..").PinchConditionType.PHASE>;
+                phase: z.ZodEnum<typeof import("..").MatchPhase>;
             }, z.core.$strip>], "type">>>;
             conditionLogic: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodLiteral<"ANY">]>>;
             starter: z.ZodCustom<Player, Player>;
@@ -106,15 +112,77 @@ export declare const TeamInputSchema: z.ZodObject<{
                     NEVER: "NEVER";
                     FATIGUE: "FATIGUE";
                     ALWAYS: "ALWAYS";
+                    CONDITIONS: "CONDITIONS";
                 }>;
                 fatigueBand: z.ZodOptional<z.ZodEnum<typeof import("..").EnergyBand>>;
+                conditions: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    type: z.ZodLiteral<import("..").PinchConditionType.ASAP>;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<import("..").PinchConditionType.TEAM_SET_POINT>;
+                    margin: z.ZodNumber;
+                    opponent: z.ZodEnum<typeof import("..").OpponentRelation>;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<import("..").PinchConditionType.OPPONENT_SET_POINT>;
+                    margin: z.ZodNumber;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<import("..").PinchConditionType.SCORE_DIFF>;
+                    direction: z.ZodEnum<typeof import("..").ScoreDirection>;
+                    points: z.ZodNumber;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<import("..").PinchConditionType.AFTER_ROTATIONS>;
+                    rotations: z.ZodNumber;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<import("..").PinchConditionType.FROM_SET>;
+                    set: z.ZodNumber;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<import("..").PinchConditionType.MIN_OWN_SCORE>;
+                    score: z.ZodNumber;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<import("..").PinchConditionType.MIN_OPPONENT_SCORE>;
+                    score: z.ZodNumber;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<import("..").PinchConditionType.PHASE>;
+                    phase: z.ZodEnum<typeof import("..").MatchPhase>;
+                }, z.core.$strip>], "type">>>;
+                conditionLogic: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodLiteral<"ANY">]>>;
             }, z.core.$strip>>>;
             mode: z.ZodEnum<{
                 NEVER: "NEVER";
                 FATIGUE: "FATIGUE";
                 ALWAYS: "ALWAYS";
+                CONDITIONS: "CONDITIONS";
             }>;
             fatigueBand: z.ZodOptional<z.ZodEnum<typeof import("..").EnergyBand>>;
+            conditions: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<import("..").PinchConditionType.ASAP>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<import("..").PinchConditionType.TEAM_SET_POINT>;
+                margin: z.ZodNumber;
+                opponent: z.ZodEnum<typeof import("..").OpponentRelation>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<import("..").PinchConditionType.OPPONENT_SET_POINT>;
+                margin: z.ZodNumber;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<import("..").PinchConditionType.SCORE_DIFF>;
+                direction: z.ZodEnum<typeof import("..").ScoreDirection>;
+                points: z.ZodNumber;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<import("..").PinchConditionType.AFTER_ROTATIONS>;
+                rotations: z.ZodNumber;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<import("..").PinchConditionType.FROM_SET>;
+                set: z.ZodNumber;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<import("..").PinchConditionType.MIN_OWN_SCORE>;
+                score: z.ZodNumber;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<import("..").PinchConditionType.MIN_OPPONENT_SCORE>;
+                score: z.ZodNumber;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<import("..").PinchConditionType.PHASE>;
+                phase: z.ZodEnum<typeof import("..").MatchPhase>;
+            }, z.core.$strip>], "type">>>;
+            conditionLogic: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodLiteral<"ANY">]>>;
         }, z.core.$strip>>;
         liberoReplacementSets: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodCustom<Player, Player>>>>;
         rotationSystem: z.ZodDefault<z.ZodEnum<typeof import("..").RotationSystemEnum>>;
@@ -137,6 +205,11 @@ export declare const TeamInputSchema: z.ZodObject<{
             replacement: z.ZodCustom<Player, Player>;
             benchBackfill: z.ZodOptional<z.ZodCustom<Player, Player>>;
         }, z.core.$strip>>>;
+        liberoInjury: z.ZodOptional<z.ZodObject<{
+            preMatchReplacement: z.ZodOptional<z.ZodCustom<Player, Player>>;
+            secondLiberoBackfill: z.ZodOptional<z.ZodCustom<Player, Player>>;
+            inMatchDesignate: z.ZodOptional<z.ZodCustom<Player, Player>>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type TeamInput = z.infer<typeof TeamInputSchema>;

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

@@ -6,6 +6,7 @@ import { SubBand } from './energy-band';
 import { RotationSystemEnum } from './rotation-system';
 import { OffensivePreference } from './offensive-preference';
 import { InjuryReplacement } from './injury-replacement';
+import { LiberoInjuryConfig } from './libero-injury';
 export interface StartingLineup {
     readonly [CourtPosition.LEFT_FRONT]: Player;
     readonly [CourtPosition.MIDDLE_FRONT]: Player;
@@ -36,6 +37,7 @@ export interface TacticsOpts {
     readonly offensivePreferenceSets?: OffensivePreference[][];
     readonly replaceKnockedImmediately: Record<string, boolean>;
     readonly injuryReplacements: InjuryReplacement[];
+    readonly liberoInjury?: LiberoInjuryConfig;
 }
 export declare class Tactics {
     readonly lineup: StartingLineup;
@@ -53,6 +55,7 @@ export declare class Tactics {
     readonly offensivePreferenceSets?: OffensivePreference[][];
     readonly replaceKnockedImmediately: Record<string, boolean>;
     readonly injuryReplacements: InjuryReplacement[];
+    readonly liberoInjury?: LiberoInjuryConfig;
     static create(input: unknown): Tactics;
     private constructor();
     findPlayerInLineup(id: string): CourtPosition | undefined;

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

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

package/dist/esm/src/api/index.d.ts

@@ -111,9 +111,16 @@ export interface ApiInjuryReplacement {
     replacementId: string;
     benchBackfillId?: string;
 }
+export interface ApiLiberoInjury {
+    preMatchReplacementId?: string;
+    secondLiberoBackfillId?: string;
+    inMatchDesignateId?: string;
+}
 export interface ApiLiberoSetSubConfig {
     mode: LiberoSubMode;
     fatigueBand?: EnergyBand;
+    conditions?: PinchCondition[];
+    conditionLogic?: ConditionLogic;
 }
 export interface ApiLiberoSubConfig extends ApiLiberoSetSubConfig {
     sets?: ApiLiberoSetSubConfig[];
@@ -134,6 +141,7 @@ export interface Tactics {
     offensivePreferenceSets?: ApiOffensivePreference[][];
     replaceKnockedImmediately?: Record<string, boolean>;
     injuryReplacements?: ApiInjuryReplacement[];
+    liberoInjury?: ApiLiberoInjury;
 }
 export interface ApiLineupPreset {
     presetId: string;

package/dist/esm/src/data/models/tactics.d.ts

@@ -44,9 +44,16 @@ export interface InjuryReplacementAttributes {
     replacementId: PlayerId;
     benchBackfillId?: PlayerId;
 }
+export interface LiberoInjuryAttributes {
+    preMatchReplacementId?: PlayerId;
+    secondLiberoBackfillId?: PlayerId;
+    inMatchDesignateId?: PlayerId;
+}
 export interface LiberoSetSubConfigAttributes {
     mode: LiberoSubMode;
     fatigueBand?: EnergyBand;
+    conditions?: PinchCondition[];
+    conditionLogic?: ConditionLogic;
 }
 export interface LiberoSubConfigAttributes extends LiberoSetSubConfigAttributes {
     sets?: LiberoSetSubConfigAttributes[];
@@ -68,10 +75,11 @@ export interface TacticsAttributes {
     offensive_preference_sets?: OffensivePreferenceAttributes[][];
     replace_knocked_immediately?: Record<PlayerId, boolean>;
     injury_replacements?: InjuryReplacementAttributes[];
+    libero_injury?: LiberoInjuryAttributes;
 }
 export type TacticsPk = 'team_id';
 export type TacticsId = TacticsModel[TacticsPk];
-export type TacticsOptionalAttributes = 'lineup' | 'libero_replacements' | 'receive_rotation_offset' | 'designated_subs' | 'substitution_band' | 'second_libero' | 'libero_sub' | 'libero_replacement_sets' | 'rotation_system' | 'designated_setters' | 'offensive_preferences' | 'system_sets' | 'offensive_preference_sets' | 'replace_knocked_immediately' | 'injury_replacements';
+export type TacticsOptionalAttributes = 'lineup' | 'libero_replacements' | 'receive_rotation_offset' | 'designated_subs' | 'substitution_band' | 'second_libero' | 'libero_sub' | 'libero_replacement_sets' | 'rotation_system' | 'designated_setters' | 'offensive_preferences' | 'system_sets' | 'offensive_preference_sets' | 'replace_knocked_immediately' | 'injury_replacements' | 'libero_injury';
 export type TacticsCreationAttributes = Optional<TacticsAttributes, TacticsOptionalAttributes>;
 export declare class TacticsModel extends Model<TacticsAttributes, TacticsCreationAttributes> implements TacticsAttributes {
     team_id: string;
@@ -90,6 +98,7 @@ export declare class TacticsModel extends Model<TacticsAttributes, TacticsCreati
     offensive_preference_sets?: OffensivePreferenceAttributes[][];
     replace_knocked_immediately?: Record<PlayerId, boolean>;
     injury_replacements?: InjuryReplacementAttributes[];
+    libero_injury?: LiberoInjuryAttributes;
     team: TeamModel;
     getTeam: Sequelize.BelongsToGetAssociationMixin<TeamModel>;
     setTeam: Sequelize.BelongsToSetAssociationMixin<TeamModel, TeamId>;

package/dist/esm/src/data/models/tactics.js

@@ -79,6 +79,10 @@ export class TacticsModel extends Model {
             injury_replacements: {
                 type: DataTypes.JSONB,
                 allowNull: true
+            },
+            libero_injury: {
+                type: DataTypes.JSONB,
+                allowNull: true
             }
         }, {
             sequelize,

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

@@ -87,7 +87,14 @@ function transformToAttributes(tactics, teamId) {
             starterId: ir.starter.id,
             replacementId: ir.replacement.id,
             benchBackfillId: ir.benchBackfill?.id
-        }))
+        })),
+        libero_injury: tactics.liberoInjury != null
+            ? {
+                preMatchReplacementId: tactics.liberoInjury.preMatchReplacement?.id,
+                secondLiberoBackfillId: tactics.liberoInjury.secondLiberoBackfill?.id,
+                inMatchDesignateId: tactics.liberoInjury.inMatchDesignate?.id
+            }
+            : undefined
     };
 }
 // Accepts TacticsAttributes (not just TacticsModel) so a per-match preset's config, shaped as column data by
@@ -215,6 +222,38 @@ function transformToObject(model, roster) {
                 healed.push({ starter, replacement, benchBackfill });
             }
             return healed;
+        })(),
+        // LENIENT (roster.find): drop any stale/invalid libero-injury id so a bad row can never crash a team load.
+        // Mirrors the schema pool rules: preMatchReplacement is a RESERVE or the L2 (not in the lineup) and needs a
+        // starting libero; secondLiberoBackfill is a RESERVE (not the current L2) kept only when the L2 is the
+        // replacement; inMatchDesignate is a bench/reserve player (not a court starter, the libero, or the L2).
+        liberoInjury: (() => {
+            const li = model.libero_injury;
+            if (li == null)
+                return undefined;
+            const liberoZoneId = lineup[CourtPosition.LIBERO_ZONE]?.id;
+            const injuryStarterIds = new Set([lineup[CourtPosition.LEFT_FRONT], lineup[CourtPosition.MIDDLE_FRONT], lineup[CourtPosition.RIGHT_FRONT],
+                lineup[CourtPosition.LEFT_BACK], lineup[CourtPosition.MIDDLE_BACK], lineup[CourtPosition.RIGHT_BACK]]
+                .map((p) => p.id));
+            const reserveOrL2 = (id) => {
+                if (id == null)
+                    return undefined;
+                const p = roster.find((x) => x.id === id);
+                return p != null && !inLineupIds.has(p.id) ? p : undefined;
+            };
+            const preMatchReplacement = liberoZoneId != null ? reserveOrL2(li.preMatchReplacementId) : undefined;
+            const secondLiberoBackfill = (preMatchReplacement != null && preMatchReplacement.id === secondLibero?.id)
+                ? (() => { const p = reserveOrL2(li.secondLiberoBackfillId); return p != null && p.id !== secondLibero?.id ? p : undefined; })()
+                : undefined;
+            const inMatchDesignate = (() => {
+                const p = li.inMatchDesignateId != null ? roster.find((x) => x.id === li.inMatchDesignateId) : undefined;
+                if (p == null || injuryStarterIds.has(p.id) || p.id === liberoZoneId || p.id === secondLibero?.id)
+                    return undefined;
+                return p;
+            })();
+            if (preMatchReplacement == null && secondLiberoBackfill == null && inMatchDesignate == null)
+                return undefined;
+            return { preMatchReplacement, secondLiberoBackfill, inMatchDesignate };
         })()
     });
 }
@@ -319,6 +358,30 @@ function tacticsColumnsToApiDto(model) {
                 healed.push({ starterId: ir.starterId, replacementId: ir.replacementId, benchBackfillId });
             }
             return healed.length > 0 ? healed : undefined;
+        })(),
+        // Same stale-data policy for the libero-injury ids (ids only; roster membership is checked in the service
+        // heal). preMatchReplacement = reserve or the L2 (not in the lineup) + needs a starting libero;
+        // secondLiberoBackfill = a reserve (not the current L2) kept only when the L2 is the replacement;
+        // inMatchDesignate = a bench/reserve player (not a court starter, the libero, or the L2).
+        liberoInjury: (() => {
+            const li = model.libero_injury;
+            if (li == null)
+                return undefined;
+            const liberoZoneId = model.lineup[CourtPosition.LIBERO_ZONE];
+            const starterSlotIds = new Set([model.lineup[CourtPosition.LEFT_FRONT], model.lineup[CourtPosition.MIDDLE_FRONT],
+                model.lineup[CourtPosition.RIGHT_FRONT], model.lineup[CourtPosition.LEFT_BACK],
+                model.lineup[CourtPosition.MIDDLE_BACK], model.lineup[CourtPosition.RIGHT_BACK]]);
+            const reserveOrL2 = (id) => (id != null && !lineupIds.has(id)) ? id : undefined;
+            const preMatchReplacementId = liberoZoneId != null ? reserveOrL2(li.preMatchReplacementId) : undefined;
+            const secondLiberoBackfillId = (preMatchReplacementId != null && preMatchReplacementId === validSecondLibero)
+                ? (() => { const id = reserveOrL2(li.secondLiberoBackfillId); return id != null && id !== validSecondLibero ? id : undefined; })()
+                : undefined;
+            const designateEligible = li.inMatchDesignateId != null && !starterSlotIds.has(li.inMatchDesignateId) &&
+                li.inMatchDesignateId !== liberoZoneId && li.inMatchDesignateId !== validSecondLibero;
+            const inMatchDesignateId = designateEligible ? li.inMatchDesignateId : undefined;
+            if (preMatchReplacementId == null && secondLiberoBackfillId == null && inMatchDesignateId == null)
+                return undefined;
+            return { preMatchReplacementId, secondLiberoBackfillId, inMatchDesignateId };
         })()
     };
 }
@@ -354,7 +417,8 @@ function apiTacticsConfigToAttributes(config, teamId) {
         system_sets: config.systemSets,
         offensive_preference_sets: config.offensivePreferenceSets,
         replace_knocked_immediately: config.replaceKnockedImmediately,
-        injury_replacements: config.injuryReplacements
+        injury_replacements: config.injuryReplacements,
+        libero_injury: config.liberoInjury
     };
 }
 export { transformToObject as transformToTactics, transformToAttributes as transformFromTactics, tacticsColumnsToApiDto, apiTacticsConfigToAttributes as apiTacticsConfigToTacticsAttributes };

package/dist/esm/src/data/transformers/tactics.test.js

@@ -137,3 +137,47 @@ describe('per-set tactics — service <-> row round-trip', () => {
         expect(back.offensivePreferenceSets).toBeUndefined();
     });
 });
+describe('libero injuries — service <-> row round-trip + lenient heal', () => {
+    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 libero = makePlayer(country);
+    const l2 = makePlayer(country);
+    const reserveA = makePlayer(country);
+    const reserveB = makePlayer(country);
+    const roster = [p1, p2, p3, p4, p5, p6, libero, l2, reserveA, reserveB];
+    const tactics = Tactics.create({
+        lineup: { 4: p4, 3: p3, 2: p2, 5: p5, 6: p6, 1: p1, 0: libero, bench: [] },
+        liberoReplacements: [],
+        secondLibero: l2,
+        liberoInjury: { preMatchReplacement: l2, secondLiberoBackfill: reserveA, inMatchDesignate: reserveB }
+    });
+    it('writes libero_injury as id-based jsonb', () => {
+        const attrs = transformFromTactics(tactics, 'team-1');
+        expect(attrs.libero_injury).toEqual({
+            preMatchReplacementId: l2.id,
+            secondLiberoBackfillId: reserveA.id,
+            inMatchDesignateId: reserveB.id
+        });
+    });
+    it('resolves the stored libero_injury ids back to roster players', () => {
+        const attrs = transformFromTactics(tactics, 'team-1');
+        const back = transformToTactics(attrs, roster);
+        expect(back.liberoInjury?.preMatchReplacement?.id).toBe(l2.id);
+        expect(back.liberoInjury?.secondLiberoBackfill?.id).toBe(reserveA.id);
+        expect(back.liberoInjury?.inMatchDesignate?.id).toBe(reserveB.id);
+    });
+    it('drops a stale pre-match replacement that is now a court starter (lenient heal, no crash)', () => {
+        const attrs = transformFromTactics(tactics, 'team-1');
+        attrs.libero_injury.preMatchReplacementId = p2.id;
+        attrs.libero_injury.secondLiberoBackfillId = undefined;
+        const back = transformToTactics(attrs, roster);
+        expect(back.liberoInjury?.preMatchReplacement).toBeUndefined();
+        expect(back.liberoInjury?.secondLiberoBackfill).toBeUndefined();
+        expect(back.liberoInjury?.inMatchDesignate?.id).toBe(reserveB.id);
+    });
+});

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

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

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

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

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

@@ -0,0 +1,6 @@
+import { Player } from '../player';
+export interface LiberoInjuryConfig {
+    readonly preMatchReplacement?: Player;
+    readonly secondLiberoBackfill?: Player;
+    readonly inMatchDesignate?: Player;
+}

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

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

package/dist/esm/src/service/team/libero-sub.d.ts

@@ -1,8 +1,11 @@
 import { EnergyBand } from './energy-band';
-export type LiberoSubMode = 'NEVER' | 'FATIGUE' | 'ALWAYS';
+import { ConditionLogic, PinchCondition } from './pinch-condition';
+export type LiberoSubMode = 'NEVER' | 'FATIGUE' | 'ALWAYS' | 'CONDITIONS';
 export interface LiberoSetSubConfig {
     readonly mode: LiberoSubMode;
     readonly fatigueBand?: EnergyBand;
+    readonly conditions?: PinchCondition[];
+    readonly conditionLogic?: ConditionLogic;
 }
 export interface LiberoSubConfig extends LiberoSetSubConfig {
     readonly sets?: LiberoSetSubConfig[];