volleyballsimtypes 0.0.482 → 0.0.483

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

@@ -34,26 +34,17 @@ export declare const PinchConditionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<PinchConditionType.PHASE>;
     phase: z.ZodEnum<typeof MatchPhase>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<PinchConditionType.FATIGUE>;
+    band: z.ZodOptional<z.ZodEnum<typeof EnergyBand>>;
 }, z.core.$strip>], "type">;
 export declare const ConditionLogicSchema: z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodLiteral<"ANY">]>;
-export declare const SubModeSchema: z.ZodEnum<{
-    NEVER: "NEVER";
-    FATIGUE: "FATIGUE";
-    PINCH: "PINCH";
-}>;
 export declare const SubBackModeSchema: z.ZodEnum<{
     FATIGUE: "FATIGUE";
     CONDITIONS: "CONDITIONS";
 }>;
-export declare const SetSubConfigSchema: z.ZodObject<{
-    mode: z.ZodEnum<{
-        NEVER: "NEVER";
-        FATIGUE: "FATIGUE";
-        PINCH: "PINCH";
-    }>;
+export declare const SetSubConfigSchema: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodObject<{
     bench: z.ZodOptional<z.ZodCustom<Player, Player>>;
-    fatigueBand: z.ZodOptional<z.ZodEnum<typeof EnergyBand>>;
-    benchFatigueBand: z.ZodOptional<z.ZodEnum<typeof EnergyBand>>;
     conditions: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         type: z.ZodLiteral<PinchConditionType.ASAP>;
     }, z.core.$strip>, z.ZodObject<{
@@ -85,9 +76,13 @@ export declare const SetSubConfigSchema: z.ZodObject<{
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<PinchConditionType.PHASE>;
         phase: z.ZodEnum<typeof MatchPhase>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<PinchConditionType.FATIGUE>;
+        band: z.ZodOptional<z.ZodEnum<typeof EnergyBand>>;
     }, z.core.$strip>], "type">>>;
     conditionLogic: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodLiteral<"ANY">]>>;
     pinchServer: z.ZodOptional<z.ZodBoolean>;
+    benchFatigueBand: z.ZodOptional<z.ZodEnum<typeof EnergyBand>>;
     subBackMode: z.ZodOptional<z.ZodEnum<{
         FATIGUE: "FATIGUE";
         CONDITIONS: "CONDITIONS";
@@ -123,19 +118,15 @@ export declare const SetSubConfigSchema: z.ZodObject<{
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<PinchConditionType.PHASE>;
         phase: z.ZodEnum<typeof MatchPhase>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<PinchConditionType.FATIGUE>;
+        band: z.ZodOptional<z.ZodEnum<typeof EnergyBand>>;
     }, z.core.$strip>], "type">>>;
     subBackConditionLogic: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodLiteral<"ANY">]>>;
-}, z.core.$strip>;
-export declare const DesignatedSubSchema: z.ZodObject<{
-    sets: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        mode: z.ZodEnum<{
-            NEVER: "NEVER";
-            FATIGUE: "FATIGUE";
-            PINCH: "PINCH";
-        }>;
+}, z.core.$strip>>;
+export declare const DesignatedSubSchema: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodObject<{
+    sets: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodObject<{
         bench: z.ZodOptional<z.ZodCustom<Player, Player>>;
-        fatigueBand: z.ZodOptional<z.ZodEnum<typeof EnergyBand>>;
-        benchFatigueBand: z.ZodOptional<z.ZodEnum<typeof EnergyBand>>;
         conditions: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
             type: z.ZodLiteral<PinchConditionType.ASAP>;
         }, z.core.$strip>, z.ZodObject<{
@@ -167,9 +158,13 @@ export declare const DesignatedSubSchema: z.ZodObject<{
         }, z.core.$strip>, z.ZodObject<{
             type: z.ZodLiteral<PinchConditionType.PHASE>;
             phase: z.ZodEnum<typeof MatchPhase>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<PinchConditionType.FATIGUE>;
+            band: z.ZodOptional<z.ZodEnum<typeof EnergyBand>>;
         }, z.core.$strip>], "type">>>;
         conditionLogic: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodLiteral<"ANY">]>>;
         pinchServer: z.ZodOptional<z.ZodBoolean>;
