volleyballsimtypes 0.0.464 → 0.0.465

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

@@ -83,9 +83,10 @@ function transformToAttributes(tactics, teamId) {
             order: p.order.map((a) => a.id)
         }))),
         replace_injured_immediately: tactics.replaceInjuredImmediately,
-        reserve_priorities: tactics.reservePriorities.map(rp => ({
-            position: rp.position,
-            reserves: rp.reserves.map((p) => p.id)
+        injury_replacements: tactics.injuryReplacements.map(ir => ({
+            starterId: ir.starter.id,
+            replacementId: ir.replacement.id,
+            benchBackfillId: ir.benchBackfill?.id
         }))
     };
 }
@@ -165,36 +166,43 @@ function transformToObject(model, roster) {
             order: p.order.map((id) => findPlayer(id, roster))
         }))),
         replaceInjuredImmediately: model.replace_injured_immediately ?? true,
-        // LENIENT (roster.find, not findPlayer): a dismissed/retired reserve, one that has since moved INTO the
-        // lineup, one that doubles as the resolved second libero, or a duplicate (player in two lists, repeated
-        // position) is DROPPED rather than crashing the sim batch (reserves are depth, not structure); now-empty
-        // entries are pruned. First occurrence wins on duplicates; the next tactics save rewrites cleanly.
-        reservePriorities: (() => {
-            const seenIds = new Set();
-            const seenPositions = new Set();
-            return (model.reserve_priorities ?? [])
-                .filter(rp => {
-                // Court slots only (1-6): jsonb has no constraint, and an out-of-range position would pass the
-                // heal only to be rejected by the schema, crashing the very sim batch this heal protects.
-                if (!Number.isInteger(rp.position) || rp.position < 1 || rp.position > 6)
-                    return false;
-                if (seenPositions.has(rp.position))
-                    return false;
-                seenPositions.add(rp.position);
-                return true;
-            })
-                .map(rp => ({
-                position: rp.position,
-                reserves: rp.reserves
-                    .map((id) => roster.find((p) => p.id === id))
-                    .filter((p) => {
-                    if (p == null || inLineupIds.has(p.id) || p.id === secondLibero?.id || seenIds.has(p.id))
-                        return false;
-                    seenIds.add(p.id);
-                    return true;
-                })
-            }))
-                .filter(rp => rp.reserves.length > 0);
+        // LENIENT (roster.find, not findPlayer): an entry whose starter or replacement is gone/invalid is DROPPED
+        // rather than crashing the sim batch (a dropped entry = unconfigured = the bench-only auto fallback, per
+        // the owner rules); an invalid benchBackfill drops only the backfill. First occurrence wins on duplicates;
+        // the next tactics save rewrites cleanly. Schema invariants mirrored: starter must be a court starter,
+        // replacement bench-or-reserve (never a starter/libero/L2), backfill only-with-bench-replacement + reserve.
+        injuryReplacements: (() => {
+            const starterIds = new Set([lineup[CourtPosition.LEFT_FRONT], lineup[CourtPosition.MIDDLE_FRONT], lineup[CourtPosition.RIGHT_FRONT],
+                lineup[CourtPosition.LEFT_BACK], lineup[CourtPosition.MIDDLE_BACK], lineup[CourtPosition.RIGHT_BACK]]
+                .map((p) => p.id));
+            const benchIds = new Set(lineup.bench.map((p) => p.id));
+            const seenStarters = new Set();
+            const seenIncoming = new Set();
+            const healed = [];
+            for (const ir of model.injury_replacements ?? []) {
+                const starter = roster.find((p) => p.id === ir.starterId);
+                const replacement = roster.find((p) => p.id === ir.replacementId);
+                if (starter == null || replacement == null)
+                    continue;
+                if (!starterIds.has(starter.id) || seenStarters.has(starter.id))
+                    continue;
+                if (starterIds.has(replacement.id) || replacement.id === lineup[CourtPosition.LIBERO_ZONE]?.id ||
+                    replacement.id === secondLibero?.id || seenIncoming.has(replacement.id))
+                    continue;
+                seenStarters.add(starter.id);
+                seenIncoming.add(replacement.id);
+                let benchBackfill;
+                if (ir.benchBackfillId != null && benchIds.has(replacement.id)) {
+                    const candidate = roster.find((p) => p.id === ir.benchBackfillId);
+                    if (candidate != null && !inLineupIds.has(candidate.id) && candidate.id !== secondLibero?.id &&
+                        !seenIncoming.has(candidate.id)) {
+                        benchBackfill = candidate;
+                        seenIncoming.add(candidate.id);
+                    }
+                }
+                healed.push({ starter, replacement, benchBackfill });
+            }
+            return healed;
         })()
     });
 }
