volleyballsimtypes 0.0.478 → 0.0.480

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

@@ -0,0 +1,6 @@
+export declare const NOTIFICATION_TYPES: readonly ["MATCH_RESULT", "INJURY", "INJURY_RECOVERED", "SEASON_END", "GRANT_RECEIVED", "PROMOTION", "DAILY_LOGIN", "WELCOME", "COMPENSATION"];
+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];
+export declare const DEFAULT_NOTIFICATION_LOCALE: NotificationLocale;
+export declare function normalizeNotificationLocale(locale: string | null | undefined): NotificationLocale;

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

@@ -0,0 +1,30 @@
+"use strict";
+// Single source of truth for the set of notification types and the locales the catalog ships.
+// Adding a notification type: add it here, add a NOTIFICATION_REGISTRY entry, and add its catalog
+// strings to every locale file. The completeness test (notification.test.ts) fails the build if any
+// of those three is missing. See README.md in this folder.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_NOTIFICATION_LOCALE = exports.NOTIFICATION_LOCALES = exports.NOTIFICATION_TYPES = void 0;
+exports.normalizeNotificationLocale = normalizeNotificationLocale;
+exports.NOTIFICATION_TYPES = [
+    'MATCH_RESULT',
+    'INJURY',
+    'INJURY_RECOVERED',
+    'SEASON_END',
+    'GRANT_RECEIVED',
+    'PROMOTION',
+    'DAILY_LOGIN',
+    'WELCOME',
+    'COMPENSATION'
+];
+// The 7 supported locales. Must stay in sync with the API VALID_LOCALES set and the UI src/locales/*.json.
+exports.NOTIFICATION_LOCALES = ['en', 'es', 'fr', 'it', 'pl', 'pt-BR', 'tr'];
+exports.DEFAULT_NOTIFICATION_LOCALE = 'en';
+// Coalesce an arbitrary/untrusted locale string (e.g. UserSettings.locale, which is nullable) to a
+// supported locale, defaulting to English. Push senders MUST call this before renderPush.
+function normalizeNotificationLocale(locale) {
+    if (locale != null && exports.NOTIFICATION_LOCALES.includes(locale)) {
+        return locale;
+    }
+    return exports.DEFAULT_NOTIFICATION_LOCALE;
+}

