volleyballsimtypes 0.0.475 → 0.0.477

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,
@@ -178,15 +200,20 @@ function transformToObject(model, roster) {
             rotation: p.rotation,
             order: p.order.map((id) => findPlayer(id, roster))
         }))),
-        // LENIENT: keep only starter-keyed boolean entries so stale jsonb (an ex-starter's key, a non-boolean
-        // value) can never fail schema validation and crash a team load; a dropped key = the ON default.
+        // LENIENT: keep only boolean entries keyed by a court starter or, when a second libero exists, the starting
+        // libero (the libero knock toggle is an L2-only feature, owner 2026-07-06) so stale jsonb (an ex-starter's
+        // key, a non-boolean value, a libero key left after the L2 was removed) can never fail schema validation
+        // and crash a team load; a dropped key = the ON default.
         replaceKnockedImmediately: (() => {
-            const starterIds = new Set([lineup[service_1.CourtPosition.LEFT_FRONT], lineup[service_1.CourtPosition.MIDDLE_FRONT], lineup[service_1.CourtPosition.RIGHT_FRONT],
+            const allowedIds = new Set([lineup[service_1.CourtPosition.LEFT_FRONT], lineup[service_1.CourtPosition.MIDDLE_FRONT], lineup[service_1.CourtPosition.RIGHT_FRONT],
                 lineup[service_1.CourtPosition.LEFT_BACK], lineup[service_1.CourtPosition.MIDDLE_BACK], lineup[service_1.CourtPosition.RIGHT_BACK]]
                 .map((p) => p.id));
+            const liberoZoneId = lineup[service_1.CourtPosition.LIBERO_ZONE]?.id;
+            if (liberoZoneId != null && secondLibero != null)
+                allowedIds.add(liberoZoneId);
             const healed = {};
             for (const [id, value] of Object.entries(model.replace_knocked_immediately ?? {})) {
-                if (starterIds.has(id) && typeof value === 'boolean')
+                if (allowedIds.has(id) && typeof value === 'boolean')
                     healed[id] = value;
             }
             return healed;
@@ -307,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,
@@ -321,15 +356,19 @@ function tacticsColumnsToApiDto(model) {
         offensivePreferences: model.offensive_preferences,
         systemSets: model.system_sets,
         offensivePreferenceSets: model.offensive_preference_sets,
-        // Same stale-data policy as the heals below: only starter-keyed boolean entries survive, and an empty
-        // map surfaces as absent (missing key = ON).
+        // Same stale-data policy as the heals below: only boolean entries keyed by a court starter or, when a second
+        // libero exists, the starting libero (the libero knock toggle is an L2-only feature, owner 2026-07-06)
+        // survive; an empty map surfaces as absent (missing key = ON).
         replaceKnockedImmediately: (() => {
-            const starterSlotIds = new Set([model.lineup[service_1.CourtPosition.LEFT_FRONT], model.lineup[service_1.CourtPosition.MIDDLE_FRONT],
+            const allowedSlotIds = new Set([model.lineup[service_1.CourtPosition.LEFT_FRONT], model.lineup[service_1.CourtPosition.MIDDLE_FRONT],
                 model.lineup[service_1.CourtPosition.RIGHT_FRONT], model.lineup[service_1.CourtPosition.LEFT_BACK],
                 model.lineup[service_1.CourtPosition.MIDDLE_BACK], model.lineup[service_1.CourtPosition.RIGHT_BACK]]);
+            const liberoZoneId = model.lineup[service_1.CourtPosition.LIBERO_ZONE];
+            if (liberoZoneId != null && validSecondLibero != null)
+                allowedSlotIds.add(liberoZoneId);
             const healed = {};
             for (const [id, value] of Object.entries(model.replace_knocked_immediately ?? {})) {
-                if (starterSlotIds.has(id) && typeof value === 'boolean')
+                if (allowedSlotIds.has(id) && typeof value === 'boolean')
                     healed[id] = value;
             }
             return Object.keys(healed).length > 0 ? healed : undefined;

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';
@@ -78,6 +109,21 @@ function makeTactics(designatedSubs) {
         (0, globals_1.expect)(dto.secondLibero).toBe('reserve1');
         (0, globals_1.expect)(dto.liberoSub).toEqual({ mode: 'FATIGUE' });
     });
+    (0, globals_1.it)('keeps a libero-keyed replaceKnockedImmediately entry when a second libero exists (L2-only feature)', () => {
+        const model = makeTactics([]);
+        model.lineup[service_1.CourtPosition.LIBERO_ZONE] = 'libero1';
+        model.second_libero = 'reserve1';
+        model.replace_knocked_immediately = { libero1: false, lf: false };
+        const dto = (0, tactics_1.tacticsColumnsToApiDto)(model);
+        (0, globals_1.expect)(dto.replaceKnockedImmediately).toEqual({ libero1: false, lf: false });
+    });
+    (0, globals_1.it)('drops a libero-keyed replaceKnockedImmediately entry when there is no second libero', () => {
+        const model = makeTactics([]);
+        model.lineup[service_1.CourtPosition.LIBERO_ZONE] = 'libero1';
+        model.replace_knocked_immediately = { libero1: false, lf: false };
+        const dto = (0, tactics_1.tacticsColumnsToApiDto)(model);
+        (0, globals_1.expect)(dto.replaceKnockedImmediately).toEqual({ lf: false });
+    });
     (0, globals_1.it)('passes per-set tactics columns through to the API DTO shape', () => {
         const model = makeTactics([]);
         model.system_sets = [{ rotationSystem: service_1.RotationSystemEnum.FIVE_ONE, designatedSetters: ['lf'] }];
@@ -182,4 +228,25 @@ function makeTactics(designatedSubs) {
         (0, globals_1.expect)(back.liberoInjury?.secondLiberoBackfill).toBeUndefined();
         (0, globals_1.expect)(back.liberoInjury?.inMatchDesignate?.id).toBe(reserveB.id);
     });
+    (0, globals_1.it)('keeps a libero-keyed replaceKnockedImmediately entry on load when an L2 exists', () => {
+        const withKnock = service_1.Tactics.create({
+            lineup: { 4: p4, 3: p3, 2: p2, 5: p5, 6: p6, 1: p1, 0: libero, bench: [] },
+            liberoReplacements: [],
+            secondLibero: l2,
+            replaceKnockedImmediately: { [libero.id]: false, [p1.id]: false }
+        });
+        const attrs = (0, tactics_1.transformFromTactics)(withKnock, 'team-1');
+        const back = (0, tactics_1.transformToTactics)(attrs, roster);
+        (0, globals_1.expect)(back.replaceKnockedImmediately).toEqual({ [libero.id]: false, [p1.id]: false });
+    });
+    (0, globals_1.it)('drops a libero-keyed replaceKnockedImmediately entry on load when there is no L2', () => {
+        const withKnock = service_1.Tactics.create({
+            lineup: { 4: p4, 3: p3, 2: p2, 5: p5, 6: p6, 1: p1, 0: libero, bench: [] },
+            liberoReplacements: [],
+            replaceKnockedImmediately: { [libero.id]: false, [p1.id]: false }
+        });
+        const attrs = (0, tactics_1.transformFromTactics)(withKnock, 'team-1');
+        const back = (0, tactics_1.transformToTactics)(attrs, roster);
+        (0, globals_1.expect)(back.replaceKnockedImmediately).toEqual({ [p1.id]: false });
+    });
 });

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

@@ -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/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");
@@ -23,6 +23,7 @@ exports.PinchConditionSchema = zod_1.z.discriminatedUnion('type', [
 ]);
 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 +31,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 +50,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({

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

@@ -218,4 +218,77 @@ const test_helpers_1 = require("../../test-helpers");
         });
         (0, globals_1.expect)(res.success).toBe(false);
     });
+    (0, globals_1.it)('accepts a pinch-mode entry marked as a pinch server (serve-and-return)', () => {
+        const res = designated_sub_z_1.DesignatedSubSchema.safeParse({
+            starter,
+            bench,
+            mode: 'PINCH',
+            conditions: [{ type: pinch_condition_1.PinchConditionType.ASAP }],
+            pinchServer: true
+        });
+        (0, globals_1.expect)(res.success).toBe(true);
+    });
+    (0, globals_1.it)('accepts a regular conditional sub (pinchServer false) with a tiredness sub-back', () => {
+        const res = designated_sub_z_1.DesignatedSubSchema.safeParse({
+            starter,
+            bench,
+            mode: 'PINCH',
+            conditions: [{ type: pinch_condition_1.PinchConditionType.SCORE_DIFF, direction: pinch_condition_1.ScoreDirection.TRAILING, points: 3 }],
+            pinchServer: false,
+            subBackMode: 'FATIGUE',
+            benchFatigueBand: energy_band_1.EnergyBand.TIRED
+        });
+        (0, globals_1.expect)(res.success).toBe(true);
+    });
+    (0, globals_1.it)('accepts a regular conditional sub with a condition-based sub-back', () => {
+        const res = designated_sub_z_1.DesignatedSubSchema.safeParse({
+            starter,
+            bench,
+            mode: 'PINCH',
+            conditions: [{ type: pinch_condition_1.PinchConditionType.SCORE_DIFF, direction: pinch_condition_1.ScoreDirection.TRAILING, points: 3 }],
+            pinchServer: false,
+            subBackMode: 'CONDITIONS',
+            subBackConditions: [{ type: pinch_condition_1.PinchConditionType.TEAM_SET_POINT, margin: 2, opponent: pinch_condition_1.OpponentRelation.EITHER }],
+            subBackConditionLogic: 'ANY'
+        });
+        (0, globals_1.expect)(res.success).toBe(true);
+    });
+    (0, globals_1.it)('rejects a condition-based sub-back with no sub-back conditions', () => {
+        const res = designated_sub_z_1.DesignatedSubSchema.safeParse({
+            starter,
+            bench,
+            mode: 'PINCH',
+            conditions: [{ type: pinch_condition_1.PinchConditionType.ASAP }],
+            pinchServer: false,
+            subBackMode: 'CONDITIONS',
+            subBackConditions: []
+        });
+        (0, globals_1.expect)(res.success).toBe(false);
+        if (!res.success) {
+            (0, globals_1.expect)(res.error.issues.some(issue => issue.message === 'CONDITIONAL_SUB_BACK_REQUIRES_CONDITIONS')).toBe(true);
+        }
+    });
+    (0, globals_1.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 = designated_sub_z_1.DesignatedSubSchema.safeParse({
+            starter,
+            bench,
+            mode: 'PINCH',
+            conditions: [{ type: pinch_condition_1.PinchConditionType.ASAP }],
+            pinchServer: true,
+            subBackMode: 'CONDITIONS'
+        });
+        (0, globals_1.expect)(res.success).toBe(true);
+    });
+    (0, globals_1.it)('rejects an invalid subBackMode', () => {
+        const res = designated_sub_z_1.DesignatedSubSchema.safeParse({
+            starter,
+            bench,
+            mode: 'PINCH',
+            conditions: [{ type: pinch_condition_1.PinchConditionType.ASAP }],
+            pinchServer: false,
+            subBackMode: 'WHENEVER'
+        });
+        (0, globals_1.expect)(res.success).toBe(false);
+    });
 });

package/dist/cjs/src/service/team/schemas/injury-replacement.z.test.js

@@ -49,8 +49,17 @@ const test_helpers_1 = require("../../test-helpers");
             (0, globals_1.expect)(res.data.replaceKnockedImmediately).toEqual({ [p1.id]: false, [p3.id]: true });
         }
     });
-    (0, globals_1.it)('rejects a replaceKnockedImmediately key that is not a court starter', () => {
-        for (const outsider of [benchA, libero, reserveA]) {
+    (0, globals_1.it)('accepts a libero-keyed replaceKnockedImmediately map', () => {
+        const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
+            replaceKnockedImmediately: { [libero.id]: false }
+        }));
+        (0, globals_1.expect)(res.success).toBe(true);
+        if (res.success) {
+            (0, globals_1.expect)(res.data.replaceKnockedImmediately).toEqual({ [libero.id]: false });
+        }
+    });
+    (0, globals_1.it)('rejects a replaceKnockedImmediately key that is not a court starter or the libero', () => {
+        for (const outsider of [benchA, reserveA]) {
             const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
                 replaceKnockedImmediately: { [outsider.id]: false }
             }));

package/dist/cjs/src/service/team/schemas/libero-sub.z.d.ts

@@ -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<{