volleyballsimtypes 0.0.473 → 0.0.475

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

@@ -111,9 +111,16 @@ export interface ApiInjuryReplacement {
     replacementId: string;
     benchBackfillId?: string;
 }
+export interface ApiLiberoInjury {
+    preMatchReplacementId?: string;
+    secondLiberoBackfillId?: string;
+    inMatchDesignateId?: string;
+}
 export interface ApiLiberoSetSubConfig {
     mode: LiberoSubMode;
     fatigueBand?: EnergyBand;
+    conditions?: PinchCondition[];
+    conditionLogic?: ConditionLogic;
 }
 export interface ApiLiberoSubConfig extends ApiLiberoSetSubConfig {
     sets?: ApiLiberoSetSubConfig[];
@@ -134,6 +141,7 @@ export interface Tactics {
     offensivePreferenceSets?: ApiOffensivePreference[][];
     replaceKnockedImmediately?: Record<string, boolean>;
     injuryReplacements?: ApiInjuryReplacement[];
+    liberoInjury?: ApiLiberoInjury;
 }
 export interface ApiLineupPreset {
     presetId: string;

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

@@ -44,9 +44,16 @@ export interface InjuryReplacementAttributes {
     replacementId: PlayerId;
     benchBackfillId?: PlayerId;
 }
+export interface LiberoInjuryAttributes {
+    preMatchReplacementId?: PlayerId;
+    secondLiberoBackfillId?: PlayerId;
+    inMatchDesignateId?: PlayerId;
+}
 export interface LiberoSetSubConfigAttributes {
     mode: LiberoSubMode;
     fatigueBand?: EnergyBand;
+    conditions?: PinchCondition[];
+    conditionLogic?: ConditionLogic;
 }
 export interface LiberoSubConfigAttributes extends LiberoSetSubConfigAttributes {
     sets?: LiberoSetSubConfigAttributes[];
@@ -68,10 +75,11 @@ export interface TacticsAttributes {
     offensive_preference_sets?: OffensivePreferenceAttributes[][];
     replace_knocked_immediately?: Record<PlayerId, boolean>;
     injury_replacements?: InjuryReplacementAttributes[];
+    libero_injury?: LiberoInjuryAttributes;
 }
 export type TacticsPk = 'team_id';
 export type TacticsId = TacticsModel[TacticsPk];
-export type TacticsOptionalAttributes = 'lineup' | 'libero_replacements' | 'receive_rotation_offset' | 'designated_subs' | 'substitution_band' | 'second_libero' | 'libero_sub' | 'libero_replacement_sets' | 'rotation_system' | 'designated_setters' | 'offensive_preferences' | 'system_sets' | 'offensive_preference_sets' | 'replace_knocked_immediately' | 'injury_replacements';
+export type TacticsOptionalAttributes = 'lineup' | 'libero_replacements' | 'receive_rotation_offset' | 'designated_subs' | 'substitution_band' | 'second_libero' | 'libero_sub' | 'libero_replacement_sets' | 'rotation_system' | 'designated_setters' | 'offensive_preferences' | 'system_sets' | 'offensive_preference_sets' | 'replace_knocked_immediately' | 'injury_replacements' | 'libero_injury';
 export type TacticsCreationAttributes = Optional<TacticsAttributes, TacticsOptionalAttributes>;
 export declare class TacticsModel extends Model<TacticsAttributes, TacticsCreationAttributes> implements TacticsAttributes {
     team_id: string;
@@ -90,6 +98,7 @@ export declare class TacticsModel extends Model<TacticsAttributes, TacticsCreati
     offensive_preference_sets?: OffensivePreferenceAttributes[][];
     replace_knocked_immediately?: Record<PlayerId, boolean>;
     injury_replacements?: InjuryReplacementAttributes[];
+    libero_injury?: LiberoInjuryAttributes;
     team: TeamModel;
     getTeam: Sequelize.BelongsToGetAssociationMixin<TeamModel>;
     setTeam: Sequelize.BelongsToSetAssociationMixin<TeamModel, TeamId>;

package/dist/cjs/src/data/models/tactics.js

@@ -82,6 +82,10 @@ class TacticsModel extends sequelize_1.Model {
             injury_replacements: {
                 type: sequelize_1.DataTypes.JSONB,
                 allowNull: true
+            },
+            libero_injury: {
+                type: sequelize_1.DataTypes.JSONB,
+                allowNull: true
             }
         }, {
             sequelize,

package/dist/cjs/src/data/transformers/tactics.js

@@ -93,7 +93,14 @@ function transformToAttributes(tactics, teamId) {
             starterId: ir.starter.id,
             replacementId: ir.replacement.id,
             benchBackfillId: ir.benchBackfill?.id
-        }))
+        })),
+        libero_injury: tactics.liberoInjury != null
+            ? {
+                preMatchReplacementId: tactics.liberoInjury.preMatchReplacement?.id,
+                secondLiberoBackfillId: tactics.liberoInjury.secondLiberoBackfill?.id,
+                inMatchDesignateId: tactics.liberoInjury.inMatchDesignate?.id
+            }
+            : undefined
     };
 }
 // Accepts TacticsAttributes (not just TacticsModel) so a per-match preset's config, shaped as column data by