package/dist/cjs/src/service/notification/notification.test.d.ts

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

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

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+const notification_type_1 = require("./notification-type");
+const registry_1 = require("./registry");
+const catalog_1 = require("./catalog");
+const render_1 = require("./render");
+function readNested(node, dotKey) {
+    let current = node;
+    for (const part of dotKey.split('.')) {
+        if (typeof current !== 'object' || current == null)
+            return undefined;
+        current = current[part];
+    }
+    return typeof current === 'string' ? current : undefined;
+}
+function placeholders(value) {
+    return (value.match(/\{\{(\w+)\}\}/g) ?? []).sort((a, b) => a.localeCompare(b));
+}
+function flattenStrings(node, prefix = '') {
+    const out = [];
+    if (typeof node !== 'object' || node == null)
+        return out;
+    for (const [key, value] of Object.entries(node)) {
+        if (typeof value === 'string')
+            out.push([prefix + key, value]);
+        else if (typeof value === 'object' && value != null)
+            out.push(...flattenStrings(value, `${prefix}${key}.`));
+    }
+    return out;
+}
+(0, globals_1.describe)('notification registry + catalog completeness', () => {
+    (0, globals_1.it)('has exactly one descriptor per declared type', () => {
+        (0, globals_1.expect)(Object.keys(registry_1.NOTIFICATION_REGISTRY).sort((a, b) => a.localeCompare(b)))
+            .toEqual([...notification_type_1.NOTIFICATION_TYPES].sort((a, b) => a.localeCompare(b)));
+    });
+    (0, globals_1.it)('resolves every descriptor catalog key to a non-empty string in all 7 locales', () => {
+        for (const type of notification_type_1.NOTIFICATION_TYPES) {
+            for (const key of registry_1.NOTIFICATION_REGISTRY[type].catalogKeys) {
+                for (const locale of notification_type_1.NOTIFICATION_LOCALES) {
+                    const value = readNested(catalog_1.NOTIFICATION_CATALOG[locale], key);
+                    (0, globals_1.expect)([locale, key, (value ?? '').length > 0]).toEqual([locale, key, true]);
+                }
+            }
+        }
+    });
+    (0, globals_1.it)('ships an identical key set across all 7 locales (no drift)', () => {
+        const enKeys = flattenStrings(catalog_1.NOTIFICATION_CATALOG.en).map(([key]) => key).sort((a, b) => a.localeCompare(b));
+        for (const locale of notification_type_1.NOTIFICATION_LOCALES) {
+            const keys = flattenStrings(catalog_1.NOTIFICATION_CATALOG[locale]).map(([key]) => key).sort((a, b) => a.localeCompare(b));
+            (0, globals_1.expect)([locale, keys]).toEqual([locale, enKeys]);
+        }
+    });
+    (0, globals_1.it)('keeps placeholders identical across locales', () => {
+        for (const [key, enValue] of flattenStrings(catalog_1.NOTIFICATION_CATALOG.en)) {
+            const expected = placeholders(enValue);
+            for (const locale of notification_type_1.NOTIFICATION_LOCALES) {
+                const value = readNested(catalog_1.NOTIFICATION_CATALOG[locale], key);
+                if (value == null)
+                    continue;
+                (0, globals_1.expect)([locale, key, placeholders(value)]).toEqual([locale, key, expected]);
+            }
+        }
+    });
+    (0, globals_1.it)('contains no em or en dashes', () => {
+        for (const locale of notification_type_1.NOTIFICATION_LOCALES) {
+            for (const [key, value] of flattenStrings(catalog_1.NOTIFICATION_CATALOG[locale])) {
+                (0, globals_1.expect)([locale, key, value.includes('—') || value.includes('–')]).toEqual([locale, key, false]);
+            }
+        }
+    });
+});
+(0, globals_1.describe)('renderPush', () => {
+    (0, globals_1.it)('renders a localized MATCH_RESULT win with a named opponent', () => {
+        const payload = { matchId: 'm1', result: 'WIN', side: 'HOME', awayTeam: { name: 'Rivals' } };
+        const en = (0, render_1.renderPush)('MATCH_RESULT', payload, 'en');
+        (0, globals_1.expect)(en?.title).toBe('Match result');
+        (0, globals_1.expect)(en?.body).toBe('You won against Rivals');
+        (0, globals_1.expect)(en?.data.path).toBe('/match/m1');
+        (0, globals_1.expect)((0, render_1.renderPush)('MATCH_RESULT', payload, 'es')?.body).toBe('Ganaste contra Rivals');
+    });
+    (0, globals_1.it)('uses the unnamed variant and root path when the opponent is unknown', () => {
+        const en = (0, render_1.renderPush)('MATCH_RESULT', { result: 'LOSS' }, 'en');
+        (0, globals_1.expect)(en?.body).toBe('You lost your match');
+        (0, globals_1.expect)(en?.data.path).toBe('/');
+    });
+    (0, globals_1.it)('interpolates the injured player name and links to the infirmary', () => {
+        const en = (0, render_1.renderPush)('INJURY', { playerNickname: 'Ace', teamId: 't1' }, 'en');
+        (0, globals_1.expect)(en?.title).toBe('Player injured');
+        (0, globals_1.expect)(en?.body).toContain('Ace');
+        (0, globals_1.expect)(en?.data.path).toBe('/infirmary');
+    });
+    (0, globals_1.it)('uses a generic subject when the injury payload has no player name', () => {
+        const en = (0, render_1.renderPush)('INJURY', { teamId: 't1' }, 'en');
+        (0, globals_1.expect)(en?.body.startsWith('A player')).toBe(true);
+    });
+    (0, globals_1.it)('returns undefined for in-app-only types (COMPENSATION)', () => {
+        (0, globals_1.expect)((0, render_1.renderPush)('COMPENSATION', { currency: 100 }, 'en')).toBeUndefined();
+    });
+    (0, globals_1.it)('falls back to generic copy and root path for an unknown type', () => {
+        const en = (0, render_1.renderPush)('SOMETHING_NEW', {}, 'en');
+        (0, globals_1.expect)(en?.title).toBe('World Aces');
+        (0, globals_1.expect)(en?.body).toBe('You have a new notification.');
+        (0, globals_1.expect)(en?.data.path).toBe('/');
+    });
+    (0, globals_1.it)('serializes the payload into the FCM data block', () => {
+        const en = (0, render_1.renderPush)('GRANT_RECEIVED', { pullType: 'MYTHIC' }, 'en');
+        (0, globals_1.expect)(en?.data.type).toBe('GRANT_RECEIVED');
+        (0, globals_1.expect)(JSON.parse(en?.data.payload ?? '{}')).toEqual({ pullType: 'MYTHIC' });
+    });
+});
+(0, globals_1.describe)('translateNotification + interpolate + notificationPath', () => {
+    (0, globals_1.it)('falls back to English then to the raw key', () => {
+        (0, globals_1.expect)((0, render_1.translateNotification)('fr', 'promotion.title')).toBe('Promotion');
+        (0, globals_1.expect)((0, render_1.translateNotification)('en', 'does.not.exist')).toBe('does.not.exist');
+    });
+    (0, globals_1.it)('replaces placeholders and drops unknown ones', () => {
+        (0, globals_1.expect)((0, render_1.interpolate)('Hi {{name}}!', { name: 'X' })).toBe('Hi X!');
+        (0, globals_1.expect)((0, render_1.interpolate)('Hi {{name}}!', {})).toBe('Hi !');
+    });
+    (0, globals_1.it)('derives the deep-link path per type', () => {
+        (0, globals_1.expect)((0, render_1.notificationPath)('SEASON_END', { leagueId: 'l1' })).toBe('/league/l1');
+        (0, globals_1.expect)((0, render_1.notificationPath)('SEASON_END', {})).toBe('/league');
+        (0, globals_1.expect)((0, render_1.notificationPath)('PROMOTION', { teamId: 't1' })).toBe('/team/t1');
+        (0, globals_1.expect)((0, render_1.notificationPath)('GRANT_RECEIVED', {})).toBe('/recruit');
+        (0, globals_1.expect)((0, render_1.notificationPath)('COMPENSATION', {})).toBe('/');
+    });
+});

