volleyballsimtypes 0.0.482 → 0.0.485

package/dist/esm/src/service/event/spike.d.ts

@@ -21,5 +21,4 @@ export declare class Spike extends InPlayEvent<SpikeFailure, SpikeType> {
     readonly type: SpikeType;
     static create(input: unknown): Spike;
     private constructor();
-    toString(): string;
 }

package/dist/esm/src/service/event/spike.js

@@ -37,9 +37,4 @@ export class Spike extends InPlayEvent {
         this.type = type;
         this.failure = failure;
     }
-    toString() {
-        const failure = `"failure":${this.failure}`;
-        const type = `"type":${this.type}`;
-        return `{${this._toString()},${failure},${type}}`;
-    }
 }

package/dist/esm/src/service/event/substitution.d.ts

@@ -4,5 +4,4 @@ export declare class Substitution extends RallyEvent {
     readonly injury?: boolean;
     static create(input: unknown): Substitution;
     private constructor();
-    toString(): string;
 }

package/dist/esm/src/service/event/substitution.js

@@ -19,11 +19,4 @@ export class Substitution extends RallyEvent {
         this.playerOut = playerOut;
         this.injury = injury;
     }
-    toString() {
-        const playerId = `"playerId":"${this.playerId}"`;
-        const playerOut = `"playerOut":"${this.playerOut}"`;
-        const eventType = `"eventType":${this.eventType}`;
-        const injury = this.injury === true ? ',"injury":true' : '';
-        return `{${playerId},${playerOut},${eventType}${injury}}`;
-    }
 }

package/dist/esm/src/service/player/improvement.d.ts

@@ -3,7 +3,6 @@ import { Stats } from './stats';
 import { DeclineProfile } from './decline';
 export type TrainingFocus = Stats;
 export declare function getStatCap(rarity: Rarity): number;
-export declare function getRarityMultiplier(rarity: Rarity): number;
 export declare function getImprovementFloor(rarity: Rarity): number;
 export declare function getImprovementThreshold(statTotal: number, rarity: Rarity): number;
 export declare function getCoachMultiplier(rarity: Rarity): number;

package/dist/esm/src/service/player/improvement.js

@@ -30,14 +30,6 @@ export function getStatCap(rarity) {
         throw new Error(`UNKNOWN_RARITY: ${rarity}`);
     return entry.cap;
 }
-// Retained for config/reference. No longer used by the improvement curve -- superseded by IMPROVEMENT_FLOOR,
-// which is the per-rarity adjustment now.
-export function getRarityMultiplier(rarity) {
-    const entry = statCaps.find(e => e.rarity === rarity);
-    if (entry == null)
-        throw new Error(`UNKNOWN_RARITY: ${rarity}`);
-    return entry.rarityMultiplier;
-}
 export function getImprovementFloor(rarity) {
     const floor = IMPROVEMENT_FLOOR[rarity];
     if (floor == null)

package/dist/esm/src/service/player/improvement.test.js

@@ -1,6 +1,6 @@
 import { describe, it, expect } from '@jest/globals';
 import { RarityEnum } from './rarity';
-import { getStatCap, getRarityMultiplier, getImprovementFloor, getImprovementThreshold, getCoachMultiplier, selectImprovableStat, matchExperience, experienceGained } from './improvement';
+import { getStatCap, getImprovementFloor, getImprovementThreshold, getCoachMultiplier, selectImprovableStat, matchExperience, experienceGained } from './improvement';
 import { StatsEnum } from './stats';
 import { DeclineProfileEnum } from './decline';
 // ─── getStatCap ───────────────────────────────────────────────────────────────
@@ -18,21 +18,6 @@ describe('getStatCap()', () => {
         expect(() => getStatCap('DIVINE')).toThrow('UNKNOWN_RARITY');
     });
 });
