volleyballsimtypes 0.0.475 → 0.0.477

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

@@ -55,6 +55,41 @@ export declare const TacticsInputSchema: 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";
@@ -94,6 +129,41 @@ export declare const TacticsInputSchema: 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 EnergyBand>, z.ZodLiteral<"NEVER">]>>;
@@ -103,8 +173,8 @@ export declare const TacticsInputSchema: 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<{
@@ -141,8 +211,8 @@ export declare const TacticsInputSchema: 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<{

package/dist/cjs/src/service/team/schemas/tactics.z.js

@@ -198,10 +198,11 @@ exports.TacticsInputSchema = zod_1.z.object({
             }
         }
     }
-    // Per-starter knock toggle: every key must be a configured court starter (bench/reserve/libero players
-    // follow the slot they occupy, so they never carry their own key).
-    for (const starterId of Object.keys(data.replaceKnockedImmediately)) {
-        if (!starterIds.has(starterId)) {
+    // Per-player knock toggle: every key must be a court starter OR the starting libero. The libero may carry its
+    // own key so the user can choose to keep a lightly knocked libero on court (owner 2026-07-06). Bench/reserve
+    // players still follow the slot they occupy, so they never carry their own key.
+    for (const knockedId of Object.keys(data.replaceKnockedImmediately)) {
+        if (!starterIds.has(knockedId) && knockedId !== libero?.id) {
             ctx.addIssue({ code: 'custom', message: 'REPLACE_KNOCKED_KEY_NOT_A_STARTER', path: ['replaceKnockedImmediately'] });
         }
     }

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

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

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

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

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

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

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

@@ -11,6 +11,12 @@ function subModeFromAttributes(d) {
         return 'NEVER';
     return 'FATIGUE';
 }
+// pinchServer only applies to PINCH ("Conditions") mode. A LEGACY PINCH row (no flag) defaults to true so
+// existing pinch servers keep serve-and-return behavior; a new conditional sub persists an explicit false. This
+// default must resolve identically on every READ path (both transformToObject and tacticsColumnsToApiDto).
+function effectivePinchServer(mode, pinchServer) {
+    return mode === 'PINCH' ? (pinchServer ?? true) : undefined;
+}
 function findPlayer(id, roster) {
     const player = roster.find((p) => p.id === id);
     if (player == null)
@@ -59,13 +65,21 @@ function transformToAttributes(tactics, teamId) {
             benchFatigueBand: ds.benchFatigueBand,
             conditions: ds.conditions,
             conditionLogic: ds.conditionLogic,
+            pinchServer: ds.pinchServer,
+            subBackMode: ds.subBackMode,
+            subBackConditions: ds.subBackConditions,
+            subBackConditionLogic: ds.subBackConditionLogic,
             sets: ds.sets?.map(s => ({
                 mode: s.mode,
                 benchId: s.bench?.id,
                 fatigueBand: s.fatigueBand,
                 benchFatigueBand: s.benchFatigueBand,
                 conditions: s.conditions,
-                conditionLogic: s.conditionLogic
+                conditionLogic: s.conditionLogic,
+                pinchServer: s.pinchServer,
+                subBackMode: s.subBackMode,
+                subBackConditions: s.subBackConditions,
+                subBackConditionLogic: s.subBackConditionLogic
             }))
         })),
         rotation_system: tactics.rotationSystem,
@@ -149,13 +163,21 @@ function transformToObject(model, roster) {
             benchFatigueBand: d.benchFatigueBand,
             conditions: d.conditions,
             conditionLogic: d.conditionLogic,
+            pinchServer: effectivePinchServer(subModeFromAttributes(d), d.pinchServer),
+            subBackMode: d.subBackMode,
+            subBackConditions: d.subBackConditions,
+            subBackConditionLogic: d.subBackConditionLogic,
             sets: d.sets?.map(s => ({
                 mode: s.mode,
                 bench: s.benchId != null ? findPlayer(s.benchId, roster) : undefined,
                 fatigueBand: s.fatigueBand,
                 benchFatigueBand: s.benchFatigueBand,
                 conditions: s.conditions,
-                conditionLogic: s.conditionLogic
+                conditionLogic: s.conditionLogic,
+                pinchServer: effectivePinchServer(s.mode, s.pinchServer),
+                subBackMode: s.subBackMode,
+                subBackConditions: s.subBackConditions,
+                subBackConditionLogic: s.subBackConditionLogic
             }))
         })),
         rotationSystem: model.rotation_system,
@@ -172,15 +194,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[CourtPosition.LEFT_FRONT], lineup[CourtPosition.MIDDLE_FRONT], lineup[CourtPosition.RIGHT_FRONT],
+            const allowedIds = new Set([lineup[CourtPosition.LEFT_FRONT], lineup[CourtPosition.MIDDLE_FRONT], lineup[CourtPosition.RIGHT_FRONT],
                 lineup[CourtPosition.LEFT_BACK], lineup[CourtPosition.MIDDLE_BACK], lineup[CourtPosition.RIGHT_BACK]]
                 .map((p) => p.id));