package/dist/cjs/src/service/notification/payloads.d.ts

@@ -0,0 +1,34 @@
+export interface MatchResultTeam {
+    id?: string;
+    name?: string;
+}
+export interface MatchResultPayload {
+    matchId?: string;
+    homeTeam?: MatchResultTeam;
+    awayTeam?: MatchResultTeam;
+    result?: 'WIN' | 'LOSS';
+    side?: 'HOME' | 'AWAY';
+}
+export interface InjuryPayload {
+    playerId?: string;
+    playerName?: string;
+    playerNickname?: string;
+    teamId?: string;
+    matchId?: string;
+}
+export interface InjuryRecoveredPayload {
+    playerId?: string;
+    playerName?: string;
+    playerNickname?: string;
+    teamId?: string;
+}
+export interface SeasonEndPayload {
+    competitionId?: string;
+    leagueId?: string;
+    position?: number;
+}
+export interface PromotionPayload {
+    teamId?: string;
+    amount?: number;
+}
+export type NotificationPayload = MatchResultPayload | InjuryPayload | InjuryRecoveredPayload | SeasonEndPayload | PromotionPayload | Record<string, unknown>;

package/dist/cjs/src/service/notification/payloads.js

@@ -0,0 +1,5 @@
+"use strict";
+// Typed payload shapes per notification type, for call-site safety in the Sim/API. The DB `Notification.payload`
+// column is jsonb (free-form), so the registry reads payloads defensively (Record<string, unknown>); these
+// interfaces document the intended shape and can be used by emitters when constructing the payload.
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/src/service/notification/registry.d.ts