@@ -221,6 +228,38 @@ function transformToObject(model, roster) {
                 healed.push({ starter, replacement, benchBackfill });
             }
             return healed;
+        })(),
+        // LENIENT (roster.find): drop any stale/invalid libero-injury id so a bad row can never crash a team load.
+        // Mirrors the schema pool rules: preMatchReplacement is a RESERVE or the L2 (not in the lineup) and needs a
+        // starting libero; secondLiberoBackfill is a RESERVE (not the current L2) kept only when the L2 is the
+        // replacement; inMatchDesignate is a bench/reserve player (not a court starter, the libero, or the L2).
+        liberoInjury: (() => {
+            const li = model.libero_injury;
+            if (li == null)
+                return undefined;
+            const liberoZoneId = lineup[service_1.CourtPosition.LIBERO_ZONE]?.id;
+            const injuryStarterIds = new Set([lineup[service_1.CourtPosition.LEFT_FRONT], lineup[service_1.CourtPosition.MIDDLE_FRONT], lineup[service_1.CourtPosition.RIGHT_FRONT],
+                lineup[service_1.CourtPosition.LEFT_BACK], lineup[service_1.CourtPosition.MIDDLE_BACK], lineup[service_1.CourtPosition.RIGHT_BACK]]
+                .map((p) => p.id));
+            const reserveOrL2 = (id) => {
+                if (id == null)
+                    return undefined;
+                const p = roster.find((x) => x.id === id);
+                return p != null && !inLineupIds.has(p.id) ? p : undefined;
+            };
+            const preMatchReplacement = liberoZoneId != null ? reserveOrL2(li.preMatchReplacementId) : undefined;
+            const secondLiberoBackfill = (preMatchReplacement != null && preMatchReplacement.id === secondLibero?.id)
+                ? (() => { const p = reserveOrL2(li.secondLiberoBackfillId); return p != null && p.id !== secondLibero?.id ? p : undefined; })()
+                : undefined;
+            const inMatchDesignate = (() => {
+                const p = li.inMatchDesignateId != null ? roster.find((x) => x.id === li.inMatchDesignateId) : undefined;
+                if (p == null || injuryStarterIds.has(p.id) || p.id === liberoZoneId || p.id === secondLibero?.id)
+                    return undefined;
+                return p;
+            })();
+            if (preMatchReplacement == null && secondLiberoBackfill == null && inMatchDesignate == null)
+                return undefined;
+            return { preMatchReplacement, secondLiberoBackfill, inMatchDesignate };
         })()
     });
 }
@@ -325,6 +364,30 @@ function tacticsColumnsToApiDto(model) {
                 healed.push({ starterId: ir.starterId, replacementId: ir.replacementId, benchBackfillId });
             }
             return healed.length > 0 ? healed : undefined;
