volleyballsimtypes 0.0.471 → 0.0.474

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>>;

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>>;

package/dist/esm/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/esm/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/esm/src/data/transformers/rally-event-injury.test.js

@@ -1,7 +1,7 @@
 import { describe, it, expect } from '@jest/globals';
 import { v4 as uuidv4 } from 'uuid';
-import { EventTypeEnum, Serve, ServeFailureEnum, ServeTypeEnum, Spike, SpikeFailureEnum, SpikeTypeEnum, Substitution } from '../../service';
-import { transformToCompact, transformToServe, transformToSpike, transformToSubstitution } from './rally-event';
+import { Block, BlockFailureEnum, BlockTypeEnum, EventTypeEnum, Serve, ServeFailureEnum, ServeTypeEnum, Spike, SpikeFailureEnum, SpikeTypeEnum, Substitution } from '../../service';
+import { transformToBlock, transformToCompact, transformToServe, transformToSpike, transformToSubstitution } from './rally-event';
 describe('rally-event compact round trip — injury substitution marker', () => {
     const playerIn = uuidv4();
     const playerOut = uuidv4();
@@ -74,6 +74,33 @@ describe('rally-event compact round trip — incident marker on the causing even
         const decoded = transformToSpike(legacy, roster);
         expect(decoded.incident).toBeUndefined();
     });
+    it('packs a non-actor blocker incident with the hurt player under h and round-trips it', () => {
+        const lead = uuidv4();
+        const helper = uuidv4();
+        const blockRoster = [lead, helper];
+        const blockIndex = new Map(blockRoster.map((id, i) => [id, i]));
+        const block = Block.create({
+            playerId: lead,
+            blockers: [lead, helper],
+            score: 48,
+            target: 8,
+            failure: BlockFailureEnum.NO_FAILURE,
+            type: BlockTypeEnum.DOUBLE,
+            incident: { kind: 'KNOCK', severity: 3, playerId: helper }
+        });
+        const compact = transformToCompact(block, blockIndex);
+        expect(compact.i).toBe(13);
+        expect(compact.h).toBe(1);
+        const decoded = transformToBlock(compact, blockRoster);
+        expect(decoded.incident).toEqual({ kind: 'KNOCK', severity: 3, playerId: helper });
+    });
+    it('omits h when the hurt player IS the event actor', () => {
+        const compact = transformToCompact(makeSpike({ kind: 'INJURY', severity: 2, playerId }), playerIndex);
+        expect(compact.i).toBe(2);
+        expect('h' in compact).toBe(false);
+        const decoded = transformToSpike(compact, roster);
+        expect(decoded.incident).toEqual({ kind: 'INJURY', severity: 2 });
+    });
     it('rejects an out-of-range or malformed incident at the schema', () => {
         expect(() => makeSpike({ kind: 'INJURY', severity: 5 })).toThrow(/INVALID_SPIKE/);
         expect(() => makeSpike({ kind: 'INJURY', severity: 0 })).toThrow(/INVALID_SPIKE/);

package/dist/esm/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/esm/src/data/transformers/rally-event.js

@@ -5,10 +5,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 } : {})
+    };
 }
 export function transformToCompact(evt, playerIndex) {
     const out = {
@@ -21,8 +25,12 @@ export 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 Block) {
             out.b = evt.blockers.map(id => playerIndex.get(id));
         }
@@ -46,7 +54,7 @@ export 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)
     });
 }
 export function transformToLiberoReplacement(event, roster) {
@@ -63,7 +71,7 @@ export 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)
     });
 }
 export function transformToServe(event, roster) {
@@ -73,7 +81,7 @@ export 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)
     });
 }
 export function transformToSet(event, roster) {
@@ -83,7 +91,7 @@ export 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)
     });
 }
 export function transformToSpike(event, roster) {
@@ -93,7 +101,7 @@ export 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)
     });
 }
 export function transformToSubstitution(event, roster) {

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

@@ -4,5 +4,8 @@ import { z } from 'zod';
 // InjurySeverityEnum value (1-4).
 export const EventIncidentSchema = z.object({
     kind: z.enum(['KNOCK', 'INJURY']),
-    severity: z.number().int().min(1).max(4)
+    severity: 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: z.uuid().optional()
 }).refine(v => v.kind !== 'KNOCK' || v.severity <= 3, { message: 'INVALID_KNOCK_TIER' });

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

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']);