volleyballsimtypes 0.0.471 → 0.0.474

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

@@ -114,6 +114,8 @@ export interface ApiInjuryReplacement {
 export interface ApiLiberoSetSubConfig {
     mode: LiberoSubMode;
     fatigueBand?: EnergyBand;
+    conditions?: PinchCondition[];
+    conditionLogic?: ConditionLogic;
 }
 export interface ApiLiberoSubConfig extends ApiLiberoSetSubConfig {
     sets?: ApiLiberoSetSubConfig[];

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

@@ -47,6 +47,8 @@ export interface InjuryReplacementAttributes {
 export interface LiberoSetSubConfigAttributes {
     mode: LiberoSubMode;
     fatigueBand?: EnergyBand;
+    conditions?: PinchCondition[];
+    conditionLogic?: ConditionLogic;
 }
 export interface LiberoSubConfigAttributes extends LiberoSetSubConfigAttributes {
     sets?: LiberoSetSubConfigAttributes[];

package/dist/cjs/src/data/transformers/rally-event-injury.test.js

@@ -76,6 +76,33 @@ const rally_event_1 = require("./rally-event");
         const decoded = (0, rally_event_1.transformToSpike)(legacy, roster);
         (0, globals_1.expect)(decoded.incident).toBeUndefined();
     });
+    (0, globals_1.it)('packs a non-actor blocker incident with the hurt player under h and round-trips it', () => {
+        const lead = (0, uuid_1.v4)();
+        const helper = (0, uuid_1.v4)();
+        const blockRoster = [lead, helper];
+        const blockIndex = new Map(blockRoster.map((id, i) => [id, i]));
+        const block = service_1.Block.create({
+            playerId: lead,
+            blockers: [lead, helper],
+            score: 48,
+            target: 8,
+            failure: service_1.BlockFailureEnum.NO_FAILURE,
+            type: service_1.BlockTypeEnum.DOUBLE,
+            incident: { kind: 'KNOCK', severity: 3, playerId: helper }
+        });
+        const compact = (0, rally_event_1.transformToCompact)(block, blockIndex);
+        (0, globals_1.expect)(compact.i).toBe(13);
+        (0, globals_1.expect)(compact.h).toBe(1);
+        const decoded = (0, rally_event_1.transformToBlock)(compact, blockRoster);
+        (0, globals_1.expect)(decoded.incident).toEqual({ kind: 'KNOCK', severity: 3, playerId: helper });
+    });
+    (0, globals_1.it)('omits h when the hurt player IS the event actor', () => {
+        const compact = (0, rally_event_1.transformToCompact)(makeSpike({ kind: 'INJURY', severity: 2, playerId }), playerIndex);
+        (0, globals_1.expect)(compact.i).toBe(2);
+        (0, globals_1.expect)('h' in compact).toBe(false);
+        const decoded = (0, rally_event_1.transformToSpike)(compact, roster);
+        (0, globals_1.expect)(decoded.incident).toEqual({ kind: 'INJURY', severity: 2 });
+    });
     (0, globals_1.it)('rejects an out-of-range or malformed incident at the schema', () => {
         (0, globals_1.expect)(() => makeSpike({ kind: 'INJURY', severity: 5 })).toThrow(/INVALID_SPIKE/);
         (0, globals_1.expect)(() => makeSpike({ kind: 'INJURY', severity: 0 })).toThrow(/INVALID_SPIKE/);

package/dist/cjs/src/data/transformers/rally-event.d.ts

@@ -11,6 +11,7 @@ export interface CompactEvent {
     o?: number;
     j?: number;
     i?: number;
+    h?: number;
 }
 export declare function transformToCompact(evt: RallyEvent, playerIndex: Map<string, number>): CompactEvent;
 export declare function transformToBlock(event: CompactEvent, roster: string[]): Block;

package/dist/cjs/src/data/transformers/rally-event.js

@@ -15,10 +15,14 @@ function incidentToCompact(incident) {
         return undefined;
     return incident.kind === 'KNOCK' ? 10 + incident.severity : incident.severity;
 }
-function incidentFromCompact(i) {
+function incidentFromCompact(i, h, roster) {
     if (i == null)
         return undefined;
-    return i >= 10 ? { kind: 'KNOCK', severity: i - 10 } : { kind: 'INJURY', severity: i };
+    const playerId = h != null && roster != null ? roster[h] : undefined;
+    return {
+        ...(i >= 10 ? { kind: 'KNOCK', severity: i - 10 } : { kind: 'INJURY', severity: i }),
+        ...(playerId != null ? { playerId } : {})
+    };
 }
 function transformToCompact(evt, playerIndex) {
     const out = {
@@ -31,8 +35,12 @@ function transformToCompact(evt, playerIndex) {
         out.a = evt.target;
         out.s = evt.score;
         const i = incidentToCompact(evt.incident);
-        if (i != null)
+        if (i != null) {
             out.i = i;
+            if (evt.incident?.playerId != null && evt.incident.playerId !== evt.playerId) {
+                out.h = playerIndex.get(evt.incident.playerId);
+            }
+        }
         if (evt instanceof service_1.Block) {
             out.b = evt.blockers.map(id => playerIndex.get(id));
         }
@@ -56,7 +64,7 @@ function transformToBlock(event, roster) {
         target: event.a,
         blockers: (event.b ?? []).map(i => roster[i]),
         score: event.s,
-        incident: incidentFromCompact(event.i)
+        incident: incidentFromCompact(event.i, event.h, roster)
     });
 }
 function transformToLiberoReplacement(event, roster) {
@@ -73,7 +81,7 @@ function transformToReception(event, roster) {
         playerId: roster[event.p],
         target: event.a,
         score: event.s,
-        incident: incidentFromCompact(event.i)
+        incident: incidentFromCompact(event.i, event.h, roster)
     });
 }
 function transformToServe(event, roster) {
@@ -83,7 +91,7 @@ function transformToServe(event, roster) {
         playerId: roster[event.p],
         target: event.a,
         score: event.s,
-        incident: incidentFromCompact(event.i)
+        incident: incidentFromCompact(event.i, event.h, roster)
     });
 }
 function transformToSet(event, roster) {
@@ -93,7 +101,7 @@ function transformToSet(event, roster) {
         playerId: roster[event.p],
         target: event.a,
         score: event.s,
-        incident: incidentFromCompact(event.i)
+        incident: incidentFromCompact(event.i, event.h, roster)
     });
 }
 function transformToSpike(event, roster) {
@@ -103,7 +111,7 @@ function transformToSpike(event, roster) {
         playerId: roster[event.p],
         target: event.a,
         score: event.s,
-        incident: incidentFromCompact(event.i)
+        incident: incidentFromCompact(event.i, event.h, roster)
     });
 }
 function transformToSubstitution(event, roster) {

package/dist/cjs/src/service/event/in-play-event.d.ts

@@ -4,6 +4,7 @@ import { Trait } from '../player';
 export interface EventIncident {
     readonly kind: 'KNOCK' | 'INJURY';
     readonly severity: number;
+    readonly playerId?: string;
 }
 export interface InPlayEventOpts extends RallyEventOpts {
     readonly target: CourtTarget;

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

@@ -33,6 +33,7 @@ export declare const BlockInputSchema: z.ZodObject<{
             INJURY: "INJURY";
         }>;
         severity: z.ZodNumber;
+        playerId: z.ZodOptional<z.ZodUUID>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type BlockInput = z.infer<typeof BlockInputSchema>;

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

@@ -5,5 +5,6 @@ export declare const EventIncidentSchema: z.ZodObject<{
         INJURY: "INJURY";
     }>;
     severity: z.ZodNumber;
+    playerId: z.ZodOptional<z.ZodUUID>;
 }, z.core.$strip>;
 export type EventIncidentInput = z.infer<typeof EventIncidentSchema>;

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

@@ -7,5 +7,8 @@ const zod_1 = require("zod");
 // InjurySeverityEnum value (1-4).
 exports.EventIncidentSchema = zod_1.z.object({
     kind: zod_1.z.enum(['KNOCK', 'INJURY']),
-    severity: zod_1.z.number().int().min(1).max(4)
+    severity: zod_1.z.number().int().min(1).max(4),
+    // Who got hurt, ONLY when it is not the event's actor (a secondary blocker on a multi-player block);
+    // absent = the event's own playerId.
+    playerId: zod_1.z.uuid().optional()
 }).refine(v => v.kind !== 'KNOCK' || v.severity <= 3, { message: 'INVALID_KNOCK_TIER' });

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

@@ -32,6 +32,7 @@ export declare const ReceptionInputSchema: z.ZodObject<{
             INJURY: "INJURY";
         }>;
         severity: z.ZodNumber;
+        playerId: z.ZodOptional<z.ZodUUID>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type ReceptionInput = z.infer<typeof ReceptionInputSchema>;

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

@@ -32,6 +32,7 @@ export declare const ServeInputSchema: z.ZodObject<{
             INJURY: "INJURY";
         }>;
         severity: z.ZodNumber;
+        playerId: z.ZodOptional<z.ZodUUID>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type ServeInput = z.infer<typeof ServeInputSchema>;

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

@@ -32,6 +32,7 @@ export declare const SetInputSchema: z.ZodObject<{
             INJURY: "INJURY";
         }>;
         severity: z.ZodNumber;
+        playerId: z.ZodOptional<z.ZodUUID>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type SetInput = z.infer<typeof SetInputSchema>;

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

@@ -32,6 +32,7 @@ export declare const SpikeInputSchema: z.ZodObject<{
             INJURY: "INJURY";
         }>;
         severity: z.ZodNumber;
+        playerId: z.ZodOptional<z.ZodUUID>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type SpikeInput = z.infer<typeof SpikeInputSchema>;

package/dist/cjs/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[];

package/dist/cjs/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/cjs/src/service/team/pinch-condition.js

@@ -3,7 +3,7 @@
 // wins back the serve, out the moment the serve is lost). Each condition is evaluated against the live set
 // state; a pinch entry combines them with ALL (every condition must hold) or ANY (one is enough).
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ScoreDirection = exports.OpponentRelation = exports.PinchConditionType = void 0;
+exports.ScoreDirection = exports.OpponentRelation = exports.MatchPhase = exports.PinchConditionType = void 0;
 var PinchConditionType;
 (function (PinchConditionType) {
     PinchConditionType["ASAP"] = "ASAP";
@@ -13,8 +13,16 @@ 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 || (exports.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.
+var MatchPhase;
+(function (MatchPhase) {
+    MatchPhase["SERVING"] = "SERVING";
+    MatchPhase["RECEIVING"] = "RECEIVING";
+})(MatchPhase || (exports.MatchPhase = MatchPhase = {}));
 var OpponentRelation;
 (function (OpponentRelation) {
     OpponentRelation["AHEAD"] = "AHEAD";

package/dist/cjs/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/cjs/src/service/team/schemas/designated-sub.z.js

@@ -17,7 +17,9 @@ exports.PinchConditionSchema = zod_1.z.discriminatedUnion('type', [
     zod_1.z.object({ type: zod_1.z.literal(pinch_condition_1.PinchConditionType.AFTER_ROTATIONS), rotations: zod_1.z.number().int().min(1).max(6) }),
     zod_1.z.object({ type: zod_1.z.literal(pinch_condition_1.PinchConditionType.FROM_SET), set: zod_1.z.number().int().min(1).max(5) }),
     zod_1.z.object({ type: zod_1.z.literal(pinch_condition_1.PinchConditionType.MIN_OWN_SCORE), score: zod_1.z.number().int().min(0).max(40) }),
-    zod_1.z.object({ type: zod_1.z.literal(pinch_condition_1.PinchConditionType.MIN_OPPONENT_SCORE), score: zod_1.z.number().int().min(0).max(40) })
+    zod_1.z.object({ type: zod_1.z.literal(pinch_condition_1.PinchConditionType.MIN_OPPONENT_SCORE), score: zod_1.z.number().int().min(0).max(40) }),
+    // PHASE is used by the libero deployment rule (which reuses this schema); pinch servers never offer it.
+    zod_1.z.object({ type: zod_1.z.literal(pinch_condition_1.PinchConditionType.PHASE), phase: zod_1.z.nativeEnum(pinch_condition_1.MatchPhase) })
 ]);
 exports.ConditionLogicSchema = zod_1.z.union([zod_1.z.literal('ALL'), zod_1.z.literal('ANY')]);
 exports.SubModeSchema = zod_1.z.enum(['FATIGUE', 'PINCH', 'NEVER']);

package/dist/cjs/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/cjs/src/service/team/schemas/libero-sub.z.js

@@ -3,18 +3,35 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LiberoSubConfigSchema = exports.LiberoSetSubConfigSchema = exports.LiberoSubModeSchema = void 0;
 const zod_1 = require("zod");
 const energy_band_1 = require("../energy-band");
-exports.LiberoSubModeSchema = zod_1.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.
+const designated_sub_z_1 = require("./designated-sub.z");
+exports.LiberoSubModeSchema = zod_1.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: exports.LiberoSubModeSchema,
     // fatigue mode only (absent => the team default `substitutionBand`):
-    fatigueBand: zod_1.z.nativeEnum(energy_band_1.EnergyBand).optional()
+    fatigueBand: zod_1.z.nativeEnum(energy_band_1.EnergyBand).optional(),
+    // conditions mode only:
+    conditions: zod_1.z.array(designated_sub_z_1.PinchConditionSchema).optional(),
+    conditionLogic: designated_sub_z_1.ConditionLogicSchema.optional()
 };
-exports.LiberoSetSubConfigSchema = zod_1.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'] });
+    }
+}
+exports.LiberoSetSubConfigSchema = zod_1.z.object(liberoSetSubConfigShape).superRefine(refineConditions);
 exports.LiberoSubConfigSchema = zod_1.z.object({
     ...liberoSetSubConfigShape,
     // Optional per-set overrides (index 0 = set 1 ... index 4 = set 5); absent => the flat config for all sets.
     sets: zod_1.z.array(exports.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/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', () => {