volleyballsimtypes 0.0.459 → 0.0.463

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

@@ -0,0 +1,273 @@
+import { describe, it, expect, jest } from '@jest/globals';
+import { v4 as uuidv4 } from 'uuid';
+import { apiTacticsConfigToTacticsAttributes, tacticsColumnsToApiDto, transformToTactics } from './tactics';
+import { transformToTeam } from './team';
+import { transformToMatch } from './match';
+import { CourtPosition, DeclineProfileEnum, RarityEnum, RoleEnum } from '../../service';
+// ─── shared mocks (model-shaped plain objects, cast through unknown) ──────────
+const countryFixture = {
+    country_id: uuidv4(),
+    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: RarityEnum.COMMON,
+        roles: [RoleEnum.OUTSIDE_HITTER],
+        traits: [],
+        birth_age: 18,
+        birth_iteration: 1,
+        last_declined_iteration: null,
+        decline_profile: 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 }, () => uuidv4());
+const teamId = uuidv4();
+function rowLineup(order) {
+    return {
+        [CourtPosition.RIGHT_BACK]: order[0],
+        [CourtPosition.RIGHT_FRONT]: order[1],
+        [CourtPosition.MIDDLE_FRONT]: order[2],
+        [CourtPosition.LEFT_FRONT]: order[3],
+        [CourtPosition.LEFT_BACK]: order[4],
+        [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: uuidv4(),
+        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: {
+            [CourtPosition.RIGHT_BACK]: order[0],
+            [CourtPosition.RIGHT_FRONT]: order[1],
+            [CourtPosition.MIDDLE_FRONT]: order[2],
+            [CourtPosition.LEFT_FRONT]: order[3],
+            [CourtPosition.LEFT_BACK]: order[4],
+            [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 ──────────────────────────────────────
+describe('apiTacticsConfigToTacticsAttributes()', () => {
+    it('round-trips a fully-loaded Tactics row through tacticsColumnsToApiDto', () => {
+        const full = {
+            team_id: teamId,
+            lineup: { ...rowLineup(activeOrder), [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 = tacticsColumnsToApiDto(full);
+        const back = apiTacticsConfigToTacticsAttributes(dto, teamId);
+        expect(back.lineup).toEqual(full.lineup);
+        expect(back.libero_replacements).toEqual(full.libero_replacements);
+        expect(back.receive_rotation_offset).toBe(true);
+        expect(back.designated_subs).toEqual(full.designated_subs);
+        expect(back.libero_replacement_sets).toEqual(full.libero_replacement_sets);
+        expect(back.rotation_system).toBe('5-1');
+        expect(back.designated_setters).toEqual(full.designated_setters);
+        expect(back.offensive_preferences).toEqual(full.offensive_preferences);
+        expect(back.system_sets).toEqual(full.system_sets);
+        expect(back.offensive_preference_sets).toEqual(full.offensive_preference_sets);
+    });
+    it('hydrates through transformToTactics identically to the row path', () => {
+        const roster = ids.map(id => transformToTeam(makeTeamModel(activeOrder)).roster.find(p => p.id === id));
+        expect(roster.every(p => p != null)).toBe(true);
+        const teamModel = makeTeamModel(activeOrder);
+        const players = transformToTeam(teamModel).roster;
+        const fromRow = transformToTactics(makeTacticsRow(activeOrder), players);
+        const fromConfig = transformToTactics(apiTacticsConfigToTacticsAttributes(makeConfig(activeOrder), teamId), players);
+        for (const zone of [1, 2, 3, 4, 5, 6]) {
+            expect(starterAt(fromConfig, zone)).toBe(starterAt(fromRow, zone));
+        }
+    });
+    it('throws PLAYER_NOT_FOUND when the config references an off-roster player', () => {
+        const players = transformToTeam(makeTeamModel(activeOrder)).roster;
+        const drifted = makeConfig([uuidv4(), ...ids.slice(1)]);
+        expect(() => transformToTactics(apiTacticsConfigToTacticsAttributes(drifted, teamId), players)).toThrow('PLAYER_NOT_FOUND');
+    });
+});
+// ─── transformToTeam override / fallback ──────────────────────────────────────
+describe('transformToTeam() tacticsOverride', () => {
+    it('uses the override config when it hydrates', () => {
+        const team = transformToTeam(makeTeamModel(activeOrder), undefined, {
+            presetId: 'preset-1',
+            config: makeConfig(presetOrder)
+        });
+        expect(starterAt(team.tactics, CourtPosition.RIGHT_BACK)).toBe(presetOrder[0]);
+    });
+    it('falls back to the active tactics and notifies onFallback when the override fails', () => {
+        const onFallback = jest.fn();
+        const drifted = makeConfig([uuidv4(), ...ids.slice(1)]);
+        const team = transformToTeam(makeTeamModel(activeOrder), undefined, {
+            presetId: 'preset-1',
+            config: drifted,
+            onFallback
+        });
+        expect(onFallback).toHaveBeenCalledTimes(1);
+        expect(onFallback.mock.calls[0][0]).toBe('preset-1');
+        expect(starterAt(team.tactics, CourtPosition.RIGHT_BACK)).toBe(activeOrder[0]);
+    });
+    it('keeps the active tactics when no override is given', () => {
+        const team = transformToTeam(makeTeamModel(activeOrder));
+        expect(starterAt(team.tactics, CourtPosition.RIGHT_BACK)).toBe(activeOrder[0]);
+    });
+});
+// ─── transformToMatch per-team override ───────────────────────────────────────
+describe('transformToMatch() MatchPresets', () => {
+    const awayIds = Array.from({ length: 6 }, () => uuidv4());
+    const awayTeamId = uuidv4();
+    function makeAwayModel() {
+        return {
+            team_id: awayTeamId,
+            name: 'Away Team',
+            short_name: 'AWY',
+            rating: 0,
+            division_id: uuidv4(),
+            active: true,
+            country: countryFixture,
+            tactics: {
+                team_id: awayTeamId,
+                lineup: {
+                    [CourtPosition.RIGHT_BACK]: awayIds[0],
+                    [CourtPosition.RIGHT_FRONT]: awayIds[1],
+                    [CourtPosition.MIDDLE_FRONT]: awayIds[2],
+                    [CourtPosition.LEFT_FRONT]: awayIds[3],
+                    [CourtPosition.LEFT_BACK]: awayIds[4],
+                    [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: uuidv4(),
+            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
+        };
+    }
+    it('applies the home override and leaves the away team on active tactics', () => {
+        const match = transformToMatch(makeMatchModel(true));
+        expect(starterAt(match.homeTeam.tactics, CourtPosition.RIGHT_BACK)).toBe(presetOrder[0]);
+        expect(starterAt(match.awayTeam.tactics, CourtPosition.RIGHT_BACK)).toBe(awayIds[0]);
+    });
+    it('behaves exactly as before when the association is absent', () => {
+        const match = transformToMatch(makeMatchModel(false));
+        expect(starterAt(match.homeTeam.tactics, CourtPosition.RIGHT_BACK)).toBe(activeOrder[0]);
+        expect(starterAt(match.awayTeam.tactics, CourtPosition.RIGHT_BACK)).toBe(awayIds[0]);
+    });
+    it('routes the fallback callback with the failing team id', () => {
+        const onPresetFallback = jest.fn();
+        const model = makeMatchModel(true);
+        model.MatchPresets[0].preset.config = makeConfig([uuidv4(), ...ids.slice(1)]);
+        const match = transformToMatch(model, undefined, onPresetFallback);
+        expect(onPresetFallback).toHaveBeenCalledTimes(1);
+        expect(onPresetFallback.mock.calls[0][0]).toBe(teamId);
+        expect(onPresetFallback.mock.calls[0][1]).toBe('preset-1');
+        expect(starterAt(match.homeTeam.tactics, CourtPosition.RIGHT_BACK)).toBe(activeOrder[0]);
+    });
+});

package/dist/esm/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/esm/src/data/transformers/match.js

@@ -11,7 +11,19 @@ function transformToAttributes(match) {
         status: match.status
     };
 }
-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(transformToMatchSet)
         .sort((s1, s2) => s1.order - s2.order);
     let homeScore = 0;
@@ -43,8 +55,8 @@ function transformToObject(model, currentIteration) {
     const VPERs = (model.VPERs ?? []).map(transformToVPER);
     return Match.create({
         id: model.match_id,
-        homeTeam: transformToTeam(model.HomeTeam, currentIteration),
-        awayTeam: transformToTeam(model.AwayTeam, currentIteration),
+        homeTeam: transformToTeam(model.HomeTeam, currentIteration, overrideFor(model.home_team)),
+        awayTeam: transformToTeam(model.AwayTeam, currentIteration, overrideFor(model.away_team)),
         scheduledDate: new Date(model.scheduled_date),
         sets,
         status: model.status,

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

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

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

@@ -29,7 +29,7 @@ function transformToAttributes(season) {
     };
 }
 function transformToObject(model) {
-    const teams = sortTeamsByCompetitionIndex(model.Teams ?? []).map(transformToTeam);
+    const teams = sortTeamsByCompetitionIndex(model.Teams ?? []).map(team => 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/esm/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/esm/src/data/transformers/tactics.js

@@ -84,6 +84,8 @@ function transformToAttributes(tactics, teamId) {
         })))
     };
 }
+// 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
@@ -219,4 +221,37 @@ function tacticsColumnsToApiDto(model) {
         offensivePreferenceSets: model.offensive_preference_sets
     };
 }
-export { transformToObject as transformToTactics, transformToAttributes as transformFromTactics, tacticsColumnsToApiDto };
+// 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: {
+            [CourtPosition.LIBERO_ZONE]: config.lineup[CourtPosition.LIBERO_ZONE],
+            [CourtPosition.LEFT_BACK]: config.lineup[CourtPosition.LEFT_BACK],
+            [CourtPosition.LEFT_FRONT]: config.lineup[CourtPosition.LEFT_FRONT],
+            [CourtPosition.MIDDLE_BACK]: config.lineup[CourtPosition.MIDDLE_BACK],
+            [CourtPosition.MIDDLE_FRONT]: config.lineup[CourtPosition.MIDDLE_FRONT],
+            [CourtPosition.RIGHT_BACK]: config.lineup[CourtPosition.RIGHT_BACK],
+            [CourtPosition.RIGHT_FRONT]: config.lineup[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
+    };
+}
+export { transformToObject as transformToTactics, transformToAttributes as transformFromTactics, tacticsColumnsToApiDto, apiTacticsConfigToAttributes as apiTacticsConfigToTacticsAttributes };

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

@@ -1,6 +1,7 @@
 import { describe, it, expect } from '@jest/globals';
-import { tacticsColumnsToApiDto } from './tactics';
-import { CourtPosition, EnergyBand } from '../../service';
+import { tacticsColumnsToApiDto, transformFromTactics, transformToTactics } from './tactics';
+import { CourtPosition, EnergyBand, RotationSystemEnum, Tactics } from '../../service';
+import { makeCountry, makePlayer } from '../../service/test-helpers';
 // Minimal TacticsModel-shaped object; cast through unknown since the transformer only reads columns.
 function makeTactics(designatedSubs) {
     return {
@@ -75,4 +76,64 @@ describe('tacticsColumnsToApiDto()', () => {
         expect(dto.secondLibero).toBe('reserve1');
         expect(dto.liberoSub).toEqual({ mode: 'FATIGUE' });
     });
+    it('passes per-set tactics columns through to the API DTO shape', () => {
+        const model = makeTactics([]);
+        model.system_sets = [{ rotationSystem: RotationSystemEnum.FIVE_ONE, designatedSetters: ['lf'] }];
+        model.offensive_preference_sets = [[{ rotation: 1, order: ['rf', 'mf'] }]];
+        const dto = tacticsColumnsToApiDto(model);
+        expect(dto.systemSets).toEqual([{ rotationSystem: '5-1', designatedSetters: ['lf'] }]);
+        expect(dto.offensivePreferenceSets).toEqual([[{ rotation: 1, order: ['rf', 'mf'] }]]);
+    });
+    it('leaves the per-set DTO fields undefined when the columns are absent', () => {
+        const dto = tacticsColumnsToApiDto(makeTactics([]));
+        expect(dto.systemSets).toBeUndefined();
+        expect(dto.offensivePreferenceSets).toBeUndefined();
+    });
+});
+describe('per-set tactics — service <-> row round-trip', () => {
+    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 roster = [p1, p2, p3, p4, p5, p6];
+    const tactics = Tactics.create({
+        lineup: { 4: p4, 3: p3, 2: p2, 5: p5, 6: p6, 1: p1, bench: [] },
+        liberoReplacements: [],
+        systemSets: [
+            { rotationSystem: RotationSystemEnum.FIVE_ONE, designatedSetters: [p1] },
+            { rotationSystem: RotationSystemEnum.SIX_ZERO, designatedSetters: [] }
+        ],
+        offensivePreferenceSets: [[{ rotation: 1, order: [p2, p3] }]]
+    });
+    it('transformFromTactics writes the per-set overrides as id-based jsonb columns', () => {
+        const attrs = transformFromTactics(tactics, 'team-1');
+        expect(attrs.system_sets).toEqual([
+            { rotationSystem: '5-1', designatedSetters: [p1.id] },
+            { rotationSystem: '6-0', designatedSetters: [] }
+        ]);
+        expect(attrs.offensive_preference_sets).toEqual([[{ rotation: 1, order: [p2.id, p3.id] }]]);
+    });
+    it('transformToTactics resolves the stored ids back to roster players', () => {
+        const attrs = transformFromTactics(tactics, 'team-1');
+        const back = transformToTactics(attrs, roster);
+        expect(back.systemSets?.[0].rotationSystem).toBe(RotationSystemEnum.FIVE_ONE);
+        expect(back.systemSets?.[0].designatedSetters[0].id).toBe(p1.id);
+        expect(back.systemSets?.[1].designatedSetters).toEqual([]);
+        expect(back.offensivePreferenceSets?.[0][0].order.map(p => p.id)).toEqual([p2.id, p3.id]);
+    });
+    it('omits the per-set columns entirely for an all-sets config', () => {
+        const flat = Tactics.create({
+            lineup: { 4: p4, 3: p3, 2: p2, 5: p5, 6: p6, 1: p1, bench: [] },
+            liberoReplacements: []
+        });
+        const attrs = transformFromTactics(flat, 'team-1');
+        expect(attrs.system_sets).toBeUndefined();
+        expect(attrs.offensive_preference_sets).toBeUndefined();
+        const back = transformToTactics(attrs, roster);
+        expect(back.systemSets).toBeUndefined();
+        expect(back.offensivePreferenceSets).toBeUndefined();
+    });
 });

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

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

@@ -1,5 +1,6 @@
 import { Team } from '../../service';
-import { transformFromTactics, transformToCountry, transformToPlayer, transformToTactics } from '.';
+import { apiTacticsConfigToTacticsAttributes, transformFromTactics, transformToCountry, transformToPlayer, transformToTactics } from '.';
+import logger from '../../logger';
 function transformToAttributes(team) {
     return {
         team_id: team.id,
@@ -12,11 +13,25 @@ function transformToAttributes(team) {
         division_id: team.divisionId
     };
 }
-function transformToObject(model, currentIteration) {
+function transformToObject(model, currentIteration, tacticsOverride) {
     const roster = (model.PlayerTeams ?? []).map((pt) => transformToPlayer(pt.player, currentIteration));
-    const tactics = model.tactics != null && roster != null && roster.length > 0
-        ? transformToTactics(model.tactics, roster)
-        : undefined;
+    let tactics;
+    if (tacticsOverride != null && roster.length > 0) {
+        try {
+            tactics = transformToTactics(apiTacticsConfigToTacticsAttributes(tacticsOverride.config, model.team_id), roster);
+        }
+        catch (err) {
+            if (tacticsOverride.onFallback != null)
+                tacticsOverride.onFallback(tacticsOverride.presetId, err);
+            else
+                logger.warn(`MATCH_PRESET_FALLBACK: team=${model.team_id} preset=${tacticsOverride.presetId} failed to hydrate; using active tactics`);
+        }
+    }
+    if (tactics == null) {
+        tactics = model.tactics != null && roster.length > 0
+            ? transformToTactics(model.tactics, roster)
+            : undefined;
+    }
     return Team.create({
         id: model.team_id,
         name: model.name,

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

@@ -41,7 +41,7 @@ function transformToObject(model) {
         id: model.competition_id,
         iteration: transformToIteration(model.Iteration),
         matches: (model.CompetitionMatches ?? []).map(transformToTournamentMatch),
-        teams: sortTeamsByCompetitionIndex(model.Teams ?? []).map(transformToTeam),
+        teams: sortTeamsByCompetitionIndex(model.Teams ?? []).map(team => transformToTeam(team)),
         status: model.status,
         champion
     });

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

@@ -67,3 +67,118 @@ describe('TacticsInputSchema — second libero rules', () => {
         }
     });
 });
+describe('TacticsInputSchema — per-set tactics (systemSets / offensivePreferenceSets)', () => {
+    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 reserve = makePlayer(country);
+    // Minimal valid flat input (6-0 default: no setters, no preferences). Zone layout: p1@1, p2@2, p3@3,
+    // p4@4, p5@5, p6@6 — opposite slot pairs (3 apart) are (1,4), (2,5), (3,6).
+    function baseInput(overrides = {}) {
+        return {
+            lineup: { 4: p4, 3: p3, 2: p2, 5: p5, 6: p6, 1: p1, bench: [] },
+            liberoReplacements: [],
+            ...overrides
+        };
+    }
+    it('accepts valid per-set overrides for both scopes', () => {
+        const res = TacticsInputSchema.safeParse(baseInput({
+            systemSets: [
+                { rotationSystem: '5-1', designatedSetters: [p1] },
+                { rotationSystem: '6-0', designatedSetters: [] },
+                { rotationSystem: '4-2', designatedSetters: [p1, p4] }
+            ],
+            offensivePreferenceSets: [
+                [{ rotation: 1, order: [p2, p3] }],
+                []
+            ]
+        }));
+        expect(res.success).toBe(true);
+    });
+    it('carries the per-set fields through Tactics.create parsing', () => {
+        const res = TacticsInputSchema.safeParse(baseInput({
+            systemSets: [{ rotationSystem: '5-1', designatedSetters: [p1] }],
+            offensivePreferenceSets: [[{ rotation: 2, order: [p3] }]]
+        }));
+        expect(res.success).toBe(true);
+        if (res.success) {
+            expect(res.data.systemSets?.[0].rotationSystem).toBe('5-1');
+            expect(res.data.systemSets?.[0].designatedSetters[0].id).toBe(p1.id);
+            expect(res.data.offensivePreferenceSets?.[0][0]).toMatchObject({ rotation: 2 });
+        }
+    });
+    it('rejects more than 5 per-set entries', () => {
+        const entry = { rotationSystem: '6-0', designatedSetters: [] };
+        expect(TacticsInputSchema.safeParse(baseInput({ systemSets: Array.from({ length: 6 }, () => entry) })).success).toBe(false);
+        expect(TacticsInputSchema.safeParse(baseInput({ offensivePreferenceSets: Array.from({ length: 6 }, () => []) })).success).toBe(false);
+    });
+    it('rejects a set entry whose setter count does not match its system (5-1 with none)', () => {
+        const res = TacticsInputSchema.safeParse(baseInput({
+            systemSets: [{ rotationSystem: '5-1', designatedSetters: [] }]
+        }));
+        expect(res.success).toBe(false);
+        if (!res.success) {
+            const issue = res.error.issues.find(i => i.message === 'DESIGNATED_SETTERS_COUNT_5-1_EXPECTED_1');
+            expect(issue?.path).toEqual(['systemSets', 0]);
+        }
+    });
+    it('rejects a set entry whose setter is not a court starter', () => {
+        const res = TacticsInputSchema.safeParse(baseInput({
+            systemSets: [
+                { rotationSystem: '6-0', designatedSetters: [] },
+                { rotationSystem: '5-1', designatedSetters: [reserve] }
+            ]
+        }));
+        expect(res.success).toBe(false);
+        if (!res.success) {
+            const issue = res.error.issues.find(i => i.message === 'DESIGNATED_SETTER_NOT_A_STARTER');
+            expect(issue?.path).toEqual(['systemSets', 1]);
+        }
+    });
+    it('rejects a 4-2 set entry whose setters are not in opposite slots', () => {
+        // p1@1 and p2@2 are adjacent (not 3 apart), so the 4-2 pair rule fails for that set entry.
+        const res = TacticsInputSchema.safeParse(baseInput({
+            systemSets: [{ rotationSystem: '4-2', designatedSetters: [p1, p2] }]
+        }));
+        expect(res.success).toBe(false);
+        if (!res.success) {
+            expect(res.error.issues.some(i => i.message === 'DESIGNATED_SETTERS_NOT_IN_OPPOSITE_SLOTS')).toBe(true);
+        }
+    });
+    it('rejects a per-set preferences list with a duplicate rotation', () => {
+        const res = TacticsInputSchema.safeParse(baseInput({
+            offensivePreferenceSets: [[{ rotation: 1, order: [p2] }, { rotation: 1, order: [p3] }]]
+        }));
+        expect(res.success).toBe(false);
+        if (!res.success) {
+            const issue = res.error.issues.find(i => i.message === 'OFFENSIVE_PREFERENCE_DUPLICATE_ROTATION');
+            expect(issue?.path).toEqual(['offensivePreferenceSets', 0]);
+        }
+    });
+    it('rejects a per-set preferences order that lists a non-starter', () => {
+        const res = TacticsInputSchema.safeParse(baseInput({
+            offensivePreferenceSets: [[{ rotation: 1, order: [reserve] }]]
+        }));
+        expect(res.success).toBe(false);
+        if (!res.success) {
+            expect(res.error.issues.some(i => i.message === 'OFFENSIVE_PREFERENCE_ATTACKER_NOT_A_STARTER')).toBe(true);
+        }
+    });
+    it('still validates the flat fields when per-set overrides are present', () => {
+        // Flat 5-1 with no setter is invalid even though every set entry is valid.
+        const res = TacticsInputSchema.safeParse(baseInput({
+            rotationSystem: '5-1',
+            designatedSetters: [],
+            systemSets: [{ rotationSystem: '6-0', designatedSetters: [] }]
+        }));
+        expect(res.success).toBe(false);
+        if (!res.success) {
+            const issue = res.error.issues.find(i => i.message === 'DESIGNATED_SETTERS_COUNT_5-1_EXPECTED_1');
+            expect(issue?.path).toEqual(['designatedSetters']);
+        }
+    });
+});

package/package.json

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