volleyballsimtypes 0.0.482 → 0.0.483

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

@@ -15,16 +15,9 @@ export declare const TacticsInputSchema: z.ZodObject<{
     }, z.core.$strip>;
     liberoReplacements: z.ZodArray<z.ZodCustom<Player, Player>>;
     receiveRotationOffset: z.ZodDefault<z.ZodBoolean>;
-    designatedSubs: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        sets: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            mode: z.ZodEnum<{
-                NEVER: "NEVER";
-                FATIGUE: "FATIGUE";
-                PINCH: "PINCH";
-            }>;
+    designatedSubs: z.ZodDefault<z.ZodArray<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<import("..").PinchConditionType.ASAP>;
             }, z.core.$strip>, z.ZodObject<{
@@ -56,9 +49,13 @@ export declare const TacticsInputSchema: 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 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";
@@ -94,17 +91,13 @@ export declare const TacticsInputSchema: 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 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<import("..").PinchConditionType.ASAP>;
         }, z.core.$strip>, z.ZodObject<{
@@ -136,9 +129,13 @@ export declare const TacticsInputSchema: 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 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";
@@ -174,21 +171,17 @@ export declare const TacticsInputSchema: 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 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>>>>;
     substitutionBand: z.ZodDefault<z.ZodUnion<readonly [z.ZodEnum<typeof EnergyBand>, z.ZodLiteral<"NEVER">]>>;
     secondLibero: z.ZodOptional<z.ZodCustom<Player, Player>>;
-    liberoSub: z.ZodOptional<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>>;
+    liberoSub: z.ZodOptional<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<{
@@ -220,16 +213,12 @@ export declare const TacticsInputSchema: 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 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<{
@@ -261,9 +250,12 @@ export declare const TacticsInputSchema: 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 EnergyBand>>;
         }, z.core.$strip>], "type">>>;
         conditionLogic: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodLiteral<"ANY">]>>;
-    }, z.core.$strip>>;
+    }, z.core.$strip>>>;
     liberoReplacementSets: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodCustom<Player, Player>>>>;
     rotationSystem: z.ZodDefault<z.ZodEnum<typeof RotationSystemEnum>>;
     designatedSetters: z.ZodDefault<z.ZodArray<z.ZodCustom<Player, Player>>>;

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

@@ -221,10 +221,11 @@ exports.TacticsInputSchema = zod_1.z.object({
         ...(libero != null ? [libero.id] : []),
         ...data.lineup.bench.map(p => p.id)
     ]);
-    const liberoSubModes = data.liberoSub != null
-        ? [data.liberoSub.mode, ...(data.liberoSub.sets ?? []).map(s => s.mode)]
+    // Unified condition engine: the rule wants a swap when ANY config (flat or per-set) has conditions.
+    const liberoConditionSets = data.liberoSub != null
+        ? [data.liberoSub.conditions ?? [], ...(data.liberoSub.sets ?? []).map(s => s.conditions ?? [])]
         : [];
-    const wantsLiberoSwap = liberoSubModes.some(mode => mode !== 'NEVER');
+    const wantsLiberoSwap = liberoConditionSets.some(conditions => conditions.length > 0);
     if (wantsLiberoSwap && data.secondLibero == null) {
         ctx.addIssue({ code: 'custom', message: 'LIBERO_SWAP_REQUIRES_SECOND_LIBERO', path: ['secondLibero'] });
     }

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

@@ -23,16 +23,9 @@ export declare const TeamInputSchema: z.ZodObject<{
         }, z.core.$strip>;
         liberoReplacements: z.ZodArray<z.ZodCustom<Player, Player>>;
         receiveRotationOffset: z.ZodDefault<z.ZodBoolean>;
