volleyballsimtypes 0.0.481 → 0.0.483

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const globals_1 = require("@jest/globals");
 const tactics_z_1 = require("./tactics.z");
+const player_1 = require("../../player");
 const test_helpers_1 = require("../../test-helpers");
 (0, globals_1.describe)('TacticsInputSchema — second libero rules', () => {
     const country = (0, test_helpers_1.makeCountry)();
@@ -95,7 +96,7 @@ const test_helpers_1 = require("../../test-helpers");
                 { rotationSystem: '4-2', designatedSetters: [p1, p4] }
             ],
             offensivePreferenceSets: [
-                [{ rotation: 1, order: [p2, p3] }],
+                [{ rotation: 1, weights: { [p2.id]: 60, [p3.id]: 40 } }],
                 []
             ]
         }));
@@ -104,7 +105,7 @@ const test_helpers_1 = require("../../test-helpers");
     (0, globals_1.it)('carries the per-set fields through Tactics.create parsing', () => {
         const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
             systemSets: [{ rotationSystem: '5-1', designatedSetters: [p1] }],
-            offensivePreferenceSets: [[{ rotation: 2, order: [p3] }]]
+            offensivePreferenceSets: [[{ rotation: 2, weights: { [p3.id]: 100 } }]]
         }));
         (0, globals_1.expect)(res.success).toBe(true);
         if (res.success) {
@@ -153,7 +154,7 @@ const test_helpers_1 = require("../../test-helpers");
     });
     (0, globals_1.it)('rejects a per-set preferences list with a duplicate rotation', () => {
         const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
-            offensivePreferenceSets: [[{ rotation: 1, order: [p2] }, { rotation: 1, order: [p3] }]]
+            offensivePreferenceSets: [[{ rotation: 1, weights: { [p2.id]: 100 } }, { rotation: 1, weights: { [p3.id]: 100 } }]]
         }));
         (0, globals_1.expect)(res.success).toBe(false);
         if (!res.success) {
@@ -161,18 +162,27 @@ const test_helpers_1 = require("../../test-helpers");
             (0, globals_1.expect)(issue?.path).toEqual(['offensivePreferenceSets', 0]);
         }
     });
-    (0, globals_1.it)('rejects a per-set preferences order that lists a non-starter', () => {
+    (0, globals_1.it)('rejects a per-set preferences map that keys a non-starter', () => {
         const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
-            offensivePreferenceSets: [[{ rotation: 1, order: [reserve] }]]
+            offensivePreferenceSets: [[{ rotation: 1, weights: { [reserve.id]: 100 } }]]
         }));
         (0, globals_1.expect)(res.success).toBe(false);
         if (!res.success) {
             (0, globals_1.expect)(res.error.issues.some(i => i.message === 'OFFENSIVE_PREFERENCE_ATTACKER_NOT_A_STARTER')).toBe(true);
         }
     });