+        benchFatigueBand: z.ZodOptional<z.ZodEnum<typeof EnergyBand>>;
         subBackMode: z.ZodOptional<z.ZodEnum<{
             FATIGUE: "FATIGUE";
             CONDITIONS: "CONDITIONS";
@@ -205,17 +200,13 @@ export declare const DesignatedSubSchema: z.ZodObject<{
         }, z.core.$strip>, z.ZodObject<{
             type: z.ZodLiteral<PinchConditionType.PHASE>;
             phase: z.ZodEnum<typeof MatchPhase>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<PinchConditionType.FATIGUE>;
+            band: z.ZodOptional<z.ZodEnum<typeof EnergyBand>>;
         }, z.core.$strip>], "type">>>;
         subBackConditionLogic: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodLiteral<"ANY">]>>;
-    }, z.core.$strip>>>;
-    mode: z.ZodEnum<{
-        NEVER: "NEVER";
-        FATIGUE: "FATIGUE";
-        PINCH: "PINCH";
-    }>;
+    }, z.core.$strip>>>>;
     bench: z.ZodOptional<z.ZodCustom<Player, Player>>;
-    fatigueBand: z.ZodOptional<z.ZodEnum<typeof EnergyBand>>;
-    benchFatigueBand: z.ZodOptional<z.ZodEnum<typeof EnergyBand>>;
     conditions: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         type: z.ZodLiteral<PinchConditionType.ASAP>;
     }, z.core.$strip>, z.ZodObject<{
@@ -247,9 +238,13 @@ export declare const DesignatedSubSchema: z.ZodObject<{
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<PinchConditionType.PHASE>;
         phase: z.ZodEnum<typeof MatchPhase>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<PinchConditionType.FATIGUE>;
+        band: z.ZodOptional<z.ZodEnum<typeof EnergyBand>>;
     }, z.core.$strip>], "type">>>;
     conditionLogic: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodLiteral<"ANY">]>>;
     pinchServer: z.ZodOptional<z.ZodBoolean>;
+    benchFatigueBand: z.ZodOptional<z.ZodEnum<typeof EnergyBand>>;
     subBackMode: z.ZodOptional<z.ZodEnum<{
         FATIGUE: "FATIGUE";
         CONDITIONS: "CONDITIONS";
@@ -285,7 +280,10 @@ export declare const DesignatedSubSchema: z.ZodObject<{
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<PinchConditionType.PHASE>;
         phase: z.ZodEnum<typeof MatchPhase>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<PinchConditionType.FATIGUE>;
+        band: z.ZodOptional<z.ZodEnum<typeof EnergyBand>>;
     }, z.core.$strip>], "type">>>;
     subBackConditionLogic: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodLiteral<"ANY">]>>;
     starter: z.ZodCustom<Player, Player>;
-}, z.core.$strip>;
+}, z.core.$strip>>;

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

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DesignatedSubSchema = exports.SetSubConfigSchema = exports.SubBackModeSchema = exports.SubModeSchema = exports.ConditionLogicSchema = exports.PinchConditionSchema = exports.SubBandSchema = void 0;
+exports.DesignatedSubSchema = exports.SetSubConfigSchema = exports.SubBackModeSchema = exports.ConditionLogicSchema = exports.PinchConditionSchema = exports.SubBandSchema = void 0;
 const zod_1 = require("zod");
 const player_1 = require("../../player");
 const energy_band_1 = require("../energy-band");
 const pinch_condition_1 = require("../pinch-condition");
