volleyballsimtypes 0.0.462 → 0.0.464

package/dist/cjs/src/data/transformers/lineup-preset.test.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const globals_1 = require("@jest/globals");
 const lineup_preset_1 = require("./lineup-preset");
 (0, globals_1.describe)('transformToLineupPreset()', () => {
-    (0, globals_1.it)('maps preset columns to the API shape and passes config through by reference', () => {
+    (0, globals_1.it)('maps preset columns to the API shape and heals a pre-injuries config to the effective default', () => {
         const config = { lineup: { bench: [] }, substitutionBand: 'TIRED' };
         const preset = (0, lineup_preset_1.transformToLineupPreset)({
             preset_id: 'p1',
@@ -18,8 +18,21 @@ const lineup_preset_1 = require("./lineup-preset");
             name: 'Starters',
             isActive: true,
             orderIndex: 2,
+            // A config stored before the injuries fields lacks replaceInjuredImmediately; the transform heals it
+            // to true (the effective hydration default) so the DTO's required field is honest.
+            config: { ...config, replaceInjuredImmediately: true }
+        });
+    });
+    (0, globals_1.it)('keeps an explicit replaceInjuredImmediately: false', () => {
+        const config = { lineup: { bench: [] }, substitutionBand: 'TIRED', replaceInjuredImmediately: false };
+        const preset = (0, lineup_preset_1.transformToLineupPreset)({
+            preset_id: 'p2',
+            team_id: 't1',
+            name: 'Risky',
+            is_active: false,
+            order_index: 3,
             config
         });
-        (0, globals_1.expect)(preset.config).toBe(config);
+        (0, globals_1.expect)(preset.config.replaceInjuredImmediately).toBe(false);
     });
 });

package/dist/cjs/src/data/transformers/match-preset-override.test.d.ts

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

package/dist/cjs/src/data/transformers/match-preset-override.test.js

@@ -0,0 +1,275 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+const uuid_1 = require("uuid");
+const tactics_1 = require("./tactics");
+const team_1 = require("./team");
+const match_1 = require("./match");
+const service_1 = require("../../service");
+// ─── shared mocks (model-shaped plain objects, cast through unknown) ──────────
+const countryFixture = {
+    country_id: (0, uuid_1.v4)(),
+    name: 'Test Country',
+    alpha_2: 'TC',
+    alpha_3: 'TCN',
+    country_code: '999',
+    iso_3166_2: 'TC-TEST',
+    region: '',
+    region_code: '',
+    sub_region: '',
+    sub_region_code: '',
+    intermediate_region: '',
+    intermediate_region_code: ''
+};
+function makePlayerModel(id) {
+    const stat = 50;
+    return {
+        player_id: id,
+        first_name: 'Test',
+        last_name: `P-${id.slice(0, 4)}`,
+        rarity: service_1.RarityEnum.COMMON,
+        roles: [service_1.RoleEnum.OUTSIDE_HITTER],
+        traits: [],
+        birth_age: 18,
+        birth_iteration: 1,
+        last_declined_iteration: null,
+        decline_profile: service_1.DeclineProfileEnum.STANDARD,
+        BoxScores: [],
+        BoxScoreTotals: null,
+        country: countryFixture,
+        PerformanceStat: {
+            setting: stat,
+            serve: stat,
+            spike: stat,
+            quick: stat,
+            power: stat,
+            awareness: stat,
+            attack: stat,
+            back_attack: stat,
+            reception: stat,
+            overhand: stat,
+            bump: stat,
+            block: stat,
+            read: stat,
+            commit: stat,
+            focus: stat,
+            defense: stat,
+            stamina: stat,
+            reflex: stat
+        }
+    };
+}
+// Six starters; index order is the row lineup's zone 1..6 order.
+const ids = Array.from({ length: 6 }, () => (0, uuid_1.v4)());
+const teamId = (0, uuid_1.v4)();
+function rowLineup(order) {
+    return {
+        [service_1.CourtPosition.RIGHT_BACK]: order[0],
+        [service_1.CourtPosition.RIGHT_FRONT]: order[1],
+        [service_1.CourtPosition.MIDDLE_FRONT]: order[2],
+        [service_1.CourtPosition.LEFT_FRONT]: order[3],
+        [service_1.CourtPosition.LEFT_BACK]: order[4],
+        [service_1.CourtPosition.MIDDLE_BACK]: order[5],
+        bench: []
+    };
+}
+function makeTacticsRow(order) {
+    return {
+        team_id: teamId,
+        lineup: rowLineup(order),
+        libero_replacements: [],
+        receive_rotation_offset: false,
+        designated_subs: [],
+        substitution_band: 'TIRED',
+        rotation_system: '6-0',
+        designated_setters: [],
+        offensive_preferences: []
+    };
+}
+function makeTeamModel(activeOrder) {
+    return {
+        team_id: teamId,
+        name: 'Test Team',
+        short_name: 'TST',
+        rating: 0,
+        division_id: (0, uuid_1.v4)(),
+        active: true,
+        country: countryFixture,
+        tactics: makeTacticsRow(activeOrder),
+        PlayerTeams: ids.map(id => ({ player: makePlayerModel(id) }))
+    };
+}
+// The API-DTO config for a preset whose starters are the REVERSE of the active order, so an applied
+// override is visible through the hydrated lineup.
+function makeConfig(order) {
+    return {
+        lineup: {
+            [service_1.CourtPosition.RIGHT_BACK]: order[0],
+            [service_1.CourtPosition.RIGHT_FRONT]: order[1],
+            [service_1.CourtPosition.MIDDLE_FRONT]: order[2],
+            [service_1.CourtPosition.LEFT_FRONT]: order[3],
+            [service_1.CourtPosition.LEFT_BACK]: order[4],
+            [service_1.CourtPosition.MIDDLE_BACK]: order[5],
+            bench: []
+        },
+        liberoReplacements: [],
+        receiveRotationOffset: false,
+        designatedSubs: [],
+        substitutionBand: 'TIRED',
+        rotationSystem: '6-0',
+        designatedSetters: [],
+        offensivePreferences: []
+    };
+}
+const activeOrder = ids;
+const presetOrder = [...ids].reverse();
+function starterAt(tactics, zone) {
+    return tactics.lineup[zone]?.id;
+}
+// ─── apiTacticsConfigToTacticsAttributes ──────────────────────────────────────
+(0, globals_1.describe)('apiTacticsConfigToTacticsAttributes()', () => {
+    (0, globals_1.it)('round-trips a fully-loaded Tactics row through tacticsColumnsToApiDto', () => {
+        const full = {
+            team_id: teamId,
+            lineup: { ...rowLineup(activeOrder), [service_1.CourtPosition.LIBERO_ZONE]: undefined },
+            libero_replacements: [ids[5]],
+            receive_rotation_offset: true,
+            designated_subs: [{ starterId: ids[0], benchId: undefined, mode: 'FATIGUE', fatigueBand: 'WORN', sets: [{ mode: 'NEVER' }] }],
+            substitution_band: 'TIRED',
+            second_libero: undefined,
+            libero_sub: undefined,
+            libero_replacement_sets: [[ids[0]], [ids[1]]],
+            rotation_system: '5-1',
+            designated_setters: [ids[0]],
+            offensive_preferences: [{ rotation: 1, order: [ids[1], ids[2]] }],
+            system_sets: [{ rotationSystem: '5-1', designatedSetters: [ids[0]] }],
+            offensive_preference_sets: [[{ rotation: 2, order: [ids[3]] }]]
+        };
+        const dto = (0, tactics_1.tacticsColumnsToApiDto)(full);
+        const back = (0, tactics_1.apiTacticsConfigToTacticsAttributes)(dto, teamId);
+        (0, globals_1.expect)(back.lineup).toEqual(full.lineup);
+        (0, globals_1.expect)(back.libero_replacements).toEqual(full.libero_replacements);
+        (0, globals_1.expect)(back.receive_rotation_offset).toBe(true);
+        (0, globals_1.expect)(back.designated_subs).toEqual(full.designated_subs);
+        (0, globals_1.expect)(back.libero_replacement_sets).toEqual(full.libero_replacement_sets);
+        (0, globals_1.expect)(back.rotation_system).toBe('5-1');
+        (0, globals_1.expect)(back.designated_setters).toEqual(full.designated_setters);
+        (0, globals_1.expect)(back.offensive_preferences).toEqual(full.offensive_preferences);
+        (0, globals_1.expect)(back.system_sets).toEqual(full.system_sets);
+        (0, globals_1.expect)(back.offensive_preference_sets).toEqual(full.offensive_preference_sets);
+    });
+    (0, globals_1.it)('hydrates through transformToTactics identically to the row path', () => {
+        const roster = ids.map(id => (0, team_1.transformToTeam)(makeTeamModel(activeOrder)).roster.find(p => p.id === id));
+        (0, globals_1.expect)(roster.every(p => p != null)).toBe(true);
+        const teamModel = makeTeamModel(activeOrder);
+        const players = (0, team_1.transformToTeam)(teamModel).roster;
+        const fromRow = (0, tactics_1.transformToTactics)(makeTacticsRow(activeOrder), players);
+        const fromConfig = (0, tactics_1.transformToTactics)((0, tactics_1.apiTacticsConfigToTacticsAttributes)(makeConfig(activeOrder), teamId), players);
+        for (const zone of [1, 2, 3, 4, 5, 6]) {
+            (0, globals_1.expect)(starterAt(fromConfig, zone)).toBe(starterAt(fromRow, zone));
+        }
+    });
+    (0, globals_1.it)('throws PLAYER_NOT_FOUND when the config references an off-roster player', () => {
+        const players = (0, team_1.transformToTeam)(makeTeamModel(activeOrder)).roster;
+        const drifted = makeConfig([(0, uuid_1.v4)(), ...ids.slice(1)]);
+        (0, globals_1.expect)(() => (0, tactics_1.transformToTactics)((0, tactics_1.apiTacticsConfigToTacticsAttributes)(drifted, teamId), players)).toThrow('PLAYER_NOT_FOUND');
+    });
+});
+// ─── transformToTeam override / fallback ──────────────────────────────────────
+(0, globals_1.describe)('transformToTeam() tacticsOverride', () => {
+    (0, globals_1.it)('uses the override config when it hydrates', () => {
+        const team = (0, team_1.transformToTeam)(makeTeamModel(activeOrder), undefined, {
+            presetId: 'preset-1',
+            config: makeConfig(presetOrder)
+        });
+        (0, globals_1.expect)(starterAt(team.tactics, service_1.CourtPosition.RIGHT_BACK)).toBe(presetOrder[0]);
+    });
+    (0, globals_1.it)('falls back to the active tactics and notifies onFallback when the override fails', () => {
+        const onFallback = globals_1.jest.fn();
+        const drifted = makeConfig([(0, uuid_1.v4)(), ...ids.slice(1)]);
+        const team = (0, team_1.transformToTeam)(makeTeamModel(activeOrder), undefined, {
+            presetId: 'preset-1',
+            config: drifted,
+            onFallback
+        });
+        (0, globals_1.expect)(onFallback).toHaveBeenCalledTimes(1);
+        (0, globals_1.expect)(onFallback.mock.calls[0][0]).toBe('preset-1');
+        (0, globals_1.expect)(starterAt(team.tactics, service_1.CourtPosition.RIGHT_BACK)).toBe(activeOrder[0]);
+    });
+    (0, globals_1.it)('keeps the active tactics when no override is given', () => {
+        const team = (0, team_1.transformToTeam)(makeTeamModel(activeOrder));
+        (0, globals_1.expect)(starterAt(team.tactics, service_1.CourtPosition.RIGHT_BACK)).toBe(activeOrder[0]);
+    });
+});
+// ─── transformToMatch per-team override ───────────────────────────────────────
+(0, globals_1.describe)('transformToMatch() MatchPresets', () => {
+    const awayIds = Array.from({ length: 6 }, () => (0, uuid_1.v4)());
+    const awayTeamId = (0, uuid_1.v4)();
+    function makeAwayModel() {
+        return {
+            team_id: awayTeamId,
+            name: 'Away Team',
+            short_name: 'AWY',
+            rating: 0,
+            division_id: (0, uuid_1.v4)(),
+            active: true,
+            country: countryFixture,
+            tactics: {
+                team_id: awayTeamId,
+                lineup: {
+                    [service_1.CourtPosition.RIGHT_BACK]: awayIds[0],
+                    [service_1.CourtPosition.RIGHT_FRONT]: awayIds[1],
+                    [service_1.CourtPosition.MIDDLE_FRONT]: awayIds[2],
+                    [service_1.CourtPosition.LEFT_FRONT]: awayIds[3],
+                    [service_1.CourtPosition.LEFT_BACK]: awayIds[4],
+                    [service_1.CourtPosition.MIDDLE_BACK]: awayIds[5],
+                    bench: []
+                },
+                libero_replacements: [],
+                receive_rotation_offset: false,
+                designated_subs: [],
+                substitution_band: 'TIRED',
+                rotation_system: '6-0',
+                designated_setters: [],
+                offensive_preferences: []
+            },
+            PlayerTeams: awayIds.map(id => ({ player: makePlayerModel(id) }))
+        };
+    }
+    function makeMatchModel(withPreset) {
+        return {
+            match_id: (0, uuid_1.v4)(),
+            home_team: teamId,
+            away_team: awayTeamId,
+            scheduled_date: new Date(),
+            status: 'PENDING',
+            HomeTeam: makeTeamModel(activeOrder),
+            AwayTeam: makeAwayModel(),
+            MatchSets: [],
+            VPERs: [],
+            MatchPresets: withPreset
+                ? [{ match_id: 'm', team_id: teamId, preset_id: 'preset-1', preset: { config: makeConfig(presetOrder) } }]
+                : undefined
+        };
+    }
+    (0, globals_1.it)('applies the home override and leaves the away team on active tactics', () => {
+        const match = (0, match_1.transformToMatch)(makeMatchModel(true));
+        (0, globals_1.expect)(starterAt(match.homeTeam.tactics, service_1.CourtPosition.RIGHT_BACK)).toBe(presetOrder[0]);
+        (0, globals_1.expect)(starterAt(match.awayTeam.tactics, service_1.CourtPosition.RIGHT_BACK)).toBe(awayIds[0]);
+    });
+    (0, globals_1.it)('behaves exactly as before when the association is absent', () => {
+        const match = (0, match_1.transformToMatch)(makeMatchModel(false));
+        (0, globals_1.expect)(starterAt(match.homeTeam.tactics, service_1.CourtPosition.RIGHT_BACK)).toBe(activeOrder[0]);
+        (0, globals_1.expect)(starterAt(match.awayTeam.tactics, service_1.CourtPosition.RIGHT_BACK)).toBe(awayIds[0]);
+    });
+    (0, globals_1.it)('routes the fallback callback with the failing team id', () => {
+        const onPresetFallback = globals_1.jest.fn();
+        const model = makeMatchModel(true);
+        model.MatchPresets[0].preset.config = makeConfig([(0, uuid_1.v4)(), ...ids.slice(1)]);
+        const match = (0, match_1.transformToMatch)(model, undefined, onPresetFallback);
+        (0, globals_1.expect)(onPresetFallback).toHaveBeenCalledTimes(1);
+        (0, globals_1.expect)(onPresetFallback.mock.calls[0][0]).toBe(teamId);
+        (0, globals_1.expect)(onPresetFallback.mock.calls[0][1]).toBe('preset-1');
+        (0, globals_1.expect)(starterAt(match.homeTeam.tactics, service_1.CourtPosition.RIGHT_BACK)).toBe(activeOrder[0]);
+    });
+});

package/dist/cjs/src/data/transformers/match-set.js

@@ -27,6 +27,7 @@ function transformToAttributes(set, matchId) {
         is_tie_break: set.isTieBreak,
         home_score: set.homeScore,
         away_score: set.awayScore,
+        forfeited: set.forfeited,
         player_positions: [...homeSetPositions, ...awaySetPositions],
         BoxScores: (set.boxScores ?? []).map(_1.transformFromBoxScore),
         Rallies: (set.rallies ?? []).map((rally) => (0, _1.transformFromRally)(rally, set.id))
@@ -43,6 +44,7 @@ function transformToObject(model) {
         homeScore: model.home_score,
         awayScore: model.away_score,
         isTieBreak: model.is_tie_break,
+        forfeited: model.forfeited ?? false,
         boxScores: (model.BoxScores ?? []).map(_1.transformToBoxScore),
         homePlayerPosition,
         awayPlayerPosition,

package/dist/cjs/src/data/transformers/match.d.ts

@@ -1,5 +1,6 @@
 import { MatchAttributes, MatchModel } from '../models';
 import { Match } from '../../service';
+export type PresetFallbackHandler = (teamId: string, presetId: string, err: unknown) => void;
 declare function transformToAttributes(match: Match): MatchAttributes;
-declare function transformToObject(model: MatchModel, currentIteration?: number): Match;
+declare function transformToObject(model: MatchModel, currentIteration?: number, onPresetFallback?: PresetFallbackHandler): Match;
 export { transformToObject as transformToMatch, transformToAttributes as transformFromMatch };

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

@@ -12,10 +12,25 @@ function transformToAttributes(match) {
         away_team: match.awayTeam.id,
         home_team: match.homeTeam.id,
         scheduled_date: match.scheduledDate,
-        status: match.status
+        status: match.status,
+        // Both directions on purpose (the read is in transformToObject below). NOTE for the Sim: updateMatch's
+        // completion write uses an explicit column list and must include forfeit_type or the marker is lost.
+        forfeit_type: match.forfeitType ?? null
     };
 }
-function transformToObject(model, currentIteration) {
+function transformToObject(model, currentIteration, onPresetFallback) {
+    // The (match, team)-chosen preset override for one side, when the loader included MatchPresets with the
+    // preset loaded (only the simulator's match query does). Association absent = active tactics, as always.
+    const overrideFor = (teamId) => {
+        const row = (model.MatchPresets ?? []).find(mp => mp.team_id === teamId);
+        if (row?.preset == null)
+            return undefined;
+        return {
+            presetId: row.preset_id,
+            config: row.preset.config,
+            onFallback: (presetId, err) => onPresetFallback?.(teamId, presetId, err)
+        };
+    };
     const sets = (model.MatchSets ?? []).map(match_set_1.transformToMatchSet)
         .sort((s1, s2) => s1.order - s2.order);
     let homeScore = 0;
@@ -47,14 +62,15 @@ function transformToObject(model, currentIteration) {
     const VPERs = (model.VPERs ?? []).map(vper_1.transformToVPER);
     return service_1.Match.create({
         id: model.match_id,
-        homeTeam: (0, team_1.transformToTeam)(model.HomeTeam, currentIteration),
-        awayTeam: (0, team_1.transformToTeam)(model.AwayTeam, currentIteration),
+        homeTeam: (0, team_1.transformToTeam)(model.HomeTeam, currentIteration, overrideFor(model.home_team)),
+        awayTeam: (0, team_1.transformToTeam)(model.AwayTeam, currentIteration, overrideFor(model.away_team)),
         scheduledDate: new Date(model.scheduled_date),
         sets,
         status: model.status,
         VPERs,
         homeScore,
         awayScore,
-        winner: model.MatchResult?.Winner != null ? (0, team_1.transformToTeam)(model.MatchResult.Winner, currentIteration) : undefined
+        winner: model.MatchResult?.Winner != null ? (0, team_1.transformToTeam)(model.MatchResult.Winner, currentIteration) : undefined,
+        forfeitType: model.forfeit_type ?? undefined
     });
 }

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

@@ -25,7 +25,11 @@ function transformToAttributes(player) {
         birth_age: player.birthAge,
         birth_iteration: player.birthIteration,
         last_declined_iteration: null,
-        decline_profile: player.declineProfile
+        decline_profile: player.declineProfile,
+        injury_prone_profile: player.injuryProneProfile,
+        injury_severity: player.injury?.severity ?? null,
+        injured_until: player.injury?.injuredUntil ?? null,
+        injury_debuff: player.injury?.debuff ?? null
     };
 }
 function transformToBoxScoreTotals(model) {
@@ -91,6 +95,16 @@ function transformToObject(model, currentIteration) {
         birthAge: model.birth_age,
         birthIteration: model.birth_iteration,
         declineProfile: model.decline_profile,
+        // DECIMAL comes back as a string from pg; schema-defaulted when the column is absent (pre-migration rows).
+        injuryProneProfile: model.injury_prone_profile != null ? Number(model.injury_prone_profile) : undefined,
+        // Severity defends against a partial write: an injured_until without severity reads as MINOR.
+        injury: model.injured_until != null
+            ? {
+                severity: model.injury_severity != null ? Number(model.injury_severity) : 1,
+                injuredUntil: model.injured_until,
+                debuff: model.injury_debuff != null ? Number(model.injury_debuff) : undefined
+            }
+            : undefined,
         boxScores: (model.BoxScores ?? []).map(_1.transformToBoxScore),
         boxScoreTotals
     });

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

@@ -44,7 +44,7 @@ function transformToObject(model) {
         id: model.competition_id,
         iteration: (0, _1.transformToIteration)(model.Iteration),
         matches: (model.CompetitionMatches ?? []).map(_1.transformToQualifierMatch),
-        teams: (0, _1.sortTeamsByCompetitionIndex)(model.Teams ?? []).map(_1.transformToTeam),
+        teams: (0, _1.sortTeamsByCompetitionIndex)(model.Teams ?? []).map(team => (0, _1.transformToTeam)(team)),
         status: model.status,
         region: (0, _1.transformToRegion)(regionQualifier),
         champion

package/dist/cjs/src/data/transformers/rally-event-injury.test.d.ts

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

package/dist/cjs/src/data/transformers/rally-event-injury.test.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+const uuid_1 = require("uuid");
+const service_1 = require("../../service");
+const rally_event_1 = require("./rally-event");
+(0, globals_1.describe)('rally-event compact round trip — injury substitution marker', () => {
+    const playerIn = (0, uuid_1.v4)();
+    const playerOut = (0, uuid_1.v4)();
+    const roster = [playerIn, playerOut];
+    const playerIndex = new Map(roster.map((id, i) => [id, i]));
+    (0, globals_1.it)('packs the injury flag as j=1 and round-trips it', () => {
+        const sub = service_1.Substitution.create({ playerId: playerIn, playerOut, injury: true });
+        const compact = (0, rally_event_1.transformToCompact)(sub, playerIndex);
+        (0, globals_1.expect)(compact.j).toBe(1);
+        const decoded = (0, rally_event_1.transformToSubstitution)(compact, roster);
+        (0, globals_1.expect)(decoded.injury).toBe(true);
+        (0, globals_1.expect)(decoded.playerId).toBe(playerIn);
+        (0, globals_1.expect)(decoded.playerOut).toBe(playerOut);
+    });
+    (0, globals_1.it)('omits j entirely for a normal substitution', () => {
+        const sub = service_1.Substitution.create({ playerId: playerIn, playerOut });
+        const compact = (0, rally_event_1.transformToCompact)(sub, playerIndex);
+        (0, globals_1.expect)('j' in compact).toBe(false);
+        const decoded = (0, rally_event_1.transformToSubstitution)(compact, roster);
+        (0, globals_1.expect)(decoded.injury).toBeUndefined();
+    });
+    (0, globals_1.it)('decodes a legacy compact event (no j key) as a non-injury substitution', () => {
+        const legacy = { p: 0, e: service_1.EventTypeEnum.SUBSTITUTION, o: 1 };
+        const decoded = (0, rally_event_1.transformToSubstitution)(legacy, roster);
+        (0, globals_1.expect)(decoded.injury).toBeUndefined();
+    });
+});

package/dist/cjs/src/data/transformers/rally-event.d.ts

@@ -9,6 +9,7 @@ export interface CompactEvent {
     b?: number[];
     l?: number;
     o?: number;
+    j?: number;
 }
 export declare function transformToCompact(evt: RallyEvent, playerIndex: Map<string, number>): CompactEvent;
 export declare function transformToBlock(event: CompactEvent, roster: string[]): Block;

package/dist/cjs/src/data/transformers/rally-event.js

@@ -29,6 +29,8 @@ function transformToCompact(evt, playerIndex) {
     }
     else if (evt instanceof service_1.Substitution) {
         out.o = playerIndex.get(evt.playerOut);
+        if (evt.injury === true)
+            out.j = 1;
     }
     return out;
 }
@@ -88,6 +90,7 @@ function transformToSpike(event, roster) {
 function transformToSubstitution(event, roster) {
     return service_1.Substitution.create({
         playerId: roster[event.p],
-        playerOut: roster[event.o]
+        playerOut: roster[event.o],
+        injury: event.j === 1 ? true : undefined
     });
 }

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

@@ -33,7 +33,7 @@ function transformToAttributes(season) {
     };
 }
 function transformToObject(model) {
-    const teams = (0, _1.sortTeamsByCompetitionIndex)(model.Teams ?? []).map(_1.transformToTeam);
+    const teams = (0, _1.sortTeamsByCompetitionIndex)(model.Teams ?? []).map(team => (0, _1.transformToTeam)(team));
     // One standing per roster team: the persisted CompetitionStandings aggregate where it exists, a zero-stat
     // row otherwise. CompetitionStandings only gains a row once a team plays (the DB trigger fires on match
     // COMPLETE), so mapping it directly dropped un-played teams from the table for the first part of a season.

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

@@ -2,6 +2,7 @@ import { TacticsAttributes, TacticsModel } from '../models';
 import { Player, Tactics } from '../../service';
 import type { Tactics as ApiTactics } from '../../api';
 declare function transformToAttributes(tactics: Tactics, teamId: string): TacticsAttributes;
-declare function transformToObject(model: TacticsModel, roster: Player[]): Tactics;
+declare function transformToObject(model: TacticsAttributes, roster: Player[]): Tactics;
 declare function tacticsColumnsToApiDto(model: TacticsModel): ApiTactics;
-export { transformToObject as transformToTactics, transformToAttributes as transformFromTactics, tacticsColumnsToApiDto };
+declare function apiTacticsConfigToAttributes(config: ApiTactics, teamId: string): TacticsAttributes;
+export { transformToObject as transformToTactics, transformToAttributes as transformFromTactics, tacticsColumnsToApiDto, apiTacticsConfigToAttributes as apiTacticsConfigToTacticsAttributes };

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.transformToTactics = transformToObject;
 exports.transformFromTactics = transformToAttributes;
 exports.tacticsColumnsToApiDto = tacticsColumnsToApiDto;
+exports.apiTacticsConfigToTacticsAttributes = apiTacticsConfigToAttributes;
 const service_1 = require("../../service");
 // Back-compat: new rows persist `mode`; rows written before the mode change persist `isPinchServer` (+ a
 // 'NEVER' fatigueBand for the old "never fatigue-sub" state). Derive the mode so existing data keeps working
@@ -86,9 +87,16 @@ function transformToAttributes(tactics, teamId) {
         offensive_preference_sets: tactics.offensivePreferenceSets?.map(prefs => prefs.map(p => ({
             rotation: p.rotation,
             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)
+        }))
     };
 }
+// Accepts TacticsAttributes (not just TacticsModel) so a per-match preset's config, shaped as column data by
+// apiTacticsConfigToTacticsAttributes below, can be hydrated through the exact same validation/healing path.
 function transformToObject(model, roster) {
     const lineup = transformToLineup(model.lineup, roster);
     // A second libero is only valid as a RESERVE: it needs a starting libero (LIBERO_ZONE), the L2 player must be
@@ -161,7 +169,39 @@ function transformToObject(model, roster) {
         offensivePreferenceSets: model.offensive_preference_sets?.map(prefs => prefs.map(p => ({
             rotation: p.rotation,
             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);
+        })()
     });
 }
 // Serialize a Tactics ROW (db columns) straight to the API Tactics DTO (player references stay as ids; no
@@ -221,6 +261,69 @@ function tacticsColumnsToApiDto(model) {
         designatedSetters: model.designated_setters,
         offensivePreferences: model.offensive_preferences,
         systemSets: model.system_sets,
-        offensivePreferenceSets: model.offensive_preference_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);
+            return healed.length > 0 ? healed : undefined;
+        })()
+    };
+}
+// Inverse of tacticsColumnsToApiDto: shape a preset's stored API config (camelCase, player ids) as
+// TacticsAttributes-shaped column data so transformToTactics can hydrate it against a roster through the
+// exact same validation/healing path as the Tactics row. Only the top-level keys need renaming -- the jsonb
+// sub-objects (designated subs, libero sub, preferences, system sets) are stored camelCase in both shapes.
+// Deliberately NOT mirroring writeTacticsRow's null-clears-column rule: nothing is being UPDATEd here, so
+// absent optionals simply stay undefined.
+function apiTacticsConfigToAttributes(config, teamId) {
+    return {
+        team_id: teamId,
+        lineup: {
+            [service_1.CourtPosition.LIBERO_ZONE]: config.lineup[service_1.CourtPosition.LIBERO_ZONE],
+            [service_1.CourtPosition.LEFT_BACK]: config.lineup[service_1.CourtPosition.LEFT_BACK],
+            [service_1.CourtPosition.LEFT_FRONT]: config.lineup[service_1.CourtPosition.LEFT_FRONT],
+            [service_1.CourtPosition.MIDDLE_BACK]: config.lineup[service_1.CourtPosition.MIDDLE_BACK],
+            [service_1.CourtPosition.MIDDLE_FRONT]: config.lineup[service_1.CourtPosition.MIDDLE_FRONT],
+            [service_1.CourtPosition.RIGHT_BACK]: config.lineup[service_1.CourtPosition.RIGHT_BACK],
+            [service_1.CourtPosition.RIGHT_FRONT]: config.lineup[service_1.CourtPosition.RIGHT_FRONT],
+            bench: config.lineup.bench
+        },
+        libero_replacements: config.liberoReplacements,
+        receive_rotation_offset: config.receiveRotationOffset,
+        designated_subs: config.designatedSubs,
+        substitution_band: config.substitutionBand,
+        second_libero: config.secondLibero,
+        libero_sub: config.liberoSub,
+        libero_replacement_sets: config.liberoReplacementSets,
+        rotation_system: config.rotationSystem,
+        designated_setters: config.designatedSetters,
+        offensive_preferences: config.offensivePreferences,
+        system_sets: config.systemSets,
+        offensive_preference_sets: config.offensivePreferenceSets,
+        replace_injured_immediately: config.replaceInjuredImmediately,
+        reserve_priorities: config.reservePriorities
     };
 }

package/dist/cjs/src/data/transformers/team.d.ts

@@ -1,5 +1,11 @@
 import { Team } from '../../service';
 import { TeamAttributes, TeamModel } from '../models';
+import type { Tactics as ApiTactics } from '../../api';
+export interface MatchTacticsOverride {
+    presetId: string;
+    config: ApiTactics;
+    onFallback?: (presetId: string, err: unknown) => void;
+}
 declare function transformToAttributes(team: Team): TeamAttributes;
-declare function transformToObject(model: TeamModel, currentIteration?: number): Team;
+declare function transformToObject(model: TeamModel, currentIteration?: number, tacticsOverride?: MatchTacticsOverride): Team;
 export { transformToObject as transformToTeam, transformToAttributes as transformFromTeam };