volleyballsimtypes 0.0.476 → 0.0.478

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

@@ -1,7 +1,7 @@
 import * as Sequelize from 'sequelize';
 import { Model, Optional } from 'sequelize';
 import { PlayerId, TeamId, TeamModel } from '.';
-import { ConditionLogic, CourtPosition, EnergyBand, LiberoSubMode, PinchCondition, RotationSystemEnum, SubBand, SubMode } from '../../service';
+import { ConditionLogic, CourtPosition, EnergyBand, LiberoSubMode, PinchCondition, RotationSystemEnum, SubBackMode, SubBand, SubMode } from '../../service';
 export interface TacticsLineupAttributes {
     [CourtPosition.LIBERO_ZONE]?: PlayerId;
     [CourtPosition.LEFT_BACK]: PlayerId;
@@ -19,6 +19,10 @@ export interface SetSubConfigAttributes {
     benchFatigueBand?: EnergyBand;
     conditions?: PinchCondition[];
     conditionLogic?: ConditionLogic;
+    pinchServer?: boolean;
+    subBackMode?: SubBackMode;
+    subBackConditions?: PinchCondition[];
+    subBackConditionLogic?: ConditionLogic;
 }
 export interface DesignatedSubAttributes {
     starterId: PlayerId;
@@ -29,6 +33,10 @@ export interface DesignatedSubAttributes {
     benchFatigueBand?: EnergyBand;
     conditions?: PinchCondition[];
     conditionLogic?: ConditionLogic;
+    pinchServer?: boolean;
+    subBackMode?: SubBackMode;
+    subBackConditions?: PinchCondition[];
+    subBackConditionLogic?: ConditionLogic;
     sets?: SetSubConfigAttributes[];
 }
 export interface OffensivePreferenceAttributes {

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

@@ -11,6 +11,12 @@ function subModeFromAttributes(d) {
         return 'NEVER';
     return 'FATIGUE';
 }
+// pinchServer only applies to PINCH ("Conditions") mode. A LEGACY PINCH row (no flag) defaults to true so
+// existing pinch servers keep serve-and-return behavior; a new conditional sub persists an explicit false. This
+// default must resolve identically on every READ path (both transformToObject and tacticsColumnsToApiDto).
+function effectivePinchServer(mode, pinchServer) {
+    return mode === 'PINCH' ? (pinchServer ?? true) : undefined;
+}
 function findPlayer(id, roster) {
     const player = roster.find((p) => p.id === id);
     if (player == null)
@@ -59,13 +65,21 @@ function transformToAttributes(tactics, teamId) {
             benchFatigueBand: ds.benchFatigueBand,
             conditions: ds.conditions,
             conditionLogic: ds.conditionLogic,
+            pinchServer: ds.pinchServer,
+            subBackMode: ds.subBackMode,
+            subBackConditions: ds.subBackConditions,
+            subBackConditionLogic: ds.subBackConditionLogic,
             sets: ds.sets?.map(s => ({
                 mode: s.mode,
                 benchId: s.bench?.id,
                 fatigueBand: s.fatigueBand,
                 benchFatigueBand: s.benchFatigueBand,
                 conditions: s.conditions,
-                conditionLogic: s.conditionLogic
+                conditionLogic: s.conditionLogic,
+                pinchServer: s.pinchServer,
+                subBackMode: s.subBackMode,
+                subBackConditions: s.subBackConditions,
+                subBackConditionLogic: s.subBackConditionLogic
             }))
         })),
         rotation_system: tactics.rotationSystem,
@@ -149,13 +163,21 @@ function transformToObject(model, roster) {
             benchFatigueBand: d.benchFatigueBand,
             conditions: d.conditions,
             conditionLogic: d.conditionLogic,
+            pinchServer: effectivePinchServer(subModeFromAttributes(d), d.pinchServer),
+            subBackMode: d.subBackMode,
+            subBackConditions: d.subBackConditions,
+            subBackConditionLogic: d.subBackConditionLogic,
             sets: d.sets?.map(s => ({
                 mode: s.mode,
                 bench: s.benchId != null ? findPlayer(s.benchId, roster) : undefined,
                 fatigueBand: s.fatigueBand,
                 benchFatigueBand: s.benchFatigueBand,
                 conditions: s.conditions,
-                conditionLogic: s.conditionLogic
+                conditionLogic: s.conditionLogic,
+                pinchServer: effectivePinchServer(s.mode, s.pinchServer),
+                subBackMode: s.subBackMode,
+                subBackConditions: s.subBackConditions,
+                subBackConditionLogic: s.subBackConditionLogic
             }))
         })),
         rotationSystem: model.rotation_system,
