volleyballsimtypes 0.0.489 → 0.0.492

package/dist/esm/src/service/match/match-generator.js

@@ -2,9 +2,13 @@ import dayjs from 'dayjs';
 import utc from 'dayjs/plugin/utc';
 import { v4 as uuidv4 } from 'uuid';
 import { Match } from './match';
+import { roundRobinRounds } from './round-robin';
 import { shuffle } from '../utils';
 import { StatusEnum } from '../../data';
 dayjs.extend(utc);
+// Consecutive matches in a league season start half an hour apart, so a 16-team double round robin (240 matches)
+// spans five days from the iteration's Monday.
+const MATCH_SPACING_MINUTES = 30;
 // eslint-disable-next-line @typescript-eslint/no-extraneous-class
 export default class MatchGenerator {
     static generateMatches(teams, baseDate) {
@@ -16,57 +20,30 @@ export default class MatchGenerator {
         if (t.size !== teams.length) {
             throw new Error('DUPLICATE_TEAMS');
         }
-        let shuffled = shuffle([...teams]);
-        const l = shuffled.length - 1;
-        const half = Math.ceil(shuffled.length / 2);
-        const matches = [];
-        // We fix the first team
-        let firstTeam = shuffled.shift();
-        if (firstTeam == null) {
+        if (teams.length < 1) {
             throw new Error('EMPTY_TEAM_ARRAY');
         }
-        let homeRow;
-        let awayRow;
-        for (let i = 0; i < l; i++) {
-            // split array in 2 halves
-            const row1 = shuffled.slice(0, half);
-            const row2 = shuffled.slice(half);
-            row2.push(firstTeam);
-            if (i % 2 === 0) {
-                homeRow = row1;
-                awayRow = row2;
-            }
-            else {
-                homeRow = row2;
-                awayRow = row1;
-            }
-            for (let j = 0; j < half; j++) {
-                matches.push(Match.create({
-                    id: uuidv4(),
-                    homeTeam: homeRow[j],
-                    awayTeam: awayRow[j],
-                    scheduledDate: date.toDate(),
-                    status: StatusEnum.PENDING
-                }));
-                date = date.add(30, 'minutes');
-            }
-            firstTeam = row2.pop();
-            row1.unshift(row2.shift());
-            row2.push(row1.pop());
-            shuffled = [...row1, ...row2];
-        }
-        // Generate Inverted matches for home-away pairings
-        matches.push(...matches.map(match => {
+        const nextDate = () => {
             const scheduledDate = date.toDate();
-            date = date.add(30, 'minutes');
-            return Match.create({
-                id: uuidv4(),
-                homeTeam: match.awayTeam,
-                awayTeam: match.homeTeam,
-                scheduledDate,
-                status: StatusEnum.PENDING
-            });
+            date = date.add(MATCH_SPACING_MINUTES, 'minutes');
+            return scheduledDate;
+        };
+        // First leg: one pass of the round robin, matches laid out back to back in round order.
+        const firstLeg = roundRobinRounds(shuffle([...teams])).flat().map(([homeTeam, awayTeam]) => Match.create({
+            id: uuidv4(),
+            homeTeam,
+            awayTeam,
+            scheduledDate: nextDate(),
+            status: StatusEnum.PENDING
+        }));
+        // Second leg: the same fixtures with the sides swapped, so every pairing is played home and away.
+        const secondLeg = firstLeg.map(match => Match.create({
+            id: uuidv4(),
+            homeTeam: match.awayTeam,
+            awayTeam: match.homeTeam,
+            scheduledDate: nextDate(),
+            status: StatusEnum.PENDING
         }));
-        return matches;
+        return [...firstLeg, ...secondLeg];
     }
 }

package/dist/esm/src/service/match/match-generator.test.d.ts

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

package/dist/esm/src/service/match/match-generator.test.js

@@ -0,0 +1,43 @@
+import { describe, it, expect } from '@jest/globals';
+import MatchGenerator from './match-generator';
+import { makeTeam } from '../test-helpers';
+// The league season schedule. These assertions pin the behaviour the rollover depends on, so the shared
+// roundRobinRounds helper (used by events too) cannot silently change how a season is laid out.
+const MONDAY = new Date('2026-07-20T00:00:00.000Z');
+function orderedKey(match) {
+    return `${match.homeTeam.id}>${match.awayTeam.id}`;
+}
+describe('MatchGenerator.generateMatches()', () => {
+    it('plays a full double round robin for a 16-team division', () => {
+        const teams = Array.from({ length: 16 }, () => makeTeam());
+        const matches = MatchGenerator.generateMatches(teams, MONDAY);
+        // 16 teams x 15 opponents, home and away.
+        expect(matches).toHaveLength(240);
+        const seen = new Set(matches.map(orderedKey));
+        expect(seen.size).toBe(240);
+        // Every ordered pairing exists exactly once, so every team hosts and visits every other team.
+        for (const home of teams) {
+            for (const away of teams) {
+                if (home.id === away.id)
+                    continue;
+                expect(seen.has(`${home.id}>${away.id}`)).toBe(true);
+            }
+        }
+    });
+    it('anchors to 00:00 UTC of the base day and spaces matches 30 minutes apart', () => {
+        const teams = Array.from({ length: 16 }, () => makeTeam());
+        const matches = MatchGenerator.generateMatches(teams, new Date('2026-07-20T17:42:11.000Z'));
+        const times = matches.map(m => m.scheduledDate.getTime()).sort((a, b) => a - b);
+        expect(new Date(times[0]).toISOString()).toBe('2026-07-20T00:00:00.000Z');
+        for (let i = 1; i < times.length; i++) {
+            expect(times[i] - times[i - 1]).toBe(30 * 60 * 1000);
+        }
+        // 240 matches at half-hour spacing = five days, ending Friday 23:30 UTC.
+        expect(new Date(times[times.length - 1]).toISOString()).toBe('2026-07-24T23:30:00.000Z');
+    });
+    it('rejects a duplicated team and an empty division', () => {
+        const team = makeTeam();
+        expect(() => MatchGenerator.generateMatches([team, team], MONDAY)).toThrow('DUPLICATE_TEAMS');
+        expect(() => MatchGenerator.generateMatches([], MONDAY)).toThrow('EMPTY_TEAM_ARRAY');
+    });
+});

package/dist/esm/src/service/match/round-robin.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Circle-method single round robin. Returns one entry per round, each holding the pairings that round plays,
+ * as `[home, away]` tuples. Every unordered pair of entrants appears exactly once across all rounds.
+ *
+ * An ODD entrant count produces a bye: one entrant sits out each round, so a round has `floor(n / 2)` pairings
+ * instead of `n / 2`. Callers that need everyone playing every round must pad to an even count first.
+ *
+ * Home and away alternate by round and by court index, so no entrant ends up at home in all of its games. For a
+ * double round robin the caller replays the same rounds with the sides swapped, which balances them exactly.
+ */
+export declare function roundRobinRounds<T>(entrants: T[]): Array<Array<[T, T]>>;

package/dist/esm/src/service/match/round-robin.js

@@ -0,0 +1,41 @@
+// A bye slot, used to keep the circle even when an odd number of entrants is passed. Pairings that involve it
+// are dropped, so that entrant sits the round out. Module-level so the type is nameable inside the function.
+const BYE = Symbol('ROUND_ROBIN_BYE');
+/**
+ * Circle-method single round robin. Returns one entry per round, each holding the pairings that round plays,
+ * as `[home, away]` tuples. Every unordered pair of entrants appears exactly once across all rounds.
+ *
+ * An ODD entrant count produces a bye: one entrant sits out each round, so a round has `floor(n / 2)` pairings
+ * instead of `n / 2`. Callers that need everyone playing every round must pad to an even count first.
+ *
+ * Home and away alternate by round and by court index, so no entrant ends up at home in all of its games. For a
+ * double round robin the caller replays the same rounds with the sides swapped, which balances them exactly.
+ */
+export function roundRobinRounds(entrants) {
+    if (entrants.length < 2)
+        return [];
+    const wheel = entrants.length % 2 === 0 ? [...entrants] : [...entrants, BYE];
+    const size = wheel.length;
+    const half = size / 2;
+    const rounds = [];
+    // Index 0 stays put while the rest rotate one place per round; pairing i against size-1-i then yields every
+    // pair exactly once over size-1 rounds.
+    let circle = wheel;
+    for (let round = 0; round < size - 1; round++) {
+        const pairings = [];
+        for (let court = 0; court < half; court++) {
+            const a = circle[court];
+            const b = circle[size - 1 - court];
+            if (a === BYE || b === BYE)
+                continue;
+            // Flip the whole column every other round. A rotating entrant advances one place per round, so it spends
+            // consecutive rounds on the same side of the circle and this parity alternates its home/away within them.
+            // Folding the court index into the parity instead would keep it CONSTANT for that entrant (its index and
+            // the round number rise together), pinning some entrants to one side for the entire event.
+            pairings.push(round % 2 === 0 ? [a, b] : [b, a]);
+        }
+        rounds.push(pairings);
+        circle = [circle[0], circle[size - 1], ...circle.slice(1, size - 1)];
+    }
+    return rounds;
+}

package/dist/esm/src/service/match/round-robin.test.d.ts

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

package/dist/esm/src/service/match/round-robin.test.js

@@ -0,0 +1,69 @@
+import { roundRobinRounds } from './round-robin';
+function key(a, b) {
+    return a < b ? `${a}:${b}` : `${b}:${a}`;
+}
+function entrants(n) {
+    return Array.from({ length: n }, (_, i) => `t${i}`);
+}
+describe('roundRobinRounds()', () => {
+    it('returns nothing for fewer than two entrants', () => {
+        expect(roundRobinRounds([])).toEqual([]);
+        expect(roundRobinRounds(['solo'])).toEqual([]);
+    });
+    it.each([2, 4, 6, 8, 16, 20, 50])('pairs every even field of %i exactly once', (n) => {
+        const rounds = roundRobinRounds(entrants(n));
+        expect(rounds).toHaveLength(n - 1);
+        rounds.forEach(round => expect(round).toHaveLength(n / 2));
+        const seen = new Set();
+        for (const round of rounds) {
+            // Nobody plays twice in the same round.
+            const playing = new Set();
+            for (const [home, away] of round) {
+                expect(home).not.toEqual(away);
+                expect(playing.has(home)).toBe(false);
+                expect(playing.has(away)).toBe(false);
+                playing.add(home);
+                playing.add(away);
+                const k = key(home, away);
+                expect(seen.has(k)).toBe(false);
+                seen.add(k);
+            }
+            expect(playing.size).toBe(n);
+        }
+        expect(seen.size).toBe((n * (n - 1)) / 2);
+    });
+    it.each([3, 5, 7, 15])('gives an odd field of %i one bye per round and still pairs everyone once', (n) => {
+        const rounds = roundRobinRounds(entrants(n));
+        // An odd field runs the even-sized circle it was padded into: n rounds, one entrant idle in each.
+        expect(rounds).toHaveLength(n);
+        rounds.forEach(round => expect(round).toHaveLength((n - 1) / 2));
+        const seen = new Set();
+        const byes = new Map();
+        for (const round of rounds) {
+            const playing = new Set();
+            for (const [home, away] of round) {
+                seen.add(key(home, away));
+                playing.add(home);
+                playing.add(away);
+            }
+            const idle = entrants(n).filter(t => !playing.has(t));
+            expect(idle).toHaveLength(1);
+            byes.set(idle[0], (byes.get(idle[0]) ?? 0) + 1);
+        }
+        expect(seen.size).toBe((n * (n - 1)) / 2);
+        // Exactly one bye each: nobody sits out twice while another entrant never rests.
+        expect([...byes.values()]).toEqual(Array.from({ length: n }, () => 1));
+    });
+    it.each([8, 16, 20, 50])('splits home and away near evenly across a field of %i', (n) => {
+        const homeCounts = new Map();
+        for (const round of roundRobinRounds(entrants(n))) {
+            for (const [home] of round)
+                homeCounts.set(home, (homeCounts.get(home) ?? 0) + 1);
+        }
+        // n-1 games each, so half of them is the ideal. Folding the court index into the side parity used to pin
+        // some entrants to a single side for the whole event; this guards that regression.
+        for (const t of entrants(n)) {
+            expect(Math.abs((homeCounts.get(t) ?? 0) - (n - 1) / 2)).toBeLessThanOrEqual(2);
+        }
+    });
+});

package/dist/esm/src/service/notification/catalog/en.json

@@ -37,5 +37,26 @@
     "generic": {
         "title": "World Aces",
         "body": "You have a new notification."
+    },
+    "eventRegistrationOpen": {
+        "title": "Event registration open",
+        "body": "A new event is open. Draft your squad from the packs before registration closes."
+    },
+    "eventRegistrationClosing": {
+        "title": "Registration closes soon",
+        "body": "Registration for the event closes in an hour. Draft your squad to take part."
+    },
+    "eventStarted": {
+        "title": "Event started",
+        "body": "Your event matches have begun. Good luck!"
+    },
+    "eventFinalRound": {
+        "title": "You reached the final",
+        "body": "You qualified for the final round. It starts now."
+    },
+    "eventFinished": {
+        "title": "Event finished",
+        "body": "The event is over. See the final table and your rewards.",
+        "placed": "The event is over. You finished {{position}} of {{entrants}}."
     }
 }

package/dist/esm/src/service/notification/catalog/es.json

@@ -37,5 +37,26 @@
     "generic": {
         "title": "World Aces",
         "body": "Tienes una nueva notificación."
+    },
+    "eventRegistrationOpen": {
+        "title": "Inscripciones abiertas",
+        "body": "Hay un nuevo evento abierto. Arma tu plantilla con los sobres antes de que cierren las inscripciones."
+    },
+    "eventRegistrationClosing": {
+        "title": "Las inscripciones cierran pronto",
+        "body": "Las inscripciones del evento cierran en una hora. Arma tu plantilla para participar."
+    },
+    "eventStarted": {
+        "title": "El evento ha empezado",
+        "body": "Tus partidos del evento han comenzado. ¡Suerte!"
+    },
+    "eventFinalRound": {
+        "title": "Has llegado a la final",
+        "body": "Te has clasificado para la ronda final. Empieza ahora."
+    },
+    "eventFinished": {
+        "title": "Evento terminado",
+        "body": "El evento ha terminado. Mira la tabla final y tus recompensas.",
+        "placed": "El evento ha terminado. Has quedado {{position}} de {{entrants}}."
     }
 }

package/dist/esm/src/service/notification/catalog/fr.json

@@ -37,5 +37,26 @@
     "generic": {
         "title": "World Aces",
         "body": "Vous avez une nouvelle notification."
+    },
+    "eventRegistrationOpen": {
+        "title": "Inscriptions ouvertes",
+        "body": "Un nouvel événement est ouvert. Compose ton effectif avec les packs avant la clôture des inscriptions."
+    },
+    "eventRegistrationClosing": {
+        "title": "Les inscriptions ferment bientôt",
+        "body": "Les inscriptions à l'événement ferment dans une heure. Compose ton effectif pour participer."
+    },
+    "eventStarted": {
+        "title": "L'événement a commencé",
+        "body": "Tes matchs ont commencé. Bonne chance !"
+    },
+    "eventFinalRound": {
+        "title": "Tu es en finale",
+        "body": "Tu es qualifié pour la finale. Elle commence maintenant."
+    },
+    "eventFinished": {
+        "title": "Événement terminé",
+        "body": "L'événement est terminé. Consulte le classement final et tes récompenses.",
+        "placed": "L'événement est terminé. Tu finis {{position}} sur {{entrants}}."
     }
 }

package/dist/esm/src/service/notification/catalog/it.json

@@ -37,5 +37,26 @@
     "generic": {
         "title": "World Aces",
         "body": "Hai una nuova notifica."
+    },
+    "eventRegistrationOpen": {
+        "title": "Iscrizioni aperte",
+        "body": "Un nuovo evento è aperto. Costruisci la rosa dai pacchetti prima che chiudano le iscrizioni."
+    },
+    "eventRegistrationClosing": {
+        "title": "Le iscrizioni stanno per chiudere",
+        "body": "Le iscrizioni all'evento chiudono tra un'ora. Costruisci la rosa per partecipare."
+    },
+    "eventStarted": {
+        "title": "L'evento è iniziato",
+        "body": "Le tue partite sono iniziate. In bocca al lupo!"
+    },
+    "eventFinalRound": {
+        "title": "Sei in finale",
+        "body": "Ti sei qualificato per la finale. Inizia ora."
+    },
+    "eventFinished": {
+        "title": "Evento concluso",
+        "body": "L'evento è finito. Guarda la classifica finale e i tuoi premi.",
+        "placed": "L'evento è finito. Hai chiuso {{position}} su {{entrants}}."
     }
 }

package/dist/esm/src/service/notification/catalog/pl.json

@@ -37,5 +37,26 @@
     "generic": {
         "title": "World Aces",
         "body": "Masz nowe powiadomienie."
+    },
+    "eventRegistrationOpen": {
+        "title": "Zapisy otwarte",
+        "body": "Nowe wydarzenie jest otwarte. Zbuduj skład z paczek, zanim zamkną się zapisy."
+    },
+    "eventRegistrationClosing": {
+        "title": "Zapisy wkrótce się zamkną",
+        "body": "Zapisy na wydarzenie zamykają się za godzinę. Zbuduj skład, aby wziąć udział."
+    },
+    "eventStarted": {
+        "title": "Wydarzenie ruszyło",
+        "body": "Twoje mecze się rozpoczęły. Powodzenia!"
+    },
+    "eventFinalRound": {
+        "title": "Jesteś w finale",
+        "body": "Awansowałeś do rundy finałowej. Zaczyna się teraz."
+    },
+    "eventFinished": {
+        "title": "Wydarzenie zakończone",
+        "body": "Wydarzenie się skończyło. Zobacz tabelę końcową i nagrody.",
+        "placed": "Wydarzenie się skończyło. Zająłeś {{position}} miejsce na {{entrants}}."
     }
 }