@@ -0,0 +1,13 @@
+import { type NotificationType } from './notification-type';
+export type CatalogKeyResolver = string | ((payload: Record<string, unknown>) => string);
+export interface NotificationDescriptor {
+    emitsPush: boolean;
+    deepLink?: (payload: Record<string, unknown>) => string;
+    pushTitleKey?: CatalogKeyResolver;
+    pushBodyKey?: CatalogKeyResolver;
+    inAppMessageKey?: CatalogKeyResolver;
+    richRender?: NotificationType;
+    params?: (payload: Record<string, unknown>) => Record<string, string>;
+    catalogKeys: string[];
+}
+export declare const NOTIFICATION_REGISTRY: Record<NotificationType, NotificationDescriptor>;

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

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NOTIFICATION_REGISTRY = void 0;
+function readString(value) {
+    return typeof value === 'string' && value !== '' ? value : null;
+}
+function teamPath(payload) {
+    const teamId = readString(payload.teamId);
+    return teamId != null ? `/team/${encodeURIComponent(teamId)}` : '/';
+}
+// MATCH_RESULT copy is recipient-relative: `result` is WIN/LOSS from the recipient's view and `side` marks
+// which team is theirs, so the OTHER team is the opponent. When side/names are missing, do not name a winner.
+function matchOpponent(payload) {
+    const homeTeam = typeof payload.homeTeam === 'object' && payload.homeTeam != null ? payload.homeTeam : {};
+    const awayTeam = typeof payload.awayTeam === 'object' && payload.awayTeam != null ? payload.awayTeam : {};
+    const homeName = readString(homeTeam.name);
+    const awayName = readString(awayTeam.name);
+    if (payload.side === 'HOME')
+        return awayName;
+    if (payload.side === 'AWAY')
+        return homeName;
+    return null;
+}
+function injuredName(payload) {
+    // Matches the old Sim injuredPlayerName fallback so a name-less payload never renders a subjectless sentence.
+    return readString(payload.playerNickname) ?? readString(payload.playerName) ?? 'A player';
+}
+exports.NOTIFICATION_REGISTRY = {
+    MATCH_RESULT: {
+        emitsPush: true,
+        deepLink: (p) => {
+            const matchId = readString(p.matchId);
+            return matchId != null ? `/match/${encodeURIComponent(matchId)}` : '/';
+        },
+        pushTitleKey: 'matchResult.title',
+        pushBodyKey: (p) => {
+            const outcome = p.result === 'WIN' ? 'won' : 'lost';
+            const named = matchOpponent(p) != null ? 'Named' : 'Unnamed';
+            return `matchResult.${outcome}${named}`;
+        },
+        params: (p) => ({ opponent: matchOpponent(p) ?? '' }),
+        richRender: 'MATCH_RESULT',
+        catalogKeys: ['matchResult.title', 'matchResult.wonNamed', 'matchResult.wonUnnamed', 'matchResult.lostNamed', 'matchResult.lostUnnamed']
+    },
+    INJURY: {
+        emitsPush: true,
+        deepLink: () => '/infirmary',
+        pushTitleKey: 'injury.title',
+        pushBodyKey: 'injury.body',
+        inAppMessageKey: 'injury.body',
+        params: (p) => ({ name: injuredName(p) }),
+        catalogKeys: ['injury.title', 'injury.body']
+    },
+    INJURY_RECOVERED: {
+        emitsPush: true,
+        deepLink: teamPath,
+        pushTitleKey: 'injuryRecovered.title',
+        pushBodyKey: 'injuryRecovered.body',
+        inAppMessageKey: 'injuryRecovered.body',
+        params: (p) => ({ name: injuredName(p) }),
+        catalogKeys: ['injuryRecovered.title', 'injuryRecovered.body']
+    },
+    SEASON_END: {
+        emitsPush: true,
+        deepLink: (p) => {
+            const leagueId = readString(p.leagueId);
+            return leagueId != null ? `/league/${encodeURIComponent(leagueId)}` : '/league';
+        },
+        pushTitleKey: 'seasonEnd.title',
+        pushBodyKey: 'seasonEnd.body',
+        inAppMessageKey: 'seasonEnd.body',
+        catalogKeys: ['seasonEnd.title', 'seasonEnd.body']
+    },
+    GRANT_RECEIVED: {
+        emitsPush: true,
+        deepLink: () => '/recruit',
+        pushTitleKey: 'grant.title',
+        pushBodyKey: 'grant.body',
+        inAppMessageKey: 'grant.body',
+        catalogKeys: ['grant.title', 'grant.body']
+    },
+    PROMOTION: {
+        emitsPush: true,
+        deepLink: teamPath,
+        pushTitleKey: 'promotion.title',
+        pushBodyKey: 'promotion.body',
+        inAppMessageKey: 'promotion.body',
+        catalogKeys: ['promotion.title', 'promotion.body']
+    },
+    DAILY_LOGIN: {
+        emitsPush: true,
+        deepLink: () => '/recruit',
+        pushTitleKey: 'dailyLogin.title',
+        pushBodyKey: 'dailyLogin.body',
+        inAppMessageKey: 'dailyLogin.body',
+        catalogKeys: ['dailyLogin.title', 'dailyLogin.body']
+    },
+    WELCOME: {
+        emitsPush: true,
+        deepLink: () => '/recruit',
+        pushTitleKey: 'welcome.title',
+        pushBodyKey: 'welcome.body',
+        richRender: 'WELCOME',
+        catalogKeys: ['welcome.title', 'welcome.body']
+    },
+    // In-app only (no push); the UI keeps a bespoke renderer (amount formatting) and its own `compensation` label.
+    COMPENSATION: {
+        emitsPush: false,
+        richRender: 'COMPENSATION',
+        catalogKeys: []
+    }
+};