+        })(),
+        // Same stale-data policy for the libero-injury ids (ids only; roster membership is checked in the service
+        // heal). preMatchReplacement = reserve or the L2 (not in the lineup) + needs a starting libero;
+        // secondLiberoBackfill = a reserve (not the current L2) kept only when the L2 is the replacement;
+        // inMatchDesignate = a bench/reserve player (not a court starter, the libero, or the L2).
+        liberoInjury: (() => {
+            const li = model.libero_injury;
+            if (li == null)
+                return undefined;
+            const liberoZoneId = model.lineup[service_1.CourtPosition.LIBERO_ZONE];
+            const starterSlotIds = new Set([model.lineup[service_1.CourtPosition.LEFT_FRONT], model.lineup[service_1.CourtPosition.MIDDLE_FRONT],
+                model.lineup[service_1.CourtPosition.RIGHT_FRONT], model.lineup[service_1.CourtPosition.LEFT_BACK],
+                model.lineup[service_1.CourtPosition.MIDDLE_BACK], model.lineup[service_1.CourtPosition.RIGHT_BACK]]);
+            const reserveOrL2 = (id) => (id != null && !lineupIds.has(id)) ? id : undefined;
+            const preMatchReplacementId = liberoZoneId != null ? reserveOrL2(li.preMatchReplacementId) : undefined;
+            const secondLiberoBackfillId = (preMatchReplacementId != null && preMatchReplacementId === validSecondLibero)
+                ? (() => { const id = reserveOrL2(li.secondLiberoBackfillId); return id != null && id !== validSecondLibero ? id : undefined; })()
+                : undefined;
+            const designateEligible = li.inMatchDesignateId != null && !starterSlotIds.has(li.inMatchDesignateId) &&
+                li.inMatchDesignateId !== liberoZoneId && li.inMatchDesignateId !== validSecondLibero;
+            const inMatchDesignateId = designateEligible ? li.inMatchDesignateId : undefined;
+            if (preMatchReplacementId == null && secondLiberoBackfillId == null && inMatchDesignateId == null)
+                return undefined;
+            return { preMatchReplacementId, secondLiberoBackfillId, inMatchDesignateId };
         })()
     };
 }
@@ -360,6 +423,7 @@ function apiTacticsConfigToAttributes(config, teamId) {
         system_sets: config.systemSets,
         offensive_preference_sets: config.offensivePreferenceSets,
         replace_knocked_immediately: config.replaceKnockedImmediately,
-        injury_replacements: config.injuryReplacements
+        injury_replacements: config.injuryReplacements,
+        libero_injury: config.liberoInjury
     };
 }

package/dist/cjs/src/data/transformers/tactics.test.js

@@ -139,3 +139,47 @@ function makeTactics(designatedSubs) {
         (0, globals_1.expect)(back.offensivePreferenceSets).toBeUndefined();
     });
 });
