volleyballsimtypes 0.0.459 → 0.0.463

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

@@ -49,6 +49,7 @@ export type Match = Omit<DataProps<_Match>, 'sets' | 'homeTeam' | 'awayTeam' | '
     awayForm?: MatchForm[];
     isFriendly?: boolean;
     detailUnavailable?: boolean;
+    selectedPresetId?: string;
 };
 export type RallyEvent = DataProps<_RallyEvent> & {
     teamId?: string;
@@ -128,6 +129,7 @@ export interface ApiLineupPreset {
     orderIndex: number;
     config: Tactics;
 }
+export type ApiLineupPresetSummary = Omit<ApiLineupPreset, 'config'>;
 export type Team = Omit<DataProps<_Team>, 'roster' | '_rating' | 'rating' | 'tactics'> & {
     roster: Player[];
     rating: {

package/dist/cjs/src/data/init-models.js

@@ -8,6 +8,7 @@ function initModels(sequelize) {
     const CurrencyTransaction = models_1.CurrencyTransactionModel.initModel(sequelize);
     const Tactics = models_1.TacticsModel.initModel(sequelize);
     const LineupPreset = models_1.LineupPresetModel.initModel(sequelize);
+    const MatchPreset = models_1.MatchPresetModel.initModel(sequelize);
     const AuthUser = models_1.AuthUserModel.initModel(sequelize);
     const UserCurrency = models_1.UserCurrencyModel.initModel(sequelize);
     const UserPlayerProgress = models_1.UserPlayerProgressModel.initModel(sequelize);
@@ -16,6 +17,7 @@ function initModels(sequelize) {
     const UserPullGrant = models_1.UserPullGrantModel.initModel(sequelize);
     const Wishlist = models_1.WishlistModel.initModel(sequelize);
     const UserSettings = models_1.UserSettingsModel.initModel(sequelize);
+    const UserDeviceToken = models_1.UserDeviceTokenModel.initModel(sequelize);
     const Notification = models_1.NotificationModel.initModel(sequelize);
     const AuthIdentity = models_1.AuthIdentityModel.initModel(sequelize);
     const AuthSession = models_1.AuthSessionModel.initModel(sequelize);
@@ -63,7 +65,9 @@ function initModels(sequelize) {
     AuthUser.hasOne(GachaPity, { as: 'GachaPity', foreignKey: 'user_id' });
     AuthUser.hasOne(Wishlist, { as: 'Wishlist', foreignKey: 'user_id' });
     AuthUser.hasOne(UserSettings, { as: 'UserSettings', foreignKey: 'user_id' });
+    AuthUser.hasMany(UserDeviceToken, { as: 'UserDeviceTokens', foreignKey: 'user_id' });
     AuthUser.hasMany(Notification, { as: 'Notifications', foreignKey: 'user_id' });
+    UserDeviceToken.belongsTo(AuthUser, { as: 'user', foreignKey: 'user_id' });
     Notification.belongsTo(AuthUser, { as: 'user', foreignKey: 'user_id' });
     AuthUser.hasMany(GachaPullHistory, { as: 'GachaPullHistory', foreignKey: 'user_id' });
     AuthUser.hasMany(UserPullGrant, { as: 'UserPullGrants', foreignKey: 'user_id' });
@@ -212,6 +216,13 @@ function initModels(sequelize) {
     // simulator's team loads are unchanged (it reads the active config from the mirrored Tactics row).
     Team.hasMany(LineupPreset, { as: 'lineupPresets', foreignKey: 'team_id' });
     LineupPreset.belongsTo(Team, { as: 'team', foreignKey: 'team_id' });
+    // Per-match preset choices. Deliberately NOT part of any default scope: only the simulator's match query
+    // loads MatchPresets, so every other transformToMatch caller stays on the active-tactics path.
+    Match.hasMany(MatchPreset, { as: 'MatchPresets', foreignKey: 'match_id' });
+    MatchPreset.belongsTo(Match, { as: 'match', foreignKey: 'match_id' });
+    MatchPreset.belongsTo(Team, { as: 'team', foreignKey: 'team_id' });
+    MatchPreset.belongsTo(LineupPreset, { as: 'preset', foreignKey: 'preset_id' });
+    LineupPreset.hasMany(MatchPreset, { as: 'MatchPresets', foreignKey: 'preset_id' });
     Team.belongsTo(Country, { as: 'country', foreignKey: 'country_id' });
     Team.belongsToMany(Competition, {
         as: 'Competitions',
@@ -286,6 +297,7 @@ function initModels(sequelize) {
         TeamReplacement,
         Tactics,
         LineupPreset,
+        MatchPreset,
         UserTeam,
         UserCurrency,
         UserPlayerProgress,
@@ -294,6 +306,7 @@ function initModels(sequelize) {
         UserPullGrant,
         Wishlist,
         UserSettings,
+        UserDeviceToken,
         Notification,
         Coach,
         Scout,

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

@@ -36,6 +36,7 @@ export * from './team';
 export * from './team-replacement';
 export * from './tactics';
 export * from './lineup-preset';
+export * from './match-preset';
 export * from './user-currency';
 export * from './user-player-progress';
 export * from './gacha-pity';
@@ -44,6 +45,7 @@ export * from './wishlist';
 export * from './currency-transaction';
 export * from './user-pull-grant';
 export * from './user-settings';
+export * from './user-device-token';
 export * from './notification';
 export * from './vper';
 export * from './views';

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

@@ -52,6 +52,7 @@ __exportStar(require("./team"), exports);
 __exportStar(require("./team-replacement"), exports);
 __exportStar(require("./tactics"), exports);
 __exportStar(require("./lineup-preset"), exports);
+__exportStar(require("./match-preset"), exports);
 __exportStar(require("./user-currency"), exports);
 __exportStar(require("./user-player-progress"), exports);
 __exportStar(require("./gacha-pity"), exports);
@@ -60,6 +61,7 @@ __exportStar(require("./wishlist"), exports);
 __exportStar(require("./currency-transaction"), exports);
 __exportStar(require("./user-pull-grant"), exports);
 __exportStar(require("./user-settings"), exports);
+__exportStar(require("./user-device-token"), exports);
 __exportStar(require("./notification"), exports);
 __exportStar(require("./vper"), exports);
 __exportStar(require("./views"), exports);

package/dist/cjs/src/data/models/match-preset.d.ts

@@ -0,0 +1,28 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import { LineupPresetId, LineupPresetModel, MatchId, MatchModel, TeamId, TeamModel } from '.';
+export interface MatchPresetAttributes {
+    match_id: string;
+    team_id: string;
+    preset_id: string;
+}
+export type MatchPresetPk = 'match_id' | 'team_id';
+export type MatchPresetCreationAttributes = MatchPresetAttributes;
+export declare class MatchPresetModel extends Model<MatchPresetAttributes, MatchPresetCreationAttributes> implements MatchPresetAttributes {
+    match_id: string;
+    team_id: string;
+    preset_id: string;
+    match: MatchModel;
+    getMatch: Sequelize.BelongsToGetAssociationMixin<MatchModel>;
+    setMatch: Sequelize.BelongsToSetAssociationMixin<MatchModel, MatchId>;
+    createMatch: Sequelize.BelongsToCreateAssociationMixin<MatchModel>;
+    team: TeamModel;
+    getTeam: Sequelize.BelongsToGetAssociationMixin<TeamModel>;
+    setTeam: Sequelize.BelongsToSetAssociationMixin<TeamModel, TeamId>;
+    createTeam: Sequelize.BelongsToCreateAssociationMixin<TeamModel>;
+    preset: LineupPresetModel;
+    getPreset: Sequelize.BelongsToGetAssociationMixin<LineupPresetModel>;
+    setPreset: Sequelize.BelongsToSetAssociationMixin<LineupPresetModel, LineupPresetId>;
+    createPreset: Sequelize.BelongsToCreateAssociationMixin<LineupPresetModel>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof MatchPresetModel;
+}

package/dist/cjs/src/data/models/match-preset.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MatchPresetModel = void 0;
+const sequelize_1 = require("sequelize");
+class MatchPresetModel extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return MatchPresetModel.init({
+            match_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'Match',
+                    key: 'match_id'
+                }
+            },
+            team_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'Team',
+                    key: 'team_id'
+                }
+            },
+            preset_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'LineupPreset',
+                    key: 'preset_id'
+                }
+            }
+        }, {
+            sequelize,
+            tableName: 'MatchPreset',
+            schema: 'public',
+            timestamps: false,
+            indexes: [
+                {
+                    name: 'MatchPreset_pk',
+                    unique: true,
+                    fields: [
+                        { name: 'match_id' },
+                        { name: 'team_id' }
+                    ]
+                },
+                {
+                    name: 'MatchPreset_team_id_idx',
+                    fields: [
+                        { name: 'team_id' }
+                    ]
+                },
+                {
+                    // Keeps the LineupPreset ON DELETE CASCADE cheap.
+                    name: 'MatchPreset_preset_id_idx',
+                    fields: [
+                        { name: 'preset_id' }
+                    ]
+                }
+            ]
+        });
+    }
+}
+exports.MatchPresetModel = MatchPresetModel;

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

@@ -1,7 +1,7 @@
 import * as Sequelize from 'sequelize';
 import { Model } from 'sequelize';
 import { Status } from '../common';
-import { CompetitionMatchId, CompetitionMatchModel, MatchRatingId, MatchRatingModel, MatchResultId, MatchResultModel, MatchSetAttributes, MatchSetId, MatchSetModel, VPERAttributes, VPERId, VPERModel, TeamId, TeamModel } from '.';
+import { CompetitionMatchId, CompetitionMatchModel, MatchRatingId, MatchRatingModel, MatchResultId, MatchResultModel, MatchPresetModel, MatchSetAttributes, MatchSetId, MatchSetModel, VPERAttributes, VPERId, VPERModel, TeamId, TeamModel } from '.';
 import { MatchRallyAggregates } from '../../service';
 export interface MatchAttributes {
     match_id: string;
@@ -59,6 +59,7 @@ export declare class MatchModel extends Model<MatchAttributes, MatchCreationAttr
     hasVPER: Sequelize.HasManyHasAssociationMixin<VPERModel, VPERId>;
     hasVPERs: Sequelize.HasManyHasAssociationsMixin<VPERModel, VPERId>;
     countVPERs: Sequelize.HasManyCountAssociationsMixin;
+    MatchPresets?: MatchPresetModel[];
     MatchSets: MatchSetModel[];
     getMatchSets: Sequelize.HasManyGetAssociationsMixin<MatchSetModel>;
     setMatchSets: Sequelize.HasManySetAssociationsMixin<MatchSetModel, MatchSetId>;

package/dist/cjs/src/data/models/user-device-token.d.ts

@@ -0,0 +1,23 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+export interface UserDeviceTokenAttributes {
+    user_device_token_id: string;
+    user_id: string;
+    device_token: string;
+    platform: string;
+    created_at?: Date;
+    updated_at?: Date;
+}
+export type UserDeviceTokenPk = 'user_device_token_id';
+export type UserDeviceTokenId = UserDeviceTokenModel[UserDeviceTokenPk];
+export type UserDeviceTokenOptionalAttributes = 'user_device_token_id' | 'platform' | 'created_at' | 'updated_at';
+export type UserDeviceTokenCreationAttributes = Optional<UserDeviceTokenAttributes, UserDeviceTokenOptionalAttributes>;
+export declare class UserDeviceTokenModel extends Model<UserDeviceTokenAttributes, UserDeviceTokenCreationAttributes> implements UserDeviceTokenAttributes {
+    user_device_token_id: string;
+    user_id: string;
+    device_token: string;
+    platform: string;
+    created_at?: Date;
+    updated_at?: Date;
+    static initModel(sequelize: Sequelize.Sequelize): typeof UserDeviceTokenModel;
+}

package/dist/cjs/src/data/models/user-device-token.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserDeviceTokenModel = void 0;
+const sequelize_1 = require("sequelize");
+class UserDeviceTokenModel extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return UserDeviceTokenModel.init({
+            user_device_token_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                defaultValue: sequelize_1.DataTypes.UUIDV4
+            },
+            user_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'AuthUser',
+                    key: 'user_id'
+                }
+            },
+            device_token: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: false
+            },
+            platform: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: false,
+                defaultValue: 'android'
+            },
+            created_at: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false,
+                defaultValue: sequelize_1.DataTypes.NOW
+            },
+            updated_at: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false,
+                defaultValue: sequelize_1.DataTypes.NOW
+            }
+        }, {
+            sequelize,
+            tableName: 'UserDeviceToken',
+            schema: 'public',
+            timestamps: false,
+            indexes: [
+                {
+                    name: 'UserDeviceToken_pk',
+                    unique: true,
+                    fields: [{ name: 'user_device_token_id' }]
+                },
+                {
+                    name: 'UserDeviceToken_user_id_device_token_uq',
+                    unique: true,
+                    fields: [{ name: 'user_id' }, { name: 'device_token' }]
+                },
+                {
+                    name: 'UserDeviceToken_user_id_idx',
+                    fields: [{ name: 'user_id' }]
+                }
+            ]
+        });
+    }
+}
+exports.UserDeviceTokenModel = UserDeviceTokenModel;

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

@@ -27,6 +27,6 @@ function transformToObject(model) {
         subdivision: model.subdivision,
         leagueId: model.league_id,
         seasons: (model.DivisionSeasons ?? []).map((ds) => (0, season_1.transformToSeason)(ds.competition)),
-        teams: model.Teams != null ? model.Teams.map(team_1.transformToTeam) : undefined
+        teams: model.Teams != null ? model.Teams.map(team => (0, team_1.transformToTeam)(team)) : undefined
     });
 }

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.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

@@ -15,7 +15,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(match_set_1.transformToMatchSet)
         .sort((s1, s2) => s1.order - s2.order);
     let homeScore = 0;
@@ -47,8 +59,8 @@ 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,

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/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.