package/dist/cjs/src/service/notification/render.d.ts

@@ -0,0 +1,10 @@
+import { type NotificationLocale } from './notification-type';
+export interface RenderedPush {
+    title: string;
+    body: string;
+    data: Record<string, string>;
+}
+export declare function interpolate(template: string, params: Record<string, string>): string;
+export declare function translateNotification(locale: NotificationLocale, key: string, params?: Record<string, string>): string;
+export declare function renderPush(type: string, payload: Record<string, unknown>, locale: NotificationLocale): RenderedPush | undefined;
+export declare function notificationPath(type: string, payload: Record<string, unknown>): string;

package/dist/cjs/src/service/notification/render.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.interpolate = interpolate;
+exports.translateNotification = translateNotification;
+exports.renderPush = renderPush;
+exports.notificationPath = notificationPath;
+const notification_type_1 = require("./notification-type");
+const registry_1 = require("./registry");
+const catalog_1 = require("./catalog");
+function readNested(node, dotKey) {
+    let current = node;
+    for (const part of dotKey.split('.')) {
+        if (typeof current !== 'object' || current == null)
+            return undefined;
+        current = current[part];
+    }
+    return typeof current === 'string' ? current : undefined;
+}
+function lookupCatalog(locale, dotKey) {
+    return readNested(catalog_1.NOTIFICATION_CATALOG[locale], dotKey) ??
+        readNested(catalog_1.NOTIFICATION_CATALOG[notification_type_1.DEFAULT_NOTIFICATION_LOCALE], dotKey) ??
+        dotKey;
+}
+function resolveKey(resolver, payload) {
+    if (resolver == null)
+        return undefined;
+    return typeof resolver === 'function' ? resolver(payload) : resolver;
+}
+function interpolate(template, params) {
+    return template.replace(/\{\{(\w+)\}\}/g, (_match, key) => params[key] ?? '');
+}
+// Resolve one catalog key to a localized, interpolated string. Missing key/locale falls back to English,
+// then to the raw key. Exposed so consumers can render notification copy off the shared catalog too.
+function translateNotification(locale, key, params = {}) {
+    return interpolate(lookupCatalog(locale, key), params);
+}
+// Build the localized push payload for a notification. Returns undefined for in-app-only types (emitsPush
+// false, e.g. COMPENSATION). Unknown/future types fall back to the generic copy and the root path, matching
+// the previous hardcoded fallback. Callers pass the recipient's locale (normalizeNotificationLocale first).
+function renderPush(type, payload, locale) {
+    const buildData = (path) => ({ type, payload: JSON.stringify(payload), path });
+    const descriptor = registry_1.NOTIFICATION_REGISTRY[type];
+    if (descriptor == null) {
+        return {
+            title: translateNotification(locale, 'generic.title'),
+            body: translateNotification(locale, 'generic.body'),
+            data: buildData('/')
+        };
+    }
+    if (!descriptor.emitsPush)
+        return undefined;
+    const params = descriptor.params?.(payload) ?? {};
+    const titleKey = resolveKey(descriptor.pushTitleKey, payload) ?? 'generic.title';
+    const bodyKey = resolveKey(descriptor.pushBodyKey, payload) ?? 'generic.body';
+    return {
+        title: translateNotification(locale, titleKey, params),
+        body: translateNotification(locale, bodyKey, params),
+        data: buildData(descriptor.deepLink?.(payload) ?? '/')
+    };
+}
+// Deep-link path for a type/payload, used for both the push data.path and the in-app click target.
+function notificationPath(type, payload) {
+    return registry_1.NOTIFICATION_REGISTRY[type]?.deepLink?.(payload) ?? '/';
+}