package/dist/esm/src/service/notification/catalog/pt-BR.json

@@ -37,5 +37,26 @@
     "generic": {
         "title": "World Aces",
         "body": "Você tem uma nova notificação."
+    },
+    "eventRegistrationOpen": {
+        "title": "Inscrições abertas",
+        "body": "Um novo evento está aberto. Monte seu elenco com os pacotes antes das inscrições fecharem."
+    },
+    "eventRegistrationClosing": {
+        "title": "As inscrições fecham em breve",
+        "body": "As inscrições do evento fecham em uma hora. Monte seu elenco para participar."
+    },
+    "eventStarted": {
+        "title": "O evento começou",
+        "body": "Suas partidas do evento começaram. Boa sorte!"
+    },
+    "eventFinalRound": {
+        "title": "Você chegou à final",
+        "body": "Você se classificou para a rodada final. Começa agora."
+    },
+    "eventFinished": {
+        "title": "Evento encerrado",
+        "body": "O evento acabou. Veja a tabela final e suas recompensas.",
+        "placed": "O evento acabou. Você terminou em {{position}} de {{entrants}}."
     }
 }

package/dist/esm/src/service/notification/catalog/tr.json

@@ -37,5 +37,26 @@
     "generic": {
         "title": "World Aces",
         "body": "Yeni bir bildirimin var."
+    },
+    "eventRegistrationOpen": {
+        "title": "Kayıtlar açıldı",
+        "body": "Yeni bir etkinlik açıldı. Kayıtlar kapanmadan paketlerden kadronu kur."
+    },
+    "eventRegistrationClosing": {
+        "title": "Kayıtlar birazdan kapanıyor",
+        "body": "Etkinlik kayıtları bir saat içinde kapanıyor. Katılmak için kadronu kur."
+    },
+    "eventStarted": {
+        "title": "Etkinlik başladı",
+        "body": "Etkinlik maçların başladı. Bol şans!"
+    },
+    "eventFinalRound": {
+        "title": "Finale kaldın",
+        "body": "Final turuna kaldın. Şimdi başlıyor."
+    },
+    "eventFinished": {
+        "title": "Etkinlik bitti",
+        "body": "Etkinlik sona erdi. Final tablosuna ve ödüllerine bak.",
+        "placed": "Etkinlik sona erdi. {{entrants}} takım arasında {{position}}. oldun."
     }
 }