+(0, globals_1.describe)('libero injuries — service <-> row round-trip + lenient heal', () => {
+    const country = (0, test_helpers_1.makeCountry)();
+    const p1 = (0, test_helpers_1.makePlayer)(country);
+    const p2 = (0, test_helpers_1.makePlayer)(country);
+    const p3 = (0, test_helpers_1.makePlayer)(country);
+    const p4 = (0, test_helpers_1.makePlayer)(country);
+    const p5 = (0, test_helpers_1.makePlayer)(country);
+    const p6 = (0, test_helpers_1.makePlayer)(country);
+    const libero = (0, test_helpers_1.makePlayer)(country);
+    const l2 = (0, test_helpers_1.makePlayer)(country);
+    const reserveA = (0, test_helpers_1.makePlayer)(country);
+    const reserveB = (0, test_helpers_1.makePlayer)(country);
+    const roster = [p1, p2, p3, p4, p5, p6, libero, l2, reserveA, reserveB];
+    const tactics = service_1.Tactics.create({
+        lineup: { 4: p4, 3: p3, 2: p2, 5: p5, 6: p6, 1: p1, 0: libero, bench: [] },
+        liberoReplacements: [],
+        secondLibero: l2,
+        liberoInjury: { preMatchReplacement: l2, secondLiberoBackfill: reserveA, inMatchDesignate: reserveB }
+    });
+    (0, globals_1.it)('writes libero_injury as id-based jsonb', () => {
+        const attrs = (0, tactics_1.transformFromTactics)(tactics, 'team-1');
+        (0, globals_1.expect)(attrs.libero_injury).toEqual({
+            preMatchReplacementId: l2.id,
+            secondLiberoBackfillId: reserveA.id,
+            inMatchDesignateId: reserveB.id
+        });
+    });
+    (0, globals_1.it)('resolves the stored libero_injury ids back to roster players', () => {
+        const attrs = (0, tactics_1.transformFromTactics)(tactics, 'team-1');
+        const back = (0, tactics_1.transformToTactics)(attrs, roster);
+        (0, globals_1.expect)(back.liberoInjury?.preMatchReplacement?.id).toBe(l2.id);
+        (0, globals_1.expect)(back.liberoInjury?.secondLiberoBackfill?.id).toBe(reserveA.id);
+        (0, globals_1.expect)(back.liberoInjury?.inMatchDesignate?.id).toBe(reserveB.id);
+    });
+    (0, globals_1.it)('drops a stale pre-match replacement that is now a court starter (lenient heal, no crash)', () => {
+        const attrs = (0, tactics_1.transformFromTactics)(tactics, 'team-1');
+        attrs.libero_injury.preMatchReplacementId = p2.id;
+        attrs.libero_injury.secondLiberoBackfillId = undefined;
+        const back = (0, tactics_1.transformToTactics)(attrs, roster);
+        (0, globals_1.expect)(back.liberoInjury?.preMatchReplacement).toBeUndefined();
+        (0, globals_1.expect)(back.liberoInjury?.secondLiberoBackfill).toBeUndefined();
+        (0, globals_1.expect)(back.liberoInjury?.inMatchDesignate?.id).toBe(reserveB.id);
+    });
+});

package/dist/cjs/src/service/team/index.d.ts

@@ -12,3 +12,4 @@ export * from './lineup-function';
 export * from './base-position';
 export * from './offensive-preference';
 export * from './injury-replacement';
+export * from './libero-injury';

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

@@ -28,3 +28,4 @@ __exportStar(require("./lineup-function"), exports);
 __exportStar(require("./base-position"), exports);
 __exportStar(require("./offensive-preference"), exports);
 __exportStar(require("./injury-replacement"), exports);
+__exportStar(require("./libero-injury"), exports);

package/dist/cjs/src/service/team/libero-injury.d.ts

@@ -0,0 +1,6 @@
+import { Player } from '../player';
+export interface LiberoInjuryConfig {
+    readonly preMatchReplacement?: Player;
+    readonly secondLiberoBackfill?: Player;
+    readonly inMatchDesignate?: Player;
+}

package/dist/cjs/src/service/team/libero-injury.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,8 +1,11 @@
 import { EnergyBand } from './energy-band';
