volleyballsimtypes 0.0.481 → 0.0.483

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

@@ -1,37 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LiberoSubConfigSchema = exports.LiberoSetSubConfigSchema = exports.LiberoSubModeSchema = void 0;
+exports.LiberoSubConfigSchema = exports.LiberoSetSubConfigSchema = void 0;
 const zod_1 = require("zod");
-const energy_band_1 = require("../energy-band");
+const sub_config_convert_1 = require("../sub-config-convert");
 const designated_sub_z_1 = require("./designated-sub.z");
-exports.LiberoSubModeSchema = zod_1.z.enum(['NEVER', 'FATIGUE', 'ALWAYS', 'CONDITIONS']);
-// Fields shared by the all-sets config and each per-set config. The swapped-in player is always the dedicated
-// `secondLibero`, so there is no bench to validate; the CONDITIONS mode reuses the pinch-server condition
-// catalog (PinchConditionSchema, which includes the libero-only PHASE condition) + ALL/ANY logic.
+// Pure condition engine (owner 2026-07-11): the second libero is active while `conditions` hold (combined
+// per `conditionLogic`, default ALL; the STARTING libero is the FATIGUE-condition subject). No conditions =
+// the starting libero always plays; [{ASAP}] = always the second libero (the old ALWAYS). The swapped-in
+// player is always the dedicated `secondLibero`, so there is no bench to validate. Legacy mode-shaped
+// configs (NEVER/FATIGUE/ALWAYS/CONDITIONS) are auto-converted by the preprocess.
 const liberoSetSubConfigShape = {
-    mode: exports.LiberoSubModeSchema,
-    // fatigue mode only (absent => the team default `substitutionBand`):
-    fatigueBand: zod_1.z.nativeEnum(energy_band_1.EnergyBand).optional(),
-    // conditions mode only:
     conditions: zod_1.z.array(designated_sub_z_1.PinchConditionSchema).optional(),
     conditionLogic: designated_sub_z_1.ConditionLogicSchema.optional()
 };
-// CONDITIONS mode needs at least one condition (mirrors the designated-sub pinch refine).
-function refineConditions(data, ctx) {
-    if (data.mode !== 'CONDITIONS')
-        return;
-    if (data.conditions == null || data.conditions.length === 0) {
-        ctx.addIssue({ code: 'custom', message: 'LIBERO_CONDITIONS_REQUIRE_A_CONDITION', path: ['conditions'] });
-    }
-}
-exports.LiberoSetSubConfigSchema = zod_1.z.object(liberoSetSubConfigShape).superRefine(refineConditions);
-exports.LiberoSubConfigSchema = zod_1.z.object({
+exports.LiberoSetSubConfigSchema = zod_1.z.preprocess(sub_config_convert_1.convertLegacyLiberoSetSubConfig, zod_1.z.object(liberoSetSubConfigShape));
+exports.LiberoSubConfigSchema = zod_1.z.preprocess(sub_config_convert_1.convertLegacyLiberoSubConfig, zod_1.z.object({
     ...liberoSetSubConfigShape,
     // Optional per-set overrides (index 0 = set 1 ... index 4 = set 5); absent => the flat config for all sets.
     sets: zod_1.z.array(exports.LiberoSetSubConfigSchema).max(5).optional()
-}).superRefine((data, ctx) => {
-    // The flat config is the fallback for any set a partial `sets` array doesn't cover, so validate it whenever
-    // `sets` is absent or covers fewer than 5 sets (each present per-set config is validated by its own schema).
-    if (data.sets == null || data.sets.length < 5)
-        refineConditions(data, ctx);
-});
+}));

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

@@ -4,85 +4,124 @@ const globals_1 = require("@jest/globals");
 const libero_sub_z_1 = require("./libero-sub.z");
 const energy_band_1 = require("../energy-band");
 const pinch_condition_1 = require("../pinch-condition");
