volleyballsimtypes 0.0.464 → 0.0.465

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

@@ -105,9 +105,10 @@ export interface ApiSystemSet {
     rotationSystem: RotationSystemEnum;
     designatedSetters: string[];
 }
-export interface ApiReservePriority {
-    position: number;
-    reserves: string[];
+export interface ApiInjuryReplacement {
+    starterId: string;
+    replacementId: string;
+    benchBackfillId?: string;
 }
 export interface ApiLiberoSetSubConfig {
     mode: LiberoSubMode;
@@ -131,7 +132,7 @@ export interface Tactics {
     systemSets?: ApiSystemSet[];
     offensivePreferenceSets?: ApiOffensivePreference[][];
     replaceInjuredImmediately: boolean;
-    reservePriorities?: ApiReservePriority[];
+    injuryReplacements?: ApiInjuryReplacement[];
 }
 export interface ApiLineupPreset {
     presetId: string;

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

@@ -39,9 +39,10 @@ export interface SystemSetAttributes {
     rotationSystem: RotationSystemEnum;
     designatedSetters: PlayerId[];
 }
-export interface ReservePriorityAttributes {
-    position: CourtPosition;
-    reserves: PlayerId[];
+export interface InjuryReplacementAttributes {
+    starterId: PlayerId;
+    replacementId: PlayerId;
+    benchBackfillId?: PlayerId;
 }
 export interface LiberoSetSubConfigAttributes {
     mode: LiberoSubMode;
@@ -66,11 +67,11 @@ export interface TacticsAttributes {
     system_sets?: SystemSetAttributes[];
     offensive_preference_sets?: OffensivePreferenceAttributes[][];
     replace_injured_immediately?: boolean;
-    reserve_priorities?: ReservePriorityAttributes[];
+    injury_replacements?: InjuryReplacementAttributes[];
 }
 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_injured_immediately' | 'reserve_priorities';
+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_injured_immediately' | 'injury_replacements';
 export type TacticsCreationAttributes = Optional<TacticsAttributes, TacticsOptionalAttributes>;
 export declare class TacticsModel extends Model<TacticsAttributes, TacticsCreationAttributes> implements TacticsAttributes {
     team_id: string;
@@ -88,7 +89,7 @@ export declare class TacticsModel extends Model<TacticsAttributes, TacticsCreati
     system_sets?: SystemSetAttributes[];
     offensive_preference_sets?: OffensivePreferenceAttributes[][];
     replace_injured_immediately?: boolean;
-    reserve_priorities?: ReservePriorityAttributes[];
+    injury_replacements?: InjuryReplacementAttributes[];
     team: TeamModel;
     getTeam: Sequelize.BelongsToGetAssociationMixin<TeamModel>;
     setTeam: Sequelize.BelongsToSetAssociationMixin<TeamModel, TeamId>;

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

@@ -80,7 +80,7 @@ class TacticsModel extends sequelize_1.Model {
                 allowNull: false,
                 defaultValue: true
             },
-            reserve_priorities: {
+            injury_replacements: {
                 type: sequelize_1.DataTypes.JSONB,
                 allowNull: true
             }

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

@@ -89,9 +89,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
         }))
     };
 }
@@ -171,36 +172,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[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 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[service_1.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;
         })()
     });
 }
@@ -263,31 +271,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[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 benchIdSet = new Set(model.lineup.bench);
+            const liberoId = model.lineup[service_1.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;
         })()
     };
@@ -324,6 +336,6 @@ 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
     };
 }

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

@@ -27,4 +27,4 @@ __exportStar(require("./rotation-system"), exports);
 __exportStar(require("./lineup-function"), exports);
 __exportStar(require("./base-position"), exports);
 __exportStar(require("./offensive-preference"), exports);
-__exportStar(require("./reserve-priority"), exports);
+__exportStar(require("./injury-replacement"), exports);

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

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

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