-export type LiberoSubMode = 'NEVER' | 'FATIGUE' | 'ALWAYS';
+import { ConditionLogic, PinchCondition } from './pinch-condition';
+export type LiberoSubMode = 'NEVER' | 'FATIGUE' | 'ALWAYS' | 'CONDITIONS';
 export interface LiberoSetSubConfig {
     readonly mode: LiberoSubMode;
     readonly fatigueBand?: EnergyBand;
+    readonly conditions?: PinchCondition[];
+    readonly conditionLogic?: ConditionLogic;
 }
 export interface LiberoSubConfig extends LiberoSetSubConfig {
     readonly sets?: LiberoSetSubConfig[];

package/dist/cjs/src/service/team/pinch-condition.d.ts

@@ -6,7 +6,12 @@ export declare enum PinchConditionType {
     AFTER_ROTATIONS = "AFTER_ROTATIONS",// from the team's Nth serve turn in the set onward
     FROM_SET = "FROM_SET",// only set N or later
     MIN_OWN_SCORE = "MIN_OWN_SCORE",// only once own score >= N
-    MIN_OPPONENT_SCORE = "MIN_OPPONENT_SCORE"
+    MIN_OPPONENT_SCORE = "MIN_OPPONENT_SCORE",// only once opponent score >= N
+    PHASE = "PHASE"
+}
+export declare enum MatchPhase {
+    SERVING = "SERVING",
+    RECEIVING = "RECEIVING"
 }
 export declare enum OpponentRelation {
     AHEAD = "AHEAD",
@@ -50,7 +55,11 @@ export interface MinOpponentScoreCondition {
     readonly type: PinchConditionType.MIN_OPPONENT_SCORE;
     readonly score: number;
 }
-export type PinchCondition = AsapCondition | TeamSetPointCondition | OpponentSetPointCondition | ScoreDiffCondition | AfterRotationsCondition | FromSetCondition | MinOwnScoreCondition | MinOpponentScoreCondition;
+export interface PhaseCondition {
+    readonly type: PinchConditionType.PHASE;
+    readonly phase: MatchPhase;
+}
+export type PinchCondition = AsapCondition | TeamSetPointCondition | OpponentSetPointCondition | ScoreDiffCondition | AfterRotationsCondition | FromSetCondition | MinOwnScoreCondition | MinOpponentScoreCondition | PhaseCondition;
 export type ConditionLogic = 'ALL' | 'ANY';
 export interface PinchSetState {
     readonly ownScore: number;
@@ -58,4 +67,5 @@ export interface PinchSetState {
     readonly setTarget: number;
     readonly setNumber: number;
     readonly ownServeTurns: number;
+    readonly phase: MatchPhase;
 }

package/dist/cjs/src/service/team/pinch-condition.js

@@ -3,7 +3,7 @@
 // wins back the serve, out the moment the serve is lost). Each condition is evaluated against the live set
 // state; a pinch entry combines them with ALL (every condition must hold) or ANY (one is enough).
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ScoreDirection = exports.OpponentRelation = exports.PinchConditionType = void 0;
+exports.ScoreDirection = exports.OpponentRelation = exports.MatchPhase = exports.PinchConditionType = void 0;
 var PinchConditionType;
 (function (PinchConditionType) {
     PinchConditionType["ASAP"] = "ASAP";
@@ -13,8 +13,16 @@ var PinchConditionType;
     PinchConditionType["AFTER_ROTATIONS"] = "AFTER_ROTATIONS";
     PinchConditionType["FROM_SET"] = "FROM_SET";
     PinchConditionType["MIN_OWN_SCORE"] = "MIN_OWN_SCORE";
-    PinchConditionType["MIN_OPPONENT_SCORE"] = "MIN_OPPONENT_SCORE"; // only once opponent score >= N
+    PinchConditionType["MIN_OPPONENT_SCORE"] = "MIN_OPPONENT_SCORE";
+    PinchConditionType["PHASE"] = "PHASE"; // the team is serving or receiving this rally (used by the libero deployment rule)
 })(PinchConditionType || (exports.PinchConditionType = PinchConditionType = {}));
+// Which side of the rally the team is on. Known at each dead ball: the serving team is SERVING, the other
+// RECEIVING. Consumed by the PHASE condition (libero deployment); pinch servers always evaluate while SERVING.
+var MatchPhase;
+(function (MatchPhase) {
+    MatchPhase["SERVING"] = "SERVING";
+    MatchPhase["RECEIVING"] = "RECEIVING";
+})(MatchPhase || (exports.MatchPhase = MatchPhase = {}));
 var OpponentRelation;
 (function (OpponentRelation) {
     OpponentRelation["AHEAD"] = "AHEAD";

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

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { Player } from '../../player';
 import { EnergyBand } from '../energy-band';
-import { OpponentRelation, PinchConditionType, ScoreDirection } from '../pinch-condition';
+import { MatchPhase, OpponentRelation, PinchConditionType, ScoreDirection } from '../pinch-condition';
 export declare const SubBandSchema: z.ZodUnion<readonly [z.ZodEnum<typeof EnergyBand>, z.ZodLiteral<"NEVER">]>;
 export declare const PinchConditionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<PinchConditionType.ASAP>;
@@ -28,6 +28,9 @@ export declare const PinchConditionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<PinchConditionType.MIN_OPPONENT_SCORE>;
     score: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<PinchConditionType.PHASE>;
+    phase: z.ZodEnum<typeof MatchPhase>;
 }, z.core.$strip>], "type">;
 export declare const ConditionLogicSchema: z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodLiteral<"ANY">]>;
 export declare const SubModeSchema: z.ZodEnum<{
@@ -69,6 +72,9 @@ export declare const SetSubConfigSchema: z.ZodObject<{
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<PinchConditionType.MIN_OPPONENT_SCORE>;
         score: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<PinchConditionType.PHASE>;
+        phase: z.ZodEnum<typeof MatchPhase>;
     }, z.core.$strip>], "type">>>;
     conditionLogic: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodLiteral<"ANY">]>>;
 }, z.core.$strip>;
