volleyballsimtypes 0.0.481 → 0.0.483

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

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { Player } from '../../player';
+import { Player, RoleEnum } from '../../player';
 import { EnergyBand } from '../energy-band';
 import { RotationSystemEnum } from '../rotation-system';
 export declare const TacticsInputSchema: z.ZodObject<{
@@ -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,15 +250,18 @@ 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>>>;
     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";
@@ -281,12 +273,20 @@ export declare const TacticsInputSchema: 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 RoleEnum> & z.ZodType<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum, z.core.$ZodTypeInternals<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum>>>;
+    }, z.core.$strip>>>;
+    blockingPreferenceSets: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodObject<{
+        rotation: z.ZodNumber;
+        targets: z.ZodRecord<z.ZodString, z.ZodEnum<typeof RoleEnum> & z.ZodType<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum, z.core.$ZodTypeInternals<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, 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/esm/src/service/team/schemas/tactics.z.js

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { Player } from '../../player';
+import { Player, RoleEnum } from '../../player';
 import { EnergyBand } from '../energy-band';
 import { RotationSystemEnum, setterCountFor } from '../rotation-system';
 import { DesignatedSubSchema, SubBandSchema } from './designated-sub.z';
@@ -47,14 +47,23 @@ const lineupSchema = z.object({
 });
 // Per-player tempo preference (set-tempo rework): absent key = Auto.
 const tempoPreferenceSchema = z.enum(['FAST', 'HIGH']);
-// One rotation's ranked attacker priority. `rotation` is the main setter's rotational slot (1..6); `order` lists
-// the attackers ranked best-first. `tempos` optionally forces a per-starter tempo (Auto when absent). Cross-field
-// checks (starters only in both order and tempos, no dupes) live in the superRefine below.
+// One rotation's attacker weighting. `rotation` is the main setter's rotational slot (1..6); `weights` maps each
+// attacker's starter id to an integer percentage share (values sum to 100; 0 removes an attacker). `tempos`
+// optionally forces a per-starter tempo (Auto when absent). Cross-field checks (keys are starters, weights sum to
+// 100) live in the superRefine below.
 const offensivePreferenceSchema = z.object({
     rotation: z.number().int().min(1).max(6),
-    order: z.array(playerInstanceSchema),
+    weights: z.record(z.string(), z.number().int().min(0)),
     tempos: z.record(z.string(), tempoPreferenceSchema).optional()
 });
+// The opposing attacking functions a dedicated blocker can commit to: every RoleEnum except the libero.
+const blockingFunctionSchema = z.nativeEnum(RoleEnum).refine((v) => v !== RoleEnum.LIBERO, { message: 'BLOCKING_TARGET_CANNOT_BE_LIBERO' });
+// One rotation's dedicated-blocking assignments: `targets` maps my front-row starter ids to the opposing function
+// each commits to block. Cross-field checks (keys are starters) live in the superRefine below.
+const blockingPreferenceSchema = z.object({
+    rotation: z.number().int().min(1).max(6),
+    targets: z.record(z.string(), blockingFunctionSchema)
+});
 // One set's rotation-system override (per-set tactics): system + its designated setters travel together.
 const systemSetSchema = z.object({
     rotationSystem: z.nativeEnum(RotationSystemEnum),
@@ -82,6 +91,9 @@ export const TacticsInputSchema = z.object({
     // validated with the same cross-field rules as the flat fields (see superRefine below).
     systemSets: z.array(systemSetSchema).max(5).optional(),
     offensivePreferenceSets: z.array(z.array(offensivePreferenceSchema)).max(5).optional(),
+    // Blocking preferences (dedicated blocking). Defaults keep every existing Tactics.create({...}) call valid.
+    blockingPreferences: z.array(blockingPreferenceSchema).default([]),
+    blockingPreferenceSets: z.array(z.array(blockingPreferenceSchema)).max(5).optional(),
     // Injuries. Defaults keep every existing Tactics.create({...}) call valid. replaceKnockedImmediately is
     // PER STARTER (owner order 2026-07-05): keyed by starter id, missing key = ON; keys validated against the
     // lineup in the superRefine below. injuryReplacements is the per-starter explicit replacement mapping
@@ -150,16 +162,17 @@ export const TacticsInputSchema = z.object({
                 ctx.addIssue({ code: 'custom', message: 'OFFENSIVE_PREFERENCE_DUPLICATE_ROTATION', path });
             }
             seenRotations.add(pref.rotation);
-            const ids = pref.order.map(p => p.id);
-            if (new Set(ids).size !== ids.length) {
-                ctx.addIssue({ code: 'custom', message: 'OFFENSIVE_PREFERENCE_DUPLICATE_ATTACKER', path });
-            }
-            for (const id of ids) {
+            // Weight keys are on-court starters, and the percentages must sum to exactly 100 (0 removes an attacker).
+            for (const id of Object.keys(pref.weights)) {
                 if (!starterIds.has(id)) {
                     ctx.addIssue({ code: 'custom', message: 'OFFENSIVE_PREFERENCE_ATTACKER_NOT_A_STARTER', path });
                 }
             }
-            // Tempo preference keys are starter ids too (same rule as order).
+            const total = Object.values(pref.weights).reduce((sum, w) => sum + w, 0);
+            if (total !== 100) {
+                ctx.addIssue({ code: 'custom', message: 'OFFENSIVE_PREFERENCE_WEIGHTS_MUST_SUM_TO_100', path });
+            }
+            // Tempo preference keys are starter ids too.
             for (const id of Object.keys(pref.tempos ?? {})) {
                 if (!starterIds.has(id)) {
                     ctx.addIssue({ code: 'custom', message: 'OFFENSIVE_PREFERENCE_TEMPO_NOT_A_STARTER', path });
@@ -167,6 +180,22 @@ export const TacticsInputSchema = z.object({
             }
         }
     };
+    // Blocking preferences: unique rotations; each assignment keys an on-court starter (the UI only offers front-row
+    // players, the schema checks starters). The target function is validated by blockingFunctionSchema.
+    const validateBlockingPreferences = (preferences, path) => {
+        const seenRotations = new Set();
+        for (const pref of preferences) {
+            if (seenRotations.has(pref.rotation)) {
+                ctx.addIssue({ code: 'custom', message: 'BLOCKING_PREFERENCE_DUPLICATE_ROTATION', path });
+            }
+            seenRotations.add(pref.rotation);
+            for (const id of Object.keys(pref.targets)) {
+                if (!starterIds.has(id)) {
+                    ctx.addIssue({ code: 'custom', message: 'BLOCKING_PREFERENCE_BLOCKER_NOT_A_STARTER', path });
+                }
+            }
+        }
+    };
     validateSystem(data.rotationSystem, data.designatedSetters, ['designatedSetters']);
     for (const [i, systemSet] of (data.systemSets ?? []).entries()) {
         validateSystem(systemSet.rotationSystem, systemSet.designatedSetters, ['systemSets', i]);
@@ -175,6 +204,10 @@ export const TacticsInputSchema = z.object({
     for (const [i, preferences] of (data.offensivePreferenceSets ?? []).entries()) {
         validateOffensivePreferences(preferences, ['offensivePreferenceSets', i]);
     }
+    validateBlockingPreferences(data.blockingPreferences, ['blockingPreferences']);
+    for (const [i, preferences] of (data.blockingPreferenceSets ?? []).entries()) {
+        validateBlockingPreferences(preferences, ['blockingPreferenceSets', i]);
+    }
     // Second libero (L2). The second libero is a reserve (not a starter, the libero, or a bench player). A swap
     // rule (FATIGUE/ALWAYS in any set) needs someone to swap in, so it requires a second libero, and a second
     // libero needs a starting libero to replace ("no L2 without an L"). Per-set libero replacements, like the
@@ -185,10 +218,11 @@ export const TacticsInputSchema = 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/esm/src/service/team/schemas/tactics.z.test.js

@@ -1,5 +1,6 @@
 import { describe, it, expect } from '@jest/globals';
 import { TacticsInputSchema } from './tactics.z';
+import { RoleEnum } from '../../player';
 import { makeCountry, makePlayer } from '../../test-helpers';
 describe('TacticsInputSchema — second libero rules', () => {
     const country = makeCountry();
@@ -93,7 +94,7 @@ describe('TacticsInputSchema — per-set tactics (systemSets / offensivePreferen
                 { rotationSystem: '4-2', designatedSetters: [p1, p4] }
             ],
             offensivePreferenceSets: [
-                [{ rotation: 1, order: [p2, p3] }],
+                [{ rotation: 1, weights: { [p2.id]: 60, [p3.id]: 40 } }],
                 []
             ]
         }));
@@ -102,7 +103,7 @@ describe('TacticsInputSchema — per-set tactics (systemSets / offensivePreferen
     it('carries the per-set fields through Tactics.create parsing', () => {
         const res = TacticsInputSchema.safeParse(baseInput({
             systemSets: [{ rotationSystem: '5-1', designatedSetters: [p1] }],
-            offensivePreferenceSets: [[{ rotation: 2, order: [p3] }]]
+            offensivePreferenceSets: [[{ rotation: 2, weights: { [p3.id]: 100 } }]]
         }));
         expect(res.success).toBe(true);
         if (res.success) {
@@ -151,7 +152,7 @@ describe('TacticsInputSchema — per-set tactics (systemSets / offensivePreferen
     });
     it('rejects a per-set preferences list with a duplicate rotation', () => {
         const res = 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 } }]]
         }));
         expect(res.success).toBe(false);
         if (!res.success) {
@@ -159,18 +160,27 @@ describe('TacticsInputSchema — per-set tactics (systemSets / offensivePreferen
             expect(issue?.path).toEqual(['offensivePreferenceSets', 0]);
         }
     });
-    it('rejects a per-set preferences order that lists a non-starter', () => {
+    it('rejects a per-set preferences map that keys a non-starter', () => {
         const res = TacticsInputSchema.safeParse(baseInput({
-            offensivePreferenceSets: [[{ rotation: 1, order: [reserve] }]]
+            offensivePreferenceSets: [[{ rotation: 1, weights: { [reserve.id]: 100 } }]]
         }));
         expect(res.success).toBe(false);
         if (!res.success) {
             expect(res.error.issues.some(i => i.message === 'OFFENSIVE_PREFERENCE_ATTACKER_NOT_A_STARTER')).toBe(true);
         }
     });
+    it('rejects offensive preference weights that do not sum to 100', () => {
+        const res = TacticsInputSchema.safeParse(baseInput({
+            offensivePreferences: [{ rotation: 1, weights: { [p2.id]: 50, [p3.id]: 40 } }]
+        }));
+        expect(res.success).toBe(false);
+        if (!res.success) {
+            expect(res.error.issues.some(i => i.message === 'OFFENSIVE_PREFERENCE_WEIGHTS_MUST_SUM_TO_100')).toBe(true);
+        }
+    });
     it('accepts offensive preferences with a starter-keyed tempos map', () => {
         const res = 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' } }]
         }));
         expect(res.success).toBe(true);
         if (res.success) {
@@ -179,7 +189,7 @@ describe('TacticsInputSchema — per-set tactics (systemSets / offensivePreferen
     });
     it('rejects a tempos map keyed by a non-starter', () => {
         const res = TacticsInputSchema.safeParse(baseInput({
-            offensivePreferences: [{ rotation: 1, order: [p2], tempos: { [reserve.id]: 'FAST' } }]
+            offensivePreferences: [{ rotation: 1, weights: { [p2.id]: 100 }, tempos: { [reserve.id]: 'FAST' } }]
         }));
         expect(res.success).toBe(false);
         if (!res.success) {
@@ -188,7 +198,7 @@ describe('TacticsInputSchema — per-set tactics (systemSets / offensivePreferen
     });
     it('rejects an invalid tempo value', () => {
         const res = TacticsInputSchema.safeParse(baseInput({
-            offensivePreferences: [{ rotation: 1, order: [p2], tempos: { [p2.id]: 'SLOW' } }]
+            offensivePreferences: [{ rotation: 1, weights: { [p2.id]: 100 }, tempos: { [p2.id]: 'SLOW' } }]
         }));
         expect(res.success).toBe(false);
     });
@@ -206,3 +216,66 @@ describe('TacticsInputSchema — per-set tactics (systemSets / offensivePreferen
         }
     });
 });
+describe('TacticsInputSchema — blocking preferences', () => {
+    const country = makeCountry();
+    const p1 = makePlayer(country);
+    const p2 = makePlayer(country);
+    const p3 = makePlayer(country);
+    const p4 = makePlayer(country);
+    const p5 = makePlayer(country);
+    const p6 = makePlayer(country);
+    const reserve = 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
+        };
+    }
+    it('accepts a blocking preference that keys starters to attacking functions', () => {
+        const res = TacticsInputSchema.safeParse(baseInput({
+            blockingPreferences: [{ rotation: 1, targets: { [p4.id]: RoleEnum.OUTSIDE_HITTER, [p3.id]: RoleEnum.MIDDLE_BLOCKER } }]
+        }));
+        expect(res.success).toBe(true);
+        if (res.success) {
+            expect(res.data.blockingPreferences[0].targets[p4.id]).toBe(RoleEnum.OUTSIDE_HITTER);
+        }
+    });
+    it('rejects a blocking target that is not a starter', () => {
+        const res = TacticsInputSchema.safeParse(baseInput({
+            blockingPreferences: [{ rotation: 1, targets: { [reserve.id]: RoleEnum.OUTSIDE_HITTER } }]
+        }));
+        expect(res.success).toBe(false);
+        if (!res.success) {
+            expect(res.error.issues.some(i => i.message === 'BLOCKING_PREFERENCE_BLOCKER_NOT_A_STARTER')).toBe(true);
+        }
+    });
+    it('rejects a blocking target function of libero', () => {
+        const res = TacticsInputSchema.safeParse(baseInput({
+            blockingPreferences: [{ rotation: 1, targets: { [p4.id]: RoleEnum.LIBERO } }]
+        }));
+        expect(res.success).toBe(false);
+        if (!res.success) {
+            expect(res.error.issues.some(i => i.message === 'BLOCKING_TARGET_CANNOT_BE_LIBERO')).toBe(true);
+        }
+    });
+    it('rejects a duplicate rotation in blocking preferences', () => {
+        const res = TacticsInputSchema.safeParse(baseInput({
+            blockingPreferences: [
+                { rotation: 1, targets: { [p4.id]: RoleEnum.OUTSIDE_HITTER } },
+                { rotation: 1, targets: { [p3.id]: RoleEnum.MIDDLE_BLOCKER } }
+            ]
+        }));
+        expect(res.success).toBe(false);
+        if (!res.success) {
+            expect(res.error.issues.some(i => i.message === 'BLOCKING_PREFERENCE_DUPLICATE_ROTATION')).toBe(true);
+        }
+    });
+    it('accepts per-set blocking preference overrides', () => {
+        const res = TacticsInputSchema.safeParse(baseInput({
+            blockingPreferenceSets: [[{ rotation: 1, targets: { [p4.id]: RoleEnum.OPPOSITE_HITTER } }], []]
+        }));
+        expect(res.success).toBe(true);
+    });
+});

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