@@ -306,13 +328,21 @@ function tacticsColumnsToApiDto(model) {
             benchFatigueBand: d.benchFatigueBand,
             conditions: d.conditions,
             conditionLogic: d.conditionLogic,
+            pinchServer: effectivePinchServer(subModeFromAttributes(d), d.pinchServer),
+            subBackMode: d.subBackMode,
+            subBackConditions: d.subBackConditions,
+            subBackConditionLogic: d.subBackConditionLogic,
             sets: d.sets?.map(s => ({
                 mode: s.mode,
                 benchId: s.benchId,
                 fatigueBand: s.fatigueBand,
                 benchFatigueBand: s.benchFatigueBand,
                 conditions: s.conditions,
-                conditionLogic: s.conditionLogic
+                conditionLogic: s.conditionLogic,
+                pinchServer: effectivePinchServer(s.mode, s.pinchServer),
+                subBackMode: s.subBackMode,
+                subBackConditions: s.subBackConditions,
+                subBackConditionLogic: s.subBackConditionLogic
             }))
         })),
         rotationSystem: model.rotation_system,

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

@@ -58,6 +58,37 @@ describe('tacticsColumnsToApiDto()', () => {
         expect(dto.designatedSubs[0].fatigueBand).toBe(EnergyBand.WORN);
         expect(dto.designatedSubs[0].benchFatigueBand).toBe(EnergyBand.TIRED);
     });
