volleyballsimtypes 0.0.489 → 0.0.492

package/dist/cjs/src/service/team/blocking-preference.js

@@ -1,2 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.NO_BLOCK = void 0;
+// A front-row player opted OUT of blocking for this rotation. They never join the wall under any circumstance:
+// not as the lead blocker (the lane's next-nearest front-row player leads instead), not as a side blocker, and
+// no trait can coerce them in -- MOVING_WALL's guaranteed lead hand, its beaten-read hand and its side-joiner
+// roll are all suppressed, as is a dedicated-blocking commit. Sits in the same `targets` map as a commit
+// assignment, so the two are mutually exclusive by construction: a player is reading, committed, or out.
+exports.NO_BLOCK = 'NO_BLOCK';

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

@@ -281,11 +281,11 @@ export declare const TacticsInputSchema: z.ZodObject<{
     }, z.core.$strip>>>>;
     blockingPreferences: z.ZodDefault<z.ZodArray<z.ZodObject<{
         rotation: z.ZodNumber;
-        targets: z.ZodRecord<z.ZodString, z.ZodEnum<typeof RoleEnum> & z.ZodType<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum, z.core.$ZodTypeInternals<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum>>>;
+        targets: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<typeof RoleEnum> & z.ZodType<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum, z.core.$ZodTypeInternals<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum>>, z.ZodLiteral<"NO_BLOCK">]>>;
     }, z.core.$strip>>>;
     blockingPreferenceSets: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodObject<{
         rotation: z.ZodNumber;
-        targets: z.ZodRecord<z.ZodString, z.ZodEnum<typeof RoleEnum> & z.ZodType<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum, z.core.$ZodTypeInternals<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum>>>;
+        targets: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<typeof RoleEnum> & z.ZodType<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum, z.core.$ZodTypeInternals<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum>>, z.ZodLiteral<"NO_BLOCK">]>>;
     }, z.core.$strip>>>>;
     replaceKnockedImmediately: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
     injuryReplacements: z.ZodDefault<z.ZodArray<z.ZodObject<{

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TacticsInputSchema = void 0;
 const zod_1 = require("zod");
 const player_1 = require("../../player");
+const blocking_preference_1 = require("../blocking-preference");
 const energy_band_1 = require("../energy-band");
 const rotation_system_1 = require("../rotation-system");
 const designated_sub_z_1 = require("./designated-sub.z");
@@ -59,8 +60,12 @@ const offensivePreferenceSchema = zod_1.z.object({
     weights: zod_1.z.record(zod_1.z.string(), zod_1.z.number().int().min(0)),
     tempos: zod_1.z.record(zod_1.z.string(), tempoPreferenceSchema).optional()
 });
-// The opposing attacking functions a dedicated blocker can commit to: every RoleEnum except the libero.
-const blockingFunctionSchema = zod_1.z.nativeEnum(player_1.RoleEnum).refine((v) => v !== player_1.RoleEnum.LIBERO, { message: 'BLOCKING_TARGET_CANNOT_BE_LIBERO' });
+// What a front-row starter can be assigned: an opposing attacking function to commit to (every RoleEnum except
+// the libero, which never attacks), or NO_BLOCK to sit the rotation out of the block entirely.
+const blockingFunctionSchema = zod_1.z.union([
+    zod_1.z.nativeEnum(player_1.RoleEnum).refine((v) => v !== player_1.RoleEnum.LIBERO, { message: 'BLOCKING_TARGET_CANNOT_BE_LIBERO' }),
+    zod_1.z.literal(blocking_preference_1.NO_BLOCK)
+]);
 // One rotation's dedicated-blocking assignments: `targets` maps my front-row starter ids to the opposing function
 // each commits to block. Cross-field checks (keys are starters) live in the superRefine below.
 const blockingPreferenceSchema = zod_1.z.object({

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const globals_1 = require("@jest/globals");
 const tactics_z_1 = require("./tactics.z");
+const blocking_preference_1 = require("../blocking-preference");
 const player_1 = require("../../player");
 const test_helpers_1 = require("../../test-helpers");
 (0, globals_1.describe)('TacticsInputSchema — second libero rules', () => {
@@ -280,4 +281,35 @@ const test_helpers_1 = require("../../test-helpers");
         }));
         (0, globals_1.expect)(res.success).toBe(true);
     });