package/dist/esm/src/service/notification/notification-type.d.ts

@@ -1,4 +1,4 @@
-export declare const NOTIFICATION_TYPES: readonly ["MATCH_RESULT", "INJURY", "INJURY_RECOVERED", "SEASON_END", "GRANT_RECEIVED", "PROMOTION", "DAILY_LOGIN", "WELCOME", "COMPENSATION"];
+export declare const NOTIFICATION_TYPES: readonly ["MATCH_RESULT", "INJURY", "INJURY_RECOVERED", "SEASON_END", "GRANT_RECEIVED", "PROMOTION", "DAILY_LOGIN", "WELCOME", "COMPENSATION", "EVENT_REGISTRATION_OPEN", "EVENT_REGISTRATION_CLOSING", "EVENT_STARTED", "EVENT_FINAL_ROUND", "EVENT_FINISHED"];
 export type NotificationType = typeof NOTIFICATION_TYPES[number];
 export declare const NOTIFICATION_LOCALES: readonly ["en", "es", "fr", "it", "pl", "pt-BR", "tr"];
 export type NotificationLocale = typeof NOTIFICATION_LOCALES[number];

package/dist/esm/src/service/notification/notification-type.js

@@ -11,7 +11,12 @@ export const NOTIFICATION_TYPES = [
     'PROMOTION',
     'DAILY_LOGIN',
     'WELCOME',
-    'COMPENSATION'
+    'COMPENSATION',
+    'EVENT_REGISTRATION_OPEN',
+    'EVENT_REGISTRATION_CLOSING',
+    'EVENT_STARTED',
+    'EVENT_FINAL_ROUND',
+    'EVENT_FINISHED'
 ];
 // The 7 supported locales. Must stay in sync with the API VALID_LOCALES set and the UI src/locales/*.json.
 export const NOTIFICATION_LOCALES = ['en', 'es', 'fr', 'it', 'pl', 'pt-BR', 'tr'];

