volleyballsimtypes 0.0.476 → 0.0.478

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

@@ -1,4 +1,4 @@
-import { BoxScore, DataProps, DeclineStatus, Division as _Division, League as _League, Match as _Match, MatchSet as _MatchSet, Player as _Player, PlayerPosition, Qualifier as _Qualifier, QualifierMatch as _QualifierMatch, Rally as _Rally, RallyEvent as _RallyEvent, PointBreakdown, RallyMetrics, Season as _Season, Standing as _Standing, Team as _Team, Tournament as _Tournament, TournamentMatch as _TournamentMatch, National as _National, NationalMatch as _NationalMatch, Country as _Country, CourtPosition, ConditionLogic, EnergyBand, LiberoSubMode, MatchForfeitType, PerformanceStats, PinchCondition, RotationSystemEnum, SubBand, SubMode } from '../service';
+import { BoxScore, DataProps, DeclineStatus, Division as _Division, League as _League, Match as _Match, MatchSet as _MatchSet, Player as _Player, PlayerPosition, Qualifier as _Qualifier, QualifierMatch as _QualifierMatch, Rally as _Rally, RallyEvent as _RallyEvent, PointBreakdown, RallyMetrics, Season as _Season, Standing as _Standing, Team as _Team, Tournament as _Tournament, TournamentMatch as _TournamentMatch, National as _National, NationalMatch as _NationalMatch, Country as _Country, CourtPosition, ConditionLogic, EnergyBand, LiberoSubMode, MatchForfeitType, PerformanceStats, PinchCondition, RotationSystemEnum, SubBackMode, SubBand, SubMode } from '../service';
 export type Rally = DataProps<_Rally> & {
     homePlayerPosition: PlayerPosition[];
     awayPlayerPosition: PlayerPosition[];
@@ -87,6 +87,10 @@ export interface ApiSetSubConfig {
     benchFatigueBand?: EnergyBand;
     conditions?: PinchCondition[];
     conditionLogic?: ConditionLogic;
+    pinchServer?: boolean;
+    subBackMode?: SubBackMode;
+    subBackConditions?: PinchCondition[];
+    subBackConditionLogic?: ConditionLogic;
 }
 export interface ApiDesignatedSub {
     starterId: string;
@@ -96,6 +100,10 @@ export interface ApiDesignatedSub {
     benchFatigueBand?: EnergyBand;
     conditions?: PinchCondition[];
     conditionLogic?: ConditionLogic;
+    pinchServer?: boolean;
+    subBackMode?: SubBackMode;
+    subBackConditions?: PinchCondition[];
+    subBackConditionLogic?: ConditionLogic;
     sets?: ApiSetSubConfig[];
 }
 export interface ApiOffensivePreference {

package/dist/cjs/src/data/models/auth-session.d.ts

@@ -11,10 +11,12 @@ export interface AuthSessionAttributes {
     user_agent?: string | null;
     created_at?: Date;
     updated_at?: Date;
+    previous_refresh_token_hash?: string | null;
+    previous_token_expires_at?: Date | null;
 }
 export type AuthSessionPk = 'session_id';
 export type AuthSessionId = AuthSessionModel[AuthSessionPk];
-export type AuthSessionOptionalAttributes = 'revoked_at' | 'ip_address' | 'user_agent' | 'created_at' | 'updated_at';
+export type AuthSessionOptionalAttributes = 'revoked_at' | 'ip_address' | 'user_agent' | 'created_at' | 'updated_at' | 'previous_refresh_token_hash' | 'previous_token_expires_at';
 export type AuthSessionCreationAttributes = Optional<AuthSessionAttributes, AuthSessionOptionalAttributes>;
 export declare class AuthSessionModel extends Model<AuthSessionAttributes, AuthSessionCreationAttributes> implements AuthSessionAttributes {
     session_id: string;
@@ -26,6 +28,8 @@ export declare class AuthSessionModel extends Model<AuthSessionAttributes, AuthS
     user_agent?: string | null;
     created_at?: Date;
     updated_at?: Date;
+    previous_refresh_token_hash?: string | null;
+    previous_token_expires_at?: Date | null;
     user: AuthUserModel;
     getUser: Sequelize.BelongsToGetAssociationMixin<AuthUserModel>;
     setUser: Sequelize.BelongsToSetAssociationMixin<AuthUserModel, AuthUserId>;

package/dist/cjs/src/data/models/auth-session.js

@@ -47,6 +47,14 @@ class AuthSessionModel extends sequelize_1.Model {
                 type: sequelize_1.DataTypes.DATE,
                 allowNull: false,
                 defaultValue: sequelize_1.DataTypes.NOW
+            },
+            previous_refresh_token_hash: {
+                type: sequelize_1.DataTypes.STRING,
+                allowNull: true
+            },
+            previous_token_expires_at: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: true
             }
         }, {
             sequelize,

package/dist/cjs/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/cjs/src/data/transformers/tactics.js

@@ -17,6 +17,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)
@@ -65,13 +71,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,
@@ -155,13 +169,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,
@@ -312,13 +334,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/cjs/src/data/transformers/tactics.test.js

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

package/dist/cjs/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/cjs/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/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.MatchPhase = exports.PinchConditionType = void 0;
+exports.Comparison = exports.ScoreDirection = exports.OpponentRelation = exports.MatchPhase = exports.PinchConditionType = void 0;
 var PinchConditionType;
 (function (PinchConditionType) {
     PinchConditionType["ASAP"] = "ASAP";
@@ -34,3 +34,12 @@ var ScoreDirection;
     ScoreDirection["TRAILING"] = "TRAILING";
     ScoreDirection["LEADING"] = "LEADING";
 })(ScoreDirection || (exports.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").
+var Comparison;
+(function (Comparison) {
+    Comparison["AT_LEAST"] = "AT_LEAST";
+    Comparison["AT_MOST"] = "AT_MOST";
+})(Comparison || (exports.Comparison = Comparison = {}));

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DesignatedSubSchema = exports.SetSubConfigSchema = exports.SubModeSchema = exports.ConditionLogicSchema = exports.PinchConditionSchema = exports.SubBandSchema = void 0;
+exports.DesignatedSubSchema = exports.SetSubConfigSchema = exports.SubBackModeSchema = exports.SubModeSchema = exports.ConditionLogicSchema = exports.PinchConditionSchema = exports.SubBandSchema = void 0;
 const zod_1 = require("zod");
 const player_1 = require("../../player");
 const energy_band_1 = require("../energy-band");
@@ -13,16 +13,19 @@ exports.PinchConditionSchema = zod_1.z.discriminatedUnion('type', [
     zod_1.z.object({ type: zod_1.z.literal(pinch_condition_1.PinchConditionType.ASAP) }),
     zod_1.z.object({ type: zod_1.z.literal(pinch_condition_1.PinchConditionType.TEAM_SET_POINT), margin: zod_1.z.number().int().min(1).max(25), opponent: zod_1.z.nativeEnum(pinch_condition_1.OpponentRelation) }),
     zod_1.z.object({ type: zod_1.z.literal(pinch_condition_1.PinchConditionType.OPPONENT_SET_POINT), margin: zod_1.z.number().int().min(1).max(25) }),
-    zod_1.z.object({ type: zod_1.z.literal(pinch_condition_1.PinchConditionType.SCORE_DIFF), direction: zod_1.z.nativeEnum(pinch_condition_1.ScoreDirection), points: zod_1.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.
+    zod_1.z.object({ type: zod_1.z.literal(pinch_condition_1.PinchConditionType.SCORE_DIFF), direction: zod_1.z.nativeEnum(pinch_condition_1.ScoreDirection), points: zod_1.z.number().int().min(1).max(25), comparison: zod_1.z.nativeEnum(pinch_condition_1.Comparison).optional() }),
     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_OWN_SCORE), score: zod_1.z.number().int().min(0).max(40), comparison: zod_1.z.nativeEnum(pinch_condition_1.Comparison).optional() }),
+    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), comparison: zod_1.z.nativeEnum(pinch_condition_1.Comparison).optional() }),
     // 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']);
+exports.SubBackModeSchema = zod_1.z.enum(['FATIGUE', 'CONDITIONS']);
 // Fields shared by the all-sets config and each per-set config.
 const setSubConfigShape = {
     mode: exports.SubModeSchema,
@@ -30,9 +33,16 @@ const setSubConfigShape = {
     fatigueBand: zod_1.z.nativeEnum(energy_band_1.EnergyBand).optional(),
     benchFatigueBand: zod_1.z.nativeEnum(energy_band_1.EnergyBand).optional(),
     conditions: zod_1.z.array(exports.PinchConditionSchema).optional(),
-    conditionLogic: exports.ConditionLogicSchema.optional()
+    conditionLogic: exports.ConditionLogicSchema.optional(),
+    // pinch ("Conditions") mode. true = serve-and-return pinch server; false/absent = regular conditional sub.
+    pinchServer: zod_1.z.boolean().optional(),
+    // a regular conditional sub's sub-back trigger + its condition set (subBackMode === 'CONDITIONS').
+    subBackMode: exports.SubBackModeSchema.optional(),
+    subBackConditions: zod_1.z.array(exports.PinchConditionSchema).optional(),
+    subBackConditionLogic: exports.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;
@@ -42,6 +52,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'] });
+    }
 }
 exports.SetSubConfigSchema = zod_1.z.object(setSubConfigShape).superRefine(refinePinch);
 exports.DesignatedSubSchema = zod_1.z.object({