volleyballsimtypes 0.0.482 → 0.0.483

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

@@ -1,8 +1,8 @@
 import { pack, unpack } from 'msgpackr';
 import { deflateRawSync, inflateRawSync } from 'zlib';
 import { decompressFromBase64 } from 'lz-string';
-import { Block, LiberoReplacement, Rally, Reception, Serve, Set as VolleySet, Spike, Substitution } from '../../service';
-import { transformToBlock, transformToCompact, transformToLiberoReplacement, transformToReception, transformToServe, transformToSet, transformToSpike, transformToSubstitution } from './rally-event';
+import { Block, FreeBall, LiberoReplacement, Rally, Reception, Serve, Set as VolleySet, Spike, Substitution } from '../../service';
+import { transformToBlock, transformToCompact, transformToFreeBall, transformToLiberoReplacement, transformToReception, transformToServe, transformToSet, transformToSpike, transformToSubstitution } from './rally-event';
 const VERSION_BYTE = 0x01;
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function deflate(data) { return deflateRawSync(data); }
@@ -57,6 +57,7 @@ function decodeCompactEvent(event, roster) {
         case 4: return transformToSet(event, roster);
         case 5: return transformToSpike(event, roster);
         case 6: return transformToBlock(event, roster);
+        case 7: return transformToFreeBall(event, roster);
         default: throw new Error(`UNKNOWN_EVENT_TYPE: ${String(event.e)}`);
     }
 }
@@ -69,6 +70,7 @@ function decodeLegacyEvent(event) {
         case 4: return VolleySet.create({ failure: event.f, type: event.t, playerId: event.p, target: event.a, score: event.s });
         case 5: return Spike.create({ failure: event.f, type: event.t, playerId: event.p, target: event.a, score: event.s });
         case 6: return Block.create({ failure: event.f, type: event.t, playerId: event.p, target: event.a, blockers: event.b ?? [], score: event.s });
+        case 7: return FreeBall.create({ failure: event.f, type: event.t, playerId: event.p, target: event.a, score: event.s });
         default: throw new Error(`UNKNOWN_EVENT_TYPE: ${String(event.e)}`);
     }
 }

package/dist/esm/src/data/transformers/rally.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/src/data/transformers/rally.test.js

