npm - volleyballsimtypes - Versions diffs - 0.0.476 → 0.0.477 - Mend

volleyballsimtypes 0.0.476 → 0.0.477

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (27) hide show

package/dist/cjs/src/service/team/schemas/team.z.d.ts CHANGED Viewed

@@ -63,6 +63,41 @@ export declare const TeamInputSchema: z.ZodObject<{
                     phase: z.ZodEnum<typeof import("..").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<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">>>;
+                subBackConditionLogic: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodLiteral<"ANY">]>>;
             }, z.core.$strip>>>;
             mode: z.ZodEnum<{
                 NEVER: "NEVER";
@@ -102,6 +137,41 @@ export declare const TeamInputSchema: z.ZodObject<{
                 phase: z.ZodEnum<typeof import("..").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<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">>>;
+            subBackConditionLogic: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodLiteral<"ANY">]>>;
             starter: z.ZodCustom<Player, Player>;
         }, z.core.$strip>>>;
         substitutionBand: z.ZodDefault<z.ZodUnion<readonly [z.ZodEnum<typeof import("..").EnergyBand>, z.ZodLiteral<"NEVER">]>>;
@@ -111,8 +181,8 @@ export declare const TeamInputSchema: z.ZodObject<{
                 mode: z.ZodEnum<{
                     NEVER: "NEVER";
                     FATIGUE: "FATIGUE";
-                    ALWAYS: "ALWAYS";
                     CONDITIONS: "CONDITIONS";
+                    ALWAYS: "ALWAYS";
                 }>;
                 fatigueBand: z.ZodOptional<z.ZodEnum<typeof import("..").EnergyBand>>;
                 conditions: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -149,8 +219,8 @@ export declare const TeamInputSchema: z.ZodObject<{
             mode: z.ZodEnum<{
                 NEVER: "NEVER";
                 FATIGUE: "FATIGUE";
-                ALWAYS: "ALWAYS";
                 CONDITIONS: "CONDITIONS";
+                ALWAYS: "ALWAYS";
             }>;
             fatigueBand: z.ZodOptional<z.ZodEnum<typeof import("..").EnergyBand>>;
             conditions: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{

package/dist/esm/src/api/index.d.ts CHANGED Viewed

@@ -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/esm/src/data/models/auth-session.d.ts CHANGED Viewed

@@ -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/esm/src/data/models/auth-session.js CHANGED Viewed

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

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

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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/schemas/designated-sub.z.d.ts CHANGED Viewed

@@ -38,6 +38,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";
@@ -77,6 +81,41 @@ export declare const SetSubConfigSchema: z.ZodObject<{
         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;
+    }, 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;
+    }, 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">>>;
+    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<{
@@ -118,6 +157,41 @@ export declare const DesignatedSubSchema: z.ZodObject<{
             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;
+        }, 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;
+        }, 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">>>;
+        subBackConditionLogic: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodLiteral<"ANY">]>>;
     }, z.core.$strip>>>;
     mode: z.ZodEnum<{
         NEVER: "NEVER";
@@ -157,5 +231,40 @@ export declare const DesignatedSubSchema: z.ZodObject<{
         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;
+    }, 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;
+    }, 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">>>;
+    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 CHANGED Viewed

@@ -20,6 +20,7 @@ export const PinchConditionSchema = z.discriminatedUnion('type', [
 ]);
 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 +28,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 +47,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 CHANGED Viewed

@@ -216,4 +216,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);
+    });
 });

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

@@ -3,15 +3,15 @@ import { EnergyBand } from '../energy-band';
 export declare const LiberoSubModeSchema: z.ZodEnum<{
     NEVER: "NEVER";
     FATIGUE: "FATIGUE";
-    ALWAYS: "ALWAYS";
     CONDITIONS: "CONDITIONS";
+    ALWAYS: "ALWAYS";
 }>;
 export declare const LiberoSetSubConfigSchema: z.ZodObject<{
     mode: z.ZodEnum<{
         NEVER: "NEVER";
         FATIGUE: "FATIGUE";
-        ALWAYS: "ALWAYS";
         CONDITIONS: "CONDITIONS";
+        ALWAYS: "ALWAYS";
     }>;
     fatigueBand: z.ZodOptional<z.ZodEnum<typeof EnergyBand>>;
     conditions: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -50,8 +50,8 @@ export declare const LiberoSubConfigSchema: z.ZodObject<{
         mode: z.ZodEnum<{
             NEVER: "NEVER";
             FATIGUE: "FATIGUE";
-            ALWAYS: "ALWAYS";
             CONDITIONS: "CONDITIONS";
+            ALWAYS: "ALWAYS";
         }>;
         fatigueBand: z.ZodOptional<z.ZodEnum<typeof EnergyBand>>;
         conditions: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -88,8 +88,8 @@ export declare const LiberoSubConfigSchema: z.ZodObject<{
     mode: z.ZodEnum<{
         NEVER: "NEVER";
         FATIGUE: "FATIGUE";
-        ALWAYS: "ALWAYS";
         CONDITIONS: "CONDITIONS";
+        ALWAYS: "ALWAYS";
     }>;
     fatigueBand: z.ZodOptional<z.ZodEnum<typeof EnergyBand>>;
     conditions: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{