-(0, globals_1.describe)('LiberoSubModeSchema', () => {
-    (0, globals_1.it)('accepts NEVER, FATIGUE, ALWAYS and CONDITIONS', () => {
-        for (const mode of ['NEVER', 'FATIGUE', 'ALWAYS', 'CONDITIONS']) {
-            (0, globals_1.expect)(libero_sub_z_1.LiberoSubModeSchema.safeParse(mode).success).toBe(true);
-        }
-    });
-    (0, globals_1.it)('rejects an unknown mode', () => {
-        (0, globals_1.expect)(libero_sub_z_1.LiberoSubModeSchema.safeParse('SOMETIMES').success).toBe(false);
+// Unified condition engine (owner 2026-07-11): the libero rule is a pure condition list; legacy mode-shaped
+// configs (NEVER/FATIGUE/ALWAYS/CONDITIONS) auto-convert in the schema preprocess.
+(0, globals_1.describe)('LiberoSetSubConfigSchema (unified)', () => {
+    (0, globals_1.it)('accepts an empty config (no conditions = the starting libero always plays)', () => {
+        const res = libero_sub_z_1.LiberoSetSubConfigSchema.safeParse({});
+        (0, globals_1.expect)(res.success).toBe(true);
+        if (res.success)
+            (0, globals_1.expect)(res.data.conditions ?? []).toHaveLength(0);
     });
-});
-(0, globals_1.describe)('LiberoSetSubConfigSchema', () => {
-    (0, globals_1.it)('accepts a mode with no band', () => {
-        (0, globals_1.expect)(libero_sub_z_1.LiberoSetSubConfigSchema.safeParse({ mode: 'ALWAYS' }).success).toBe(true);
+    (0, globals_1.it)('accepts a FATIGUE condition with a band', () => {
+        const res = libero_sub_z_1.LiberoSetSubConfigSchema.safeParse({
+            conditions: [{ type: pinch_condition_1.PinchConditionType.FATIGUE, band: energy_band_1.EnergyBand.TIRED }]
+        });
+        (0, globals_1.expect)(res.success).toBe(true);
     });
-    (0, globals_1.it)('accepts a fatigue mode with a band', () => {
-        (0, globals_1.expect)(libero_sub_z_1.LiberoSetSubConfigSchema.safeParse({ mode: 'FATIGUE', fatigueBand: energy_band_1.EnergyBand.TIRED }).success).toBe(true);
+    (0, globals_1.it)('accepts a FATIGUE condition without a band (team default)', () => {
+        (0, globals_1.expect)(libero_sub_z_1.LiberoSetSubConfigSchema.safeParse({ conditions: [{ type: pinch_condition_1.PinchConditionType.FATIGUE }] }).success).toBe(true);
     });
-    (0, globals_1.it)('rejects an unknown band', () => {
-        (0, globals_1.expect)(libero_sub_z_1.LiberoSetSubConfigSchema.safeParse({ mode: 'FATIGUE', fatigueBand: 'SLEEPY' }).success).toBe(false);
+    (0, globals_1.it)('rejects a FATIGUE condition with an unknown band', () => {
+        (0, globals_1.expect)(libero_sub_z_1.LiberoSetSubConfigSchema.safeParse({ conditions: [{ type: pinch_condition_1.PinchConditionType.FATIGUE, band: 'SLEEPY' }] }).success).toBe(false);
     });
-    (0, globals_1.it)('accepts CONDITIONS with a PHASE condition (serve/receive split)', () => {
+    (0, globals_1.it)('accepts a PHASE condition (serve/receive split)', () => {
         const res = libero_sub_z_1.LiberoSetSubConfigSchema.safeParse({
-            mode: 'CONDITIONS',
             conditionLogic: 'ALL',
             conditions: [{ type: pinch_condition_1.PinchConditionType.PHASE, phase: pinch_condition_1.MatchPhase.RECEIVING }]
         });
         (0, globals_1.expect)(res.success).toBe(true);
     });
-    (0, globals_1.it)('accepts CONDITIONS mixing a pinch condition and a PHASE condition', () => {
+    (0, globals_1.it)('accepts mixed conditions (score + phase + fatigue) under ANY logic', () => {
         const res = libero_sub_z_1.LiberoSetSubConfigSchema.safeParse({
-            mode: 'CONDITIONS',
             conditionLogic: 'ANY',
             conditions: [
                 { type: pinch_condition_1.PinchConditionType.MIN_OWN_SCORE, score: 20 },
-                { type: pinch_condition_1.PinchConditionType.PHASE, phase: pinch_condition_1.MatchPhase.SERVING }
+                { type: pinch_condition_1.PinchConditionType.PHASE, phase: pinch_condition_1.MatchPhase.SERVING },
+                { type: pinch_condition_1.PinchConditionType.FATIGUE, band: energy_band_1.EnergyBand.EXHAUSTED }
             ]
         });
         (0, globals_1.expect)(res.success).toBe(true);
     });
-    (0, globals_1.it)('rejects CONDITIONS mode with no conditions', () => {
-        (0, globals_1.expect)(libero_sub_z_1.LiberoSetSubConfigSchema.safeParse({ mode: 'CONDITIONS' }).success).toBe(false);
-        (0, globals_1.expect)(libero_sub_z_1.LiberoSetSubConfigSchema.safeParse({ mode: 'CONDITIONS', conditions: [] }).success).toBe(false);
-    });
     (0, globals_1.it)('rejects an invalid PHASE value', () => {
         const res = libero_sub_z_1.LiberoSetSubConfigSchema.safeParse({
-            mode: 'CONDITIONS',
             conditions: [{ type: pinch_condition_1.PinchConditionType.PHASE, phase: 'ATTACKING' }]
         });
         (0, globals_1.expect)(res.success).toBe(false);
     });
 });
+(0, globals_1.describe)('LiberoSetSubConfigSchema (legacy conversion)', () => {
+    (0, globals_1.it)('converts legacy NEVER to an empty condition list', () => {
+        const res = libero_sub_z_1.LiberoSetSubConfigSchema.safeParse({ mode: 'NEVER' });
+        (0, globals_1.expect)(res.success).toBe(true);
+        if (res.success)
+            (0, globals_1.expect)(res.data.conditions).toEqual([]);
+    });
+    (0, globals_1.it)('converts legacy ALWAYS to a single ASAP condition', () => {
+        const res = libero_sub_z_1.LiberoSetSubConfigSchema.safeParse({ mode: 'ALWAYS' });
+        (0, globals_1.expect)(res.success).toBe(true);
+        if (res.success)
+            (0, globals_1.expect)(res.data.conditions).toEqual([{ type: pinch_condition_1.PinchConditionType.ASAP }]);
+    });
+    (0, globals_1.it)('converts legacy FATIGUE + band to a FATIGUE condition carrying the band', () => {
+        const res = libero_sub_z_1.LiberoSetSubConfigSchema.safeParse({ mode: 'FATIGUE', fatigueBand: energy_band_1.EnergyBand.WORN });
+        (0, globals_1.expect)(res.success).toBe(true);
+        if (res.success)
+            (0, globals_1.expect)(res.data.conditions).toEqual([{ type: pinch_condition_1.PinchConditionType.FATIGUE, band: energy_band_1.EnergyBand.WORN }]);
+    });
+    (0, globals_1.it)('converts legacy FATIGUE without a band to a bandless FATIGUE condition (team default)', () => {
+        const res = libero_sub_z_1.LiberoSetSubConfigSchema.safeParse({ mode: 'FATIGUE' });
+        (0, globals_1.expect)(res.success).toBe(true);
+        if (res.success)
+            (0, globals_1.expect)(res.data.conditions).toEqual([{ type: pinch_condition_1.PinchConditionType.FATIGUE }]);
+    });
+    (0, globals_1.it)('converts legacy CONDITIONS by stripping the mode and keeping the conditions', () => {
+        const conditions = [{ type: pinch_condition_1.PinchConditionType.PHASE, phase: pinch_condition_1.MatchPhase.RECEIVING }];
+        const res = libero_sub_z_1.LiberoSetSubConfigSchema.safeParse({ mode: 'CONDITIONS', conditionLogic: 'ALL', conditions });
+        (0, globals_1.expect)(res.success).toBe(true);
+        if (res.success) {
+            (0, globals_1.expect)(res.data.conditions).toEqual(conditions);
+            (0, globals_1.expect)(res.data.mode).toBeUndefined();
+        }
+    });
+    (0, globals_1.it)('heals a legacy CONDITIONS config with no conditions to never (empty list) instead of rejecting', () => {
+        const res = libero_sub_z_1.LiberoSetSubConfigSchema.safeParse({ mode: 'CONDITIONS' });
+        (0, globals_1.expect)(res.success).toBe(true);
+        if (res.success)
+            (0, globals_1.expect)(res.data.conditions ?? []).toHaveLength(0);
+    });
+});
 (0, globals_1.describe)('LiberoSubConfigSchema', () => {
-    (0, globals_1.it)('accepts a flat config with no per-set overrides', () => {
+    (0, globals_1.it)('accepts a flat config with no per-set overrides (legacy shape converts)', () => {
         (0, globals_1.expect)(libero_sub_z_1.LiberoSubConfigSchema.safeParse({ mode: 'FATIGUE', fatigueBand: energy_band_1.EnergyBand.WORN }).success).toBe(true);
     });
-    (0, globals_1.it)('accepts up to five per-set configs', () => {
+    (0, globals_1.it)('accepts up to five per-set configs (legacy per-set entries convert)', () => {
         const res = libero_sub_z_1.LiberoSubConfigSchema.safeParse({
             mode: 'NEVER',
             sets: [
                 { mode: 'NEVER' },
                 { mode: 'ALWAYS' },
                 { mode: 'FATIGUE', fatigueBand: energy_band_1.EnergyBand.TIRED },
-                { mode: 'NEVER' },
-                { mode: 'ALWAYS' }
+                { conditions: [{ type: pinch_condition_1.PinchConditionType.FATIGUE }] },
+                {}
             ]
         });
         (0, globals_1.expect)(res.success).toBe(true);
+        if (res.success) {
+            (0, globals_1.expect)(res.data.sets?.[0].conditions).toEqual([]);
+            (0, globals_1.expect)(res.data.sets?.[1].conditions).toEqual([{ type: pinch_condition_1.PinchConditionType.ASAP }]);
+            (0, globals_1.expect)(res.data.sets?.[2].conditions).toEqual([{ type: pinch_condition_1.PinchConditionType.FATIGUE, band: energy_band_1.EnergyBand.TIRED }]);
+        }
     });
     (0, globals_1.it)('rejects more than five per-set configs', () => {
         const res = libero_sub_z_1.LiberoSubConfigSchema.safeParse({
-            mode: 'NEVER',
-            sets: Array.from({ length: 6 }, () => ({ mode: 'NEVER' }))
+            sets: Array.from({ length: 6 }, () => ({}))
         });
         (0, globals_1.expect)(res.success).toBe(false);
     });
-    (0, globals_1.it)('rejects an unknown mode in a per-set config', () => {
+    (0, globals_1.it)('rejects an unknown condition type in a per-set config', () => {
         const res = libero_sub_z_1.LiberoSubConfigSchema.safeParse({
-            mode: 'NEVER',
-            sets: [{ mode: 'WHENEVER' }]
+            sets: [{ conditions: [{ type: 'WHENEVER' }] }]
         });
         (0, globals_1.expect)(res.success).toBe(false);
     });

package/dist/cjs/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/cjs/src/service/team/schemas/tactics.z.js

@@ -50,14 +50,23 @@ const lineupSchema = zod_1.z.object({
 });
 // Per-player tempo preference (set-tempo rework): absent key = Auto.
 const tempoPreferenceSchema = zod_1.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 = zod_1.z.object({
     rotation: zod_1.z.number().int().min(1).max(6),
-    order: zod_1.z.array(playerInstanceSchema),
+    weights: zod_1.z.record(zod_1.z.string(), zod_1.z.number().int().min(0)),
     tempos: zod_1.z.record(zod_1.z.string(), tempoPreferenceSchema).optional()
 });
+// The opposing attacking functions a dedicated blocker can commit to: every RoleEnum except the libero.
+const blockingFunctionSchema = zod_1.z.nativeEnum(player_1.RoleEnum).refine((v) => v !== player_1.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 = zod_1.z.object({
+    rotation: zod_1.z.number().int().min(1).max(6),
+    targets: zod_1.z.record(zod_1.z.string(), blockingFunctionSchema)
+});
 // One set's rotation-system override (per-set tactics): system + its designated setters travel together.
 const systemSetSchema = zod_1.z.object({
     rotationSystem: zod_1.z.nativeEnum(rotation_system_1.RotationSystemEnum),
@@ -85,6 +94,9 @@ exports.TacticsInputSchema = zod_1.z.object({
     // validated with the same cross-field rules as the flat fields (see superRefine below).
     systemSets: zod_1.z.array(systemSetSchema).max(5).optional(),
     offensivePreferenceSets: zod_1.z.array(zod_1.z.array(offensivePreferenceSchema)).max(5).optional(),
+    // Blocking preferences (dedicated blocking). Defaults keep every existing Tactics.create({...}) call valid.
+    blockingPreferences: zod_1.z.array(blockingPreferenceSchema).default([]),
+    blockingPreferenceSets: zod_1.z.array(zod_1.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
@@ -153,16 +165,17 @@ exports.TacticsInputSchema = zod_1.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 });
@@ -170,6 +183,22 @@ exports.TacticsInputSchema = zod_1.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]);
@@ -178,6 +207,10 @@ exports.TacticsInputSchema = zod_1.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
@@ -188,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'] });
     }