package/dist/cjs/src/service/team/offensive-preference.d.ts

@@ -1,5 +1,7 @@
 import { Player } from '../player';
+export type TempoPreference = 'FAST' | 'HIGH';
 export interface OffensivePreference {
     readonly rotation: number;
     readonly order: Player[];
+    readonly tempos?: Record<string, TempoPreference>;
 }

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

@@ -270,6 +270,10 @@ export declare const TacticsInputSchema: z.ZodObject<{
     offensivePreferences: z.ZodDefault<z.ZodArray<z.ZodObject<{
         rotation: z.ZodNumber;
         order: z.ZodArray<z.ZodCustom<Player, Player>>;
+        tempos: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+            FAST: "FAST";
+            HIGH: "HIGH";
+        }>>>;
     }, z.core.$strip>>>;
     systemSets: z.ZodOptional<z.ZodArray<z.ZodObject<{
         rotationSystem: z.ZodEnum<typeof RotationSystemEnum>;
@@ -278,6 +282,10 @@ export declare const TacticsInputSchema: z.ZodObject<{
     offensivePreferenceSets: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodObject<{
         rotation: z.ZodNumber;
         order: z.ZodArray<z.ZodCustom<Player, Player>>;
+        tempos: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+            FAST: "FAST";
+            HIGH: "HIGH";
+        }>>>;
     }, 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

@@ -48,11 +48,15 @@ const lineupSchema = zod_1.z.object({
         });
     }
 });
+// Per-player tempo preference (set-tempo rework): absent key = Auto.
+const tempoPreferenceSchema = zod_1.z.enum(['FAST', 'HIGH']);
 // One rotation's ranked attacker priority. `rotation` is the main setter's rotational slot (1..6); `order` lists