+    (0, globals_1.it)('accepts NO_BLOCK as an assignment, alongside a commit on another starter', () => {
+        const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
+            blockingPreferences: [{ rotation: 1, targets: { [p4.id]: blocking_preference_1.NO_BLOCK, [p3.id]: player_1.RoleEnum.MIDDLE_BLOCKER } }]
+        }));
+        (0, globals_1.expect)(res.success).toBe(true);
+        if (res.success) {
+            (0, globals_1.expect)(res.data.blockingPreferences[0].targets[p4.id]).toBe(blocking_preference_1.NO_BLOCK);
+            (0, globals_1.expect)(res.data.blockingPreferences[0].targets[p3.id]).toBe(player_1.RoleEnum.MIDDLE_BLOCKER);
+        }
+    });
+    (0, globals_1.it)('accepts NO_BLOCK in a per-set override', () => {
+        const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
+            blockingPreferenceSets: [[{ rotation: 1, targets: { [p4.id]: blocking_preference_1.NO_BLOCK } }], []]
+        }));
+        (0, globals_1.expect)(res.success).toBe(true);
+    });
+    (0, globals_1.it)('still rejects a NO_BLOCK assignment on a player who is not a starter', () => {
+        const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
+            blockingPreferences: [{ rotation: 1, targets: { [reserve.id]: blocking_preference_1.NO_BLOCK } }]
+        }));
+        (0, globals_1.expect)(res.success).toBe(false);
+        if (!res.success) {
+            (0, globals_1.expect)(res.error.issues.some(i => i.message === 'BLOCKING_PREFERENCE_BLOCKER_NOT_A_STARTER')).toBe(true);
+        }
+    });
+    (0, globals_1.it)('rejects an unknown assignment string', () => {
+        const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
+            blockingPreferences: [{ rotation: 1, targets: { [p4.id]: 'NO_BLOCKING' } }]
+        }));
+        (0, globals_1.expect)(res.success).toBe(false);
+    });
 });

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