@@ -107,6 +113,9 @@ export declare const DesignatedSubSchema: z.ZodObject<{
         }, z.core.$strip>, z.ZodObject<{
             type: z.ZodLiteral<PinchConditionType.MIN_OPPONENT_SCORE>;
             score: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<PinchConditionType.PHASE>;
+            phase: z.ZodEnum<typeof MatchPhase>;
         }, z.core.$strip>], "type">>>;
         conditionLogic: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodLiteral<"ANY">]>>;
     }, z.core.$strip>>>;
@@ -143,6 +152,9 @@ export declare const DesignatedSubSchema: z.ZodObject<{
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<PinchConditionType.MIN_OPPONENT_SCORE>;
         score: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<PinchConditionType.PHASE>;
+        phase: z.ZodEnum<typeof MatchPhase>;
     }, z.core.$strip>], "type">>>;
     conditionLogic: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodLiteral<"ANY">]>>;
     starter: z.ZodCustom<Player, Player>;

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

@@ -17,7 +17,9 @@ exports.PinchConditionSchema = zod_1.z.discriminatedUnion('type', [
     zod_1.z.object({ type: zod_1.z.literal(pinch_condition_1.PinchConditionType.AFTER_ROTATIONS), rotations: zod_1.z.number().int().min(1).max(6) }),
     zod_1.z.object({ type: zod_1.z.literal(pinch_condition_1.PinchConditionType.FROM_SET), set: zod_1.z.number().int().min(1).max(5) }),
     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) }),