+    it('defaults a legacy PINCH row (no pinchServer flag) to pinchServer true', () => {
+        const dto = tacticsColumnsToApiDto(makeTactics([
+            { starterId: 's1', benchId: 'b1', mode: 'PINCH', conditions: [{ type: 'ASAP' }] }
+        ]));
+        expect(dto.designatedSubs[0].pinchServer).toBe(true);
+    });
+    it('leaves pinchServer undefined for a non-PINCH row', () => {
+        const dto = tacticsColumnsToApiDto(makeTactics([
+            { starterId: 's1', benchId: 'b1', mode: 'FATIGUE', fatigueBand: EnergyBand.TIRED }
+        ]));
+        expect(dto.designatedSubs[0].pinchServer).toBeUndefined();
+    });
+    it('passes a conditional regular sub (pinchServer false + condition sub-back) through unchanged', () => {
+        const dto = tacticsColumnsToApiDto(makeTactics([
+            {
+                starterId: 's1',
+                benchId: 'b1',
+                mode: 'PINCH',
+                conditions: [{ type: 'SCORE_DIFF', direction: 'TRAILING', points: 3 }],
+                pinchServer: false,
+                subBackMode: 'CONDITIONS',
+                subBackConditions: [{ type: 'TEAM_SET_POINT', margin: 2, opponent: 'EITHER' }],
+                subBackConditionLogic: 'ANY'
+            }
+        ]));
+        const ds = dto.designatedSubs[0];
+        expect(ds.pinchServer).toBe(false);
+        expect(ds.subBackMode).toBe('CONDITIONS');
+        expect(ds.subBackConditions).toEqual([{ type: 'TEAM_SET_POINT', margin: 2, opponent: 'EITHER' }]);
+        expect(ds.subBackConditionLogic).toBe('ANY');
+    });
     it('drops a second libero that collides with the starting libero (not a reserve)', () => {
         const model = makeTactics([]);
         model.lineup[CourtPosition.LIBERO_ZONE] = 'libero1';

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

@@ -1,6 +1,7 @@
 import { Player } from '../player';
 import { EnergyBand, SubMode } from './energy-band';
 import { ConditionLogic, PinchCondition } from './pinch-condition';
+export type SubBackMode = 'FATIGUE' | 'CONDITIONS';
 export interface SetSubConfig {
     readonly mode: SubMode;
     readonly bench?: Player;
@@ -8,6 +9,10 @@ export interface SetSubConfig {
     readonly benchFatigueBand?: EnergyBand;
     readonly conditions?: PinchCondition[];
     readonly conditionLogic?: ConditionLogic;
+    readonly pinchServer?: boolean;
+    readonly subBackMode?: SubBackMode;
+    readonly subBackConditions?: PinchCondition[];
+    readonly subBackConditionLogic?: ConditionLogic;
 }
 export interface DesignatedSub extends SetSubConfig {
     readonly starter: Player;

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

@@ -22,6 +22,10 @@ export declare enum ScoreDirection {
     TRAILING = "TRAILING",
     LEADING = "LEADING"
 }
+export declare enum Comparison {
+    AT_LEAST = "AT_LEAST",
+    AT_MOST = "AT_MOST"
+}
 export interface AsapCondition {
     readonly type: PinchConditionType.ASAP;
 }
@@ -38,6 +42,7 @@ export interface ScoreDiffCondition {
     readonly type: PinchConditionType.SCORE_DIFF;
     readonly direction: ScoreDirection;
     readonly points: number;
+    readonly comparison?: Comparison;
 }
 export interface AfterRotationsCondition {
     readonly type: PinchConditionType.AFTER_ROTATIONS;
@@ -50,10 +55,12 @@ export interface FromSetCondition {
 export interface MinOwnScoreCondition {
     readonly type: PinchConditionType.MIN_OWN_SCORE;
     readonly score: number;
+    readonly comparison?: Comparison;
 }
 export interface MinOpponentScoreCondition {
     readonly type: PinchConditionType.MIN_OPPONENT_SCORE;
     readonly score: number;
+    readonly comparison?: Comparison;
 }
 export interface PhaseCondition {
     readonly type: PinchConditionType.PHASE;

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

@@ -31,3 +31,12 @@ export var ScoreDirection;
     ScoreDirection["TRAILING"] = "TRAILING";
     ScoreDirection["LEADING"] = "LEADING";
 })(ScoreDirection || (ScoreDirection = {}));
+// Comparison direction for a numeric-threshold condition (SCORE_DIFF / MIN_OWN_SCORE / MIN_OPPONENT_SCORE).
+// AT_LEAST ("Or more", value >= threshold) is the default when absent, so every existing stored condition keeps
+// its `>=` behavior. AT_MOST ("Or less", value <= threshold) lets a rule fire as a value SHRINKS (e.g. a sub-back
+// once "Leading by 2 or less" holds, instead of the always-implied "Leading by 2 or more").
+export var Comparison;
+(function (Comparison) {
+    Comparison["AT_LEAST"] = "AT_LEAST";
+    Comparison["AT_MOST"] = "AT_MOST";
+})(Comparison || (Comparison = {}));

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 { MatchPhase, OpponentRelation, PinchConditionType, ScoreDirection } from '../pinch-condition';
+import { Comparison, 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>;
@@ -16,6 +16,7 @@ export declare const PinchConditionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
     type: z.ZodLiteral<PinchConditionType.SCORE_DIFF>;
     direction: z.ZodEnum<typeof ScoreDirection>;
     points: z.ZodNumber;
+    comparison: z.ZodOptional<z.ZodEnum<typeof Comparison>>;
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<PinchConditionType.AFTER_ROTATIONS>;
     rotations: z.ZodNumber;
@@ -25,9 +26,11 @@ export declare const PinchConditionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<PinchConditionType.MIN_OWN_SCORE>;
     score: z.ZodNumber;
+    comparison: z.ZodOptional<z.ZodEnum<typeof Comparison>>;
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<PinchConditionType.MIN_OPPONENT_SCORE>;
     score: z.ZodNumber;
+    comparison: z.ZodOptional<z.ZodEnum<typeof Comparison>>;
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<PinchConditionType.PHASE>;
     phase: z.ZodEnum<typeof MatchPhase>;
@@ -38,6 +41,10 @@ export declare const SubModeSchema: z.ZodEnum<{
     FATIGUE: "FATIGUE";
     PINCH: "PINCH";
 }>;
+export declare const SubBackModeSchema: z.ZodEnum<{
+    FATIGUE: "FATIGUE";
+    CONDITIONS: "CONDITIONS";
+}>;
 export declare const SetSubConfigSchema: z.ZodObject<{
     mode: z.ZodEnum<{
         NEVER: "NEVER";
@@ -60,6 +67,7 @@ export declare const SetSubConfigSchema: z.ZodObject<{
         type: z.ZodLiteral<PinchConditionType.SCORE_DIFF>;
         direction: z.ZodEnum<typeof ScoreDirection>;
         points: z.ZodNumber;
+        comparison: z.ZodOptional<z.ZodEnum<typeof Comparison>>;
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<PinchConditionType.AFTER_ROTATIONS>;
         rotations: z.ZodNumber;
@@ -69,14 +77,54 @@ export declare const SetSubConfigSchema: z.ZodObject<{
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<PinchConditionType.MIN_OWN_SCORE>;
         score: z.ZodNumber;
+        comparison: z.ZodOptional<z.ZodEnum<typeof Comparison>>;
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<PinchConditionType.MIN_OPPONENT_SCORE>;
         score: z.ZodNumber;
+        comparison: z.ZodOptional<z.ZodEnum<typeof Comparison>>;
     }, 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">]>>;
+    pinchServer: z.ZodOptional<z.ZodBoolean>;
+    subBackMode: z.ZodOptional<z.ZodEnum<{
+        FATIGUE: "FATIGUE";
+        CONDITIONS: "CONDITIONS";
+    }>>;
+    subBackConditions: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<PinchConditionType.ASAP>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<PinchConditionType.TEAM_SET_POINT>;
+        margin: z.ZodNumber;
+        opponent: z.ZodEnum<typeof OpponentRelation>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<PinchConditionType.OPPONENT_SET_POINT>;
+        margin: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<PinchConditionType.SCORE_DIFF>;
+        direction: z.ZodEnum<typeof ScoreDirection>;
+        points: z.ZodNumber;
+        comparison: z.ZodOptional<z.ZodEnum<typeof Comparison>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<PinchConditionType.AFTER_ROTATIONS>;
+        rotations: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<PinchConditionType.FROM_SET>;
+        set: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<PinchConditionType.MIN_OWN_SCORE>;
+        score: z.ZodNumber;
+        comparison: z.ZodOptional<z.ZodEnum<typeof Comparison>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<PinchConditionType.MIN_OPPONENT_SCORE>;
+        score: z.ZodNumber;
+        comparison: z.ZodOptional<z.ZodEnum<typeof Comparison>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<PinchConditionType.PHASE>;
+        phase: z.ZodEnum<typeof MatchPhase>;
+    }, z.core.$strip>], "type">>>;
+    subBackConditionLogic: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodLiteral<"ANY">]>>;
 }, z.core.$strip>;
 export declare const DesignatedSubSchema: z.ZodObject<{
     sets: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -101,6 +149,7 @@ export declare const DesignatedSubSchema: z.ZodObject<{
             type: z.ZodLiteral<PinchConditionType.SCORE_DIFF>;
             direction: z.ZodEnum<typeof ScoreDirection>;
             points: z.ZodNumber;
+            comparison: z.ZodOptional<z.ZodEnum<typeof Comparison>>;
         }, z.core.$strip>, z.ZodObject<{
             type: z.ZodLiteral<PinchConditionType.AFTER_ROTATIONS>;
             rotations: z.ZodNumber;
@@ -110,14 +159,54 @@ export declare const DesignatedSubSchema: z.ZodObject<{
         }, z.core.$strip>, z.ZodObject<{
             type: z.ZodLiteral<PinchConditionType.MIN_OWN_SCORE>;
             score: z.ZodNumber;
+            comparison: z.ZodOptional<z.ZodEnum<typeof Comparison>>;
         }, z.core.$strip>, z.ZodObject<{
             type: z.ZodLiteral<PinchConditionType.MIN_OPPONENT_SCORE>;
             score: z.ZodNumber;
+            comparison: z.ZodOptional<z.ZodEnum<typeof Comparison>>;
         }, 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">]>>;
+        pinchServer: z.ZodOptional<z.ZodBoolean>;
+        subBackMode: z.ZodOptional<z.ZodEnum<{
+            FATIGUE: "FATIGUE";
+            CONDITIONS: "CONDITIONS";
+        }>>;
+        subBackConditions: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<PinchConditionType.ASAP>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<PinchConditionType.TEAM_SET_POINT>;
+            margin: z.ZodNumber;
+            opponent: z.ZodEnum<typeof OpponentRelation>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<PinchConditionType.OPPONENT_SET_POINT>;
+            margin: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<PinchConditionType.SCORE_DIFF>;
+            direction: z.ZodEnum<typeof ScoreDirection>;
+            points: z.ZodNumber;
+            comparison: z.ZodOptional<z.ZodEnum<typeof Comparison>>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<PinchConditionType.AFTER_ROTATIONS>;
+            rotations: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<PinchConditionType.FROM_SET>;
+            set: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<PinchConditionType.MIN_OWN_SCORE>;
+            score: z.ZodNumber;
+            comparison: z.ZodOptional<z.ZodEnum<typeof Comparison>>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<PinchConditionType.MIN_OPPONENT_SCORE>;
+            score: z.ZodNumber;
+            comparison: z.ZodOptional<z.ZodEnum<typeof Comparison>>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<PinchConditionType.PHASE>;
+            phase: z.ZodEnum<typeof MatchPhase>;
+        }, z.core.$strip>], "type">>>;
+        subBackConditionLogic: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodLiteral<"ANY">]>>;
     }, z.core.$strip>>>;
     mode: z.ZodEnum<{
         NEVER: "NEVER";
@@ -140,6 +229,7 @@ export declare const DesignatedSubSchema: z.ZodObject<{
         type: z.ZodLiteral<PinchConditionType.SCORE_DIFF>;
         direction: z.ZodEnum<typeof ScoreDirection>;
         points: z.ZodNumber;
+        comparison: z.ZodOptional<z.ZodEnum<typeof Comparison>>;
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<PinchConditionType.AFTER_ROTATIONS>;
         rotations: z.ZodNumber;
@@ -149,13 +239,53 @@ export declare const DesignatedSubSchema: z.ZodObject<{
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<PinchConditionType.MIN_OWN_SCORE>;
         score: z.ZodNumber;
+        comparison: z.ZodOptional<z.ZodEnum<typeof Comparison>>;
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<PinchConditionType.MIN_OPPONENT_SCORE>;
         score: z.ZodNumber;
+        comparison: z.ZodOptional<z.ZodEnum<typeof Comparison>>;
     }, 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">]>>;
+    pinchServer: z.ZodOptional<z.ZodBoolean>;
+    subBackMode: z.ZodOptional<z.ZodEnum<{
+        FATIGUE: "FATIGUE";
+        CONDITIONS: "CONDITIONS";
+    }>>;
+    subBackConditions: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<PinchConditionType.ASAP>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<PinchConditionType.TEAM_SET_POINT>;
+        margin: z.ZodNumber;
+        opponent: z.ZodEnum<typeof OpponentRelation>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<PinchConditionType.OPPONENT_SET_POINT>;
+        margin: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<PinchConditionType.SCORE_DIFF>;
+        direction: z.ZodEnum<typeof ScoreDirection>;
+        points: z.ZodNumber;
+        comparison: z.ZodOptional<z.ZodEnum<typeof Comparison>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<PinchConditionType.AFTER_ROTATIONS>;
+        rotations: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<PinchConditionType.FROM_SET>;
+        set: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<PinchConditionType.MIN_OWN_SCORE>;
+        score: z.ZodNumber;
+        comparison: z.ZodOptional<z.ZodEnum<typeof Comparison>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<PinchConditionType.MIN_OPPONENT_SCORE>;
+        score: z.ZodNumber;
+        comparison: z.ZodOptional<z.ZodEnum<typeof Comparison>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<PinchConditionType.PHASE>;
+        phase: z.ZodEnum<typeof MatchPhase>;
+    }, z.core.$strip>], "type">>>;
+    subBackConditionLogic: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodLiteral<"ANY">]>>;
     starter: z.ZodCustom<Player, Player>;
 }, z.core.$strip>;

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 { MatchPhase, OpponentRelation, PinchConditionType, ScoreDirection } from '../pinch-condition';
+import { Comparison, MatchPhase, OpponentRelation, PinchConditionType, ScoreDirection } from '../pinch-condition';
 const playerInstanceSchema = z.custom((v) => v instanceof Player, {
     message: 'INVALID_PLAYER_INSTANCE'
 });
@@ -10,16 +10,19 @@ export const PinchConditionSchema = z.discriminatedUnion('type', [
     z.object({ type: z.literal(PinchConditionType.ASAP) }),
     z.object({ type: z.literal(PinchConditionType.TEAM_SET_POINT), margin: z.number().int().min(1).max(25), opponent: z.nativeEnum(OpponentRelation) }),
     z.object({ type: z.literal(PinchConditionType.OPPONENT_SET_POINT), margin: z.number().int().min(1).max(25) }),
-    z.object({ type: z.literal(PinchConditionType.SCORE_DIFF), direction: z.nativeEnum(ScoreDirection), points: z.number().int().min(1).max(25) }),
+    // SCORE_DIFF / MIN_OWN_SCORE / MIN_OPPONENT_SCORE carry an optional comparison direction ("Or more" AT_LEAST,
+    // the default; "Or less" AT_MOST). Absent = AT_LEAST so existing conditions keep their `>=` behavior.
+    z.object({ type: z.literal(PinchConditionType.SCORE_DIFF), direction: z.nativeEnum(ScoreDirection), points: z.number().int().min(1).max(25), comparison: z.nativeEnum(Comparison).optional() }),
     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_OWN_SCORE), score: z.number().int().min(0).max(40), comparison: z.nativeEnum(Comparison).optional() }),