-        designatedSubs: z.ZodDefault<z.ZodArray<z.ZodObject<{
-            sets: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                mode: z.ZodEnum<{
-                    NEVER: "NEVER";
-                    FATIGUE: "FATIGUE";
-                    PINCH: "PINCH";
-                }>;
+        designatedSubs: z.ZodDefault<z.ZodArray<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 import("..").EnergyBand>>;
-                benchFatigueBand: z.ZodOptional<z.ZodEnum<typeof import("..").EnergyBand>>;
                 conditions: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
                     type: z.ZodLiteral<import("..").PinchConditionType.ASAP>;
                 }, z.core.$strip>, z.ZodObject<{
@@ -64,9 +57,13 @@ export declare const TeamInputSchema: 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">]>>;
                 pinchServer: z.ZodOptional<z.ZodBoolean>;
+                benchFatigueBand: z.ZodOptional<z.ZodEnum<typeof import("..").EnergyBand>>;
                 subBackMode: z.ZodOptional<z.ZodEnum<{
                     FATIGUE: "FATIGUE";
                     CONDITIONS: "CONDITIONS";
@@ -102,17 +99,13 @@ export declare const TeamInputSchema: 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">>>;
                 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 import("..").EnergyBand>>;
-            benchFatigueBand: z.ZodOptional<z.ZodEnum<typeof import("..").EnergyBand>>;
             conditions: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
                 type: z.ZodLiteral<import("..").PinchConditionType.ASAP>;
             }, z.core.$strip>, z.ZodObject<{
@@ -144,9 +137,13 @@ export declare const TeamInputSchema: 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">]>>;
             pinchServer: z.ZodOptional<z.ZodBoolean>;
+            benchFatigueBand: z.ZodOptional<z.ZodEnum<typeof import("..").EnergyBand>>;
             subBackMode: z.ZodOptional<z.ZodEnum<{
                 FATIGUE: "FATIGUE";
                 CONDITIONS: "CONDITIONS";
@@ -182,21 +179,17 @@ export declare const TeamInputSchema: 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">>>;
             subBackConditionLogic: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodLiteral<"ANY">]>>;
             starter: z.ZodCustom<Player, Player>;
-        }, z.core.$strip>>>;
+        }, z.core.$strip>>>>;
         substitutionBand: z.ZodDefault<z.ZodUnion<readonly [z.ZodEnum<typeof import("..").EnergyBand>, z.ZodLiteral<"NEVER">]>>;
         secondLibero: z.ZodOptional<z.ZodCustom<Player, Player>>;