@@ -289,11 +289,11 @@ export declare const TeamInputSchema: z.ZodObject<{
         }, z.core.$strip>>>>;
         blockingPreferences: z.ZodDefault<z.ZodArray<z.ZodObject<{
             rotation: z.ZodNumber;
-            targets: z.ZodRecord<z.ZodString, z.ZodEnum<typeof import("../../player").RoleEnum> & z.ZodType<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum, z.core.$ZodTypeInternals<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum>>>;
+            targets: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<typeof import("../../player").RoleEnum> & z.ZodType<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum, z.core.$ZodTypeInternals<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum>>, z.ZodLiteral<"NO_BLOCK">]>>;
         }, z.core.$strip>>>;
         blockingPreferenceSets: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodObject<{
             rotation: z.ZodNumber;
-            targets: z.ZodRecord<z.ZodString, z.ZodEnum<typeof import("../../player").RoleEnum> & z.ZodType<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum, z.core.$ZodTypeInternals<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum>>>;
+            targets: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<typeof import("../../player").RoleEnum> & z.ZodType<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum, z.core.$ZodTypeInternals<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum>>, z.ZodLiteral<"NO_BLOCK">]>>;
         }, z.core.$strip>>>>;
         replaceKnockedImmediately: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
         injuryReplacements: z.ZodDefault<z.ZodArray<z.ZodObject<{

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

@@ -1,4 +1,5 @@
-import { BoxScore, DataProps, DeclineStatus, Division as _Division, League as _League, Match as _Match, MatchSet as _MatchSet, Player as _Player, PlayerPosition, Qualifier as _Qualifier, QualifierMatch as _QualifierMatch, Rally as _Rally, RallyEvent as _RallyEvent, PointBreakdown, RallyMetrics, Season as _Season, Standing as _Standing, Team as _Team, Tournament as _Tournament, TournamentMatch as _TournamentMatch, National as _National, NationalMatch as _NationalMatch, Country as _Country, CourtPosition, ConditionLogic, EnergyBand, MatchForfeitType, PerformanceStats, PinchCondition, RoleEnum, RotationSystemEnum, SubBackMode, SubBand } from '../service';
+import { BoxScore, DataProps, DeclineStatus, Division as _Division, League as _League, Match as _Match, MatchSet as _MatchSet, Player as _Player, PlayerPosition, Qualifier as _Qualifier, QualifierMatch as _QualifierMatch, Rally as _Rally, RallyEvent as _RallyEvent, PointBreakdown, RallyMetrics, Season as _Season, Standing as _Standing, Team as _Team, Tournament as _Tournament, TournamentMatch as _TournamentMatch, National as _National, NationalMatch as _NationalMatch, Country as _Country, BlockingAssignment, CourtPosition, ConditionLogic, EnergyBand, MatchForfeitType, PerformanceStats, PinchCondition, RotationSystemEnum, SubBackMode, SubBand } from '../service';
+export * from './tactics-player-refs';
 export type Rally = DataProps<_Rally> & {
     homePlayerPosition: PlayerPosition[];
     awayPlayerPosition: PlayerPosition[];
@@ -16,7 +17,7 @@ export interface Results {
     away: number[];
 }
 export interface MatchCompetition {
-    type: 'LEAGUE' | 'NATIONAL' | 'QUALIFIER' | 'TOURNAMENT';
+    type: 'LEAGUE' | 'NATIONAL' | 'QUALIFIER' | 'TOURNAMENT' | 'EVENT';
     countryName?: string;
     countryAlpha2?: string;
     countryAlpha3?: string;
@@ -101,7 +102,7 @@ export interface ApiOffensivePreference {
 }
 export interface ApiBlockingPreference {
     rotation: number;
-    targets: Record<string, RoleEnum>;
+    targets: Record<string, BlockingAssignment>;
 }
 export interface ApiSystemSet {
     rotationSystem: RotationSystemEnum;

package/dist/esm/src/api/index.js

@@ -1 +1,2 @@
 import { CourtPosition } from '../service';
+export * from './tactics-player-refs';

package/dist/esm/src/api/tactics-player-refs.d.ts

@@ -0,0 +1,13 @@
+import type { Tactics } from '.';
+/**
+ * Every player id a tactics config references, anywhere: the six court slots and the libero, the bench, libero
+ * replacements (flat and per-set), the second libero, designated subs and their per-set overrides, designated
+ * setters (flat and per-set), the keys of the offensive-weight and blocking-target maps, injury replacements
+ * and the libero-injury reserves.
+ *
+ * There is exactly ONE implementation of this on purpose. It backs three rules that must agree or a player
+ * slips through: the dismiss/retire guard (a referenced player cannot be removed), the event rarity check
+ * (every referenced player must match the event's rarity), and the simulator's re-validation of an event entry
+ * at the registration deadline. A field missed here silently unlocks a player in all three.
+ */
+export declare function collectTacticsPlayerIds(config: Tactics): string[];

package/dist/esm/src/api/tactics-player-refs.js

@@ -0,0 +1,40 @@
+/**
+ * Every player id a tactics config references, anywhere: the six court slots and the libero, the bench, libero
+ * replacements (flat and per-set), the second libero, designated subs and their per-set overrides, designated
+ * setters (flat and per-set), the keys of the offensive-weight and blocking-target maps, injury replacements
+ * and the libero-injury reserves.
+ *
+ * There is exactly ONE implementation of this on purpose. It backs three rules that must agree or a player
+ * slips through: the dismiss/retire guard (a referenced player cannot be removed), the event rarity check
+ * (every referenced player must match the event's rarity), and the simulator's re-validation of an event entry
+ * at the registration deadline. A field missed here silently unlocks a player in all three.
+ */
+export function collectTacticsPlayerIds(config) {
+    const lineup = config.lineup;
+    const referenced = [
+        lineup[0], lineup[1], lineup[2], lineup[3], lineup[4], lineup[5], lineup[6],
+        ...(Array.isArray(lineup.bench) ? lineup.bench : []),
+        ...(config.liberoReplacements ?? []),
+        ...((config.designatedSubs ?? []).flatMap(ds => [
+            ds.starterId,
+            ds.benchId,
+            ...((ds.sets ?? []).map(s => s.benchId))
+        ])),
+        config.secondLibero,
+        ...((config.liberoReplacementSets ?? []).flat()),
+        ...(config.designatedSetters ?? []),
+        ...((config.offensivePreferences ?? []).flatMap(p => Object.keys(p.weights))),
+        ...((config.systemSets ?? []).flatMap(s => s.designatedSetters)),
+        ...((config.offensivePreferenceSets ?? []).flat().flatMap(p => Object.keys(p.weights))),
+        ...((config.blockingPreferences ?? []).flatMap(p => Object.keys(p.targets))),
+        ...((config.blockingPreferenceSets ?? []).flat().flatMap(p => Object.keys(p.targets))),
+        // Injury replacements reference reserves (roster players outside the lineup); roster membership is the only
+        // player check possible here (the schema enforces the bench/reserve role rules).
+        ...((config.injuryReplacements ?? []).flatMap(ir => [ir.starterId, ir.replacementId, ir.benchBackfillId])),
+        // Libero-injury ids reference reserves/bench players; roster membership is the only check possible here.
+        ...(config.liberoInjury != null
+            ? [config.liberoInjury.preMatchReplacementId, config.liberoInjury.secondLiberoBackfillId, config.liberoInjury.inMatchDesignateId]
+            : [])
+    ];
+    return [...new Set(referenced.filter((id) => typeof id === 'string' && id.length > 0))];
+}

package/dist/esm/src/data/event-purge.d.ts

@@ -0,0 +1,14 @@
+import { Sequelize } from 'sequelize';
+/**
+ * Delete everything an event produced, keeping only the Event row itself (with purged_at stamped) so the game
+ * retains a record that it ran. Pass `removeEvent` to drop that row too, which is what an admin delete does.
+ *
+ * Order matters: MatchResult has no FK to Match and must go explicitly (same as the weekly friendly purge);
+ * deleting the Match then cascades MatchSet -> Rally/BoxScore, VPER, MatchRating, PlayerImprovementLog and
+ * MatchPreset. The drafted squads go the same way as the bots: their throwaway teams and every player in them
+ * are deleted, along with any packs whose choices were never picked.
+ *
+ * EventResult is deliberately NOT touched. It is the permanent record of where each entrant finished and the
+ * only event row besides Event itself that outlives this.
+ */
+export declare function purgeEvent(sequelize: Sequelize, eventId: string, removeEvent?: boolean): Promise<void>;

package/dist/esm/src/data/event-purge.js

@@ -0,0 +1,110 @@
+import { QueryTypes } from 'sequelize';
+import { CompetitionMatchModel, CompetitionModel, CompetitionStandingsModel, CompetitionTeamsModel, EventBotTeamModel, EventCompetitionModel, EventPackModel, EventPackPlayerModel, EventSquadModel, EventModel, LineupPresetModel, MatchModel, MatchResultModel, PlayerModel, PlayerTeamModel, TeamModel } from './models';
+import logger from '../logger';
+// Tearing an event down. This lives in Types rather than in either service because BOTH perform it and they
+// must agree exactly: the simulator purges an event on its scheduled date, and the admin API purges one that
+// is being deleted outright. A second implementation of a destructive delete is how orphans get left behind.
+/**
+ * Delete everything an event produced, keeping only the Event row itself (with purged_at stamped) so the game
+ * retains a record that it ran. Pass `removeEvent` to drop that row too, which is what an admin delete does.
+ *
+ * Order matters: MatchResult has no FK to Match and must go explicitly (same as the weekly friendly purge);
+ * deleting the Match then cascades MatchSet -> Rally/BoxScore, VPER, MatchRating, PlayerImprovementLog and
+ * MatchPreset. The drafted squads go the same way as the bots: their throwaway teams and every player in them
+ * are deleted, along with any packs whose choices were never picked.
+ *
+ * EventResult is deliberately NOT touched. It is the permanent record of where each entrant finished and the
+ * only event row besides Event itself that outlives this.
+ */
+export async function purgeEvent(sequelize, eventId, removeEvent = false) {
+    await sequelize.transaction(async (transaction) => {
+        const competitions = await EventCompetitionModel.findAll({
+            where: { event_id: eventId },
+            attributes: ['competition_id'],
+            transaction
+        });
+        const competitionIds = competitions.map(c => c.competition_id);
+        const botTeams = await EventBotTeamModel.findAll({
+            where: { event_id: eventId },
+            attributes: ['team_id'],
+            transaction
+        });
+        const squads = await EventSquadModel.findAll({
+            where: { event_id: eventId },
+            attributes: ['team_id'],
+            transaction
+        });
+        // Bots and drafted squads are the same thing here: throwaway teams full of generated players.
+        const botTeamIds = [...botTeams.map(b => b.team_id), ...squads.map(s => s.team_id)];
+        if (competitionIds.length > 0) {
+            const matchRows = await CompetitionMatchModel.findAll({
+                where: { competition_id: competitionIds },
+                attributes: ['match_id'],
+                transaction
+            });
+            const matchIds = matchRows.map(m => m.match_id);
+            if (matchIds.length > 0) {
+                await MatchResultModel.destroy({ where: { match_id: matchIds }, transaction });
+                await CompetitionMatchModel.destroy({ where: { competition_id: competitionIds }, transaction });
+                await MatchModel.destroy({ where: { match_id: matchIds }, transaction });
+            }
+            await CompetitionStandingsModel.destroy({ where: { competition_id: competitionIds }, transaction });
+            await sequelize.query('DELETE FROM "CompetitionStandingsMatch" WHERE competition_id IN (:ids)', {
+                replacements: { ids: competitionIds }, type: QueryTypes.DELETE, transaction
+            });
+            await CompetitionTeamsModel.destroy({ where: { competition_id: competitionIds }, transaction });
+            await EventCompetitionModel.destroy({ where: { event_id: eventId }, transaction });
+            await CompetitionModel.destroy({ where: { competition_id: competitionIds }, transaction });
+        }
+        // Packs first: an unpicked choice still points at a Player row, and the pack points at the picked one, so
+        // both references have to go before the players themselves.
+        const packs = await EventPackModel.findAll({
+            where: { event_id: eventId },
+            attributes: ['pack_id'],
+            transaction
+        });
+        if (packs.length > 0) {
+            const packIds = packs.map(p => p.pack_id);
+            const choices = await EventPackPlayerModel.findAll({
+                where: { pack_id: packIds },
+                attributes: ['player_id'],
+                transaction
+            });
+            await EventPackPlayerModel.destroy({ where: { pack_id: packIds }, transaction });
+            await EventPackModel.destroy({ where: { event_id: eventId }, transaction });
+            // Choices that were never picked belong to no team, so nothing below would reach them.
+            const looseIds = choices.map(c => c.player_id);
+            if (looseIds.length > 0) {
+                await PlayerTeamModel.destroy({ where: { player_id: looseIds }, transaction });
+                await PlayerModel.destroy({ where: { player_id: looseIds }, transaction });
+            }
+        }
+        // Squads and event lineups go before the teams so no FK from a preset can block the team delete.
+        await EventSquadModel.destroy({ where: { event_id: eventId }, transaction });
+        await LineupPresetModel.destroy({ where: { event_id: eventId }, transaction });
+        if (botTeamIds.length > 0) {
+            const botPlayers = await PlayerTeamModel.findAll({
+                where: { team_id: botTeamIds },
+                attributes: ['player_id'],
+                transaction
+            });
+            const botPlayerIds = botPlayers.map(p => p.player_id);
+            await EventBotTeamModel.destroy({ where: { event_id: eventId }, transaction });
+            await PlayerTeamModel.destroy({ where: { team_id: botTeamIds }, transaction });
+            if (botPlayerIds.length > 0) {
+                await PlayerModel.destroy({ where: { player_id: botPlayerIds }, transaction });
+            }
+            await sequelize.query('DELETE FROM "Tactics" WHERE team_id IN (:ids)', {
+                replacements: { ids: botTeamIds }, type: QueryTypes.DELETE, transaction
+            });
+            await TeamModel.destroy({ where: { team_id: botTeamIds }, transaction });
+        }
+        if (removeEvent) {
+            await EventModel.destroy({ where: { event_id: eventId }, transaction });
+        }
+        else {
+            await EventModel.update({ status: 'ARCHIVED', purged_at: new Date() }, { where: { event_id: eventId }, transaction });
+        }
+    });
+    logger.info(`${removeEvent ? 'Deleted' : 'Purged'} event ${eventId}`);
+}

package/dist/esm/src/data/index.d.ts

@@ -1,4 +1,5 @@
 export * from './models';
 export * from './transformers';
 export * from './common';
+export * from './event-purge';
 export { initModels } from './init-models';

package/dist/esm/src/data/index.js

@@ -1,4 +1,5 @@
 export * from './models';
 export * from './transformers';
 export * from './common';
+export * from './event-purge';
 export { initModels } from './init-models';

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

@@ -1,4 +1,4 @@
-import { AuthIdentityModel, AuthSessionModel, AuthUserModel, BoxScoreModel, CoachModel, ScoutModel, PhysicianModel, PhysiotherapistModel, BoxScoreTotalsModel, CompetitionChampionModel, CurrencyTransactionModel, GachaPityModel, GachaPullHistoryModel, WishlistModel, UserSettingsModel, UserDeviceTokenModel, CompetitionMatchModel, CompetitionMVPModel, CompetitionModel, CompetitionStandingsMatchModel, CompetitionStandingsModel, CompetitionTeamsModel, CountryModel, DivisionModel, DivisionSeasonModel, IterationModel, LeagueModel, MatchModel, MatchRatingModel, MatchResultModel, MatchSetModel, PerformanceStatsModel, PlayerModel, PlayerImprovementLogModel, PlayerDeclineLogModel, PlayerTeamModel, RetiredPlayerModel, PromotionMatchModel, FriendlyModel, RegionQualifierModel, NationalCountryModel, RallyModel, TacticsModel, LineupPresetModel, MatchPresetModel, TeamModel, TeamReplacementModel, UserCurrencyModel, UserPlayerProgressModel, UserPullGrantModel, UserTeamModel, VPERModel, NotificationModel, AppConfigModel, LegacyTeamFlagModel } from './models';
+import { AuthIdentityModel, AuthSessionModel, AuthUserModel, BoxScoreModel, CoachModel, ScoutModel, PhysicianModel, PhysiotherapistModel, BoxScoreTotalsModel, CompetitionChampionModel, CurrencyTransactionModel, GachaPityModel, GachaPullHistoryModel, WishlistModel, UserSettingsModel, UserDeviceTokenModel, CompetitionMatchModel, CompetitionMVPModel, CompetitionModel, CompetitionStandingsMatchModel, CompetitionStandingsModel, CompetitionTeamsModel, CountryModel, DivisionModel, DivisionSeasonModel, IterationModel, LeagueModel, MatchModel, MatchRatingModel, MatchResultModel, MatchSetModel, PerformanceStatsModel, PlayerModel, PlayerImprovementLogModel, PlayerDeclineLogModel, PlayerTeamModel, RetiredPlayerModel, PromotionMatchModel, FriendlyModel, RegionQualifierModel, NationalCountryModel, RallyModel, TacticsModel, LineupPresetModel, MatchPresetModel, EventModel, EventCompetitionModel, EventSquadModel, EventPackModel, EventPackPlayerModel, EventResultModel, EventBotTeamModel, TeamModel, TeamReplacementModel, UserCurrencyModel, UserPlayerProgressModel, UserPullGrantModel, UserTeamModel, VPERModel, NotificationModel, AppConfigModel, LegacyTeamFlagModel } from './models';
 export function initModels(sequelize) {
     const Coach = CoachModel.initModel(sequelize);
     const Scout = ScoutModel.initModel(sequelize);
@@ -8,6 +8,13 @@ export function initModels(sequelize) {
     const Tactics = TacticsModel.initModel(sequelize);
     const LineupPreset = LineupPresetModel.initModel(sequelize);
     const MatchPreset = MatchPresetModel.initModel(sequelize);
+    const Event = EventModel.initModel(sequelize);
+    const EventCompetition = EventCompetitionModel.initModel(sequelize);
+    const EventSquad = EventSquadModel.initModel(sequelize);
+    const EventPack = EventPackModel.initModel(sequelize);
+    const EventPackPlayer = EventPackPlayerModel.initModel(sequelize);
+    const EventResult = EventResultModel.initModel(sequelize);
+    const EventBotTeam = EventBotTeamModel.initModel(sequelize);
     const AuthUser = AuthUserModel.initModel(sequelize);
     const UserCurrency = UserCurrencyModel.initModel(sequelize);
     const UserPlayerProgress = UserPlayerProgressModel.initModel(sequelize);
@@ -226,6 +233,33 @@ export function initModels(sequelize) {
     MatchPreset.belongsTo(Team, { as: 'team', foreignKey: 'team_id' });
     MatchPreset.belongsTo(LineupPreset, { as: 'preset', foreignKey: 'preset_id' });
     LineupPreset.hasMany(MatchPreset, { as: 'MatchPresets', foreignKey: 'preset_id' });
+    // In-game events. An event owns one Competition per group plus one for the final, the entries that registered
+    // for it, the event-scoped lineup presets those entries point at, and the filler bots generated for it.
+    // Nothing here is in a default scope: only the event endpoints and the event scheduler load these.
+    Event.hasMany(EventCompetition, { as: 'EventCompetitions', foreignKey: 'event_id' });
+    EventCompetition.belongsTo(Event, { as: 'Event', foreignKey: 'event_id' });
+    EventCompetition.belongsTo(Competition, { as: 'Competition', foreignKey: 'competition_id' });
+    Competition.hasOne(EventCompetition, { as: 'EventCompetition', foreignKey: 'competition_id' });
+    // The drafted squad an entrant plays with, the packs they opened to build it, and where they finished.
+    Event.hasMany(EventSquad, { as: 'EventSquads', foreignKey: 'event_id' });
+    EventSquad.belongsTo(Event, { as: 'Event', foreignKey: 'event_id' });
+    EventSquad.belongsTo(Team, { as: 'team', foreignKey: 'team_id' });
+    Event.hasMany(EventPack, { as: 'EventPacks', foreignKey: 'event_id' });
+    EventPack.belongsTo(Event, { as: 'Event', foreignKey: 'event_id' });
+    EventPack.belongsTo(Player, { as: 'picked', foreignKey: 'picked_player_id' });
+    EventPack.hasMany(EventPackPlayer, { as: 'choices', foreignKey: 'pack_id' });
+    EventPackPlayer.belongsTo(EventPack, { as: 'pack', foreignKey: 'pack_id' });
+    EventPackPlayer.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
+    // Keyed to the entrant's REAL team, and the only event row besides Event that outlives the purge.
+    Event.hasMany(EventResult, { as: 'EventResults', foreignKey: 'event_id' });
+    EventResult.belongsTo(Event, { as: 'Event', foreignKey: 'event_id' });
+    EventResult.belongsTo(Team, { as: 'team', foreignKey: 'team_id' });
+    Team.hasMany(EventResult, { as: 'EventResults', foreignKey: 'team_id' });
+    LineupPreset.belongsTo(Event, { as: 'Event', foreignKey: 'event_id' });
+    Event.hasMany(EventBotTeam, { as: 'EventBotTeams', foreignKey: 'event_id' });
+    EventBotTeam.belongsTo(Event, { as: 'Event', foreignKey: 'event_id' });
+    EventBotTeam.belongsTo(Team, { as: 'team', foreignKey: 'team_id' });
+    Team.hasOne(EventBotTeam, { as: 'EventBotTeam', foreignKey: 'team_id' });
     Team.belongsTo(Country, { as: 'country', foreignKey: 'country_id' });
     Team.belongsToMany(Competition, {
         as: 'Competitions',
@@ -301,6 +335,13 @@ export function initModels(sequelize) {
         Tactics,
         LineupPreset,
         MatchPreset,
+        Event,
+        EventCompetition,
+        EventSquad,
+        EventPack,
+        EventPackPlayer,
+        EventResult,
+        EventBotTeam,
         UserTeam,
         UserCurrency,
         UserPlayerProgress,

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

@@ -19,7 +19,7 @@ export interface CompetitionAttributes {
     LowerPromotionMatches?: PromotionMatchAttributes[];
 }
 export type CompetitionPk = 'competition_id';
-export type CompetitionType = 'LEAGUE' | 'TOURNAMENT' | 'QUALIFIER' | 'NATIONAL';
+export type CompetitionType = 'LEAGUE' | 'TOURNAMENT' | 'QUALIFIER' | 'NATIONAL' | 'EVENT';
 export type CompetitionId = CompetitionModel[CompetitionPk];
 export type CompetitionCreationAttributes = CompetitionAttributes;
 export declare class CompetitionModel extends Model<CompetitionAttributes, CompetitionCreationAttributes> implements CompetitionAttributes {

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

@@ -18,7 +18,7 @@ export class CompetitionModel extends Model {
                 }
             },
             type: {
-                type: DataTypes.ENUM('LEAGUE', 'TOURNAMENT', 'QUALIFIER', 'NATIONAL'),
+                type: DataTypes.ENUM('LEAGUE', 'TOURNAMENT', 'QUALIFIER', 'NATIONAL', 'EVENT'),
                 allowNull: false
             },
             status: {

package/dist/esm/src/data/models/event-bot-team.d.ts

@@ -0,0 +1,21 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import { EventId, EventModel, TeamId, TeamModel } from '.';
+export interface EventBotTeamAttributes {
+    team_id: string;
+    event_id: string;
+}
+export type EventBotTeamPk = 'team_id';
+export type EventBotTeamId = EventBotTeamModel[EventBotTeamPk];
+export type EventBotTeamCreationAttributes = EventBotTeamAttributes;
+export declare class EventBotTeamModel extends Model<EventBotTeamAttributes, EventBotTeamCreationAttributes> implements EventBotTeamAttributes {
+    team_id: string;
+    event_id: string;
+    team: TeamModel;
+    getTeam: Sequelize.BelongsToGetAssociationMixin<TeamModel>;
+    setTeam: Sequelize.BelongsToSetAssociationMixin<TeamModel, TeamId>;
+    Event: EventModel;
+    getEvent: Sequelize.BelongsToGetAssociationMixin<EventModel>;
+    setEvent: Sequelize.BelongsToSetAssociationMixin<EventModel, EventId>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof EventBotTeamModel;
+}

package/dist/esm/src/data/models/event-bot-team.js

@@ -0,0 +1,40 @@
+import { DataTypes, Model } from 'sequelize';
+export class EventBotTeamModel extends Model {
+    static initModel(sequelize) {
+        return EventBotTeamModel.init({
+            team_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'Team',
+                    key: 'team_id'
+                }
+            },
+            event_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'Event',
+                    key: 'event_id'
+                }
+            }
+        }, {
+            sequelize,
+            tableName: 'EventBotTeam',
+            schema: 'public',
+            timestamps: false,
+            indexes: [
+                {
+                    name: 'EventBotTeam_pk',
+                    unique: true,
+                    fields: [{ name: 'team_id' }]
+                },
+                {
+                    name: 'EventBotTeam_event_id_idx',
+                    fields: [{ name: 'event_id' }]
+                }
+            ]
+        });
+    }
+}

package/dist/esm/src/data/models/event-competition.d.ts

@@ -0,0 +1,29 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import { CompetitionAttributes, CompetitionId, CompetitionModel, EventId, EventModel } from '.';
+/** A group table, or the single Sunday final. */
+export type EventCompetitionStage = 'GROUP' | 'FINAL';
+export interface EventCompetitionAttributes {
+    competition_id: string;
+    event_id: string;
+    stage: EventCompetitionStage;
+    /** 0-based group number for a GROUP row; null for the FINAL. */
+    group_index: number | null;
+    Competition?: CompetitionAttributes;
+}
+export type EventCompetitionPk = 'competition_id';
+export type EventCompetitionId = EventCompetitionModel[EventCompetitionPk];
+export type EventCompetitionCreationAttributes = EventCompetitionAttributes;
+export declare class EventCompetitionModel extends Model<EventCompetitionAttributes, EventCompetitionCreationAttributes> implements EventCompetitionAttributes {
+    competition_id: string;
+    event_id: string;
+    stage: EventCompetitionStage;
+    group_index: number | null;
+    Competition: CompetitionModel;
+    getCompetition: Sequelize.BelongsToGetAssociationMixin<CompetitionModel>;
+    setCompetition: Sequelize.BelongsToSetAssociationMixin<CompetitionModel, CompetitionId>;
+    Event: EventModel;
+    getEvent: Sequelize.BelongsToGetAssociationMixin<EventModel>;
+    setEvent: Sequelize.BelongsToSetAssociationMixin<EventModel, EventId>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof EventCompetitionModel;
+}

package/dist/esm/src/data/models/event-competition.js

@@ -0,0 +1,48 @@
+import { DataTypes, Model } from 'sequelize';
+export class EventCompetitionModel extends Model {
+    static initModel(sequelize) {
+        return EventCompetitionModel.init({
+            competition_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'Competition',
+                    key: 'competition_id'
+                }
+            },
+            event_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'Event',
+                    key: 'event_id'
+                }
+            },
+            stage: {
+                type: DataTypes.TEXT,
+                allowNull: false
+            },
+            group_index: {
+                type: DataTypes.INTEGER,
+                allowNull: true
+            }
+        }, {
+            sequelize,
+            tableName: 'EventCompetition',
+            schema: 'public',
+            timestamps: false,
+            indexes: [
+                {
+                    name: 'EventCompetition_pk',
+                    unique: true,
+                    fields: [{ name: 'competition_id' }]
+                },
+                {
+                    name: 'EventCompetition_event_id_idx',
+                    fields: [{ name: 'event_id' }]
+                }
+            ]
+        });
+    }
+}

package/dist/esm/src/data/models/event-pack-player.d.ts

@@ -0,0 +1,22 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import { EventPackId, EventPackModel, PlayerAttributes, PlayerId, PlayerModel } from '.';
+export interface EventPackPlayerAttributes {
+    pack_id: string;
+    player_id: string;
+    player?: PlayerAttributes;
+}
+export type EventPackPlayerPk = 'pack_id' | 'player_id';
+export type EventPackPlayerId = EventPackPlayerModel[EventPackPlayerPk];
+export type EventPackPlayerCreationAttributes = EventPackPlayerAttributes;
+export declare class EventPackPlayerModel extends Model<EventPackPlayerAttributes, EventPackPlayerCreationAttributes> implements EventPackPlayerAttributes {
+    pack_id: string;
+    player_id: string;
+    pack: EventPackModel;
+    getPack: Sequelize.BelongsToGetAssociationMixin<EventPackModel>;
+    setPack: Sequelize.BelongsToSetAssociationMixin<EventPackModel, EventPackId>;
+    player: PlayerModel;
+    getPlayer: Sequelize.BelongsToGetAssociationMixin<PlayerModel>;
+    setPlayer: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof EventPackPlayerModel;
+}

package/dist/esm/src/data/models/event-pack-player.js

@@ -0,0 +1,27 @@
+import { DataTypes, Model } from 'sequelize';
+export class EventPackPlayerModel extends Model {
+    static initModel(sequelize) {
+        return EventPackPlayerModel.init({
+            pack_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: { model: 'EventPack', key: 'pack_id' }
+            },
+            player_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: { model: 'Player', key: 'player_id' }
+            }
+        }, {
+            sequelize,
+            tableName: 'EventPackPlayer',
+            schema: 'public',
+            timestamps: false,
+            indexes: [
+                { name: 'EventPackPlayer_pk', unique: true, fields: [{ name: 'pack_id' }, { name: 'player_id' }] }
+            ]
+        });
+    }
+}