@@ -81,13 +81,14 @@ exports.TacticsInputSchema = zod_1.z.object({
     // validated with the same cross-field rules as the flat fields (see superRefine below).
     systemSets: zod_1.z.array(systemSetSchema).max(5).optional(),
     offensivePreferenceSets: zod_1.z.array(zod_1.z.array(offensivePreferenceSchema)).max(5).optional(),
-    // 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: zod_1.z.boolean().default(true),
-    reservePriorities: zod_1.z.array(zod_1.z.object({
-        position: zod_1.z.number().int().min(1).max(6),
-        reserves: zod_1.z.array(playerInstanceSchema)
+    injuryReplacements: zod_1.z.array(zod_1.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
@@ -186,27 +187,41 @@ exports.TacticsInputSchema = zod_1.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/cjs/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/cjs/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/cjs/src/service/team/tactics.js

@@ -18,7 +18,7 @@ class Tactics {
         }
         return new Tactics(result.data);
     }
-    constructor({ lineup, liberoReplacements, receiveRotationOffset = false, designatedSubs = [], substitutionBand = energy_band_1.EnergyBand.TIRED, secondLibero, liberoSub, liberoReplacementSets, rotationSystem = rotation_system_1.RotationSystemEnum.SIX_ZERO, designatedSetters = [], offensivePreferences = [], systemSets, offensivePreferenceSets, replaceInjuredImmediately = true, reservePriorities = [] }) {
+    constructor({ lineup, liberoReplacements, receiveRotationOffset = false, designatedSubs = [], substitutionBand = energy_band_1.EnergyBand.TIRED, secondLibero, liberoSub, liberoReplacementSets, rotationSystem = rotation_system_1.RotationSystemEnum.SIX_ZERO, designatedSetters = [], offensivePreferences = [], systemSets, offensivePreferenceSets, replaceInjuredImmediately = true, injuryReplacements = [] }) {
         this.lineup = lineup;
         this.liberoReplacements = liberoReplacements;
         this.receiveRotationOffset = receiveRotationOffset;
@@ -33,7 +33,7 @@ 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/dist/esm/src/api/index.d.ts

@@ -105,9 +105,10 @@ export interface ApiSystemSet {
     rotationSystem: RotationSystemEnum;
     designatedSetters: string[];
 }
-export interface ApiReservePriority {
-    position: number;
-    reserves: string[];
+export interface ApiInjuryReplacement {
+    starterId: string;
+    replacementId: string;
+    benchBackfillId?: string;
 }
 export interface ApiLiberoSetSubConfig {
     mode: LiberoSubMode;
@@ -131,7 +132,7 @@ export interface Tactics {
     systemSets?: ApiSystemSet[];
     offensivePreferenceSets?: ApiOffensivePreference[][];
     replaceInjuredImmediately: boolean;
-    reservePriorities?: ApiReservePriority[];
+    injuryReplacements?: ApiInjuryReplacement[];
 }
 export interface ApiLineupPreset {
     presetId: string;

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

@@ -39,9 +39,10 @@ export interface SystemSetAttributes {
     rotationSystem: RotationSystemEnum;
     designatedSetters: PlayerId[];
 }
-export interface ReservePriorityAttributes {
-    position: CourtPosition;
-    reserves: PlayerId[];
+export interface InjuryReplacementAttributes {
+    starterId: PlayerId;
+    replacementId: PlayerId;
+    benchBackfillId?: PlayerId;
 }
 export interface LiberoSetSubConfigAttributes {
     mode: LiberoSubMode;
@@ -66,11 +67,11 @@ export interface TacticsAttributes {
     system_sets?: SystemSetAttributes[];
     offensive_preference_sets?: OffensivePreferenceAttributes[][];
     replace_injured_immediately?: boolean;
-    reserve_priorities?: ReservePriorityAttributes[];
+    injury_replacements?: InjuryReplacementAttributes[];
 }
 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_injured_immediately' | 'reserve_priorities';
+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_injured_immediately' | 'injury_replacements';
 export type TacticsCreationAttributes = Optional<TacticsAttributes, TacticsOptionalAttributes>;
 export declare class TacticsModel extends Model<TacticsAttributes, TacticsCreationAttributes> implements TacticsAttributes {
     team_id: string;
@@ -88,7 +89,7 @@ export declare class TacticsModel extends Model<TacticsAttributes, TacticsCreati
     system_sets?: SystemSetAttributes[];
     offensive_preference_sets?: OffensivePreferenceAttributes[][];
     replace_injured_immediately?: boolean;
-    reserve_priorities?: ReservePriorityAttributes[];
+    injury_replacements?: InjuryReplacementAttributes[];
     team: TeamModel;
     getTeam: Sequelize.BelongsToGetAssociationMixin<TeamModel>;
     setTeam: Sequelize.BelongsToSetAssociationMixin<TeamModel, TeamId>;

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

@@ -77,7 +77,7 @@ export class TacticsModel extends Model {
                 allowNull: false,
                 defaultValue: true
             },
-            reserve_priorities: {
+            injury_replacements: {
                 type: DataTypes.JSONB,
                 allowNull: true
             }