+    (0, globals_1.it)('rejects offensive preference weights that do not sum to 100', () => {
+        const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
+            offensivePreferences: [{ rotation: 1, weights: { [p2.id]: 50, [p3.id]: 40 } }]
+        }));
+        (0, globals_1.expect)(res.success).toBe(false);
+        if (!res.success) {
+            (0, globals_1.expect)(res.error.issues.some(i => i.message === 'OFFENSIVE_PREFERENCE_WEIGHTS_MUST_SUM_TO_100')).toBe(true);
+        }
+    });
     (0, globals_1.it)('accepts offensive preferences with a starter-keyed tempos map', () => {
         const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
-            offensivePreferences: [{ rotation: 1, order: [p2, p3], tempos: { [p2.id]: 'FAST', [p3.id]: 'HIGH' } }]
+            offensivePreferences: [{ rotation: 1, weights: { [p2.id]: 60, [p3.id]: 40 }, tempos: { [p2.id]: 'FAST', [p3.id]: 'HIGH' } }]
         }));
         (0, globals_1.expect)(res.success).toBe(true);
         if (res.success) {
@@ -181,7 +191,7 @@ const test_helpers_1 = require("../../test-helpers");
     });
     (0, globals_1.it)('rejects a tempos map keyed by a non-starter', () => {
         const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
-            offensivePreferences: [{ rotation: 1, order: [p2], tempos: { [reserve.id]: 'FAST' } }]
+            offensivePreferences: [{ rotation: 1, weights: { [p2.id]: 100 }, tempos: { [reserve.id]: 'FAST' } }]
         }));
         (0, globals_1.expect)(res.success).toBe(false);
         if (!res.success) {
@@ -190,7 +200,7 @@ const test_helpers_1 = require("../../test-helpers");
     });
     (0, globals_1.it)('rejects an invalid tempo value', () => {
         const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
-            offensivePreferences: [{ rotation: 1, order: [p2], tempos: { [p2.id]: 'SLOW' } }]
+            offensivePreferences: [{ rotation: 1, weights: { [p2.id]: 100 }, tempos: { [p2.id]: 'SLOW' } }]
         }));
         (0, globals_1.expect)(res.success).toBe(false);
     });
@@ -208,3 +218,66 @@ const test_helpers_1 = require("../../test-helpers");
         }
     });
 });
+(0, globals_1.describe)('TacticsInputSchema — blocking preferences', () => {
+    const country = (0, test_helpers_1.makeCountry)();
+    const p1 = (0, test_helpers_1.makePlayer)(country);
+    const p2 = (0, test_helpers_1.makePlayer)(country);
+    const p3 = (0, test_helpers_1.makePlayer)(country);
+    const p4 = (0, test_helpers_1.makePlayer)(country);
+    const p5 = (0, test_helpers_1.makePlayer)(country);
+    const p6 = (0, test_helpers_1.makePlayer)(country);
+    const reserve = (0, test_helpers_1.makePlayer)(country);
+    // Front-row starters (zones 2/3/4) are p2, p3, p4; the validator only requires target keys to be starters.
+    function baseInput(overrides = {}) {
+        return {
+            lineup: { 4: p4, 3: p3, 2: p2, 5: p5, 6: p6, 1: p1, bench: [] },
+            liberoReplacements: [],
+            ...overrides
+        };
+    }
+    (0, globals_1.it)('accepts a blocking preference that keys starters to attacking functions', () => {
+        const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
+            blockingPreferences: [{ rotation: 1, targets: { [p4.id]: player_1.RoleEnum.OUTSIDE_HITTER, [p3.id]: player_1.RoleEnum.MIDDLE_BLOCKER } }]
+        }));
+        (0, globals_1.expect)(res.success).toBe(true);
+        if (res.success) {
+            (0, globals_1.expect)(res.data.blockingPreferences[0].targets[p4.id]).toBe(player_1.RoleEnum.OUTSIDE_HITTER);
+        }
+    });
+    (0, globals_1.it)('rejects a blocking target that is not a starter', () => {
+        const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
+            blockingPreferences: [{ rotation: 1, targets: { [reserve.id]: player_1.RoleEnum.OUTSIDE_HITTER } }]
+        }));
+        (0, globals_1.expect)(res.success).toBe(false);
+        if (!res.success) {
+            (0, globals_1.expect)(res.error.issues.some(i => i.message === 'BLOCKING_PREFERENCE_BLOCKER_NOT_A_STARTER')).toBe(true);
+        }
+    });
+    (0, globals_1.it)('rejects a blocking target function of libero', () => {
+        const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
+            blockingPreferences: [{ rotation: 1, targets: { [p4.id]: player_1.RoleEnum.LIBERO } }]
+        }));
+        (0, globals_1.expect)(res.success).toBe(false);
+        if (!res.success) {
+            (0, globals_1.expect)(res.error.issues.some(i => i.message === 'BLOCKING_TARGET_CANNOT_BE_LIBERO')).toBe(true);
+        }
+    });
+    (0, globals_1.it)('rejects a duplicate rotation in blocking preferences', () => {
+        const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
+            blockingPreferences: [
+                { rotation: 1, targets: { [p4.id]: player_1.RoleEnum.OUTSIDE_HITTER } },
+                { rotation: 1, targets: { [p3.id]: player_1.RoleEnum.MIDDLE_BLOCKER } }
+            ]
+        }));
+        (0, globals_1.expect)(res.success).toBe(false);
+        if (!res.success) {
+            (0, globals_1.expect)(res.error.issues.some(i => i.message === 'BLOCKING_PREFERENCE_DUPLICATE_ROTATION')).toBe(true);
+        }
+    });
+    (0, globals_1.it)('accepts per-set blocking preference overrides', () => {
+        const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
+            blockingPreferenceSets: [[{ rotation: 1, targets: { [p4.id]: player_1.RoleEnum.OPPOSITE_HITTER } }], []]
+        }));
+        (0, globals_1.expect)(res.success).toBe(true);
+    });
+});

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,15 +258,18 @@ 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>>>;
         offensivePreferences: z.ZodDefault<z.ZodArray<z.ZodObject<{
             rotation: z.ZodNumber;
-            order: z.ZodArray<z.ZodCustom<Player, Player>>;
+            weights: z.ZodRecord<z.ZodString, z.ZodNumber>;
             tempos: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
                 FAST: "FAST";
                 HIGH: "HIGH";
@@ -289,12 +281,20 @@ export declare const TeamInputSchema: z.ZodObject<{
         }, z.core.$strip>>>;
         offensivePreferenceSets: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodObject<{
             rotation: z.ZodNumber;
-            order: z.ZodArray<z.ZodCustom<Player, Player>>;
+            weights: z.ZodRecord<z.ZodString, z.ZodNumber>;
             tempos: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
                 FAST: "FAST";
                 HIGH: "HIGH";
             }>>>;
         }, z.core.$strip>>>>;