-    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) })
+    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) }),
+    // 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) })
 ]);
 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']);

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

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

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

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+const tactics_z_1 = require("./tactics.z");
+const test_helpers_1 = require("../../test-helpers");
+(0, globals_1.describe)('TacticsInputSchema — liberoInjury (owner 2026-07-06)', () => {
+    const country = (0, test_helpers_1.makeCountry)();
+    const p1 = (0, test_helpers_1.makePlayer)(country);
+    const p2 = (0, test_helpers_1.makePlayer)(country);
+    const p3 = (0, test_helpers_1.makePlayer)(country);
+    const p4 = (0, test_helpers_1.makePlayer)(country);
+    const p5 = (0, test_helpers_1.makePlayer)(country);
+    const p6 = (0, test_helpers_1.makePlayer)(country);
+    const benchA = (0, test_helpers_1.makePlayer)(country);
+    const benchB = (0, test_helpers_1.makePlayer)(country);
+    const libero = (0, test_helpers_1.makePlayer)(country);
+    const l2 = (0, test_helpers_1.makePlayer)(country); // second libero (a reserve)
+    const reserveA = (0, test_helpers_1.makePlayer)(country);
+    const reserveB = (0, test_helpers_1.makePlayer)(country);
+    function baseInput(overrides = {}) {
+        return {
+            lineup: { 4: p4, 3: p3, 2: p2, 5: p5, 6: p6, 1: p1, 0: libero, bench: [benchA, benchB] },
+            liberoReplacements: [],
+            secondLibero: l2,
+            ...overrides
+        };
+    }
+    const hasIssue = (res, message) => !res.success && res.error.issues.some(i => i.message === message);
+    (0, globals_1.it)('accepts no liberoInjury', () => {
+        (0, globals_1.expect)(tactics_z_1.TacticsInputSchema.safeParse(baseInput()).success).toBe(true);
+    });
+    (0, globals_1.it)('accepts a reserve as the pre-match libero replacement', () => {
+        (0, globals_1.expect)(tactics_z_1.TacticsInputSchema.safeParse(baseInput({ liberoInjury: { preMatchReplacement: reserveA } })).success).toBe(true);
+    });
+    (0, globals_1.it)('accepts the L2 as the replacement with a reserve backfill (new L2)', () => {
+        (0, globals_1.expect)(tactics_z_1.TacticsInputSchema.safeParse(baseInput({ liberoInjury: { preMatchReplacement: l2, secondLiberoBackfill: reserveA } })).success).toBe(true);
+    });
+    (0, globals_1.it)('rejects a starter / the libero / a bench player as the pre-match replacement', () => {
+        for (const bad of [p2, libero, benchA]) {
+            const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({ liberoInjury: { preMatchReplacement: bad } }));
+            (0, globals_1.expect)(hasIssue(res, 'LIBERO_INJURY_REPLACEMENT_MUST_BE_RESERVE_OR_L2')).toBe(true);
+        }
+    });
+    (0, globals_1.it)('rejects a pre-match replacement when there is no starting libero', () => {
+        const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
+            lineup: { 4: p4, 3: p3, 2: p2, 5: p5, 6: p6, 1: p1, bench: [benchA, benchB] },
+            secondLibero: undefined,
+            liberoInjury: { preMatchReplacement: reserveA }
+        }));
+        (0, globals_1.expect)(hasIssue(res, 'LIBERO_INJURY_REQUIRES_LIBERO')).toBe(true);
+    });
+    (0, globals_1.it)('rejects a backfill when the replacement is not the L2', () => {
+        const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({ liberoInjury: { preMatchReplacement: reserveA, secondLiberoBackfill: reserveB } }));
+        (0, globals_1.expect)(hasIssue(res, 'LIBERO_BACKFILL_REQUIRES_L2_REPLACEMENT')).toBe(true);
+    });
+    (0, globals_1.it)('rejects a non-reserve backfill (bench player) even when the L2 is the replacement', () => {
+        const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({ liberoInjury: { preMatchReplacement: l2, secondLiberoBackfill: benchA } }));
+        (0, globals_1.expect)(hasIssue(res, 'LIBERO_BACKFILL_MUST_BE_RESERVE')).toBe(true);
+    });
+    (0, globals_1.it)('accepts a bench or reserve player as the in-match designate', () => {
+        for (const ok of [benchA, reserveA]) {
+            (0, globals_1.expect)(tactics_z_1.TacticsInputSchema.safeParse(baseInput({ liberoInjury: { inMatchDesignate: ok } })).success).toBe(true);
+        }
+    });
+    (0, globals_1.it)('rejects a starter / the libero / the L2 as the in-match designate', () => {
+        for (const bad of [p2, libero, l2]) {
+            const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({ liberoInjury: { inMatchDesignate: bad } }));
+            (0, globals_1.expect)(hasIssue(res, 'LIBERO_DESIGNATE_MUST_BE_BENCH_OR_RESERVE')).toBe(true);
+        }
+    });
+});

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