@@ -257,31 +265,35 @@ function tacticsColumnsToApiDto(model) {
         systemSets: model.system_sets,
         offensivePreferenceSets: model.offensive_preference_sets,
         replaceInjuredImmediately: model.replace_injured_immediately ?? true,
-        // Same stale-data policy as validSecondLibero above: don't surface reserve entries the service load
-        // would drop (bad position, id now in the lineup, the L2, duplicates), or the UI reloads and re-emits
-        // them forever. Roster membership can't be checked here (ids only); the service heal covers that.
-        reservePriorities: (() => {
-            const seenIds = new Set();
-            const seenPositions = new Set();
-            const healed = (model.reserve_priorities ?? [])
-                .filter(rp => {
-                if (!Number.isInteger(rp.position) || rp.position < 1 || rp.position > 6)
-                    return false;
-                if (seenPositions.has(rp.position))
-                    return false;
-                seenPositions.add(rp.position);
-                return true;
-            })
-                .map(rp => ({
-                position: rp.position,
-                reserves: rp.reserves.filter(id => {
-                    if (lineupIds.has(id) || id === validSecondLibero || seenIds.has(id))
-                        return false;
-                    seenIds.add(id);
-                    return true;
-                })
-            }))
-                .filter(rp => rp.reserves.length > 0);
+        // Same stale-data policy as validSecondLibero above: don't surface entries the service load would drop
+        // (starter no longer a starter, replacement now a starter/libero/L2, duplicates), or the UI reloads and
+        // re-emits them forever. Roster membership can't be checked here (ids only); the service heal covers that.
+        injuryReplacements: (() => {
+            const starterSlotIds = new Set([model.lineup[CourtPosition.LEFT_FRONT], model.lineup[CourtPosition.MIDDLE_FRONT],
+                model.lineup[CourtPosition.RIGHT_FRONT], model.lineup[CourtPosition.LEFT_BACK],
+                model.lineup[CourtPosition.MIDDLE_BACK], model.lineup[CourtPosition.RIGHT_BACK]]);
+            const benchIdSet = new Set(model.lineup.bench);
+            const liberoId = model.lineup[CourtPosition.LIBERO_ZONE];
+            const seenStarters = new Set();
+            const seenIncoming = new Set();
+            const healed = [];
+            for (const ir of model.injury_replacements ?? []) {
+                if (!starterSlotIds.has(ir.starterId) || seenStarters.has(ir.starterId))
+                    continue;
+                if (starterSlotIds.has(ir.replacementId) || ir.replacementId === liberoId ||
+                    ir.replacementId === validSecondLibero || seenIncoming.has(ir.replacementId))
+                    continue;
+                seenStarters.add(ir.starterId);
+                seenIncoming.add(ir.replacementId);
+                let benchBackfillId;
+                if (ir.benchBackfillId != null && benchIdSet.has(ir.replacementId) &&
+                    !lineupIds.has(ir.benchBackfillId) && ir.benchBackfillId !== validSecondLibero &&
+                    !seenIncoming.has(ir.benchBackfillId)) {
+                    benchBackfillId = ir.benchBackfillId;
+                    seenIncoming.add(benchBackfillId);
+                }
+                healed.push({ starterId: ir.starterId, replacementId: ir.replacementId, benchBackfillId });
+            }
             return healed.length > 0 ? healed : undefined;
         })()
     };
@@ -318,7 +330,7 @@ function apiTacticsConfigToAttributes(config, teamId) {
         system_sets: config.systemSets,
         offensive_preference_sets: config.offensivePreferenceSets,
         replace_injured_immediately: config.replaceInjuredImmediately,
-        reserve_priorities: config.reservePriorities
+        injury_replacements: config.injuryReplacements
     };
 }
 export { transformToObject as transformToTactics, transformToAttributes as transformFromTactics, tacticsColumnsToApiDto, apiTacticsConfigToAttributes as apiTacticsConfigToTacticsAttributes };

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

@@ -11,4 +11,4 @@ export * from './rotation-system';
 export * from './lineup-function';
 export * from './base-position';
 export * from './offensive-preference';
-export * from './reserve-priority';
+export * from './injury-replacement';

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

@@ -11,4 +11,4 @@ export * from './rotation-system';
 export * from './lineup-function';
 export * from './base-position';
 export * from './offensive-preference';
-export * from './reserve-priority';
+export * from './injury-replacement';

package/dist/esm/src/service/team/injury-replacement.d.ts

@@ -0,0 +1,6 @@
+import { Player } from '../player';
+export interface InjuryReplacement {
+    readonly starter: Player;
+    readonly replacement: Player;
+    readonly benchBackfill?: Player;
+}

package/dist/esm/src/service/team/schemas/injury-replacement.z.test.js

@@ -0,0 +1,140 @@
+import { describe, it, expect } from '@jest/globals';
+import { TacticsInputSchema } from './tactics.z';
+import { makeCountry, makePlayer } from '../../test-helpers';
+describe('TacticsInputSchema — injuryReplacements (owner rules 2026-07-03)', () => {
+    const country = makeCountry();
+    const p1 = makePlayer(country);
+    const p2 = makePlayer(country);
+    const p3 = makePlayer(country);
+    const p4 = makePlayer(country);
+    const p5 = makePlayer(country);
+    const p6 = makePlayer(country);
+    const benchA = makePlayer(country);
+    const benchB = makePlayer(country);
+    const libero = makePlayer(country);
+    const reserveA = makePlayer(country);
+    const reserveB = 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: [],
+            ...overrides
+        };
+    }
+    it('defaults to true / empty', () => {
+        const res = TacticsInputSchema.safeParse(baseInput());
+        expect(res.success).toBe(true);
+        if (res.success) {
+            expect(res.data.replaceInjuredImmediately).toBe(true);
+            expect(res.data.injuryReplacements).toEqual([]);
+        }
+    });
+    it('accepts a bench replacement with a reserve backfill', () => {
+        const res = TacticsInputSchema.safeParse(baseInput({
+            injuryReplacements: [{ starter: p1, replacement: benchA, benchBackfill: reserveA }]
+        }));
+        expect(res.success).toBe(true);
+    });
+    it('accepts a bench replacement WITHOUT a backfill (empty bench seat is allowed by design)', () => {
+        const res = TacticsInputSchema.safeParse(baseInput({
+            injuryReplacements: [{ starter: p1, replacement: benchA }]
+        }));
+        expect(res.success).toBe(true);
+    });
+    it('accepts a reserve replacement (no backfill possible)', () => {
+        const res = TacticsInputSchema.safeParse(baseInput({
+            injuryReplacements: [{ starter: p1, replacement: reserveA }]
+        }));
+        expect(res.success).toBe(true);
+    });
+    it('rejects a starter as replacement', () => {
+        const res = TacticsInputSchema.safeParse(baseInput({
+            injuryReplacements: [{ starter: p1, replacement: p2 }]
+        }));
+        expect(res.success).toBe(false);
+        if (!res.success) {
+            expect(res.error.issues.some(issue => issue.message === 'INJURY_REPLACEMENT_MUST_BE_BENCH_OR_RESERVE')).toBe(true);
+        }
+    });
+    it('rejects the libero as replacement', () => {
+        const res = TacticsInputSchema.safeParse(baseInput({
+            injuryReplacements: [{ starter: p1, replacement: libero }]
+        }));
+        expect(res.success).toBe(false);
+        if (!res.success) {
+            expect(res.error.issues.some(issue => issue.message === 'INJURY_REPLACEMENT_MUST_BE_BENCH_OR_RESERVE')).toBe(true);
+        }
+    });
+    it('rejects a non-starter as the starter side', () => {
+        const res = TacticsInputSchema.safeParse(baseInput({
+            injuryReplacements: [{ starter: benchA, replacement: reserveA }]
+        }));
+        expect(res.success).toBe(false);
+        if (!res.success) {
+            expect(res.error.issues.some(issue => issue.message === 'INJURY_REPLACEMENT_STARTER_NOT_A_STARTER')).toBe(true);
+        }
+    });
+    it('rejects a backfill when the replacement is a reserve', () => {
+        const res = TacticsInputSchema.safeParse(baseInput({
+            injuryReplacements: [{ starter: p1, replacement: reserveA, benchBackfill: reserveB }]
+        }));
+        expect(res.success).toBe(false);
+        if (!res.success) {
+            expect(res.error.issues.some(issue => issue.message === 'BENCH_BACKFILL_REQUIRES_BENCH_REPLACEMENT')).toBe(true);
+        }
+    });
+    it('rejects a bench player as backfill (must be a reserve)', () => {
+        const res = TacticsInputSchema.safeParse(baseInput({
+            injuryReplacements: [{ starter: p1, replacement: benchA, benchBackfill: benchB }]
+        }));
+        expect(res.success).toBe(false);
+        if (!res.success) {
+            expect(res.error.issues.some(issue => issue.message === 'BENCH_BACKFILL_MUST_BE_RESERVE')).toBe(true);
+        }
+    });
+    it('rejects duplicate starter entries', () => {
+        const res = TacticsInputSchema.safeParse(baseInput({
+            injuryReplacements: [
+                { starter: p1, replacement: benchA },
+                { starter: p1, replacement: reserveA }
+            ]
+        }));
+        expect(res.success).toBe(false);
+        if (!res.success) {
+            expect(res.error.issues.some(issue => issue.message === 'INJURY_REPLACEMENT_DUPLICATE_STARTER')).toBe(true);
+        }
+    });
+    it('rejects the same incoming player used twice', () => {
+        const res = TacticsInputSchema.safeParse(baseInput({
+            injuryReplacements: [
+                { starter: p1, replacement: reserveA },
+                { starter: p2, replacement: reserveA }
+            ]
+        }));
+        expect(res.success).toBe(false);
+        if (!res.success) {
+            expect(res.error.issues.some(issue => issue.message === 'INJURY_REPLACEMENT_PLAYER_USED_TWICE')).toBe(true);
+        }
+    });
+    it('rejects a player used as replacement in one entry and backfill in another', () => {
+        const res = TacticsInputSchema.safeParse(baseInput({
+            injuryReplacements: [
+                { starter: p1, replacement: reserveA },
+                { starter: p2, replacement: benchA, benchBackfill: reserveA }
+            ]
+        }));
+        expect(res.success).toBe(false);
+        if (!res.success) {
+            expect(res.error.issues.some(issue => issue.message === 'INJURY_REPLACEMENT_PLAYER_USED_TWICE')).toBe(true);
+        }
+    });
+});

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