package/dist/esm/src/service/notification/notification.test.js

@@ -130,7 +130,9 @@ describe('push preferences (PUSH_NOTIFICATION_TYPES + pushEnabledFor)', () => {
             .toEqual(NOTIFICATION_TYPES.filter((t) => NOTIFICATION_REGISTRY[t].emitsPush).sort((a, b) => a.localeCompare(b)));
         expect(PUSH_NOTIFICATION_TYPES).not.toContain('COMPENSATION');
         expect(PUSH_NOTIFICATION_TYPES).toContain('MATCH_RESULT');
-        expect(PUSH_NOTIFICATION_TYPES).toHaveLength(8);
+        // COMPENSATION is the ONLY in-app-only type, so every other type pushes. Expressed as a relationship
+        // rather than a count, so adding a type does not need this number edited.
+        expect(PUSH_NOTIFICATION_TYPES).toHaveLength(NOTIFICATION_TYPES.length - 1);
     });
     it('is opt-out: absent / null / empty / true all enable, only explicit false suppresses', () => {
         expect(pushEnabledFor(undefined, 'MATCH_RESULT')).toBe(true);

package/dist/esm/src/service/notification/registry.js

@@ -85,6 +85,58 @@ export const NOTIFICATION_REGISTRY = {
         inAppMessageKey: 'promotion.body',
         catalogKeys: ['promotion.title', 'promotion.body']
     },
+    // In-game events. All five deep-link to the Events section, which is where every phase of an event lives.
+    // eventName is the event's key; the UI resolves it to the translated name, so the catalog copy interpolates
+    // a key rather than a localised string the sender would have to translate.
+    EVENT_REGISTRATION_OPEN: {
+        emitsPush: true,
+        deepLink: () => '/events',
+        pushTitleKey: 'eventRegistrationOpen.title',
+        pushBodyKey: 'eventRegistrationOpen.body',
+        inAppMessageKey: 'eventRegistrationOpen.body',
+        catalogKeys: ['eventRegistrationOpen.title', 'eventRegistrationOpen.body']
+    },
+    EVENT_REGISTRATION_CLOSING: {
+        emitsPush: true,
+        deepLink: () => '/events',
+        pushTitleKey: 'eventRegistrationClosing.title',
+        pushBodyKey: 'eventRegistrationClosing.body',
+        inAppMessageKey: 'eventRegistrationClosing.body',
+        catalogKeys: ['eventRegistrationClosing.title', 'eventRegistrationClosing.body']
+    },
+    EVENT_STARTED: {
+        emitsPush: true,
+        deepLink: () => '/events',
+        pushTitleKey: 'eventStarted.title',
+        pushBodyKey: 'eventStarted.body',
+        inAppMessageKey: 'eventStarted.body',
+        catalogKeys: ['eventStarted.title', 'eventStarted.body']
+    },
+    EVENT_FINAL_ROUND: {
+        emitsPush: true,
+        deepLink: () => '/events',
+        pushTitleKey: 'eventFinalRound.title',
+        pushBodyKey: 'eventFinalRound.body',
+        inAppMessageKey: 'eventFinalRound.body',
+        catalogKeys: ['eventFinalRound.title', 'eventFinalRound.body']
+    },
+    EVENT_FINISHED: {
+        emitsPush: true,
+        deepLink: () => '/events',
+        pushTitleKey: 'eventFinished.title',
+        // Copy depends on whether we know where they finished; a missing position never renders "You finished th".
+        pushBodyKey: (p) => readString(p.position) != null || typeof p.position === 'number'
+            ? 'eventFinished.placed'
+            : 'eventFinished.body',
+        inAppMessageKey: (p) => readString(p.position) != null || typeof p.position === 'number'
+            ? 'eventFinished.placed'
+            : 'eventFinished.body',
+        params: (p) => ({
+            position: typeof p.position === 'number' ? String(p.position) : (readString(p.position) ?? ''),
+            entrants: typeof p.entrants === 'number' ? String(p.entrants) : (readString(p.entrants) ?? '')
+        }),
+        catalogKeys: ['eventFinished.title', 'eventFinished.body', 'eventFinished.placed']
+    },
     DAILY_LOGIN: {
         emitsPush: true,
         // Fires when the reward becomes claimable (00:00 UTC), so it opens the daily-login claim view.

package/dist/esm/src/service/player/player-generator.d.ts

@@ -35,6 +35,7 @@ export interface GachaPullConfig {
 }
 export declare const NORMAL_PULL_CONFIG: GachaPullConfig;
 export declare const QUALIFIER_PULL_CONFIG: GachaPullConfig;
+export declare const EVENT_PULL_CONFIG: GachaPullConfig;
 export declare const TOURNAMENT_PULL_CONFIG: GachaPullConfig;
 export declare function scoutPullConfig(level: string): GachaPullConfig;
 export declare function rollRarity(pity: PityState, config?: GachaPullConfig): RollResult;

package/dist/esm/src/service/player/player-generator.js

@@ -63,6 +63,21 @@ export const QUALIFIER_PULL_CONFIG = {
     accumulateMythicPity: true,
     accumulateSpecialPity: true
 };
+// Event Pack (x5): the NATIONAL pool and structure, with TRIPLE the legendary and mythic chance. Special is
+// untouched and rare absorbs the difference, so it still sums to 1. Builds all three pities, like NATIONAL.
+// Owner-defined 2026-07-23.
+export const EVENT_PULL_CONFIG = {
+    special: 0.003,
+    mythic: 0.03,
+    legendary: 0.30,
+    rare: 0.667,
+    applyLegendaryPity: true,
+    applyMythicPity: true,
+    applySpecialPity: true,
+    accumulateLegendaryPity: true,
+    accumulateMythicPity: true,
+    accumulateSpecialPity: true
+};
 // Tournament gacha (x5 per match): LEGENDARY–SPECIAL, no legendary pity (floor is legendary)
 export const TOURNAMENT_PULL_CONFIG = {
     special: 0.01,

package/dist/esm/src/service/team/blocking-preference.d.ts

@@ -1,5 +1,7 @@
 import { LineupFunction } from './lineup-function';
+export declare const NO_BLOCK: "NO_BLOCK";
+export type BlockingAssignment = LineupFunction | typeof NO_BLOCK;
 export interface BlockingPreference {
     readonly rotation: number;
-    readonly targets: Record<string, LineupFunction>;
+    readonly targets: Record<string, BlockingAssignment>;
 }

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

@@ -1 +1,6 @@
-export {};
+// 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.
+export const NO_BLOCK = 'NO_BLOCK';

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

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { Player, RoleEnum } from '../../player';
+import { NO_BLOCK } from '../blocking-preference';
 import { EnergyBand } from '../energy-band';
 import { RotationSystemEnum, setterCountFor } from '../rotation-system';
 import { DesignatedSubSchema, SubBandSchema } from './designated-sub.z';
@@ -56,8 +57,12 @@ const offensivePreferenceSchema = z.object({
     weights: z.record(z.string(), z.number().int().min(0)),
     tempos: z.record(z.string(), tempoPreferenceSchema).optional()
 });
-// The opposing attacking functions a dedicated blocker can commit to: every RoleEnum except the libero.
-const blockingFunctionSchema = z.nativeEnum(RoleEnum).refine((v) => v !== 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 = z.union([
+    z.nativeEnum(RoleEnum).refine((v) => v !== RoleEnum.LIBERO, { message: 'BLOCKING_TARGET_CANNOT_BE_LIBERO' }),
+    z.literal(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 = z.object({