+const sub_config_convert_1 = require("../sub-config-convert");
 const playerInstanceSchema = zod_1.z.custom((v) => v instanceof player_1.Player, {
     message: 'INVALID_PLAYER_INSTANCE'
 });
@@ -21,44 +22,47 @@ exports.PinchConditionSchema = zod_1.z.discriminatedUnion('type', [
     zod_1.z.object({ type: zod_1.z.literal(pinch_condition_1.PinchConditionType.MIN_OWN_SCORE), score: zod_1.z.number().int().min(0).max(40), comparison: zod_1.z.nativeEnum(pinch_condition_1.Comparison).optional() }),
     zod_1.z.object({ type: zod_1.z.literal(pinch_condition_1.PinchConditionType.MIN_OPPONENT_SCORE), score: zod_1.z.number().int().min(0).max(40), comparison: zod_1.z.nativeEnum(pinch_condition_1.Comparison).optional() }),
     // PHASE is used by the libero deployment rule (which reuses this schema); pinch servers never offer it.
-    zod_1.z.object({ type: zod_1.z.literal(pinch_condition_1.PinchConditionType.PHASE), phase: zod_1.z.nativeEnum(pinch_condition_1.MatchPhase) })
+    zod_1.z.object({ type: zod_1.z.literal(pinch_condition_1.PinchConditionType.PHASE), phase: zod_1.z.nativeEnum(pinch_condition_1.MatchPhase) }),
+    // The subject player's energy is at-or-worse than `band` (absent = the team `substitutionBand`); the
+    // subject comes from the evaluation context (starter / substitute / starting libero).
+    zod_1.z.object({ type: zod_1.z.literal(pinch_condition_1.PinchConditionType.FATIGUE), band: zod_1.z.nativeEnum(energy_band_1.EnergyBand).optional() })
 ]);
 exports.ConditionLogicSchema = zod_1.z.union([zod_1.z.literal('ALL'), zod_1.z.literal('ANY')]);
-exports.SubModeSchema = zod_1.z.enum(['FATIGUE', 'PINCH', 'NEVER']);
 exports.SubBackModeSchema = zod_1.z.enum(['FATIGUE', 'CONDITIONS']);
-// Fields shared by the all-sets config and each per-set config.
+// Fields shared by the all-sets config and each per-set config. Pure condition engine (owner 2026-07-11):
+// no mode; `conditions` is the sub-in trigger and an EMPTY/absent list means the starter is never substituted
+// by this rule. Legacy mode-shaped inputs are auto-converted by the preprocess below.
 const setSubConfigShape = {
-    mode: exports.SubModeSchema,
     bench: playerInstanceSchema.optional(),
-    fatigueBand: zod_1.z.nativeEnum(energy_band_1.EnergyBand).optional(),
-    benchFatigueBand: zod_1.z.nativeEnum(energy_band_1.EnergyBand).optional(),
     conditions: zod_1.z.array(exports.PinchConditionSchema).optional(),
     conditionLogic: exports.ConditionLogicSchema.optional(),
-    // pinch ("Conditions") mode. true = serve-and-return pinch server; false/absent = regular conditional sub.
+    // true = serve-and-return pinch server; false/absent = regular conditional sub (stays until sub-back).
     pinchServer: zod_1.z.boolean().optional(),
-    // a regular conditional sub's sub-back trigger + its condition set (subBackMode === 'CONDITIONS').
+    // The substitute's own pull band for FATIGUE sub-backs (absent = the team `substitutionBand`).
+    benchFatigueBand: zod_1.z.nativeEnum(energy_band_1.EnergyBand).optional(),
     subBackMode: exports.SubBackModeSchema.optional(),
     subBackConditions: zod_1.z.array(exports.PinchConditionSchema).optional(),
     subBackConditionLogic: exports.ConditionLogicSchema.optional()
 };
