volleyballsimtypes 0.0.473 → 0.0.475

package/dist/esm/src/service/team/pinch-condition.d.ts

@@ -6,7 +6,12 @@ export declare enum PinchConditionType {
     AFTER_ROTATIONS = "AFTER_ROTATIONS",// from the team's Nth serve turn in the set onward
     FROM_SET = "FROM_SET",// only set N or later
     MIN_OWN_SCORE = "MIN_OWN_SCORE",// only once own score >= N
-    MIN_OPPONENT_SCORE = "MIN_OPPONENT_SCORE"
+    MIN_OPPONENT_SCORE = "MIN_OPPONENT_SCORE",// only once opponent score >= N
+    PHASE = "PHASE"
+}
+export declare enum MatchPhase {
+    SERVING = "SERVING",
+    RECEIVING = "RECEIVING"
 }
 export declare enum OpponentRelation {
     AHEAD = "AHEAD",
@@ -50,7 +55,11 @@ export interface MinOpponentScoreCondition {
     readonly type: PinchConditionType.MIN_OPPONENT_SCORE;
     readonly score: number;
 }
-export type PinchCondition = AsapCondition | TeamSetPointCondition | OpponentSetPointCondition | ScoreDiffCondition | AfterRotationsCondition | FromSetCondition | MinOwnScoreCondition | MinOpponentScoreCondition;
+export interface PhaseCondition {
+    readonly type: PinchConditionType.PHASE;
+    readonly phase: MatchPhase;
+}
+export type PinchCondition = AsapCondition | TeamSetPointCondition | OpponentSetPointCondition | ScoreDiffCondition | AfterRotationsCondition | FromSetCondition | MinOwnScoreCondition | MinOpponentScoreCondition | PhaseCondition;
 export type ConditionLogic = 'ALL' | 'ANY';
 export interface PinchSetState {
     readonly ownScore: number;
@@ -58,4 +67,5 @@ export interface PinchSetState {
     readonly setTarget: number;
     readonly setNumber: number;
     readonly ownServeTurns: number;
+    readonly phase: MatchPhase;
 }

package/dist/esm/src/service/team/pinch-condition.js

@@ -10,8 +10,16 @@ export var PinchConditionType;
     PinchConditionType["AFTER_ROTATIONS"] = "AFTER_ROTATIONS";
     PinchConditionType["FROM_SET"] = "FROM_SET";
     PinchConditionType["MIN_OWN_SCORE"] = "MIN_OWN_SCORE";
-    PinchConditionType["MIN_OPPONENT_SCORE"] = "MIN_OPPONENT_SCORE"; // only once opponent score >= N
+    PinchConditionType["MIN_OPPONENT_SCORE"] = "MIN_OPPONENT_SCORE";
+    PinchConditionType["PHASE"] = "PHASE"; // the team is serving or receiving this rally (used by the libero deployment rule)
 })(PinchConditionType || (PinchConditionType = {}));
+// Which side of the rally the team is on. Known at each dead ball: the serving team is SERVING, the other
+// RECEIVING. Consumed by the PHASE condition (libero deployment); pinch servers always evaluate while SERVING.
+export var MatchPhase;
+(function (MatchPhase) {
+    MatchPhase["SERVING"] = "SERVING";
+    MatchPhase["RECEIVING"] = "RECEIVING";
+})(MatchPhase || (MatchPhase = {}));
 export var OpponentRelation;
 (function (OpponentRelation) {
     OpponentRelation["AHEAD"] = "AHEAD";

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

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { Player } from '../../player';
 import { EnergyBand } from '../energy-band';
-import { OpponentRelation, PinchConditionType, ScoreDirection } from '../pinch-condition';
+import { MatchPhase, OpponentRelation, PinchConditionType, ScoreDirection } from '../pinch-condition';
 export declare const SubBandSchema: z.ZodUnion<readonly [z.ZodEnum<typeof EnergyBand>, z.ZodLiteral<"NEVER">]>;
 export declare const PinchConditionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<PinchConditionType.ASAP>;
@@ -28,6 +28,9 @@ export declare const PinchConditionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<PinchConditionType.MIN_OPPONENT_SCORE>;
     score: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<PinchConditionType.PHASE>;
+    phase: z.ZodEnum<typeof MatchPhase>;
 }, z.core.$strip>], "type">;
 export declare const ConditionLogicSchema: z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodLiteral<"ANY">]>;
 export declare const SubModeSchema: z.ZodEnum<{
@@ -69,6 +72,9 @@ export declare const SetSubConfigSchema: z.ZodObject<{
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<PinchConditionType.MIN_OPPONENT_SCORE>;
         score: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<PinchConditionType.PHASE>;
+        phase: z.ZodEnum<typeof MatchPhase>;
     }, z.core.$strip>], "type">>>;
     conditionLogic: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodLiteral<"ANY">]>>;
 }, z.core.$strip>;