+        blockingPreferences: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            rotation: z.ZodNumber;
+            targets: z.ZodRecord<z.ZodString, z.ZodEnum<typeof import("../../player").RoleEnum> & z.ZodType<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum, z.core.$ZodTypeInternals<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum>>>;
+        }, z.core.$strip>>>;
+        blockingPreferenceSets: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodObject<{
+            rotation: z.ZodNumber;
+            targets: z.ZodRecord<z.ZodString, z.ZodEnum<typeof import("../../player").RoleEnum> & z.ZodType<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum, z.core.$ZodTypeInternals<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum>>>;
+        }, z.core.$strip>>>>;
         replaceKnockedImmediately: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
         injuryReplacements: z.ZodDefault<z.ZodArray<z.ZodObject<{
             starter: 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/cjs/src/service/team/tactics.d.ts

@@ -5,6 +5,7 @@ import { LiberoSubConfig } from './libero-sub';
 import { SubBand } from './energy-band';
 import { RotationSystemEnum } from './rotation-system';
 import { OffensivePreference } from './offensive-preference';
+import { BlockingPreference } from './blocking-preference';
 import { InjuryReplacement } from './injury-replacement';
 import { LiberoInjuryConfig } from './libero-injury';
 export interface StartingLineup {
@@ -38,6 +39,8 @@ export interface TacticsOpts {
     readonly replaceKnockedImmediately: Record<string, boolean>;
     readonly injuryReplacements: InjuryReplacement[];
     readonly liberoInjury?: LiberoInjuryConfig;
+    readonly blockingPreferences: BlockingPreference[];
+    readonly blockingPreferenceSets?: BlockingPreference[][];
 }
 export declare class Tactics {
     readonly lineup: StartingLineup;
@@ -56,6 +59,8 @@ export declare class Tactics {
     readonly replaceKnockedImmediately: Record<string, boolean>;
     readonly injuryReplacements: InjuryReplacement[];
     readonly liberoInjury?: LiberoInjuryConfig;
+    readonly blockingPreferences: BlockingPreference[];
+    readonly blockingPreferenceSets?: BlockingPreference[][];
     static create(input: unknown): Tactics;
     private constructor();
     findPlayerInLineup(id: string): CourtPosition | undefined;

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

@@ -18,7 +18,7 @@ class Tactics {
         }
         return new Tactics(result.data);
     }
-    constructor({ lineup, liberoReplacements, receiveRotationOffset = false, designatedSubs = [], substitutionBand = energy_band_1.EnergyBand.TIRED, secondLibero, liberoSub, liberoReplacementSets, rotationSystem = rotation_system_1.RotationSystemEnum.SIX_ZERO, designatedSetters = [], offensivePreferences = [], systemSets, offensivePreferenceSets, replaceKnockedImmediately = {}, injuryReplacements = [], liberoInjury }) {
+    constructor({ lineup, liberoReplacements, receiveRotationOffset = false, designatedSubs = [], substitutionBand = energy_band_1.EnergyBand.TIRED, secondLibero, liberoSub, liberoReplacementSets, rotationSystem = rotation_system_1.RotationSystemEnum.SIX_ZERO, designatedSetters = [], offensivePreferences = [], systemSets, offensivePreferenceSets, replaceKnockedImmediately = {}, injuryReplacements = [], liberoInjury, blockingPreferences = [], blockingPreferenceSets }) {
         this.lineup = lineup;
         this.liberoReplacements = liberoReplacements;
         this.receiveRotationOffset = receiveRotationOffset;
@@ -35,6 +35,8 @@ class Tactics {
         this.replaceKnockedImmediately = replaceKnockedImmediately;
         this.injuryReplacements = injuryReplacements;
         this.liberoInjury = liberoInjury;
+        this.blockingPreferences = blockingPreferences;
+        this.blockingPreferenceSets = blockingPreferenceSets;
     }
     findPlayerInLineup(id) {
         if (this.lineup.bench.some(p => p.id === id))

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

@@ -1,4 +1,4 @@
-import { BoxScore, DataProps, DeclineStatus, Division as _Division, League as _League, Match as _Match, MatchSet as _MatchSet, Player as _Player, PlayerPosition, Qualifier as _Qualifier, QualifierMatch as _QualifierMatch, Rally as _Rally, RallyEvent as _RallyEvent, PointBreakdown, RallyMetrics, Season as _Season, Standing as _Standing, Team as _Team, Tournament as _Tournament, TournamentMatch as _TournamentMatch, National as _National, NationalMatch as _NationalMatch, Country as _Country, CourtPosition, ConditionLogic, EnergyBand, LiberoSubMode, MatchForfeitType, PerformanceStats, PinchCondition, RotationSystemEnum, 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,36 +81,28 @@ 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 {
     rotation: number;
-    order: string[];
+    weights: Record<string, number>;
     tempos?: Record<string, 'FAST' | 'HIGH'>;
 }
+export interface ApiBlockingPreference {
+    rotation: number;
+    targets: Record<string, RoleEnum>;
+}
 export interface ApiSystemSet {
     rotationSystem: RotationSystemEnum;
     designatedSetters: string[];
@@ -126,8 +118,6 @@ export interface ApiLiberoInjury {
     inMatchDesignateId?: string;
 }
 export interface ApiLiberoSetSubConfig {
-    mode: LiberoSubMode;
-    fatigueBand?: EnergyBand;
     conditions?: PinchCondition[];
     conditionLogic?: ConditionLogic;
 }
@@ -148,6 +138,8 @@ export interface Tactics {
     offensivePreferences: ApiOffensivePreference[];
     systemSets?: ApiSystemSet[];
     offensivePreferenceSets?: ApiOffensivePreference[][];
+    blockingPreferences: ApiBlockingPreference[];
+    blockingPreferenceSets?: ApiBlockingPreference[][];
     replaceKnockedImmediately?: Record<string, boolean>;
     injuryReplacements?: ApiInjuryReplacement[];
     liberoInjury?: ApiLiberoInjury;