@@ -0,0 +1,60 @@
+import { describe, it, expect } from '@jest/globals';
+import { v4 as uuidv4 } from 'uuid';
+import { Block, BlockFailureEnum, BlockTypeEnum, EventTypeEnum, FreeBall, FreeBallFailureEnum, FreeBallTypeEnum, LiberoReplacement, LiberoReplacementTypeEnum, Rally, Reception, ReceptionFailureEnum, ReceptionTypeEnum, Serve, ServeFailureEnum, ServeTypeEnum, Set as VolleySet, SetFailureEnum, SetTempoEnum, SetTypeEnum, Spike, SpikeFailureEnum, SpikeTypeEnum, Substitution } from '../../service';
+import { transformFromRally, transformToRally } from './rally';
+// End-to-end rally round trip (encode -> bytea -> decode) exercising the decodeCompactEvent switch, with one
+// event of EVERY EventTypeEnum member. This is the guard that would have caught the FREE_BALL decoder gap: the
+// encoder is generic (out.e = evt.eventType) but the decoder is a hardcoded switch, so a new event type that is
+// not wired into the switch throws UNKNOWN_EVENT_TYPE here. The coverage test forces new members into this list.
+describe('rally compact round trip — every event type', () => {
+    const pA = uuidv4();
+    const pB = uuidv4();
+    const pC = uuidv4();
+    const setId = uuidv4();
+    const events = [
+        LiberoReplacement.create({ playerId: pA, libero: pB, type: LiberoReplacementTypeEnum.LIBERO_IN }),
+        Substitution.create({ playerId: pA, playerOut: pC, injury: true }),
+        Serve.create({ playerId: pA, target: 6, score: 55, failure: ServeFailureEnum.NO_FAILURE, type: ServeTypeEnum.JUMP_TOPSPIN }),
+        Reception.create({ playerId: pB, target: 5, score: 50, failure: ReceptionFailureEnum.NO_FAILURE, type: ReceptionTypeEnum.DIG }),
+        VolleySet.create({ playerId: pC, target: 3, score: 48, failure: SetFailureEnum.NO_FAILURE, type: SetTypeEnum.OVERHAND, tempo: SetTempoEnum.FIRST }),
+        Spike.create({ playerId: pA, target: 4, score: 62.5, failure: SpikeFailureEnum.NO_FAILURE, type: SpikeTypeEnum.CROSS_SHOT }),
+        Block.create({ playerId: pB, blockers: [pB, pC], target: 8, score: 48, failure: BlockFailureEnum.NO_FAILURE, type: BlockTypeEnum.DOUBLE }),
+        FreeBall.create({ playerId: pC, target: 6, score: 45, failure: FreeBallFailureEnum.NO_FAILURE, type: FreeBallTypeEnum.OVER })
+    ];
+    const rally = Rally.create({ id: uuidv4(), order: 0, servingTeamId: uuidv4(), events });
+    it('covers every EventTypeEnum member (adding a new event type must extend this list)', () => {
+        const numericTypes = Object.values(EventTypeEnum).filter((v) => typeof v === 'number');
+        const present = new Set(events.map(e => e.eventType));
+        for (const t of numericTypes)
+            expect(present.has(t)).toBe(true);
+        expect(present.size).toBe(numericTypes.length);
+    });
+    it('encodes then decodes every event type back to an equal event (guards the decoder switch)', () => {
+        const attrs = transformFromRally(rally, setId);
+        const decoded = transformToRally(attrs);
+        expect(decoded.events).toHaveLength(events.length);
+        expect(decoded.events.map(e => e.eventType)).toEqual(events.map(e => e.eventType));
+        const [lib, sub, serve, rec, set, spike, block, free] = decoded.events;
+        expect(lib.playerId).toBe(pA);
+        expect(lib.libero).toBe(pB);
+        expect(lib.type).toBe(LiberoReplacementTypeEnum.LIBERO_IN);
+        expect(sub.playerOut).toBe(pC);
+        expect(sub.injury).toBe(true);
+        expect(serve.target).toBe(6);
+        expect(serve.score).toBe(55);
+        expect(serve.type).toBe(ServeTypeEnum.JUMP_TOPSPIN);
+        expect(rec.target).toBe(5);
+        expect(rec.type).toBe(ReceptionTypeEnum.DIG);
+        expect(set.type).toBe(SetTypeEnum.OVERHAND);
+        expect(set.tempo).toBe(SetTempoEnum.FIRST);
+        expect(spike.type).toBe(SpikeTypeEnum.CROSS_SHOT);
+        expect(spike.score).toBe(62.5);
+        expect(block.type).toBe(BlockTypeEnum.DOUBLE);
+        expect(block.blockers).toEqual([pB, pC]);
+        expect(free.playerId).toBe(pC);
+        expect(free.target).toBe(6);
+        expect(free.score).toBe(45);
+        expect(free.type).toBe(FreeBallTypeEnum.OVER);
+        expect(free.failure).toBe(FreeBallFailureEnum.NO_FAILURE);
+    });
+});

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