-// the attackers ranked best-first. Cross-field checks (starters only, no dupes) live in the superRefine below.
+// the attackers ranked best-first. `tempos` optionally forces a per-starter tempo (Auto when absent). Cross-field
+// checks (starters only in both order and tempos, no dupes) live in the superRefine below.
 const offensivePreferenceSchema = zod_1.z.object({
     rotation: zod_1.z.number().int().min(1).max(6),
-    order: zod_1.z.array(playerInstanceSchema)
+    order: zod_1.z.array(playerInstanceSchema),
+    tempos: zod_1.z.record(zod_1.z.string(), tempoPreferenceSchema).optional()
 });
 // One set's rotation-system override (per-set tactics): system + its designated setters travel together.
 const systemSetSchema = zod_1.z.object({
@@ -158,6 +162,12 @@ exports.TacticsInputSchema = zod_1.z.object({
                     ctx.addIssue({ code: 'custom', message: 'OFFENSIVE_PREFERENCE_ATTACKER_NOT_A_STARTER', path });
                 }
             }
+            // Tempo preference keys are starter ids too (same rule as order).
+            for (const id of Object.keys(pref.tempos ?? {})) {
+                if (!starterIds.has(id)) {
+                    ctx.addIssue({ code: 'custom', message: 'OFFENSIVE_PREFERENCE_TEMPO_NOT_A_STARTER', path });
+                }
+            }
         }
     };
     validateSystem(data.rotationSystem, data.designatedSetters, ['designatedSetters']);

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

@@ -170,6 +170,30 @@ const test_helpers_1 = require("../../test-helpers");
             (0, globals_1.expect)(res.error.issues.some(i => i.message === 'OFFENSIVE_PREFERENCE_ATTACKER_NOT_A_STARTER')).toBe(true);
         }
     });