-// ─── getRarityMultiplier ──────────────────────────────────────────────────────
-describe('getRarityMultiplier()', () => {
-    it.each([
-        [RarityEnum.COMMON, 1.0],
-        [RarityEnum.RARE, 1.15],
-        [RarityEnum.LEGENDARY, 1.3],
-        [RarityEnum.MYTHIC, 1.5],
-        [RarityEnum.SPECIAL, 1.75]
-    ])('%s → multiplier %f', (rarity, expected) => {
-        expect(getRarityMultiplier(rarity)).toBeCloseTo(expected, 5);
-    });
-    it('throws UNKNOWN_RARITY for an unrecognised rarity string', () => {
-        expect(() => getRarityMultiplier('DIVINE')).toThrow('UNKNOWN_RARITY');
-    });
-});
 // ─── getImprovementThreshold ──────────────────────────────────────────────────
 describe('getImprovementThreshold()', () => {
     it('at or below the floor the threshold is CURVE_BASE (180) — the fastest pace', () => {

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/energy-band.d.ts

@@ -6,5 +6,4 @@ export declare enum EnergyBand {
 }
 export type SubBand = EnergyBand | 'NEVER';
 export type SubMode = 'FATIGUE' | 'PINCH' | 'NEVER';
-export declare const SUB_MODES: readonly SubMode[];
 export declare const ENERGY_BAND_ORDER: readonly EnergyBand[];

package/dist/esm/src/service/team/energy-band.js

@@ -8,7 +8,6 @@ export var EnergyBand;
     EnergyBand["TIRED"] = "TIRED";
     EnergyBand["EXHAUSTED"] = "EXHAUSTED";
 })(EnergyBand || (EnergyBand = {}));
-export const SUB_MODES = ['FATIGUE', 'PINCH', 'NEVER'];
 // Ordered best -> worst. Used to compare "is this player at-or-below the configured sub band".
 export const ENERGY_BAND_ORDER = [
     EnergyBand.ENERGETIC,

package/dist/esm/src/service/team/formation.d.ts

@@ -25,6 +25,5 @@ export declare class Formation {
     readonly liberoSubPriority: SubPriority;
     static create(input: unknown): Formation;
     private constructor();
-    static getFormations(): Formation[];
 }
 export {};

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

@@ -20,9 +20,6 @@ export class Formation {
         this.base = base;
         this.liberoSubPriority = liberoSubPriority;
     }
-    static getFormations() {
-        return [this['4-2'], this['5-1'], this['6-2']];
-    }
 }
 Formation['5-1'] = Formation.create({
     name: '5-1',

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

package/dist/esm/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>>;

package/dist/esm/src/service/team/schemas/libero-sub.z.js

@@ -1,34 +1,18 @@
 import { z } from 'zod';
-import { EnergyBand } from '../energy-band';
+import { convertLegacyLiberoSetSubConfig, convertLegacyLiberoSubConfig } from '../sub-config-convert';
 import { ConditionLogicSchema, PinchConditionSchema } from './designated-sub.z';
-export const LiberoSubModeSchema = z.enum(['NEVER', 'FATIGUE', 'ALWAYS', 'CONDITIONS']);
-// Fields shared by the all-sets config and each per-set config. The swapped-in player is always the dedicated
-// `secondLibero`, so there is no bench to validate; the CONDITIONS mode reuses the pinch-server condition
-// catalog (PinchConditionSchema, which includes the libero-only PHASE condition) + ALL/ANY logic.
+// Pure condition engine (owner 2026-07-11): the second libero is active while `conditions` hold (combined
+// per `conditionLogic`, default ALL; the STARTING libero is the FATIGUE-condition subject). No conditions =
+// the starting libero always plays; [{ASAP}] = always the second libero (the old ALWAYS). The swapped-in
+// player is always the dedicated `secondLibero`, so there is no bench to validate. Legacy mode-shaped
+// configs (NEVER/FATIGUE/ALWAYS/CONDITIONS) are auto-converted by the preprocess.
 const liberoSetSubConfigShape = {
-    mode: LiberoSubModeSchema,
-    // fatigue mode only (absent => the team default `substitutionBand`):
-    fatigueBand: z.nativeEnum(EnergyBand).optional(),
-    // conditions mode only:
     conditions: z.array(PinchConditionSchema).optional(),
     conditionLogic: ConditionLogicSchema.optional()
 };
-// CONDITIONS mode needs at least one condition (mirrors the designated-sub pinch refine).
-function refineConditions(data, ctx) {
-    if (data.mode !== 'CONDITIONS')
-        return;
-    if (data.conditions == null || data.conditions.length === 0) {
-        ctx.addIssue({ code: 'custom', message: 'LIBERO_CONDITIONS_REQUIRE_A_CONDITION', path: ['conditions'] });
-    }
-}
-export const LiberoSetSubConfigSchema = z.object(liberoSetSubConfigShape).superRefine(refineConditions);
-export const LiberoSubConfigSchema = z.object({
+export const LiberoSetSubConfigSchema = z.preprocess(convertLegacyLiberoSetSubConfig, z.object(liberoSetSubConfigShape));
+export const LiberoSubConfigSchema = z.preprocess(convertLegacyLiberoSubConfig, z.object({
     ...liberoSetSubConfigShape,
     // Optional per-set overrides (index 0 = set 1 ... index 4 = set 5); absent => the flat config for all sets.
     sets: z.array(LiberoSetSubConfigSchema).max(5).optional()
-}).superRefine((data, ctx) => {
-    // 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 its own schema).
-    if (data.sets == null || data.sets.length < 5)
-        refineConditions(data, ctx);
-});
+}));