@@ -4,14 +4,46 @@ export declare const LiberoSubModeSchema: z.ZodEnum<{
     NEVER: "NEVER";
     FATIGUE: "FATIGUE";
     ALWAYS: "ALWAYS";
+    CONDITIONS: "CONDITIONS";
 }>;
 export declare const LiberoSetSubConfigSchema: z.ZodObject<{
     mode: z.ZodEnum<{
         NEVER: "NEVER";
         FATIGUE: "FATIGUE";
         ALWAYS: "ALWAYS";
+        CONDITIONS: "CONDITIONS";
     }>;
     fatigueBand: 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<{
+        type: z.ZodLiteral<import("..").PinchConditionType.TEAM_SET_POINT>;
+        margin: z.ZodNumber;
+        opponent: z.ZodEnum<typeof import("..").OpponentRelation>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<import("..").PinchConditionType.OPPONENT_SET_POINT>;
+        margin: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<import("..").PinchConditionType.SCORE_DIFF>;
+        direction: z.ZodEnum<typeof import("..").ScoreDirection>;
+        points: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<import("..").PinchConditionType.AFTER_ROTATIONS>;
+        rotations: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<import("..").PinchConditionType.FROM_SET>;
+        set: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<import("..").PinchConditionType.MIN_OWN_SCORE>;
+        score: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<import("..").PinchConditionType.MIN_OPPONENT_SCORE>;
+        score: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<import("..").PinchConditionType.PHASE>;
+        phase: z.ZodEnum<typeof import("..").MatchPhase>;
+    }, 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<{
@@ -19,13 +51,75 @@ export declare const LiberoSubConfigSchema: z.ZodObject<{
             NEVER: "NEVER";
             FATIGUE: "FATIGUE";
             ALWAYS: "ALWAYS";
+            CONDITIONS: "CONDITIONS";
         }>;
         fatigueBand: 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<{
+            type: z.ZodLiteral<import("..").PinchConditionType.TEAM_SET_POINT>;
+            margin: z.ZodNumber;
+            opponent: z.ZodEnum<typeof import("..").OpponentRelation>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<import("..").PinchConditionType.OPPONENT_SET_POINT>;
+            margin: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<import("..").PinchConditionType.SCORE_DIFF>;
+            direction: z.ZodEnum<typeof import("..").ScoreDirection>;
+            points: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<import("..").PinchConditionType.AFTER_ROTATIONS>;
+            rotations: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<import("..").PinchConditionType.FROM_SET>;
+            set: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<import("..").PinchConditionType.MIN_OWN_SCORE>;
+            score: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<import("..").PinchConditionType.MIN_OPPONENT_SCORE>;
+            score: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<import("..").PinchConditionType.PHASE>;
+            phase: z.ZodEnum<typeof import("..").MatchPhase>;
+        }, 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";
         ALWAYS: "ALWAYS";
+        CONDITIONS: "CONDITIONS";
     }>;
     fatigueBand: 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<{
+        type: z.ZodLiteral<import("..").PinchConditionType.TEAM_SET_POINT>;
+        margin: z.ZodNumber;
+        opponent: z.ZodEnum<typeof import("..").OpponentRelation>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<import("..").PinchConditionType.OPPONENT_SET_POINT>;
+        margin: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<import("..").PinchConditionType.SCORE_DIFF>;
+        direction: z.ZodEnum<typeof import("..").ScoreDirection>;
+        points: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<import("..").PinchConditionType.AFTER_ROTATIONS>;
+        rotations: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<import("..").PinchConditionType.FROM_SET>;
+        set: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<import("..").PinchConditionType.MIN_OWN_SCORE>;
+        score: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<import("..").PinchConditionType.MIN_OPPONENT_SCORE>;
+        score: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<import("..").PinchConditionType.PHASE>;
+        phase: z.ZodEnum<typeof import("..").MatchPhase>;
+    }, z.core.$strip>], "type">>>;
+    conditionLogic: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodLiteral<"ANY">]>>;
 }, z.core.$strip>;

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

@@ -3,18 +3,35 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LiberoSubConfigSchema = exports.LiberoSetSubConfigSchema = exports.LiberoSubModeSchema = void 0;
 const zod_1 = require("zod");
 const energy_band_1 = require("../energy-band");
-exports.LiberoSubModeSchema = zod_1.z.enum(['NEVER', 'FATIGUE', 'ALWAYS']);
-// Fields shared by the all-sets config and each per-set config. Unlike a designated sub there is no bench or
-// pinch condition here (the swapped-in player is always the dedicated `secondLibero`), so there is nothing to
-// cross-validate.
+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.
 const liberoSetSubConfigShape = {
     mode: exports.LiberoSubModeSchema,
     // fatigue mode only (absent => the team default `substitutionBand`):
-    fatigueBand: zod_1.z.nativeEnum(energy_band_1.EnergyBand).optional()
+    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()
 };
-exports.LiberoSetSubConfigSchema = zod_1.z.object(liberoSetSubConfigShape);
+// 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({
     ...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);
 });