-// Pinch ("Conditions") mode needs a designated bench player and at least one sub-in condition. A regular
-// conditional sub (pinchServer !== true) with a CONDITIONS sub-back also needs at least one sub-back condition.
-function refinePinch(data, ctx) {
-    if (data.mode !== 'PINCH')
-        return;
-    if (data.bench == null) {
-        ctx.addIssue({ code: 'custom', message: 'PINCH_SERVER_REQUIRES_BENCH', path: ['bench'] });
-    }
-    if (data.conditions == null || data.conditions.length === 0) {
-        ctx.addIssue({ code: 'custom', message: 'PINCH_SERVER_REQUIRES_CONDITIONS', path: ['conditions'] });
+// A pinch server needs a designated bench player and at least one sub-in condition. A regular conditional sub
+// with a CONDITIONS sub-back needs at least one sub-back condition. Empty sub-in conditions are otherwise
+// VALID (= never fires).
+function refineSubConfig(data, ctx) {
+    if (data.pinchServer === true) {
+        if (data.bench == null) {
+            ctx.addIssue({ code: 'custom', message: 'PINCH_SERVER_REQUIRES_BENCH', path: ['bench'] });
+        }
+        if (data.conditions == null || data.conditions.length === 0) {
+            ctx.addIssue({ code: 'custom', message: 'PINCH_SERVER_REQUIRES_CONDITIONS', path: ['conditions'] });
+        }
     }
     if (data.pinchServer !== true && data.subBackMode === 'CONDITIONS' &&
         (data.subBackConditions == null || data.subBackConditions.length === 0)) {
         ctx.addIssue({ code: 'custom', message: 'CONDITIONAL_SUB_BACK_REQUIRES_CONDITIONS', path: ['subBackConditions'] });
     }
 }
-exports.SetSubConfigSchema = zod_1.z.object(setSubConfigShape).superRefine(refinePinch);
-exports.DesignatedSubSchema = zod_1.z.object({
+exports.SetSubConfigSchema = zod_1.z.preprocess(sub_config_convert_1.convertLegacySetSubConfig, zod_1.z.object(setSubConfigShape).superRefine(refineSubConfig));
+exports.DesignatedSubSchema = zod_1.z.preprocess(sub_config_convert_1.convertLegacyDesignatedSub, zod_1.z.object({
     starter: playerInstanceSchema,
     ...setSubConfigShape,
     // Optional per-set overrides (index 0 = set 1 ... index 4 = set 5); absent => the flat config for all sets.
@@ -67,5 +71,5 @@ exports.DesignatedSubSchema = zod_1.z.object({
     // The flat config is the fallback for any set a partial `sets` array doesn't cover, so validate it whenever
     // `sets` is absent or covers fewer than 5 sets (each present per-set config is validated by SetSubConfigSchema).
     if (data.sets == null || data.sets.length < 5)
-        refinePinch(data, ctx);
-});
+        refineSubConfig(data, ctx);
+}));

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

@@ -116,12 +116,14 @@ const test_helpers_1 = require("../../test-helpers");
         });
         (0, globals_1.expect)(res.success).toBe(true);
     });