@@ -107,6 +113,9 @@ export declare const DesignatedSubSchema: z.ZodObject<{
         }, z.core.$strip>, z.ZodObject<{
             type: z.ZodLiteral<PinchConditionType.MIN_OPPONENT_SCORE>;
             score: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<PinchConditionType.PHASE>;
+            phase: z.ZodEnum<typeof MatchPhase>;
         }, z.core.$strip>], "type">>>;
         conditionLogic: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodLiteral<"ANY">]>>;
     }, z.core.$strip>>>;
@@ -143,6 +152,9 @@ export declare const DesignatedSubSchema: z.ZodObject<{
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<PinchConditionType.MIN_OPPONENT_SCORE>;
         score: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<PinchConditionType.PHASE>;
+        phase: z.ZodEnum<typeof MatchPhase>;
     }, z.core.$strip>], "type">>>;
     conditionLogic: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodLiteral<"ANY">]>>;
     starter: z.ZodCustom<Player, Player>;

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

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { Player } from '../../player';
 import { EnergyBand } from '../energy-band';
-import { OpponentRelation, PinchConditionType, ScoreDirection } from '../pinch-condition';
+import { MatchPhase, OpponentRelation, PinchConditionType, ScoreDirection } from '../pinch-condition';
 const playerInstanceSchema = z.custom((v) => v instanceof Player, {
     message: 'INVALID_PLAYER_INSTANCE'
 });
@@ -14,7 +14,9 @@ export const PinchConditionSchema = z.discriminatedUnion('type', [
     z.object({ type: z.literal(PinchConditionType.AFTER_ROTATIONS), rotations: z.number().int().min(1).max(6) }),
     z.object({ type: z.literal(PinchConditionType.FROM_SET), set: z.number().int().min(1).max(5) }),
     z.object({ type: z.literal(PinchConditionType.MIN_OWN_SCORE), score: z.number().int().min(0).max(40) }),
-    z.object({ type: z.literal(PinchConditionType.MIN_OPPONENT_SCORE), score: z.number().int().min(0).max(40) })
+    z.object({ type: z.literal(PinchConditionType.MIN_OPPONENT_SCORE), score: z.number().int().min(0).max(40) }),
+    // PHASE is used by the libero deployment rule (which reuses this schema); pinch servers never offer it.
+    z.object({ type: z.literal(PinchConditionType.PHASE), phase: z.nativeEnum(MatchPhase) })
 ]);
 export const ConditionLogicSchema = z.union([z.literal('ALL'), z.literal('ANY')]);
 export const SubModeSchema = z.enum(['FATIGUE', 'PINCH', 'NEVER']);

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

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

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

@@ -0,0 +1,69 @@
+import { describe, it, expect } from '@jest/globals';
+import { TacticsInputSchema } from './tactics.z';
+import { makeCountry, makePlayer } from '../../test-helpers';
+describe('TacticsInputSchema — liberoInjury (owner 2026-07-06)', () => {
+    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 l2 = makePlayer(country); // second libero (a reserve)
+    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: [],
+            secondLibero: l2,
+            ...overrides
+        };
+    }
+    const hasIssue = (res, message) => !res.success && res.error.issues.some(i => i.message === message);
+    it('accepts no liberoInjury', () => {
+        expect(TacticsInputSchema.safeParse(baseInput()).success).toBe(true);
+    });
+    it('accepts a reserve as the pre-match libero replacement', () => {
+        expect(TacticsInputSchema.safeParse(baseInput({ liberoInjury: { preMatchReplacement: reserveA } })).success).toBe(true);
+    });
+    it('accepts the L2 as the replacement with a reserve backfill (new L2)', () => {
+        expect(TacticsInputSchema.safeParse(baseInput({ liberoInjury: { preMatchReplacement: l2, secondLiberoBackfill: reserveA } })).success).toBe(true);
+    });
+    it('rejects a starter / the libero / a bench player as the pre-match replacement', () => {
+        for (const bad of [p2, libero, benchA]) {
+            const res = TacticsInputSchema.safeParse(baseInput({ liberoInjury: { preMatchReplacement: bad } }));
+            expect(hasIssue(res, 'LIBERO_INJURY_REPLACEMENT_MUST_BE_RESERVE_OR_L2')).toBe(true);
+        }
+    });
+    it('rejects a pre-match replacement when there is no starting libero', () => {
+        const res = TacticsInputSchema.safeParse(baseInput({
+            lineup: { 4: p4, 3: p3, 2: p2, 5: p5, 6: p6, 1: p1, bench: [benchA, benchB] },
+            secondLibero: undefined,
+            liberoInjury: { preMatchReplacement: reserveA }
+        }));
+        expect(hasIssue(res, 'LIBERO_INJURY_REQUIRES_LIBERO')).toBe(true);
+    });
+    it('rejects a backfill when the replacement is not the L2', () => {
+        const res = TacticsInputSchema.safeParse(baseInput({ liberoInjury: { preMatchReplacement: reserveA, secondLiberoBackfill: reserveB } }));
+        expect(hasIssue(res, 'LIBERO_BACKFILL_REQUIRES_L2_REPLACEMENT')).toBe(true);
+    });
+    it('rejects a non-reserve backfill (bench player) even when the L2 is the replacement', () => {
+        const res = TacticsInputSchema.safeParse(baseInput({ liberoInjury: { preMatchReplacement: l2, secondLiberoBackfill: benchA } }));
+        expect(hasIssue(res, 'LIBERO_BACKFILL_MUST_BE_RESERVE')).toBe(true);
+    });
+    it('accepts a bench or reserve player as the in-match designate', () => {
+        for (const ok of [benchA, reserveA]) {
+            expect(TacticsInputSchema.safeParse(baseInput({ liberoInjury: { inMatchDesignate: ok } })).success).toBe(true);
+        }
+    });
+    it('rejects a starter / the libero / the L2 as the in-match designate', () => {
+        for (const bad of [p2, libero, l2]) {
+            const res = TacticsInputSchema.safeParse(baseInput({ liberoInjury: { inMatchDesignate: bad } }));
+            expect(hasIssue(res, 'LIBERO_DESIGNATE_MUST_BE_BENCH_OR_RESERVE')).toBe(true);
+        }
+    });
+});

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