@@ -1,22 +1,7 @@
-import { CourtPosition, Tactics } from '../../service';
-// Back-compat: new rows persist `mode`; rows written before the mode change persist `isPinchServer` (+ a
-// 'NEVER' fatigueBand for the old "never fatigue-sub" state). Derive the mode so existing data keeps working
-// until the next tactics save rewrites it in the new shape.
-function subModeFromAttributes(d) {
-    if (d.mode != null)
-        return d.mode;
-    if (d.isPinchServer === true)
-        return 'PINCH';
-    if (d.fatigueBand === 'NEVER')
-        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;
-}
+import { convertLegacyLiberoSubConfig, convertLegacySetSubConfig, CourtPosition, Tactics } from '../../service';
+// Unified condition engine (owner 2026-07-11): the READ path passes legacy fields (mode / fatigueBand /
+// isPinchServer) through RAW; the schema preprocess in Tactics.create converts every legacy shape (see
+// service/team/sub-config-convert.ts). The WRITE path persists only the unified shape.
 function findPlayer(id, roster) {
     const player = roster.find((p) => p.id === id);
     if (player == null)
@@ -60,23 +45,19 @@ function transformToAttributes(tactics, teamId) {
         designated_subs: tactics.designatedSubs.map(ds => ({
             starterId: ds.starter.id,
             benchId: ds.bench?.id,
-            mode: ds.mode,
-            fatigueBand: ds.fatigueBand,
-            benchFatigueBand: ds.benchFatigueBand,
             conditions: ds.conditions,
             conditionLogic: ds.conditionLogic,
             pinchServer: ds.pinchServer,
+            benchFatigueBand: ds.benchFatigueBand,
             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,
                 pinchServer: s.pinchServer,
+                benchFatigueBand: s.benchFatigueBand,
                 subBackMode: s.subBackMode,
                 subBackConditions: s.subBackConditions,
                 subBackConditionLogic: s.subBackConditionLogic
@@ -159,15 +140,19 @@ function transformToObject(model, roster) {
         secondLibero,
         liberoSub: secondLibero != null ? (model.libero_sub ?? undefined) : undefined,
         liberoReplacementSets,
+        // Legacy fields (mode / fatigueBand / isPinchServer) pass through RAW: the DesignatedSubSchema preprocess
+        // inside Tactics.create converts every legacy shape (mode-era AND isPinchServer-era rows) to the unified
+        // condition engine. Only the player references are resolved here.
         designatedSubs: (model.designated_subs ?? []).map(d => ({
             starter: findPlayer(d.starterId, roster),
             bench: d.benchId != null ? findPlayer(d.benchId, roster) : undefined,
-            mode: subModeFromAttributes(d),
-            fatigueBand: d.fatigueBand === 'NEVER' ? undefined : d.fatigueBand,
+            mode: d.mode,
+            isPinchServer: d.isPinchServer,
+            fatigueBand: d.fatigueBand,
             benchFatigueBand: d.benchFatigueBand,
             conditions: d.conditions,
             conditionLogic: d.conditionLogic,
-            pinchServer: effectivePinchServer(subModeFromAttributes(d), d.pinchServer),
+            pinchServer: d.pinchServer,
             subBackMode: d.subBackMode,
             subBackConditions: d.subBackConditions,
             subBackConditionLogic: d.subBackConditionLogic,
@@ -178,7 +163,7 @@ function transformToObject(model, roster) {
                 benchFatigueBand: s.benchFatigueBand,
                 conditions: s.conditions,
                 conditionLogic: s.conditionLogic,
-                pinchServer: effectivePinchServer(s.mode, s.pinchServer),
+                pinchServer: s.pinchServer,
                 subBackMode: s.subBackMode,
                 subBackConditions: s.subBackConditions,
                 subBackConditionLogic: s.subBackConditionLogic
@@ -326,33 +311,20 @@ function tacticsColumnsToApiDto(model) {
         receiveRotationOffset: model.receive_rotation_offset,
         substitutionBand: model.substitution_band,
         secondLibero: validSecondLibero,
-        liberoSub: validSecondLibero != null ? model.libero_sub : undefined,
+        // The API surfaces the UNIFIED condition-engine shape: legacy rows (mode-era / isPinchServer-era) convert
+        // here via the same service converters the schema preprocess uses, so clients never see a mode.
+        liberoSub: validSecondLibero != null
+            ? (model.libero_sub != null ? convertLegacyLiberoSubConfig(model.libero_sub) : undefined)
+            : undefined,
         liberoReplacementSets: validLiberoReplacementSets,
-        designatedSubs: (model.designated_subs ?? []).map(d => ({
-            starterId: d.starterId,
-            benchId: d.benchId,
-            mode: subModeFromAttributes(d),
-            fatigueBand: d.fatigueBand === 'NEVER' ? undefined : d.fatigueBand,
-            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,
-                pinchServer: effectivePinchServer(s.mode, s.pinchServer),
-                subBackMode: s.subBackMode,
-                subBackConditions: s.subBackConditions,
-                subBackConditionLogic: s.subBackConditionLogic
-            }))
-        })),
+        designatedSubs: (model.designated_subs ?? []).map(d => {
+            const { starterId, sets, ...cfg } = d;
+            return {
+                ...convertLegacySetSubConfig(cfg),
+                starterId,
+                sets: sets?.map(s => convertLegacySetSubConfig(s))
+            };
+        }),
         rotationSystem: model.rotation_system,
         designatedSetters: model.designated_setters,
         offensivePreferences: model.offensive_preferences,

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

@@ -38,25 +38,28 @@ describe('tacticsColumnsToApiDto()', () => {
         expect(dto.lineup.bench).toEqual(['b1', 'b2']);
         expect(dto.offensivePreferences).toEqual([{ rotation: 1, weights: { lf: 60, rf: 40 } }]);
     });
-    it("resolves a legacy isPinchServer entry to mode 'PINCH'", () => {
+    it('converts a legacy isPinchServer entry to a unified pinch server (conditions kept, no mode)', () => {
         const dto = tacticsColumnsToApiDto(makeTactics([
             { starterId: 's1', benchId: 'b1', isPinchServer: true, conditions: [{ type: 'ASAP' }] }
         ]));
-        expect(dto.designatedSubs[0].mode).toBe('PINCH');
+        expect(dto.designatedSubs[0].pinchServer).toBe(true);
+        expect(dto.designatedSubs[0].conditions).toEqual([{ type: 'ASAP' }]);
+        expect(dto.designatedSubs[0].mode).toBeUndefined();
     });
-    it("resolves a legacy 'NEVER' fatigueBand to mode NEVER and drops the band", () => {
+    it("converts a legacy 'NEVER' fatigueBand to an explicit empty condition list", () => {
         const dto = tacticsColumnsToApiDto(makeTactics([
             { starterId: 's1', fatigueBand: 'NEVER' }
         ]));
-        expect(dto.designatedSubs[0].mode).toBe('NEVER');
+        expect(dto.designatedSubs[0].conditions).toEqual([]);
         expect(dto.designatedSubs[0].fatigueBand).toBeUndefined();
     });
-    it('passes a fatigue entry with its own bands through unchanged', () => {
+    it('converts a legacy fatigue entry to a FATIGUE condition carrying its band', () => {
         const dto = tacticsColumnsToApiDto(makeTactics([
             { starterId: 's1', benchId: 'b1', mode: 'FATIGUE', fatigueBand: EnergyBand.WORN, benchFatigueBand: EnergyBand.TIRED }
         ]));
-        expect(dto.designatedSubs[0].mode).toBe('FATIGUE');
-        expect(dto.designatedSubs[0].fatigueBand).toBe(EnergyBand.WORN);
+        expect(dto.designatedSubs[0].conditions).toEqual([{ type: 'FATIGUE', band: EnergyBand.WORN }]);
+        expect(dto.designatedSubs[0].subBackMode).toBe('FATIGUE');
+        expect(dto.designatedSubs[0].pinchServer).toBe(false);
         expect(dto.designatedSubs[0].benchFatigueBand).toBe(EnergyBand.TIRED);
     });
     it('defaults a legacy PINCH row (no pinchServer flag) to pinchServer true', () => {
@@ -65,11 +68,12 @@ describe('tacticsColumnsToApiDto()', () => {
         ]));
         expect(dto.designatedSubs[0].pinchServer).toBe(true);
     });
-    it('leaves pinchServer undefined for a non-PINCH row', () => {
+    it('passes an already-unified entry through untouched', () => {
         const dto = tacticsColumnsToApiDto(makeTactics([
-            { starterId: 's1', benchId: 'b1', mode: 'FATIGUE', fatigueBand: EnergyBand.TIRED }
+            { starterId: 's1', benchId: 'b1', conditions: [{ type: 'FATIGUE', band: EnergyBand.TIRED }], conditionLogic: 'ALL', pinchServer: false, subBackMode: 'FATIGUE' }
         ]));
-        expect(dto.designatedSubs[0].pinchServer).toBeUndefined();
+        expect(dto.designatedSubs[0].conditions).toEqual([{ type: 'FATIGUE', band: EnergyBand.TIRED }]);
+        expect(dto.designatedSubs[0].pinchServer).toBe(false);
     });
     it('passes a conditional regular sub (pinchServer false + condition sub-back) through unchanged', () => {
         const dto = tacticsColumnsToApiDto(makeTactics([
@@ -106,7 +110,8 @@ describe('tacticsColumnsToApiDto()', () => {
         model.libero_sub = { mode: 'FATIGUE' };
         const dto = tacticsColumnsToApiDto(model);
         expect(dto.secondLibero).toBe('reserve1');
-        expect(dto.liberoSub).toEqual({ mode: 'FATIGUE' });
+        // Legacy FATIGUE libero rule converts to the unified condition shape on the API read path.
+        expect(dto.liberoSub).toEqual({ conditions: [{ type: 'FATIGUE' }], conditionLogic: 'ALL' });
     });
     it('keeps a libero-keyed replaceKnockedImmediately entry when a second libero exists (L2-only feature)', () => {
         const model = makeTactics([]);

package/dist/esm/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/esm/src/service/team/index.d.ts

@@ -7,6 +7,7 @@ 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';

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

@@ -7,6 +7,7 @@ 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';

package/dist/esm/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/esm/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/esm/src/service/team/pinch-condition.js

@@ -1,6 +1,7 @@
-// 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).
+// 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.
 export var PinchConditionType;
 (function (PinchConditionType) {
     PinchConditionType["ASAP"] = "ASAP";
@@ -11,7 +12,11 @@ export 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 || (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/esm/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/esm/src/service/team/schemas/designated-sub.z.js

@@ -2,6 +2,7 @@ import { z } from 'zod';
 import { Player } from '../../player';
 import { EnergyBand } from '../energy-band';
 import { Comparison, MatchPhase, OpponentRelation, PinchConditionType, ScoreDirection } from '../pinch-condition';
+import { convertLegacyDesignatedSub, convertLegacySetSubConfig } from '../sub-config-convert';
 const playerInstanceSchema = z.custom((v) => v instanceof Player, {
     message: 'INVALID_PLAYER_INSTANCE'
 });
@@ -18,44 +19,47 @@ export const PinchConditionSchema = z.discriminatedUnion('type', [
     z.object({ type: z.literal(PinchConditionType.MIN_OWN_SCORE), score: z.number().int().min(0).max(40), comparison: z.nativeEnum(Comparison).optional() }),
     z.object({ type: z.literal(PinchConditionType.MIN_OPPONENT_SCORE), score: z.number().int().min(0).max(40), comparison: z.nativeEnum(Comparison).optional() }),
     // PHASE is used by the libero deployment rule (which reuses this schema); pinch servers never offer it.
-    z.object({ type: z.literal(PinchConditionType.PHASE), phase: z.nativeEnum(MatchPhase) })
+    z.object({ type: z.literal(PinchConditionType.PHASE), phase: z.nativeEnum(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).
+    z.object({ type: z.literal(PinchConditionType.FATIGUE), band: z.nativeEnum(EnergyBand).optional() })
 ]);
 export const ConditionLogicSchema = z.union([z.literal('ALL'), z.literal('ANY')]);
-export const SubModeSchema = z.enum(['FATIGUE', 'PINCH', 'NEVER']);
 export const SubBackModeSchema = z.enum(['FATIGUE', 'CONDITIONS']);
-// Fields shared by the all-sets config and each per-set config.
+// 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: SubModeSchema,
     bench: playerInstanceSchema.optional(),
-    fatigueBand: z.nativeEnum(EnergyBand).optional(),
-    benchFatigueBand: z.nativeEnum(EnergyBand).optional(),
     conditions: z.array(PinchConditionSchema).optional(),
     conditionLogic: 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: 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: z.nativeEnum(EnergyBand).optional(),
     subBackMode: SubBackModeSchema.optional(),
     subBackConditions: z.array(PinchConditionSchema).optional(),
     subBackConditionLogic: 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'] });
     }
 }
-export const SetSubConfigSchema = z.object(setSubConfigShape).superRefine(refinePinch);
-export const DesignatedSubSchema = z.object({
+export const SetSubConfigSchema = z.preprocess(convertLegacySetSubConfig, z.object(setSubConfigShape).superRefine(refineSubConfig));
+export const DesignatedSubSchema = z.preprocess(convertLegacyDesignatedSub, z.object({
     starter: playerInstanceSchema,
     ...setSubConfigShape,
     // Optional per-set overrides (index 0 = set 1 ... index 4 = set 5); absent => the flat config for all sets.
@@ -64,5 +68,5 @@ export const DesignatedSubSchema = 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/esm/src/service/team/schemas/designated-sub.z.test.js

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