-    (0, globals_1.it)('rejects an unknown mode', () => {
+    (0, globals_1.it)('heals an unknown legacy mode by stripping it (lenient conversion, config stays valid)', () => {
         const res = designated_sub_z_1.DesignatedSubSchema.safeParse({
             starter,
             mode: 'SOMETIMES'
         });
-        (0, globals_1.expect)(res.success).toBe(false);
+        (0, globals_1.expect)(res.success).toBe(true);
+        if (res.success)
+            (0, globals_1.expect)(res.data.mode).toBeUndefined();
     });
     (0, globals_1.it)('accepts a pinch-mode entry with a bench server and conditions', () => {
         const res = designated_sub_z_1.DesignatedSubSchema.safeParse({

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

@@ -1,19 +1,5 @@
 import { z } from 'zod';
-import { EnergyBand } from '../energy-band';
-export declare const LiberoSubModeSchema: z.ZodEnum<{
-    NEVER: "NEVER";
-    FATIGUE: "FATIGUE";
-    CONDITIONS: "CONDITIONS";
-    ALWAYS: "ALWAYS";
-}>;
-export declare const LiberoSetSubConfigSchema: z.ZodObject<{
-    mode: z.ZodEnum<{
-        NEVER: "NEVER";
-        FATIGUE: "FATIGUE";
-        CONDITIONS: "CONDITIONS";
-        ALWAYS: "ALWAYS";
-    }>;
-    fatigueBand: z.ZodOptional<z.ZodEnum<typeof EnergyBand>>;
+export declare const LiberoSetSubConfigSchema: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodObject<{
     conditions: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         type: z.ZodLiteral<import("..").PinchConditionType.ASAP>;
     }, z.core.$strip>, z.ZodObject<{
@@ -45,18 +31,14 @@ export declare const LiberoSetSubConfigSchema: z.ZodObject<{
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<import("..").PinchConditionType.PHASE>;
         phase: z.ZodEnum<typeof import("..").MatchPhase>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<import("..").PinchConditionType.FATIGUE>;
+        band: z.ZodOptional<z.ZodEnum<typeof import("..").EnergyBand>>;
     }, z.core.$strip>], "type">>>;
     conditionLogic: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodLiteral<"ANY">]>>;
-}, z.core.$strip>;
-export declare const LiberoSubConfigSchema: z.ZodObject<{
-    sets: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        mode: z.ZodEnum<{
-            NEVER: "NEVER";
-            FATIGUE: "FATIGUE";
-            CONDITIONS: "CONDITIONS";
-            ALWAYS: "ALWAYS";
-        }>;
-        fatigueBand: z.ZodOptional<z.ZodEnum<typeof EnergyBand>>;
+}, z.core.$strip>>;
+export declare const LiberoSubConfigSchema: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodObject<{
+    sets: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodObject<{
         conditions: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
             type: z.ZodLiteral<import("..").PinchConditionType.ASAP>;
         }, z.core.$strip>, z.ZodObject<{
@@ -88,16 +70,12 @@ export declare const LiberoSubConfigSchema: z.ZodObject<{
         }, z.core.$strip>, z.ZodObject<{
             type: z.ZodLiteral<import("..").PinchConditionType.PHASE>;
             phase: z.ZodEnum<typeof import("..").MatchPhase>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<import("..").PinchConditionType.FATIGUE>;
+            band: z.ZodOptional<z.ZodEnum<typeof import("..").EnergyBand>>;
         }, z.core.$strip>], "type">>>;
         conditionLogic: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodLiteral<"ANY">]>>;
-    }, z.core.$strip>>>;
-    mode: z.ZodEnum<{
-        NEVER: "NEVER";
-        FATIGUE: "FATIGUE";
-        CONDITIONS: "CONDITIONS";
-        ALWAYS: "ALWAYS";
-    }>;
-    fatigueBand: z.ZodOptional<z.ZodEnum<typeof EnergyBand>>;
+    }, z.core.$strip>>>>;
     conditions: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         type: z.ZodLiteral<import("..").PinchConditionType.ASAP>;
     }, z.core.$strip>, z.ZodObject<{
@@ -129,6 +107,9 @@ export declare const LiberoSubConfigSchema: z.ZodObject<{
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<import("..").PinchConditionType.PHASE>;
         phase: z.ZodEnum<typeof import("..").MatchPhase>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<import("..").PinchConditionType.FATIGUE>;
+        band: z.ZodOptional<z.ZodEnum<typeof import("..").EnergyBand>>;
     }, z.core.$strip>], "type">>>;
     conditionLogic: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodLiteral<"ANY">]>>;
-}, z.core.$strip>;
+}, z.core.$strip>>;

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