+            const liberoZoneId = lineup[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;
@@ -301,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,
@@ -315,15 +350,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[CourtPosition.LEFT_FRONT], model.lineup[CourtPosition.MIDDLE_FRONT],
+            const allowedSlotIds = new Set([model.lineup[CourtPosition.LEFT_FRONT], model.lineup[CourtPosition.MIDDLE_FRONT],
                 model.lineup[CourtPosition.RIGHT_FRONT], model.lineup[CourtPosition.LEFT_BACK],
                 model.lineup[CourtPosition.MIDDLE_BACK], model.lineup[CourtPosition.RIGHT_BACK]]);
+            const liberoZoneId = model.lineup[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/esm/src/data/transformers/tactics.test.js

@@ -58,6 +58,37 @@ describe('tacticsColumnsToApiDto()', () => {
         expect(dto.designatedSubs[0].fatigueBand).toBe(EnergyBand.WORN);
         expect(dto.designatedSubs[0].benchFatigueBand).toBe(EnergyBand.TIRED);
     });
+    it('defaults a legacy PINCH row (no pinchServer flag) to pinchServer true', () => {
+        const dto = tacticsColumnsToApiDto(makeTactics([
+            { starterId: 's1', benchId: 'b1', mode: 'PINCH', conditions: [{ type: 'ASAP' }] }
+        ]));
+        expect(dto.designatedSubs[0].pinchServer).toBe(true);
+    });
+    it('leaves pinchServer undefined for a non-PINCH row', () => {
+        const dto = tacticsColumnsToApiDto(makeTactics([
+            { starterId: 's1', benchId: 'b1', mode: 'FATIGUE', fatigueBand: EnergyBand.TIRED }
+        ]));
+        expect(dto.designatedSubs[0].pinchServer).toBeUndefined();
+    });
+    it('passes a conditional regular sub (pinchServer false + condition sub-back) through unchanged', () => {
+        const dto = tacticsColumnsToApiDto(makeTactics([
+            {
+                starterId: 's1',
+                benchId: 'b1',
+                mode: 'PINCH',
+                conditions: [{ type: 'SCORE_DIFF', direction: 'TRAILING', points: 3 }],
+                pinchServer: false,
+                subBackMode: 'CONDITIONS',
+                subBackConditions: [{ type: 'TEAM_SET_POINT', margin: 2, opponent: 'EITHER' }],
+                subBackConditionLogic: 'ANY'
+            }
+        ]));
+        const ds = dto.designatedSubs[0];
+        expect(ds.pinchServer).toBe(false);
+        expect(ds.subBackMode).toBe('CONDITIONS');
+        expect(ds.subBackConditions).toEqual([{ type: 'TEAM_SET_POINT', margin: 2, opponent: 'EITHER' }]);
+        expect(ds.subBackConditionLogic).toBe('ANY');
+    });
     it('drops a second libero that collides with the starting libero (not a reserve)', () => {
         const model = makeTactics([]);
         model.lineup[CourtPosition.LIBERO_ZONE] = 'libero1';
@@ -76,6 +107,21 @@ describe('tacticsColumnsToApiDto()', () => {
         expect(dto.secondLibero).toBe('reserve1');
         expect(dto.liberoSub).toEqual({ mode: 'FATIGUE' });
     });
+    it('keeps a libero-keyed replaceKnockedImmediately entry when a second libero exists (L2-only feature)', () => {
+        const model = makeTactics([]);
+        model.lineup[CourtPosition.LIBERO_ZONE] = 'libero1';
+        model.second_libero = 'reserve1';
+        model.replace_knocked_immediately = { libero1: false, lf: false };
+        const dto = tacticsColumnsToApiDto(model);
+        expect(dto.replaceKnockedImmediately).toEqual({ libero1: false, lf: false });
+    });
+    it('drops a libero-keyed replaceKnockedImmediately entry when there is no second libero', () => {
+        const model = makeTactics([]);
+        model.lineup[CourtPosition.LIBERO_ZONE] = 'libero1';
+        model.replace_knocked_immediately = { libero1: false, lf: false };
+        const dto = tacticsColumnsToApiDto(model);
+        expect(dto.replaceKnockedImmediately).toEqual({ lf: false });
+    });
     it('passes per-set tactics columns through to the API DTO shape', () => {
         const model = makeTactics([]);
         model.system_sets = [{ rotationSystem: RotationSystemEnum.FIVE_ONE, designatedSetters: ['lf'] }];
@@ -180,4 +226,25 @@ describe('libero injuries — service <-> row round-trip + lenient heal', () =>
         expect(back.liberoInjury?.secondLiberoBackfill).toBeUndefined();
         expect(back.liberoInjury?.inMatchDesignate?.id).toBe(reserveB.id);
     });
+    it('keeps a libero-keyed replaceKnockedImmediately entry on load when an L2 exists', () => {
+        const withKnock = 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 = transformFromTactics(withKnock, 'team-1');
+        const back = transformToTactics(attrs, roster);
+        expect(back.replaceKnockedImmediately).toEqual({ [libero.id]: false, [p1.id]: false });
+    });
+    it('drops a libero-keyed replaceKnockedImmediately entry on load when there is no L2', () => {
+        const withKnock = 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 = transformFromTactics(withKnock, 'team-1');
+        const back = transformToTactics(attrs, roster);
+        expect(back.replaceKnockedImmediately).toEqual({ [p1.id]: false });
+    });
 });

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

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