+    z.object({ type: z.literal(PinchConditionType.MIN_OPPONENT_SCORE), score: z.number().int().min(0).max(40), comparison: z.nativeEnum(Comparison).optional() }),
     // 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']);
+export const SubBackModeSchema = z.enum(['FATIGUE', 'CONDITIONS']);
 // Fields shared by the all-sets config and each per-set config.
 const setSubConfigShape = {
     mode: SubModeSchema,
@@ -27,9 +30,16 @@ const setSubConfigShape = {
     fatigueBand: z.nativeEnum(EnergyBand).optional(),
     benchFatigueBand: z.nativeEnum(EnergyBand).optional(),
     conditions: z.array(PinchConditionSchema).optional(),
-    conditionLogic: ConditionLogicSchema.optional()
+    conditionLogic: ConditionLogicSchema.optional(),
+    // pinch ("Conditions") mode. true = serve-and-return pinch server; false/absent = regular conditional sub.
+    pinchServer: z.boolean().optional(),
+    // a regular conditional sub's sub-back trigger + its condition set (subBackMode === 'CONDITIONS').
+    subBackMode: SubBackModeSchema.optional(),
+    subBackConditions: z.array(PinchConditionSchema).optional(),
+    subBackConditionLogic: ConditionLogicSchema.optional()
 };
-// Pinch mode needs a designated bench player (the server) and at least one condition.
+// Pinch ("Conditions") mode needs a designated bench player and at least one sub-in condition. A regular
+// conditional sub (pinchServer !== true) with a CONDITIONS sub-back also needs at least one sub-back condition.
 function refinePinch(data, ctx) {
     if (data.mode !== 'PINCH')
         return;
@@ -39,6 +49,10 @@ function refinePinch(data, ctx) {
     if (data.conditions == null || data.conditions.length === 0) {
         ctx.addIssue({ code: 'custom', message: 'PINCH_SERVER_REQUIRES_CONDITIONS', path: ['conditions'] });
     }
+    if (data.pinchServer !== true && data.subBackMode === 'CONDITIONS' &&
+        (data.subBackConditions == null || data.subBackConditions.length === 0)) {
+        ctx.addIssue({ code: 'custom', message: 'CONDITIONAL_SUB_BACK_REQUIRES_CONDITIONS', path: ['subBackConditions'] });
+    }
 }
 export const SetSubConfigSchema = z.object(setSubConfigShape).superRefine(refinePinch);
 export const DesignatedSubSchema = z.object({

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

@@ -1,7 +1,7 @@
 import { describe, it, expect } from '@jest/globals';
 import { ConditionLogicSchema, DesignatedSubSchema, PinchConditionSchema, SubBandSchema } from './designated-sub.z';
 import { EnergyBand } from '../energy-band';
-import { OpponentRelation, PinchConditionType, ScoreDirection } from '../pinch-condition';
+import { Comparison, OpponentRelation, PinchConditionType, ScoreDirection } from '../pinch-condition';
 import { makeCountry, makePlayer } from '../../test-helpers';
 describe('SubBandSchema', () => {
     it('accepts every energy band and NEVER', () => {
@@ -57,6 +57,16 @@ describe('PinchConditionSchema', () => {
     it('rejects a non-integer numeric field', () => {
         expect(PinchConditionSchema.safeParse({ type: PinchConditionType.FROM_SET, set: 2.5 }).success).toBe(false);
     });
+    it('accepts an optional comparison (Or more / Or less) on the numeric-threshold conditions', () => {
+        expect(PinchConditionSchema.safeParse({ type: PinchConditionType.SCORE_DIFF, direction: ScoreDirection.LEADING, points: 2, comparison: Comparison.AT_MOST }).success).toBe(true);
+        expect(PinchConditionSchema.safeParse({ type: PinchConditionType.MIN_OWN_SCORE, score: 20, comparison: Comparison.AT_MOST }).success).toBe(true);
+        expect(PinchConditionSchema.safeParse({ type: PinchConditionType.MIN_OPPONENT_SCORE, score: 20, comparison: Comparison.AT_LEAST }).success).toBe(true);
+        // absent comparison stays valid (defaults to AT_LEAST at eval time)
+        expect(PinchConditionSchema.safeParse({ type: PinchConditionType.SCORE_DIFF, direction: ScoreDirection.LEADING, points: 2 }).success).toBe(true);
+    });
+    it('rejects an invalid comparison value', () => {
+        expect(PinchConditionSchema.safeParse({ type: PinchConditionType.MIN_OWN_SCORE, score: 20, comparison: 'EXACTLY' }).success).toBe(false);
+    });
 });
 describe('DesignatedSubSchema', () => {
     const country = makeCountry();
@@ -216,4 +226,77 @@ describe('DesignatedSubSchema', () => {
         });
         expect(res.success).toBe(false);
     });
+    it('accepts a pinch-mode entry marked as a pinch server (serve-and-return)', () => {
+        const res = DesignatedSubSchema.safeParse({
+            starter,
+            bench,
+            mode: 'PINCH',
+            conditions: [{ type: PinchConditionType.ASAP }],
+            pinchServer: true
+        });
+        expect(res.success).toBe(true);
+    });
+    it('accepts a regular conditional sub (pinchServer false) with a tiredness sub-back', () => {
+        const res = DesignatedSubSchema.safeParse({
+            starter,
+            bench,
+            mode: 'PINCH',
+            conditions: [{ type: PinchConditionType.SCORE_DIFF, direction: ScoreDirection.TRAILING, points: 3 }],
+            pinchServer: false,
+            subBackMode: 'FATIGUE',
+            benchFatigueBand: EnergyBand.TIRED
+        });
+        expect(res.success).toBe(true);
+    });
+    it('accepts a regular conditional sub with a condition-based sub-back', () => {
+        const res = DesignatedSubSchema.safeParse({
+            starter,
+            bench,
+            mode: 'PINCH',
+            conditions: [{ type: PinchConditionType.SCORE_DIFF, direction: ScoreDirection.TRAILING, points: 3 }],
+            pinchServer: false,
+            subBackMode: 'CONDITIONS',
+            subBackConditions: [{ type: PinchConditionType.TEAM_SET_POINT, margin: 2, opponent: OpponentRelation.EITHER }],
+            subBackConditionLogic: 'ANY'
+        });
+        expect(res.success).toBe(true);
+    });
+    it('rejects a condition-based sub-back with no sub-back conditions', () => {
+        const res = DesignatedSubSchema.safeParse({
+            starter,
+            bench,
+            mode: 'PINCH',
+            conditions: [{ type: PinchConditionType.ASAP }],
+            pinchServer: false,
+            subBackMode: 'CONDITIONS',
+            subBackConditions: []
+        });
+        expect(res.success).toBe(false);
+        if (!res.success) {
+            expect(res.error.issues.some(issue => issue.message === 'CONDITIONAL_SUB_BACK_REQUIRES_CONDITIONS')).toBe(true);
+        }
+    });
+    it('does not require sub-back conditions for a pinch server even under subBackMode CONDITIONS', () => {
+        // A pinch server never uses a sub-back rule (it serve-reverts), so the condition requirement is skipped.
+        const res = DesignatedSubSchema.safeParse({
+            starter,
+            bench,
+            mode: 'PINCH',
+            conditions: [{ type: PinchConditionType.ASAP }],
+            pinchServer: true,
+            subBackMode: 'CONDITIONS'
+        });
+        expect(res.success).toBe(true);
+    });
+    it('rejects an invalid subBackMode', () => {
+        const res = DesignatedSubSchema.safeParse({
+            starter,
+            bench,
+            mode: 'PINCH',
+            conditions: [{ type: PinchConditionType.ASAP }],
+            pinchServer: false,
+            subBackMode: 'WHENEVER'
+        });
+        expect(res.success).toBe(false);
+    });
 });