+    (0, globals_1.it)('accepts offensive preferences with a starter-keyed tempos map', () => {
+        const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
+            offensivePreferences: [{ rotation: 1, order: [p2, p3], tempos: { [p2.id]: 'FAST', [p3.id]: 'HIGH' } }]
+        }));
+        (0, globals_1.expect)(res.success).toBe(true);
+        if (res.success) {
+            (0, globals_1.expect)(res.data.offensivePreferences[0].tempos).toEqual({ [p2.id]: 'FAST', [p3.id]: 'HIGH' });
+        }
+    });
+    (0, globals_1.it)('rejects a tempos map keyed by a non-starter', () => {
+        const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
+            offensivePreferences: [{ rotation: 1, order: [p2], tempos: { [reserve.id]: 'FAST' } }]
+        }));
+        (0, globals_1.expect)(res.success).toBe(false);
+        if (!res.success) {
+            (0, globals_1.expect)(res.error.issues.some(i => i.message === 'OFFENSIVE_PREFERENCE_TEMPO_NOT_A_STARTER')).toBe(true);
+        }
+    });
+    (0, globals_1.it)('rejects an invalid tempo value', () => {
+        const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
+            offensivePreferences: [{ rotation: 1, order: [p2], tempos: { [p2.id]: 'SLOW' } }]
+        }));
+        (0, globals_1.expect)(res.success).toBe(false);
+    });
     (0, globals_1.it)('still validates the flat fields when per-set overrides are present', () => {
         // Flat 5-1 with no setter is invalid even though every set entry is valid.
         const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({

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

@@ -278,6 +278,10 @@ export declare const TeamInputSchema: z.ZodObject<{
         offensivePreferences: z.ZodDefault<z.ZodArray<z.ZodObject<{
             rotation: z.ZodNumber;
             order: z.ZodArray<z.ZodCustom<Player, Player>>;
+            tempos: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+                FAST: "FAST";
+                HIGH: "HIGH";
+            }>>>;
         }, z.core.$strip>>>;
         systemSets: z.ZodOptional<z.ZodArray<z.ZodObject<{
             rotationSystem: z.ZodEnum<typeof import("..").RotationSystemEnum>;
@@ -286,6 +290,10 @@ export declare const TeamInputSchema: z.ZodObject<{
         offensivePreferenceSets: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodObject<{
             rotation: z.ZodNumber;
             order: z.ZodArray<z.ZodCustom<Player, Player>>;
+            tempos: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+                FAST: "FAST";
+                HIGH: "HIGH";
+            }>>>;
         }, 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

@@ -109,6 +109,7 @@ export interface ApiDesignatedSub {
 export interface ApiOffensivePreference {
     rotation: number;
     order: string[];
+    tempos?: Record<string, 'FAST' | 'HIGH'>;
 }
 export interface ApiSystemSet {
     rotationSystem: RotationSystemEnum;

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

@@ -42,6 +42,7 @@ export interface DesignatedSubAttributes {
 export interface OffensivePreferenceAttributes {
     rotation: number;
     order: PlayerId[];
+    tempos?: Record<PlayerId, 'FAST' | 'HIGH'>;
 }
 export interface SystemSetAttributes {
     rotationSystem: RotationSystemEnum;

package/dist/esm/src/data/transformers/rally-event-tempo.test.d.ts

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

package/dist/esm/src/data/transformers/rally-event-tempo.test.js

@@ -0,0 +1,38 @@
+import { describe, it, expect } from '@jest/globals';
+import { v4 as uuidv4 } from 'uuid';
+import { EventTypeEnum, Set, SetFailureEnum, SetTempoEnum, SetTypeEnum } from '../../service';
+import { transformToCompact, transformToSet } from './rally-event';
+describe('rally-event compact round trip — set tempo marker', () => {
+    const playerId = uuidv4();
+    const roster = [playerId];
+    const playerIndex = new Map(roster.map((id, i) => [id, i]));
+    function makeSet(tempo) {
+        return Set.create({
+            playerId,
+            score: 90,
+            target: 4,
+            failure: SetFailureEnum.NO_FAILURE,
+            type: SetTypeEnum.OVERHAND,
+            ...(tempo !== undefined ? { tempo } : {})
+        });
+    }
+    it('packs each tempo as m and round-trips it', () => {
+        for (const tempo of [SetTempoEnum.FIRST, SetTempoEnum.SECOND, SetTempoEnum.HIGH]) {
+            const compact = transformToCompact(makeSet(tempo), playerIndex);
+            expect(compact.m).toBe(tempo);
+            const decoded = transformToSet(compact, roster);
+            expect(decoded.tempo).toBe(tempo);
+        }
+    });
+    it('omits m entirely for a set without a tempo', () => {
+        const compact = transformToCompact(makeSet(), playerIndex);
+        expect('m' in compact).toBe(false);
+        const decoded = transformToSet(compact, roster);
+        expect(decoded.tempo).toBeUndefined();
+    });
+    it('decodes a legacy compact event (no m key) with no tempo', () => {
+        const legacy = { p: 0, e: EventTypeEnum.SET, f: 0, t: 0, a: 4, s: 90 };
+        const decoded = transformToSet(legacy, roster);
+        expect(decoded.tempo).toBeUndefined();
+    });
+});

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

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

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

@@ -34,6 +34,9 @@ export function transformToCompact(evt, playerIndex) {
         if (evt instanceof Block) {
             out.b = evt.blockers.map(id => playerIndex.get(id));
         }
+        if (evt instanceof Set && evt.tempo !== undefined) {
+            out.m = evt.tempo;
+        }
     }
     else if (evt instanceof LiberoReplacement) {
         out.t = evt.type;
@@ -91,7 +94,8 @@ export function transformToSet(event, roster) {
         playerId: roster[event.p],
         target: event.a,
         score: event.s,
-        incident: incidentFromCompact(event.i, event.h, roster)
+        incident: incidentFromCompact(event.i, event.h, roster),
+        tempo: event.m
     });
 }
 export function transformToSpike(event, roster) {