@@ -4,14 +4,46 @@ export declare const LiberoSubModeSchema: z.ZodEnum<{
     NEVER: "NEVER";
     FATIGUE: "FATIGUE";
     ALWAYS: "ALWAYS";
+    CONDITIONS: "CONDITIONS";
 }>;
 export declare const LiberoSetSubConfigSchema: z.ZodObject<{
     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>;
 export declare const LiberoSubConfigSchema: z.ZodObject<{
     sets: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -19,13 +51,75 @@ export declare const LiberoSubConfigSchema: 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>;

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

@@ -1,17 +1,34 @@
 import { z } from 'zod';
 import { EnergyBand } from '../energy-band';
-export const LiberoSubModeSchema = z.enum(['NEVER', 'FATIGUE', 'ALWAYS']);
-// Fields shared by the all-sets config and each per-set config. Unlike a designated sub there is no bench or
-// pinch condition here (the swapped-in player is always the dedicated `secondLibero`), so there is nothing to
-// cross-validate.
+import { ConditionLogicSchema, PinchConditionSchema } from './designated-sub.z';
+export const LiberoSubModeSchema = z.enum(['NEVER', 'FATIGUE', 'ALWAYS', 'CONDITIONS']);
+// Fields shared by the all-sets config and each per-set config. The swapped-in player is always the dedicated
+// `secondLibero`, so there is no bench to validate; the CONDITIONS mode reuses the pinch-server condition
+// catalog (PinchConditionSchema, which includes the libero-only PHASE condition) + ALL/ANY logic.
 const liberoSetSubConfigShape = {
     mode: LiberoSubModeSchema,
     // fatigue mode only (absent => the team default `substitutionBand`):
-    fatigueBand: z.nativeEnum(EnergyBand).optional()
+    fatigueBand: z.nativeEnum(EnergyBand).optional(),
+    // conditions mode only:
+    conditions: z.array(PinchConditionSchema).optional(),
+    conditionLogic: ConditionLogicSchema.optional()
 };
-export const LiberoSetSubConfigSchema = z.object(liberoSetSubConfigShape);
+// CONDITIONS mode needs at least one condition (mirrors the designated-sub pinch refine).
+function refineConditions(data, ctx) {
+    if (data.mode !== 'CONDITIONS')
+        return;
+    if (data.conditions == null || data.conditions.length === 0) {
+        ctx.addIssue({ code: 'custom', message: 'LIBERO_CONDITIONS_REQUIRE_A_CONDITION', path: ['conditions'] });
+    }
+}
+export const LiberoSetSubConfigSchema = z.object(liberoSetSubConfigShape).superRefine(refineConditions);
 export const LiberoSubConfigSchema = z.object({
     ...liberoSetSubConfigShape,
     // Optional per-set overrides (index 0 = set 1 ... index 4 = set 5); absent => the flat config for all sets.
     sets: z.array(LiberoSetSubConfigSchema).max(5).optional()
+}).superRefine((data, ctx) => {
+    // The flat config is the fallback for any set a partial `sets` array doesn't cover, so validate it whenever
+    // `sets` is absent or covers fewer than 5 sets (each present per-set config is validated by its own schema).
+    if (data.sets == null || data.sets.length < 5)
+        refineConditions(data, ctx);
 });

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

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

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

@@ -87,7 +87,17 @@ export const TacticsInputSchema = 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: 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).
@@ -229,4 +239,34 @@ export const TacticsInputSchema = 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'] });
+        }
+    }
 });