-        liberoSub: z.ZodOptional<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 import("..").EnergyBand>>;
+        liberoSub: z.ZodOptional<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<{
@@ -228,16 +221,12 @@ export declare const TeamInputSchema: 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 import("..").EnergyBand>>;
+            }, z.core.$strip>>>>;
             conditions: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
                 type: z.ZodLiteral<import("..").PinchConditionType.ASAP>;
             }, z.core.$strip>, z.ZodObject<{
@@ -269,9 +258,12 @@ export declare const TeamInputSchema: 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>>>;
         liberoReplacementSets: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodCustom<Player, Player>>>>;
         rotationSystem: z.ZodDefault<z.ZodEnum<typeof import("..").RotationSystemEnum>>;
         designatedSetters: z.ZodDefault<z.ZodArray<z.ZodCustom<Player, Player>>>;

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

@@ -0,0 +1,13 @@
+/**
+ * Convert ONE legacy set-sub config (flat or per-set entry). Handles BOTH legacy generations:
+ * mode-era rows ({mode: NEVER|FATIGUE|PINCH}) and the oldest isPinchServer-era rows (no mode;
+ * isPinchServer flag + a 'NEVER' fatigueBand for the old never-sub state). Non-records and
+ * already-unified shapes (neither mode nor isPinchServer nor fatigueBand keys) pass through.
+ */
+export declare function convertLegacySetSubConfig(raw: unknown): unknown;
+/** Convert a legacy DesignatedSub (flat fields + per-set entries); unified shapes pass through. */
+export declare function convertLegacyDesignatedSub(raw: unknown): unknown;
+/** Convert ONE legacy libero set-sub config; unified shapes pass through. */
+export declare function convertLegacyLiberoSetSubConfig(raw: unknown): unknown;
+/** Convert a legacy LiberoSubConfig (flat fields + per-set entries); unified shapes pass through. */
+export declare function convertLegacyLiberoSubConfig(raw: unknown): unknown;

package/dist/cjs/src/service/team/sub-config-convert.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertLegacySetSubConfig = convertLegacySetSubConfig;
+exports.convertLegacyDesignatedSub = convertLegacyDesignatedSub;
+exports.convertLegacyLiberoSetSubConfig = convertLegacyLiberoSetSubConfig;
+exports.convertLegacyLiberoSubConfig = convertLegacyLiberoSubConfig;
+const energy_band_1 = require("./energy-band");
+const pinch_condition_1 = require("./pinch-condition");
+function isRecord(v) {
+    return typeof v === 'object' && v != null && !Array.isArray(v);
+}
+function fatigueCondition(band) {
+    return Object.values(energy_band_1.EnergyBand).includes(band)
+        ? { type: pinch_condition_1.PinchConditionType.FATIGUE, band }
+        : { type: pinch_condition_1.PinchConditionType.FATIGUE };
+}
+/**
+ * Convert ONE legacy set-sub config (flat or per-set entry). Handles BOTH legacy generations:
+ * mode-era rows ({mode: NEVER|FATIGUE|PINCH}) and the oldest isPinchServer-era rows (no mode;
+ * isPinchServer flag + a 'NEVER' fatigueBand for the old never-sub state). Non-records and
+ * already-unified shapes (neither mode nor isPinchServer nor fatigueBand keys) pass through.
+ */
+function convertLegacySetSubConfig(raw) {
+    if (!isRecord(raw))
+        return raw;
+    // Derive the mode for the oldest (pre-mode) generation; a unified shape has none of these keys.
+    const mode = raw.mode ?? (raw.isPinchServer === true
+        ? 'PINCH'
+        : raw.fatigueBand === 'NEVER'
+            ? 'NEVER'
+            : raw.fatigueBand != null || 'isPinchServer' in raw ? 'FATIGUE' : null);
+    if (mode == null)
+        return raw;
+    const { mode: _m, fatigueBand, isPinchServer: _p, ...rest } = raw;
+    if (mode === 'NEVER') {
+        // Old NEVER dropped every other field; an explicit empty condition list = never substituted.
+        return { conditions: [] };
+    }
+    if (mode === 'FATIGUE') {
+        return {
+            ...rest,
+            conditions: [fatigueCondition(fatigueBand)],
+            conditionLogic: 'ALL',
+            pinchServer: false,
+            subBackMode: rest.subBackMode ?? 'FATIGUE'
+        };
+    }
+    if (mode === 'PINCH') {
+        // A legacy PINCH row without the flag is a serve-and-return pinch server (the documented default).
+        return { ...rest, pinchServer: rest.pinchServer ?? true };
+    }
+    // Unknown legacy mode: strip it and let validation judge the rest.
+    return rest;
+}
+/** Convert a legacy DesignatedSub (flat fields + per-set entries); unified shapes pass through. */
+function convertLegacyDesignatedSub(raw) {
+    if (!isRecord(raw))
+        return raw;
+    const { starter, sets, ...cfg } = raw;
+    const flat = convertLegacySetSubConfig(cfg);
+    const out = { ...(isRecord(flat) ? flat : {}), starter };
+    if (Array.isArray(sets))
+        out.sets = sets.map(convertLegacySetSubConfig);
+    return out;
+}
+/** Convert ONE legacy libero set-sub config; unified shapes pass through. */
+function convertLegacyLiberoSetSubConfig(raw) {
+    if (!isRecord(raw) || raw.mode == null)
+        return raw;
+    const { mode, fatigueBand, ...rest } = raw;
+    if (mode === 'NEVER')
+        return { conditions: [] };
+    if (mode === 'ALWAYS')
+        return { ...rest, conditions: [{ type: pinch_condition_1.PinchConditionType.ASAP }], conditionLogic: 'ALL' };
+    if (mode === 'FATIGUE')
+        return { ...rest, conditions: [fatigueCondition(fatigueBand)], conditionLogic: 'ALL' };
+    if (mode === 'CONDITIONS')
+        return rest;
+    return rest;
+}
+/** Convert a legacy LiberoSubConfig (flat fields + per-set entries); unified shapes pass through. */
+function convertLegacyLiberoSubConfig(raw) {
+    if (!isRecord(raw))
+        return raw;
+    const { sets, ...cfg } = raw;
+    const flat = convertLegacyLiberoSetSubConfig(cfg);
+    const out = { ...(isRecord(flat) ? flat : {}) };
+    if (Array.isArray(sets))
+        out.sets = sets.map(convertLegacyLiberoSetSubConfig);
+    return out;
+}

package/dist/cjs/src/service/team/sub-config-convert.test.d.ts

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

package/dist/cjs/src/service/team/sub-config-convert.test.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+const energy_band_1 = require("./energy-band");
+const pinch_condition_1 = require("./pinch-condition");
+const sub_config_convert_1 = require("./sub-config-convert");
+// The conversion matrix for the unified condition engine: every legacy generation must land on the exact
+// unified shape (these functions are the single conversion authority used by the schema preprocess, the
+// transformers, and the API repo's read path).
+(0, globals_1.describe)('convertLegacySetSubConfig', () => {
+    (0, globals_1.it)('passes an already-unified config through untouched', () => {
+        const unified = { bench: 'X', conditions: [{ type: pinch_condition_1.PinchConditionType.ASAP }], pinchServer: true };
+        (0, globals_1.expect)((0, sub_config_convert_1.convertLegacySetSubConfig)(unified)).toBe(unified);
+    });
+    (0, globals_1.it)('converts mode NEVER to an explicit empty condition list, dropping every other field', () => {
+        (0, globals_1.expect)((0, sub_config_convert_1.convertLegacySetSubConfig)({ mode: 'NEVER', bench: 'X' })).toEqual({ conditions: [] });
+    });
+    (0, globals_1.it)('converts mode FATIGUE with a band to a FATIGUE condition + FATIGUE sub-back', () => {
+        (0, globals_1.expect)((0, sub_config_convert_1.convertLegacySetSubConfig)({ mode: 'FATIGUE', fatigueBand: energy_band_1.EnergyBand.WORN, bench: 'X', benchFatigueBand: energy_band_1.EnergyBand.TIRED })).toEqual({
+            bench: 'X',
+            benchFatigueBand: energy_band_1.EnergyBand.TIRED,
+            conditions: [{ type: pinch_condition_1.PinchConditionType.FATIGUE, band: energy_band_1.EnergyBand.WORN }],
+            conditionLogic: 'ALL',
+            pinchServer: false,
+            subBackMode: 'FATIGUE'
+        });
+    });
+    (0, globals_1.it)('converts mode FATIGUE without a band to a bandless FATIGUE condition (team default)', () => {
+        const out = (0, sub_config_convert_1.convertLegacySetSubConfig)({ mode: 'FATIGUE' });
+        (0, globals_1.expect)(out.conditions).toEqual([{ type: pinch_condition_1.PinchConditionType.FATIGUE }]);
+    });
+    (0, globals_1.it)('converts mode PINCH keeping conditions and defaulting a missing pinchServer flag to true', () => {
+        (0, globals_1.expect)((0, sub_config_convert_1.convertLegacySetSubConfig)({ mode: 'PINCH', bench: 'X', conditions: [{ type: pinch_condition_1.PinchConditionType.ASAP }] })).toEqual({
+            bench: 'X',
+            conditions: [{ type: pinch_condition_1.PinchConditionType.ASAP }],
+            pinchServer: true
+        });
+    });
+    (0, globals_1.it)('keeps an explicit pinchServer false on a legacy PINCH regular conditional sub', () => {
+        const out = (0, sub_config_convert_1.convertLegacySetSubConfig)({ mode: 'PINCH', bench: 'X', conditions: [{ type: pinch_condition_1.PinchConditionType.ASAP }], pinchServer: false, subBackMode: 'CONDITIONS', subBackConditions: [{ type: pinch_condition_1.PinchConditionType.ASAP }] });
+        (0, globals_1.expect)(out.pinchServer).toBe(false);
+        (0, globals_1.expect)(out.subBackMode).toBe('CONDITIONS');
+    });
+    (0, globals_1.it)('converts the oldest isPinchServer-era row to a pinch server', () => {
+        (0, globals_1.expect)((0, sub_config_convert_1.convertLegacySetSubConfig)({ isPinchServer: true, bench: 'X', conditions: [{ type: pinch_condition_1.PinchConditionType.ASAP }] })).toEqual({
+            bench: 'X',
+            conditions: [{ type: pinch_condition_1.PinchConditionType.ASAP }],
+            pinchServer: true
+        });
+    });
+    (0, globals_1.it)("converts the oldest 'NEVER' fatigueBand row to never (empty conditions)", () => {
+        (0, globals_1.expect)((0, sub_config_convert_1.convertLegacySetSubConfig)({ fatigueBand: 'NEVER' })).toEqual({ conditions: [] });
+    });
+    (0, globals_1.it)('converts the oldest band-only row to a FATIGUE condition', () => {
+        const out = (0, sub_config_convert_1.convertLegacySetSubConfig)({ fatigueBand: energy_band_1.EnergyBand.EXHAUSTED });
+        (0, globals_1.expect)(out.conditions).toEqual([{ type: pinch_condition_1.PinchConditionType.FATIGUE, band: energy_band_1.EnergyBand.EXHAUSTED }]);
+    });
+    (0, globals_1.it)('strips an unknown legacy mode and keeps the rest (lenient heal)', () => {
+        (0, globals_1.expect)((0, sub_config_convert_1.convertLegacySetSubConfig)({ mode: 'SOMETIMES', bench: 'X' })).toEqual({ bench: 'X' });
+    });
+});
+(0, globals_1.describe)('convertLegacyDesignatedSub', () => {
+    (0, globals_1.it)('converts the flat fields and every per-set entry, keeping the starter', () => {
+        const out = (0, sub_config_convert_1.convertLegacyDesignatedSub)({
+            starter: 'S',
+            mode: 'FATIGUE',
+            fatigueBand: energy_band_1.EnergyBand.TIRED,
+            sets: [{ mode: 'NEVER' }, { mode: 'PINCH', bench: 'X', conditions: [{ type: pinch_condition_1.PinchConditionType.ASAP }] }]
+        });
+        (0, globals_1.expect)(out.starter).toBe('S');
+        (0, globals_1.expect)(out.conditions).toEqual([{ type: pinch_condition_1.PinchConditionType.FATIGUE, band: energy_band_1.EnergyBand.TIRED }]);
+        (0, globals_1.expect)(out.sets[0]).toEqual({ conditions: [] });
+        (0, globals_1.expect)(out.sets[1].pinchServer).toBe(true);
+    });
+});
+(0, globals_1.describe)('convertLegacyLiberoSetSubConfig', () => {
+    (0, globals_1.it)('maps each legacy libero mode to its unified condition list', () => {
+        (0, globals_1.expect)((0, sub_config_convert_1.convertLegacyLiberoSetSubConfig)({ mode: 'NEVER' })).toEqual({ conditions: [] });
+        (0, globals_1.expect)((0, sub_config_convert_1.convertLegacyLiberoSetSubConfig)({ mode: 'ALWAYS' })).toEqual({ conditions: [{ type: pinch_condition_1.PinchConditionType.ASAP }], conditionLogic: 'ALL' });
+        (0, globals_1.expect)((0, sub_config_convert_1.convertLegacyLiberoSetSubConfig)({ mode: 'FATIGUE', fatigueBand: energy_band_1.EnergyBand.WORN })).toEqual({ conditions: [{ type: pinch_condition_1.PinchConditionType.FATIGUE, band: energy_band_1.EnergyBand.WORN }], conditionLogic: 'ALL' });
+        const conditions = [{ type: pinch_condition_1.PinchConditionType.PHASE, phase: 'RECEIVING' }];
+        (0, globals_1.expect)((0, sub_config_convert_1.convertLegacyLiberoSetSubConfig)({ mode: 'CONDITIONS', conditions, conditionLogic: 'ANY' })).toEqual({ conditions, conditionLogic: 'ANY' });
+    });
+});

package/dist/esm/src/api/index.d.ts

@@ -1,4 +1,4 @@
-import { BoxScore, DataProps, DeclineStatus, Division as _Division, League as _League, Match as _Match, MatchSet as _MatchSet, Player as _Player, PlayerPosition, Qualifier as _Qualifier, QualifierMatch as _QualifierMatch, Rally as _Rally, RallyEvent as _RallyEvent, PointBreakdown, RallyMetrics, Season as _Season, Standing as _Standing, Team as _Team, Tournament as _Tournament, TournamentMatch as _TournamentMatch, National as _National, NationalMatch as _NationalMatch, Country as _Country, CourtPosition, ConditionLogic, EnergyBand, LiberoSubMode, MatchForfeitType, PerformanceStats, PinchCondition, RoleEnum, RotationSystemEnum, SubBackMode, SubBand, SubMode } from '../service';
+import { BoxScore, DataProps, DeclineStatus, Division as _Division, League as _League, Match as _Match, MatchSet as _MatchSet, Player as _Player, PlayerPosition, Qualifier as _Qualifier, QualifierMatch as _QualifierMatch, Rally as _Rally, RallyEvent as _RallyEvent, PointBreakdown, RallyMetrics, Season as _Season, Standing as _Standing, Team as _Team, Tournament as _Tournament, TournamentMatch as _TournamentMatch, National as _National, NationalMatch as _NationalMatch, Country as _Country, CourtPosition, ConditionLogic, EnergyBand, MatchForfeitType, PerformanceStats, PinchCondition, RoleEnum, RotationSystemEnum, SubBackMode, SubBand } from '../service';
 export type Rally = DataProps<_Rally> & {
     homePlayerPosition: PlayerPosition[];
     awayPlayerPosition: PlayerPosition[];
@@ -81,29 +81,17 @@ export interface StartingLineup {
     bench: string[];
 }
 export interface ApiSetSubConfig {
-    mode: SubMode;
     benchId?: string;
-    fatigueBand?: EnergyBand;
-    benchFatigueBand?: EnergyBand;
     conditions?: PinchCondition[];
     conditionLogic?: ConditionLogic;
     pinchServer?: boolean;
+    benchFatigueBand?: EnergyBand;
     subBackMode?: SubBackMode;
     subBackConditions?: PinchCondition[];
     subBackConditionLogic?: ConditionLogic;
 }
-export interface ApiDesignatedSub {
+export interface ApiDesignatedSub extends ApiSetSubConfig {
     starterId: string;
-    benchId?: string;
-    mode: SubMode;
-    fatigueBand?: EnergyBand;
-    benchFatigueBand?: EnergyBand;
-    conditions?: PinchCondition[];
-    conditionLogic?: ConditionLogic;
-    pinchServer?: boolean;
-    subBackMode?: SubBackMode;
-    subBackConditions?: PinchCondition[];
-    subBackConditionLogic?: ConditionLogic;
     sets?: ApiSetSubConfig[];
 }
 export interface ApiOffensivePreference {
@@ -130,8 +118,6 @@ export interface ApiLiberoInjury {
     inMatchDesignateId?: string;
 }
 export interface ApiLiberoSetSubConfig {
-    mode: LiberoSubMode;
-    fatigueBand?: EnergyBand;
     conditions?: PinchCondition[];
     conditionLogic?: ConditionLogic;
 }

package/dist/esm/src/data/models/tactics.d.ts

@@ -1,7 +1,7 @@
 import * as Sequelize from 'sequelize';
 import { Model, Optional } from 'sequelize';
 import { PlayerId, TeamId, TeamModel } from '.';
-import { ConditionLogic, CourtPosition, EnergyBand, LiberoSubMode, PinchCondition, RoleEnum, RotationSystemEnum, SubBackMode, SubBand, SubMode } from '../../service';
+import { ConditionLogic, CourtPosition, EnergyBand, PinchCondition, RoleEnum, RotationSystemEnum, SubBackMode, SubBand, SubMode } from '../../service';
 export interface TacticsLineupAttributes {
     [CourtPosition.LIBERO_ZONE]?: PlayerId;
     [CourtPosition.LEFT_BACK]: PlayerId;
@@ -13,30 +13,20 @@ export interface TacticsLineupAttributes {
     bench: PlayerId[];
 }
 export interface SetSubConfigAttributes {
-    mode: SubMode;
     benchId?: PlayerId;
-    fatigueBand?: EnergyBand;
-    benchFatigueBand?: EnergyBand;
     conditions?: PinchCondition[];
     conditionLogic?: ConditionLogic;
     pinchServer?: boolean;
+    benchFatigueBand?: EnergyBand;
     subBackMode?: SubBackMode;
     subBackConditions?: PinchCondition[];
     subBackConditionLogic?: ConditionLogic;
+    mode?: SubMode;
+    fatigueBand?: SubBand;
 }
-export interface DesignatedSubAttributes {
+export interface DesignatedSubAttributes extends SetSubConfigAttributes {
     starterId: PlayerId;
-    benchId?: PlayerId;
-    mode?: SubMode;
     isPinchServer?: boolean;
-    fatigueBand?: SubBand;
-    benchFatigueBand?: EnergyBand;
-    conditions?: PinchCondition[];
-    conditionLogic?: ConditionLogic;
-    pinchServer?: boolean;
-    subBackMode?: SubBackMode;
-    subBackConditions?: PinchCondition[];
-    subBackConditionLogic?: ConditionLogic;
     sets?: SetSubConfigAttributes[];
 }
 export interface OffensivePreferenceAttributes {
@@ -63,10 +53,10 @@ export interface LiberoInjuryAttributes {
     inMatchDesignateId?: PlayerId;
 }
 export interface LiberoSetSubConfigAttributes {
-    mode: LiberoSubMode;
-    fatigueBand?: EnergyBand;
     conditions?: PinchCondition[];
     conditionLogic?: ConditionLogic;
+    mode?: string;
+    fatigueBand?: EnergyBand;
 }
 export interface LiberoSubConfigAttributes extends LiberoSetSubConfigAttributes {
     sets?: LiberoSetSubConfigAttributes[];

package/dist/esm/src/data/transformers/match-preset-override.test.js

@@ -148,7 +148,16 @@ describe('apiTacticsConfigToTacticsAttributes()', () => {
         expect(back.lineup).toEqual(full.lineup);
         expect(back.libero_replacements).toEqual(full.libero_replacements);
         expect(back.receive_rotation_offset).toBe(true);
-        expect(back.designated_subs).toEqual(full.designated_subs);
+        // The dto path converts legacy mode-shaped subs to the unified condition engine, so the round-trip lands
+        // in the converted (unified) shape rather than the legacy input.
+        expect(back.designated_subs).toEqual([{
+                starterId: ids[0],
+                conditions: [{ type: 'FATIGUE', band: 'WORN' }],
+                conditionLogic: 'ALL',
+                pinchServer: false,
+                subBackMode: 'FATIGUE',
+                sets: [{ conditions: [] }]
+            }]);
         expect(back.libero_replacement_sets).toEqual(full.libero_replacement_sets);
         expect(back.rotation_system).toBe('5-1');
         expect(back.designated_setters).toEqual(full.designated_setters);

package/dist/esm/src/data/transformers/rally-event.d.ts

@@ -1,4 +1,4 @@
-import { Block, LiberoReplacement, RallyEvent, Reception, Serve, Set, Spike, Substitution } from '../../service';
+import { Block, FreeBall, LiberoReplacement, RallyEvent, Reception, Serve, Set, Spike, Substitution } from '../../service';
 export interface CompactEvent {
     p: number;
     e: number;
@@ -21,4 +21,5 @@ export declare function transformToReception(event: CompactEvent, roster: string
 export declare function transformToServe(event: CompactEvent, roster: string[]): Serve;
 export declare function transformToSet(event: CompactEvent, roster: string[]): Set;
 export declare function transformToSpike(event: CompactEvent, roster: string[]): Spike;
+export declare function transformToFreeBall(event: CompactEvent, roster: string[]): FreeBall;
 export declare function transformToSubstitution(event: CompactEvent, roster: string[]): Substitution;

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

@@ -1,4 +1,4 @@
-import { Block, InPlayEvent, LiberoReplacement, Reception, Serve, Set, Spike, Substitution } from '../../service';
+import { Block, FreeBall, InPlayEvent, LiberoReplacement, Reception, Serve, Set, Spike, Substitution } from '../../service';
 // Incident packing for the compact key 'i': values below 10 are injury severities, 10+ are knock tiers.
 function incidentToCompact(incident) {
     if (incident == null)
@@ -108,6 +108,17 @@ export function transformToSpike(event, roster) {
         incident: incidentFromCompact(event.i, event.h, roster)
     });
 }
+// FreeBall (Last Resort save) is a plain InPlayEvent with no incident of its own, so it decodes from f/t/a/s
+// exactly like a spike minus the incident. Must stay in lockstep with the case 7 branch in rally.ts.
+export function transformToFreeBall(event, roster) {
+    return FreeBall.create({
+        failure: event.f,
+        type: event.t,
+        playerId: roster[event.p],
+        target: event.a,
+        score: event.s
+    });
+}
 export function transformToSubstitution(event, roster) {
     return Substitution.create({
         playerId: roster[event.p],