volleyballsimtypes 0.0.481 → 0.0.483

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

@@ -26,7 +26,8 @@ function makeTactics(designatedSubs) {
         libero_replacement_sets: undefined,
         rotation_system: '5-1',
         designated_setters: ['lf'],
-        offensive_preferences: [{ rotation: 1, order: ['lf', 'rf'] }]
+        offensive_preferences: [{ rotation: 1, weights: { lf: 60, rf: 40 } }],
+        blocking_preferences: []
     };
 }
 (0, globals_1.describe)('tacticsColumnsToApiDto()', () => {
@@ -37,27 +38,30 @@ function makeTactics(designatedSubs) {
         (0, globals_1.expect)(dto.rotationSystem).toBe('5-1');
         (0, globals_1.expect)(dto.liberoReplacements).toEqual(['lf']);
         (0, globals_1.expect)(dto.lineup.bench).toEqual(['b1', 'b2']);
-        (0, globals_1.expect)(dto.offensivePreferences).toEqual([{ rotation: 1, order: ['lf', 'rf'] }]);
+        (0, globals_1.expect)(dto.offensivePreferences).toEqual([{ rotation: 1, weights: { lf: 60, rf: 40 } }]);
     });
-    (0, globals_1.it)("resolves a legacy isPinchServer entry to mode 'PINCH'", () => {
+    (0, globals_1.it)('converts a legacy isPinchServer entry to a unified pinch server (conditions kept, no mode)', () => {
         const dto = (0, tactics_1.tacticsColumnsToApiDto)(makeTactics([
             { starterId: 's1', benchId: 'b1', isPinchServer: true, conditions: [{ type: 'ASAP' }] }
         ]));
-        (0, globals_1.expect)(dto.designatedSubs[0].mode).toBe('PINCH');
+        (0, globals_1.expect)(dto.designatedSubs[0].pinchServer).toBe(true);
+        (0, globals_1.expect)(dto.designatedSubs[0].conditions).toEqual([{ type: 'ASAP' }]);
+        (0, globals_1.expect)(dto.designatedSubs[0].mode).toBeUndefined();
     });
-    (0, globals_1.it)("resolves a legacy 'NEVER' fatigueBand to mode NEVER and drops the band", () => {
+    (0, globals_1.it)("converts a legacy 'NEVER' fatigueBand to an explicit empty condition list", () => {
         const dto = (0, tactics_1.tacticsColumnsToApiDto)(makeTactics([
             { starterId: 's1', fatigueBand: 'NEVER' }
         ]));
-        (0, globals_1.expect)(dto.designatedSubs[0].mode).toBe('NEVER');
+        (0, globals_1.expect)(dto.designatedSubs[0].conditions).toEqual([]);
         (0, globals_1.expect)(dto.designatedSubs[0].fatigueBand).toBeUndefined();
     });
-    (0, globals_1.it)('passes a fatigue entry with its own bands through unchanged', () => {
+    (0, globals_1.it)('converts a legacy fatigue entry to a FATIGUE condition carrying its band', () => {
         const dto = (0, tactics_1.tacticsColumnsToApiDto)(makeTactics([
             { starterId: 's1', benchId: 'b1', mode: 'FATIGUE', fatigueBand: service_1.EnergyBand.WORN, benchFatigueBand: service_1.EnergyBand.TIRED }
         ]));
-        (0, globals_1.expect)(dto.designatedSubs[0].mode).toBe('FATIGUE');
-        (0, globals_1.expect)(dto.designatedSubs[0].fatigueBand).toBe(service_1.EnergyBand.WORN);
+        (0, globals_1.expect)(dto.designatedSubs[0].conditions).toEqual([{ type: 'FATIGUE', band: service_1.EnergyBand.WORN }]);
+        (0, globals_1.expect)(dto.designatedSubs[0].subBackMode).toBe('FATIGUE');
+        (0, globals_1.expect)(dto.designatedSubs[0].pinchServer).toBe(false);
         (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', () => {
@@ -66,11 +70,12 @@ function makeTactics(designatedSubs) {
         ]));
         (0, globals_1.expect)(dto.designatedSubs[0].pinchServer).toBe(true);
     });
-    (0, globals_1.it)('leaves pinchServer undefined for a non-PINCH row', () => {
+    (0, globals_1.it)('passes an already-unified entry through untouched', () => {
         const dto = (0, tactics_1.tacticsColumnsToApiDto)(makeTactics([
-            { starterId: 's1', benchId: 'b1', mode: 'FATIGUE', fatigueBand: service_1.EnergyBand.TIRED }
+            { starterId: 's1', benchId: 'b1', conditions: [{ type: 'FATIGUE', band: service_1.EnergyBand.TIRED }], conditionLogic: 'ALL', pinchServer: false, subBackMode: 'FATIGUE' }
         ]));
-        (0, globals_1.expect)(dto.designatedSubs[0].pinchServer).toBeUndefined();
+        (0, globals_1.expect)(dto.designatedSubs[0].conditions).toEqual([{ type: 'FATIGUE', band: service_1.EnergyBand.TIRED }]);
+        (0, globals_1.expect)(dto.designatedSubs[0].pinchServer).toBe(false);
     });
     (0, globals_1.it)('passes a conditional regular sub (pinchServer false + condition sub-back) through unchanged', () => {
         const dto = (0, tactics_1.tacticsColumnsToApiDto)(makeTactics([
@@ -107,7 +112,8 @@ function makeTactics(designatedSubs) {
         model.libero_sub = { mode: 'FATIGUE' };
         const dto = (0, tactics_1.tacticsColumnsToApiDto)(model);
         (0, globals_1.expect)(dto.secondLibero).toBe('reserve1');
-        (0, globals_1.expect)(dto.liberoSub).toEqual({ mode: 'FATIGUE' });
+        // Legacy FATIGUE libero rule converts to the unified condition shape on the API read path.
+        (0, globals_1.expect)(dto.liberoSub).toEqual({ conditions: [{ type: 'FATIGUE' }], conditionLogic: 'ALL' });
     });
     (0, globals_1.it)('keeps a libero-keyed replaceKnockedImmediately entry when a second libero exists (L2-only feature)', () => {
         const model = makeTactics([]);
@@ -127,10 +133,10 @@ function makeTactics(designatedSubs) {
     (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'] }];
-        model.offensive_preference_sets = [[{ rotation: 1, order: ['rf', 'mf'] }]];
+        model.offensive_preference_sets = [[{ rotation: 1, weights: { rf: 55, mf: 45 } }]];
         const dto = (0, tactics_1.tacticsColumnsToApiDto)(model);
         (0, globals_1.expect)(dto.systemSets).toEqual([{ rotationSystem: '5-1', designatedSetters: ['lf'] }]);
-        (0, globals_1.expect)(dto.offensivePreferenceSets).toEqual([[{ rotation: 1, order: ['rf', 'mf'] }]]);
+        (0, globals_1.expect)(dto.offensivePreferenceSets).toEqual([[{ rotation: 1, weights: { rf: 55, mf: 45 } }]]);
     });
     (0, globals_1.it)('leaves the per-set DTO fields undefined when the columns are absent', () => {
         const dto = (0, tactics_1.tacticsColumnsToApiDto)(makeTactics([]));
@@ -154,7 +160,7 @@ function makeTactics(designatedSubs) {
             { rotationSystem: service_1.RotationSystemEnum.FIVE_ONE, designatedSetters: [p1] },
             { rotationSystem: service_1.RotationSystemEnum.SIX_ZERO, designatedSetters: [] }
         ],
-        offensivePreferenceSets: [[{ rotation: 1, order: [p2, p3] }]]
+        offensivePreferenceSets: [[{ rotation: 1, weights: { [p2.id]: 60, [p3.id]: 40 } }]]
     });
     (0, globals_1.it)('transformFromTactics writes the per-set overrides as id-based jsonb columns', () => {
         const attrs = (0, tactics_1.transformFromTactics)(tactics, 'team-1');
@@ -162,7 +168,7 @@ function makeTactics(designatedSubs) {
             { rotationSystem: '5-1', designatedSetters: [p1.id] },
             { rotationSystem: '6-0', designatedSetters: [] }
         ]);
-        (0, globals_1.expect)(attrs.offensive_preference_sets).toEqual([[{ rotation: 1, order: [p2.id, p3.id] }]]);
+        (0, globals_1.expect)(attrs.offensive_preference_sets).toEqual([[{ rotation: 1, weights: { [p2.id]: 60, [p3.id]: 40 } }]]);
     });
     (0, globals_1.it)('transformToTactics resolves the stored ids back to roster players', () => {
         const attrs = (0, tactics_1.transformFromTactics)(tactics, 'team-1');
@@ -170,7 +176,7 @@ function makeTactics(designatedSubs) {
         (0, globals_1.expect)(back.systemSets?.[0].rotationSystem).toBe(service_1.RotationSystemEnum.FIVE_ONE);
         (0, globals_1.expect)(back.systemSets?.[0].designatedSetters[0].id).toBe(p1.id);
         (0, globals_1.expect)(back.systemSets?.[1].designatedSetters).toEqual([]);
-        (0, globals_1.expect)(back.offensivePreferenceSets?.[0][0].order.map(p => p.id)).toEqual([p2.id, p3.id]);
+        (0, globals_1.expect)(back.offensivePreferenceSets?.[0][0].weights).toEqual({ [p2.id]: 60, [p3.id]: 40 });
     });
     (0, globals_1.it)('omits the per-set columns entirely for an all-sets config', () => {
         const flat = service_1.Tactics.create({
@@ -188,15 +194,28 @@ function makeTactics(designatedSubs) {
         const withTempos = service_1.Tactics.create({
             lineup: { 4: p4, 3: p3, 2: p2, 5: p5, 6: p6, 1: p1, bench: [] },
             liberoReplacements: [],
-            offensivePreferences: [{ rotation: 1, order: [p2, p3], tempos: { [p2.id]: 'FAST', [p3.id]: 'HIGH' } }]
+            offensivePreferences: [{ rotation: 1, weights: { [p2.id]: 60, [p3.id]: 40 }, tempos: { [p2.id]: 'FAST', [p3.id]: 'HIGH' } }]
         });
         const attrs = (0, tactics_1.transformFromTactics)(withTempos, 'team-1');
         (0, globals_1.expect)(attrs.offensive_preferences).toEqual([
-            { rotation: 1, order: [p2.id, p3.id], tempos: { [p2.id]: 'FAST', [p3.id]: 'HIGH' } }
+            { rotation: 1, weights: { [p2.id]: 60, [p3.id]: 40 }, tempos: { [p2.id]: 'FAST', [p3.id]: 'HIGH' } }
         ]);
         const back = (0, tactics_1.transformToTactics)(attrs, roster);
         (0, globals_1.expect)(back.offensivePreferences[0].tempos).toEqual({ [p2.id]: 'FAST', [p3.id]: 'HIGH' });
     });
+    (0, globals_1.it)('round-trips blocking preferences as id-keyed function maps', () => {
+        const withBlocking = service_1.Tactics.create({
+            lineup: { 4: p4, 3: p3, 2: p2, 5: p5, 6: p6, 1: p1, bench: [] },
+            liberoReplacements: [],
+            blockingPreferences: [{ rotation: 1, targets: { [p4.id]: service_1.RoleEnum.OUTSIDE_HITTER, [p3.id]: service_1.RoleEnum.MIDDLE_BLOCKER } }]
+        });
+        const attrs = (0, tactics_1.transformFromTactics)(withBlocking, 'team-1');
+        (0, globals_1.expect)(attrs.blocking_preferences).toEqual([
+            { rotation: 1, targets: { [p4.id]: service_1.RoleEnum.OUTSIDE_HITTER, [p3.id]: service_1.RoleEnum.MIDDLE_BLOCKER } }
+        ]);
+        const back = (0, tactics_1.transformToTactics)(attrs, roster);
+        (0, globals_1.expect)(back.blockingPreferences[0].targets).toEqual({ [p4.id]: service_1.RoleEnum.OUTSIDE_HITTER, [p3.id]: service_1.RoleEnum.MIDDLE_BLOCKER });
+    });
 });
 (0, globals_1.describe)('libero injuries — service <-> row round-trip + lenient heal', () => {
     const country = (0, test_helpers_1.makeCountry)();

package/dist/cjs/src/service/team/blocking-preference.d.ts

@@ -0,0 +1,5 @@
+import { LineupFunction } from './lineup-function';
+export interface BlockingPreference {
+    readonly rotation: number;
+    readonly targets: Record<string, LineupFunction>;
+}

package/dist/cjs/src/service/team/blocking-preference.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

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

package/dist/cjs/src/service/team/index.d.ts

@@ -7,9 +7,11 @@ export * from './energy-band';
 export * from './pinch-condition';
 export * from './designated-sub';
 export * from './libero-sub';
+export * from './sub-config-convert';
 export * from './rotation-system';
 export * from './lineup-function';
 export * from './base-position';
 export * from './offensive-preference';
+export * from './blocking-preference';
 export * from './injury-replacement';
 export * from './libero-injury';

package/dist/cjs/src/service/team/index.js

@@ -23,9 +23,11 @@ __exportStar(require("./energy-band"), exports);
 __exportStar(require("./pinch-condition"), exports);
 __exportStar(require("./designated-sub"), exports);
 __exportStar(require("./libero-sub"), exports);
+__exportStar(require("./sub-config-convert"), exports);
 __exportStar(require("./rotation-system"), exports);
 __exportStar(require("./lineup-function"), exports);
 __exportStar(require("./base-position"), exports);
 __exportStar(require("./offensive-preference"), exports);
+__exportStar(require("./blocking-preference"), exports);
 __exportStar(require("./injury-replacement"), exports);
 __exportStar(require("./libero-injury"), exports);

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

@@ -1,9 +1,5 @@
-import { EnergyBand } from './energy-band';
 import { ConditionLogic, PinchCondition } from './pinch-condition';
-export type LiberoSubMode = 'NEVER' | 'FATIGUE' | 'ALWAYS' | 'CONDITIONS';
 export interface LiberoSetSubConfig {
-    readonly mode: LiberoSubMode;
-    readonly fatigueBand?: EnergyBand;
     readonly conditions?: PinchCondition[];
     readonly conditionLogic?: ConditionLogic;
 }

package/dist/cjs/src/service/team/offensive-preference.d.ts

@@ -1,7 +1,6 @@
-import { Player } from '../player';
 export type TempoPreference = 'FAST' | 'HIGH';
 export interface OffensivePreference {
     readonly rotation: number;
-    readonly order: Player[];
+    readonly weights: Record<string, number>;
     readonly tempos?: Record<string, TempoPreference>;
 }

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

@@ -1,5 +1,6 @@
+import { EnergyBand, SubBand } from './energy-band';
 export declare enum PinchConditionType {
-    ASAP = "ASAP",// every time the linked starter wins back the serve
+    ASAP = "ASAP",// unconditionally true (pinch server: every serve gain; libero rule: "Always")
     TEAM_SET_POINT = "TEAM_SET_POINT",// team within `margin` of winning the set
     OPPONENT_SET_POINT = "OPPONENT_SET_POINT",// opponent within `margin` of winning the set
     SCORE_DIFF = "SCORE_DIFF",// team trailing/leading by at least `points`
@@ -7,7 +8,8 @@ export declare enum PinchConditionType {
     FROM_SET = "FROM_SET",// only set N or later
     MIN_OWN_SCORE = "MIN_OWN_SCORE",// only once own score >= N
     MIN_OPPONENT_SCORE = "MIN_OPPONENT_SCORE",// only once opponent score >= N
-    PHASE = "PHASE"
+    PHASE = "PHASE",// the team is serving or receiving this rally (used by the libero deployment rule)
+    FATIGUE = "FATIGUE"
 }
 export declare enum MatchPhase {
     SERVING = "SERVING",
@@ -66,7 +68,11 @@ export interface PhaseCondition {
     readonly type: PinchConditionType.PHASE;
     readonly phase: MatchPhase;
 }
-export type PinchCondition = AsapCondition | TeamSetPointCondition | OpponentSetPointCondition | ScoreDiffCondition | AfterRotationsCondition | FromSetCondition | MinOwnScoreCondition | MinOpponentScoreCondition | PhaseCondition;
+export interface FatigueCondition {
+    readonly type: PinchConditionType.FATIGUE;
+    readonly band?: EnergyBand;
+}
+export type PinchCondition = AsapCondition | TeamSetPointCondition | OpponentSetPointCondition | ScoreDiffCondition | AfterRotationsCondition | FromSetCondition | MinOwnScoreCondition | MinOpponentScoreCondition | PhaseCondition | FatigueCondition;
 export type ConditionLogic = 'ALL' | 'ANY';
 export interface PinchSetState {
     readonly ownScore: number;
@@ -75,4 +81,6 @@ export interface PinchSetState {
     readonly setNumber: number;
     readonly ownServeTurns: number;
     readonly phase: MatchPhase;
+    readonly subjectBand?: EnergyBand;
+    readonly defaultBand?: SubBand;
 }

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

@@ -1,9 +1,10 @@
 "use strict";
-// Conditions that gate when a pinch server is forced in to serve (in for its linked starter when the team
-// wins back the serve, out the moment the serve is lost). Each condition is evaluated against the live set
-// state; a pinch entry combines them with ALL (every condition must hold) or ANY (one is enough).
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Comparison = exports.ScoreDirection = exports.OpponentRelation = exports.MatchPhase = exports.PinchConditionType = void 0;
+// The ONE condition vocabulary of the substitution engine (owner 2026-07-11): designated substitutions,
+// pinch servers, sub-backs, and the libero deployment rule all evaluate the same catalog against the live
+// set state, combined with ALL (every condition must hold) or ANY (one is enough). A config with NO
+// conditions never fires.
 var PinchConditionType;
 (function (PinchConditionType) {
     PinchConditionType["ASAP"] = "ASAP";
@@ -14,7 +15,11 @@ var PinchConditionType;
     PinchConditionType["FROM_SET"] = "FROM_SET";
     PinchConditionType["MIN_OWN_SCORE"] = "MIN_OWN_SCORE";
     PinchConditionType["MIN_OPPONENT_SCORE"] = "MIN_OPPONENT_SCORE";
-    PinchConditionType["PHASE"] = "PHASE"; // the team is serving or receiving this rally (used by the libero deployment rule)
+    PinchConditionType["PHASE"] = "PHASE";
+    // The SUBJECT player's energy is at-or-worse than `band` (absent band = the team `substitutionBand`). The
+    // subject comes from the evaluation context, never from the condition: sub-in conditions judge the STARTER
+    // on court, sub-back conditions judge the SUBSTITUTE on court, the libero rule judges the STARTING libero.
+    PinchConditionType["FATIGUE"] = "FATIGUE";
 })(PinchConditionType || (exports.PinchConditionType = PinchConditionType = {}));
 // Which side of the rally the team is on. Known at each dead ball: the serving team is SERVING, the other
 // RECEIVING. Consumed by the PHASE condition (libero deployment); pinch servers always evaluate while SERVING.

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

@@ -34,26 +34,17 @@ export declare const PinchConditionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<PinchConditionType.PHASE>;
     phase: z.ZodEnum<typeof MatchPhase>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<PinchConditionType.FATIGUE>;
+    band: z.ZodOptional<z.ZodEnum<typeof EnergyBand>>;
 }, z.core.$strip>], "type">;
 export declare const ConditionLogicSchema: z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodLiteral<"ANY">]>;
-export declare const SubModeSchema: z.ZodEnum<{
-    NEVER: "NEVER";
-    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";
-        FATIGUE: "FATIGUE";
-        PINCH: "PINCH";
-    }>;
+export declare const SetSubConfigSchema: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodObject<{
     bench: z.ZodOptional<z.ZodCustom<Player, Player>>;
-    fatigueBand: z.ZodOptional<z.ZodEnum<typeof EnergyBand>>;
-    benchFatigueBand: z.ZodOptional<z.ZodEnum<typeof EnergyBand>>;
     conditions: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         type: z.ZodLiteral<PinchConditionType.ASAP>;
     }, z.core.$strip>, z.ZodObject<{
@@ -85,9 +76,13 @@ export declare const SetSubConfigSchema: z.ZodObject<{
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<PinchConditionType.PHASE>;
         phase: z.ZodEnum<typeof MatchPhase>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<PinchConditionType.FATIGUE>;
+        band: z.ZodOptional<z.ZodEnum<typeof EnergyBand>>;
     }, z.core.$strip>], "type">>>;
     conditionLogic: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodLiteral<"ANY">]>>;
     pinchServer: z.ZodOptional<z.ZodBoolean>;
+    benchFatigueBand: z.ZodOptional<z.ZodEnum<typeof EnergyBand>>;
     subBackMode: z.ZodOptional<z.ZodEnum<{
         FATIGUE: "FATIGUE";
         CONDITIONS: "CONDITIONS";
@@ -123,19 +118,15 @@ export declare const SetSubConfigSchema: z.ZodObject<{
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<PinchConditionType.PHASE>;
         phase: z.ZodEnum<typeof MatchPhase>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<PinchConditionType.FATIGUE>;
+        band: z.ZodOptional<z.ZodEnum<typeof EnergyBand>>;
     }, 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<{
-        mode: z.ZodEnum<{
-            NEVER: "NEVER";
-            FATIGUE: "FATIGUE";
-            PINCH: "PINCH";
-        }>;
+}, z.core.$strip>>;
+export declare const DesignatedSubSchema: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodObject<{
+    sets: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodObject<{
         bench: z.ZodOptional<z.ZodCustom<Player, Player>>;
-        fatigueBand: z.ZodOptional<z.ZodEnum<typeof EnergyBand>>;
-        benchFatigueBand: z.ZodOptional<z.ZodEnum<typeof EnergyBand>>;
         conditions: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
             type: z.ZodLiteral<PinchConditionType.ASAP>;
         }, z.core.$strip>, z.ZodObject<{
@@ -167,9 +158,13 @@ export declare const DesignatedSubSchema: z.ZodObject<{
         }, z.core.$strip>, z.ZodObject<{
             type: z.ZodLiteral<PinchConditionType.PHASE>;
             phase: z.ZodEnum<typeof MatchPhase>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<PinchConditionType.FATIGUE>;
+            band: z.ZodOptional<z.ZodEnum<typeof EnergyBand>>;
         }, z.core.$strip>], "type">>>;
         conditionLogic: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodLiteral<"ANY">]>>;
         pinchServer: z.ZodOptional<z.ZodBoolean>;
+        benchFatigueBand: z.ZodOptional<z.ZodEnum<typeof EnergyBand>>;
         subBackMode: z.ZodOptional<z.ZodEnum<{
             FATIGUE: "FATIGUE";
             CONDITIONS: "CONDITIONS";
@@ -205,17 +200,13 @@ export declare const DesignatedSubSchema: z.ZodObject<{
         }, z.core.$strip>, z.ZodObject<{
             type: z.ZodLiteral<PinchConditionType.PHASE>;
             phase: z.ZodEnum<typeof MatchPhase>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<PinchConditionType.FATIGUE>;
+            band: z.ZodOptional<z.ZodEnum<typeof EnergyBand>>;
         }, z.core.$strip>], "type">>>;
         subBackConditionLogic: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodLiteral<"ANY">]>>;
-    }, z.core.$strip>>>;
-    mode: z.ZodEnum<{
-        NEVER: "NEVER";
-        FATIGUE: "FATIGUE";
-        PINCH: "PINCH";
-    }>;
+    }, z.core.$strip>>>>;
     bench: z.ZodOptional<z.ZodCustom<Player, Player>>;
-    fatigueBand: z.ZodOptional<z.ZodEnum<typeof EnergyBand>>;
-    benchFatigueBand: z.ZodOptional<z.ZodEnum<typeof EnergyBand>>;
     conditions: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         type: z.ZodLiteral<PinchConditionType.ASAP>;
     }, z.core.$strip>, z.ZodObject<{
@@ -247,9 +238,13 @@ export declare const DesignatedSubSchema: z.ZodObject<{
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<PinchConditionType.PHASE>;
         phase: z.ZodEnum<typeof MatchPhase>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<PinchConditionType.FATIGUE>;
+        band: z.ZodOptional<z.ZodEnum<typeof EnergyBand>>;
     }, z.core.$strip>], "type">>>;
     conditionLogic: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodLiteral<"ANY">]>>;
     pinchServer: z.ZodOptional<z.ZodBoolean>;
+    benchFatigueBand: z.ZodOptional<z.ZodEnum<typeof EnergyBand>>;
     subBackMode: z.ZodOptional<z.ZodEnum<{
         FATIGUE: "FATIGUE";
         CONDITIONS: "CONDITIONS";
@@ -285,7 +280,10 @@ export declare const DesignatedSubSchema: z.ZodObject<{
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<PinchConditionType.PHASE>;
         phase: z.ZodEnum<typeof MatchPhase>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<PinchConditionType.FATIGUE>;
+        band: z.ZodOptional<z.ZodEnum<typeof EnergyBand>>;
     }, z.core.$strip>], "type">>>;
     subBackConditionLogic: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodLiteral<"ANY">]>>;
     starter: z.ZodCustom<Player, Player>;
-}, z.core.$strip>;
+}, z.core.$strip>>;

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

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DesignatedSubSchema = exports.SetSubConfigSchema = exports.SubBackModeSchema = exports.SubModeSchema = exports.ConditionLogicSchema = exports.PinchConditionSchema = exports.SubBandSchema = void 0;
+exports.DesignatedSubSchema = exports.SetSubConfigSchema = exports.SubBackModeSchema = 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");
 const pinch_condition_1 = require("../pinch-condition");
+const sub_config_convert_1 = require("../sub-config-convert");
 const playerInstanceSchema = zod_1.z.custom((v) => v instanceof player_1.Player, {
     message: 'INVALID_PLAYER_INSTANCE'
 });
@@ -21,44 +22,47 @@ exports.PinchConditionSchema = zod_1.z.discriminatedUnion('type', [
     zod_1.z.object({ type: zod_1.z.literal(pinch_condition_1.PinchConditionType.MIN_OWN_SCORE), score: zod_1.z.number().int().min(0).max(40), comparison: zod_1.z.nativeEnum(pinch_condition_1.Comparison).optional() }),
     zod_1.z.object({ type: zod_1.z.literal(pinch_condition_1.PinchConditionType.MIN_OPPONENT_SCORE), score: zod_1.z.number().int().min(0).max(40), comparison: zod_1.z.nativeEnum(pinch_condition_1.Comparison).optional() }),
     // PHASE is used by the libero deployment rule (which reuses this schema); pinch servers never offer it.
-    zod_1.z.object({ type: zod_1.z.literal(pinch_condition_1.PinchConditionType.PHASE), phase: zod_1.z.nativeEnum(pinch_condition_1.MatchPhase) })
+    zod_1.z.object({ type: zod_1.z.literal(pinch_condition_1.PinchConditionType.PHASE), phase: zod_1.z.nativeEnum(pinch_condition_1.MatchPhase) }),
+    // The subject player's energy is at-or-worse than `band` (absent = the team `substitutionBand`); the
+    // subject comes from the evaluation context (starter / substitute / starting libero).
+    zod_1.z.object({ type: zod_1.z.literal(pinch_condition_1.PinchConditionType.FATIGUE), band: zod_1.z.nativeEnum(energy_band_1.EnergyBand).optional() })
 ]);
 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.
+// Fields shared by the all-sets config and each per-set config. Pure condition engine (owner 2026-07-11):
+// no mode; `conditions` is the sub-in trigger and an EMPTY/absent list means the starter is never substituted
+// by this rule. Legacy mode-shaped inputs are auto-converted by the preprocess below.
 const setSubConfigShape = {
-    mode: exports.SubModeSchema,
     bench: playerInstanceSchema.optional(),
-    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(),
-    // pinch ("Conditions") mode. true = serve-and-return pinch server; false/absent = regular conditional sub.
+    // true = serve-and-return pinch server; false/absent = regular conditional sub (stays until sub-back).
     pinchServer: zod_1.z.boolean().optional(),
-    // a regular conditional sub's sub-back trigger + its condition set (subBackMode === 'CONDITIONS').
+    // The substitute's own pull band for FATIGUE sub-backs (absent = the team `substitutionBand`).
+    benchFatigueBand: zod_1.z.nativeEnum(energy_band_1.EnergyBand).optional(),
     subBackMode: exports.SubBackModeSchema.optional(),
     subBackConditions: zod_1.z.array(exports.PinchConditionSchema).optional(),
     subBackConditionLogic: exports.ConditionLogicSchema.optional()
 };
-// 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;
-    if (data.bench == null) {
-        ctx.addIssue({ code: 'custom', message: 'PINCH_SERVER_REQUIRES_BENCH', path: ['bench'] });
-    }
-    if (data.conditions == null || data.conditions.length === 0) {
-        ctx.addIssue({ code: 'custom', message: 'PINCH_SERVER_REQUIRES_CONDITIONS', path: ['conditions'] });
+// A pinch server needs a designated bench player and at least one sub-in condition. A regular conditional sub
+// with a CONDITIONS sub-back needs at least one sub-back condition. Empty sub-in conditions are otherwise
+// VALID (= never fires).
+function refineSubConfig(data, ctx) {
+    if (data.pinchServer === true) {
+        if (data.bench == null) {
+            ctx.addIssue({ code: 'custom', message: 'PINCH_SERVER_REQUIRES_BENCH', path: ['bench'] });
+        }
+        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({
+exports.SetSubConfigSchema = zod_1.z.preprocess(sub_config_convert_1.convertLegacySetSubConfig, zod_1.z.object(setSubConfigShape).superRefine(refineSubConfig));
+exports.DesignatedSubSchema = zod_1.z.preprocess(sub_config_convert_1.convertLegacyDesignatedSub, zod_1.z.object({
     starter: playerInstanceSchema,
     ...setSubConfigShape,
     // Optional per-set overrides (index 0 = set 1 ... index 4 = set 5); absent => the flat config for all sets.
@@ -67,5 +71,5 @@ exports.DesignatedSubSchema = zod_1.z.object({
     // The flat config is the fallback for any set a partial `sets` array doesn't cover, so validate it whenever
     // `sets` is absent or covers fewer than 5 sets (each present per-set config is validated by SetSubConfigSchema).
     if (data.sets == null || data.sets.length < 5)
-        refinePinch(data, ctx);
-});
+        refineSubConfig(data, ctx);
+}));

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

@@ -116,12 +116,14 @@ const test_helpers_1 = require("../../test-helpers");
         });
         (0, globals_1.expect)(res.success).toBe(true);
     });
-    (0, globals_1.it)('rejects an unknown mode', () => {
+    (0, globals_1.it)('heals an unknown legacy mode by stripping it (lenient conversion, config stays valid)', () => {
         const res = designated_sub_z_1.DesignatedSubSchema.safeParse({
             starter,
             mode: 'SOMETIMES'
         });
-        (0, globals_1.expect)(res.success).toBe(false);
+        (0, globals_1.expect)(res.success).toBe(true);
+        if (res.success)
+            (0, globals_1.expect)(res.data.mode).toBeUndefined();
     });
     (0, globals_1.it)('accepts a pinch-mode entry with a bench server and conditions', () => {
         const res = designated_sub_z_1.DesignatedSubSchema.safeParse({

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

@@ -1,19 +1,5 @@
 import { z } from 'zod';
-import { EnergyBand } from '../energy-band';
-export declare const LiberoSubModeSchema: z.ZodEnum<{
-    NEVER: "NEVER";
-    FATIGUE: "FATIGUE";
-    CONDITIONS: "CONDITIONS";
-    ALWAYS: "ALWAYS";
-}>;
-export declare const LiberoSetSubConfigSchema: z.ZodObject<{
-    mode: z.ZodEnum<{
-        NEVER: "NEVER";
-        FATIGUE: "FATIGUE";
-        CONDITIONS: "CONDITIONS";
-        ALWAYS: "ALWAYS";
-    }>;
-    fatigueBand: z.ZodOptional<z.ZodEnum<typeof EnergyBand>>;
+export declare const LiberoSetSubConfigSchema: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodObject<{
     conditions: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         type: z.ZodLiteral<import("..").PinchConditionType.ASAP>;
     }, z.core.$strip>, z.ZodObject<{
@@ -45,18 +31,14 @@ export declare const LiberoSetSubConfigSchema: z.ZodObject<{
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<import("..").PinchConditionType.PHASE>;
         phase: z.ZodEnum<typeof import("..").MatchPhase>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<import("..").PinchConditionType.FATIGUE>;
+        band: z.ZodOptional<z.ZodEnum<typeof import("..").EnergyBand>>;
     }, z.core.$strip>], "type">>>;
     conditionLogic: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodLiteral<"ANY">]>>;
-}, z.core.$strip>;
-export declare const LiberoSubConfigSchema: z.ZodObject<{
-    sets: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        mode: z.ZodEnum<{
-            NEVER: "NEVER";
-            FATIGUE: "FATIGUE";
-            CONDITIONS: "CONDITIONS";
-            ALWAYS: "ALWAYS";
-        }>;
-        fatigueBand: z.ZodOptional<z.ZodEnum<typeof EnergyBand>>;
+}, z.core.$strip>>;
+export declare const LiberoSubConfigSchema: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodObject<{
+    sets: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodObject<{
         conditions: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
             type: z.ZodLiteral<import("..").PinchConditionType.ASAP>;
         }, z.core.$strip>, z.ZodObject<{
@@ -88,16 +70,12 @@ export declare const LiberoSubConfigSchema: z.ZodObject<{
         }, z.core.$strip>, z.ZodObject<{
             type: z.ZodLiteral<import("..").PinchConditionType.PHASE>;
             phase: z.ZodEnum<typeof import("..").MatchPhase>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<import("..").PinchConditionType.FATIGUE>;
+            band: z.ZodOptional<z.ZodEnum<typeof import("..").EnergyBand>>;
         }, z.core.$strip>], "type">>>;
         conditionLogic: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodLiteral<"ANY">]>>;
-    }, z.core.$strip>>>;
-    mode: z.ZodEnum<{
-        NEVER: "NEVER";
-        FATIGUE: "FATIGUE";
-        CONDITIONS: "CONDITIONS";
-        ALWAYS: "ALWAYS";
-    }>;
-    fatigueBand: z.ZodOptional<z.ZodEnum<typeof EnergyBand>>;
+    }, z.core.$strip>>>>;
     conditions: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         type: z.ZodLiteral<import("..").PinchConditionType.ASAP>;
     }, z.core.$strip>, z.ZodObject<{
@@ -129,6 +107,9 @@ export declare const LiberoSubConfigSchema: z.ZodObject<{
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<import("..").PinchConditionType.PHASE>;
         phase: z.ZodEnum<typeof import("..").MatchPhase>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<import("..").PinchConditionType.FATIGUE>;
+        band: z.ZodOptional<z.ZodEnum<typeof import("..").EnergyBand>>;
     }, z.core.$strip>], "type">>>;
     conditionLogic: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodLiteral<"ANY">]>>;
-}, z.core.$strip>;
+}, z.core.$strip>>;