@@ -124,9 +124,10 @@ export declare const TacticsInputSchema: z.ZodObject<{
         order: z.ZodArray<z.ZodCustom<Player, Player>>;
     }, z.core.$strip>>>>;
     replaceInjuredImmediately: z.ZodDefault<z.ZodBoolean>;
-    reservePriorities: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        position: z.ZodNumber;
-        reserves: z.ZodArray<z.ZodCustom<Player, Player>>;
+    injuryReplacements: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        starter: z.ZodCustom<Player, Player>;
+        replacement: z.ZodCustom<Player, Player>;
+        benchBackfill: z.ZodOptional<z.ZodCustom<Player, Player>>;
     }, z.core.$strip>>>;
 }, z.core.$strip>;
 export type TacticsInput = z.infer<typeof TacticsInputSchema>;

package/dist/esm/src/service/team/schemas/tactics.z.js

@@ -78,13 +78,14 @@ export const TacticsInputSchema = z.object({
     // validated with the same cross-field rules as the flat fields (see superRefine below).
     systemSets: z.array(systemSetSchema).max(5).optional(),
     offensivePreferenceSets: z.array(z.array(offensivePreferenceSchema)).max(5).optional(),
-    // Injuries. Defaults keep every existing Tactics.create({...}) call valid. reservePriorities is flat-only
-    // (whole match): per-position ordered reserve lists; cross-field rules (reserves must be OUTSIDE the lineup,
-    // no player in two lists, unique positions) in the superRefine below.
+    // Injuries. Defaults keep every existing Tactics.create({...}) call valid. injuryReplacements is the
+    // per-starter explicit replacement mapping (owner rules: followed verbatim, bench-only auto fallback,
+    // reserves never auto-promoted); cross-field rules in the superRefine below.
     replaceInjuredImmediately: z.boolean().default(true),
-    reservePriorities: z.array(z.object({
-        position: z.number().int().min(1).max(6),
-        reserves: z.array(playerInstanceSchema)
+    injuryReplacements: z.array(z.object({
+        starter: playerInstanceSchema,
+        replacement: playerInstanceSchema,
+        benchBackfill: playerInstanceSchema.optional()
     })).default([])
 }).superRefine((data, ctx) => {
     // Cross-field rules for the rotation system. These keep an invalid config from ever reaching the sim (the
@@ -183,27 +184,41 @@ export const TacticsInputSchema = z.object({
             }
         }
     }
-    // Reserve priorities (injuries). A reserve must be a roster member OUTSIDE the lineup (starters, libero zone
-    // and bench refill themselves via subs); each position appears at most once; no player sits in two lists; and
-    // the second libero cannot double as a reserve (its promotion would strand the L2 swap validation).
-    const seenReservePositions = new Set();
-    const seenReserveIds = new Set();
-    for (const rp of data.reservePriorities) {
-        if (seenReservePositions.has(rp.position)) {
-            ctx.addIssue({ code: 'custom', message: 'RESERVE_PRIORITY_DUPLICATE_POSITION', path: ['reservePriorities'] });
+    // Injury replacements (owner rules 2026-07-03). starter = a court starter, at most one entry each.
+    // replacement = a bench player or a reserve (never another starter, the libero, or the L2). benchBackfill
+    // only when the replacement came from the bench, and must be a RESERVE (outside the whole lineup, not the
+    // L2). No player appears as a replacement or backfill more than once across all entries.
+    const benchIds = new Set(data.lineup.bench.map((p) => p.id));
+    const liberoId = data.lineup[LIBERO_ZONE]?.id;
+    const seenInjuryStarters = new Set();
+    const seenIncoming = new Set();
+    for (const ir of data.injuryReplacements) {
+        if (!starterIds.has(ir.starter.id)) {
+            ctx.addIssue({ code: 'custom', message: 'INJURY_REPLACEMENT_STARTER_NOT_A_STARTER', path: ['injuryReplacements'] });
         }
-        seenReservePositions.add(rp.position);
-        for (const reserve of rp.reserves) {
-            if (inLineupIds.has(reserve.id)) {
-                ctx.addIssue({ code: 'custom', message: 'RESERVE_MUST_NOT_BE_IN_LINEUP', path: ['reservePriorities'] });
+        if (seenInjuryStarters.has(ir.starter.id)) {
+            ctx.addIssue({ code: 'custom', message: 'INJURY_REPLACEMENT_DUPLICATE_STARTER', path: ['injuryReplacements'] });
+        }
+        seenInjuryStarters.add(ir.starter.id);
+        const isReplacementBench = benchIds.has(ir.replacement.id);
+        if (starterIds.has(ir.replacement.id) || ir.replacement.id === liberoId || ir.replacement.id === data.secondLibero?.id) {
+            ctx.addIssue({ code: 'custom', message: 'INJURY_REPLACEMENT_MUST_BE_BENCH_OR_RESERVE', path: ['injuryReplacements'] });
+        }
+        if (seenIncoming.has(ir.replacement.id)) {
+            ctx.addIssue({ code: 'custom', message: 'INJURY_REPLACEMENT_PLAYER_USED_TWICE', path: ['injuryReplacements'] });
+        }
+        seenIncoming.add(ir.replacement.id);
+        if (ir.benchBackfill != null) {
+            if (!isReplacementBench) {
+                ctx.addIssue({ code: 'custom', message: 'BENCH_BACKFILL_REQUIRES_BENCH_REPLACEMENT', path: ['injuryReplacements'] });
             }
-            if (data.secondLibero != null && reserve.id === data.secondLibero.id) {
-                ctx.addIssue({ code: 'custom', message: 'RESERVE_MUST_NOT_BE_SECOND_LIBERO', path: ['reservePriorities'] });
+            if (inLineupIds.has(ir.benchBackfill.id) || ir.benchBackfill.id === data.secondLibero?.id) {
+                ctx.addIssue({ code: 'custom', message: 'BENCH_BACKFILL_MUST_BE_RESERVE', path: ['injuryReplacements'] });
             }
-            if (seenReserveIds.has(reserve.id)) {
-                ctx.addIssue({ code: 'custom', message: 'RESERVE_IN_MULTIPLE_LISTS', path: ['reservePriorities'] });
+            if (seenIncoming.has(ir.benchBackfill.id)) {
+                ctx.addIssue({ code: 'custom', message: 'INJURY_REPLACEMENT_PLAYER_USED_TWICE', path: ['injuryReplacements'] });
             }
-            seenReserveIds.add(reserve.id);
+            seenIncoming.add(ir.benchBackfill.id);
         }
     }
 });

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

@@ -132,9 +132,10 @@ export declare const TeamInputSchema: z.ZodObject<{
             order: z.ZodArray<z.ZodCustom<Player, Player>>;
         }, z.core.$strip>>>>;
         replaceInjuredImmediately: z.ZodDefault<z.ZodBoolean>;
-        reservePriorities: z.ZodDefault<z.ZodArray<z.ZodObject<{
-            position: z.ZodNumber;
-            reserves: z.ZodArray<z.ZodCustom<Player, Player>>;
+        injuryReplacements: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            starter: z.ZodCustom<Player, Player>;
+            replacement: z.ZodCustom<Player, Player>;
+            benchBackfill: z.ZodOptional<z.ZodCustom<Player, Player>>;
         }, z.core.$strip>>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;

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

@@ -5,7 +5,7 @@ import { LiberoSubConfig } from './libero-sub';
 import { SubBand } from './energy-band';
 import { RotationSystemEnum } from './rotation-system';
 import { OffensivePreference } from './offensive-preference';
-import { ReservePriority } from './reserve-priority';
+import { InjuryReplacement } from './injury-replacement';
 export interface StartingLineup {
     readonly [CourtPosition.LEFT_FRONT]: Player;
     readonly [CourtPosition.MIDDLE_FRONT]: Player;
@@ -35,7 +35,7 @@ export interface TacticsOpts {
     readonly systemSets?: SystemSet[];
     readonly offensivePreferenceSets?: OffensivePreference[][];
     readonly replaceInjuredImmediately: boolean;
-    readonly reservePriorities: ReservePriority[];
+    readonly injuryReplacements: InjuryReplacement[];
 }
 export declare class Tactics {
     readonly lineup: StartingLineup;
@@ -52,7 +52,7 @@ export declare class Tactics {
     readonly systemSets?: SystemSet[];
     readonly offensivePreferenceSets?: OffensivePreference[][];
     readonly replaceInjuredImmediately: boolean;
-    readonly reservePriorities: ReservePriority[];
+    readonly injuryReplacements: InjuryReplacement[];
     static create(input: unknown): Tactics;
     private constructor();
     findPlayerInLineup(id: string): CourtPosition | undefined;

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

@@ -15,7 +15,7 @@ export class Tactics {
         }
         return new Tactics(result.data);
     }
-    constructor({ lineup, liberoReplacements, receiveRotationOffset = false, designatedSubs = [], substitutionBand = EnergyBand.TIRED, secondLibero, liberoSub, liberoReplacementSets, rotationSystem = RotationSystemEnum.SIX_ZERO, designatedSetters = [], offensivePreferences = [], systemSets, offensivePreferenceSets, replaceInjuredImmediately = true, reservePriorities = [] }) {
+    constructor({ lineup, liberoReplacements, receiveRotationOffset = false, designatedSubs = [], substitutionBand = EnergyBand.TIRED, secondLibero, liberoSub, liberoReplacementSets, rotationSystem = RotationSystemEnum.SIX_ZERO, designatedSetters = [], offensivePreferences = [], systemSets, offensivePreferenceSets, replaceInjuredImmediately = true, injuryReplacements = [] }) {
         this.lineup = lineup;
         this.liberoReplacements = liberoReplacements;
         this.receiveRotationOffset = receiveRotationOffset;
@@ -30,7 +30,7 @@ export class Tactics {
         this.systemSets = systemSets;
         this.offensivePreferenceSets = offensivePreferenceSets;
         this.replaceInjuredImmediately = replaceInjuredImmediately;
-        this.reservePriorities = reservePriorities;
+        this.injuryReplacements = injuryReplacements;
     }
     findPlayerInLineup(id) {
         if (this.lineup.bench.some(p => p.id === id))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "volleyballsimtypes",
-  "version": "0.0.464",
+  "version": "0.0.465",
   "description": "vbsim types",
   "main": "./dist/cjs/src/index.js",
   "module": "./dist/esm/src/index.js",

package/dist/cjs/src/service/team/reserve-priority.d.ts

@@ -1,6 +0,0 @@
-import { CourtPosition } from '../match';
-import { Player } from '../player';
-export interface ReservePriority {
-    readonly position: CourtPosition;
-    readonly reserves: Player[];
-}

package/dist/cjs/src/service/team/schemas/reserve-priority.z.test.js

@@ -1,125 +0,0 @@
-"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 — injuries (replaceInjuredImmediately / reservePriorities)', () => {
-    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 benchPlayer = (0, test_helpers_1.makePlayer)(country);
-    const libero = (0, test_helpers_1.makePlayer)(country);
-    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: [benchPlayer]
-            },
-            liberoReplacements: [],
-            ...overrides
-        };
-    }
-    (0, globals_1.it)('defaults replaceInjuredImmediately to true and reservePriorities to empty', () => {
-        const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput());
-        (0, globals_1.expect)(res.success).toBe(true);
-        if (res.success) {
-            (0, globals_1.expect)(res.data.replaceInjuredImmediately).toBe(true);
-            (0, globals_1.expect)(res.data.reservePriorities).toEqual([]);
-        }
-    });
-    (0, globals_1.it)('accepts replaceInjuredImmediately false', () => {
-        const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({ replaceInjuredImmediately: false }));
-        (0, globals_1.expect)(res.success).toBe(true);
-        if (res.success)
-            (0, globals_1.expect)(res.data.replaceInjuredImmediately).toBe(false);
-    });
-    (0, globals_1.it)('accepts reserve lists of non-lineup roster players', () => {
-        const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
-            reservePriorities: [
-                { position: 4, reserves: [reserveA] },
-                { position: 3, reserves: [reserveB] }
-            ]
-        }));
-        (0, globals_1.expect)(res.success).toBe(true);
-    });
-    (0, globals_1.it)('rejects a reserve that is a starter', () => {
-        const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
-            reservePriorities: [{ position: 4, reserves: [p1] }]
-        }));
-        (0, globals_1.expect)(res.success).toBe(false);
-        if (!res.success) {
-            (0, globals_1.expect)(res.error.issues.some(issue => issue.message === 'RESERVE_MUST_NOT_BE_IN_LINEUP')).toBe(true);
-        }
-    });
-    (0, globals_1.it)('rejects a reserve that is on the bench', () => {
-        const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
-            reservePriorities: [{ position: 4, reserves: [benchPlayer] }]
-        }));
-        (0, globals_1.expect)(res.success).toBe(false);
-        if (!res.success) {
-            (0, globals_1.expect)(res.error.issues.some(issue => issue.message === 'RESERVE_MUST_NOT_BE_IN_LINEUP')).toBe(true);
-        }
-    });
-    (0, globals_1.it)('rejects a reserve that is the libero', () => {
-        const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
-            reservePriorities: [{ position: 4, reserves: [libero] }]
-        }));
-        (0, globals_1.expect)(res.success).toBe(false);
-        if (!res.success) {
-            (0, globals_1.expect)(res.error.issues.some(issue => issue.message === 'RESERVE_MUST_NOT_BE_IN_LINEUP')).toBe(true);
-        }
-    });
-    (0, globals_1.it)('rejects a reserve that doubles as the second libero', () => {
-        const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
-            secondLibero: reserveA,
-            liberoSub: { mode: 'ALWAYS' },
-            reservePriorities: [{ position: 4, reserves: [reserveA] }]
-        }));
-        (0, globals_1.expect)(res.success).toBe(false);
-        if (!res.success) {
-            (0, globals_1.expect)(res.error.issues.some(issue => issue.message === 'RESERVE_MUST_NOT_BE_SECOND_LIBERO')).toBe(true);
-        }
-    });
-    (0, globals_1.it)('rejects the same player in two lists', () => {
-        const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
-            reservePriorities: [
-                { position: 4, reserves: [reserveA] },
-                { position: 3, reserves: [reserveA] }
-            ]
-        }));
-        (0, globals_1.expect)(res.success).toBe(false);
-        if (!res.success) {
-            (0, globals_1.expect)(res.error.issues.some(issue => issue.message === 'RESERVE_IN_MULTIPLE_LISTS')).toBe(true);
-        }
-    });
-    (0, globals_1.it)('rejects a duplicated position', () => {
-        const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
-            reservePriorities: [
-                { position: 4, reserves: [reserveA] },
-                { position: 4, reserves: [reserveB] }
-            ]
-        }));
-        (0, globals_1.expect)(res.success).toBe(false);
-        if (!res.success) {
-            (0, globals_1.expect)(res.error.issues.some(issue => issue.message === 'RESERVE_PRIORITY_DUPLICATE_POSITION')).toBe(true);
-        }
-    });
-    (0, globals_1.it)('rejects an out-of-range position', () => {
-        const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
-            reservePriorities: [{ position: 7, reserves: [reserveA] }]
-        }));
-        (0, globals_1.expect)(res.success).toBe(false);
-    });
-});

package/dist/esm/src/service/team/reserve-priority.d.ts

@@ -1,6 +0,0 @@
-import { CourtPosition } from '../match';
-import { Player } from '../player';
-export interface ReservePriority {
-    readonly position: CourtPosition;
-    readonly reserves: Player[];
-}