volleyballsimtypes 0.0.489 → 0.0.492

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

@@ -0,0 +1,37 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import { EventId, EventModel, EventPackPlayerModel, PlayerId, PlayerModel } from '.';
+export interface EventPackAttributes {
+    pack_id: string;
+    event_id: string;
+    user_id: string;
+    /** Position in DRAFT_PLAN, so the pack's role and the draft's progress are both derivable. */
+    index: number;
+    /** The role this pack offers. A free pack stores the role it actually rolled, not 'ANY'. */
+    role: string;
+    opened_at: Date;
+    /** Null until the entrant picks; set once, and the three unpicked players are deleted at that moment. */
+    picked_player_id: string | null;
+}
+export type EventPackPk = 'pack_id';
+export type EventPackId = EventPackModel[EventPackPk];
+export type EventPackOptionalAttributes = 'pack_id' | 'opened_at' | 'picked_player_id';
+export type EventPackCreationAttributes = Optional<EventPackAttributes, EventPackOptionalAttributes>;
+export declare class EventPackModel extends Model<EventPackAttributes, EventPackCreationAttributes> implements EventPackAttributes {
+    pack_id: string;
+    event_id: string;
+    user_id: string;
+    index: number;
+    role: string;
+    opened_at: Date;
+    picked_player_id: string | null;
+    Event: EventModel;
+    getEvent: Sequelize.BelongsToGetAssociationMixin<EventModel>;
+    setEvent: Sequelize.BelongsToSetAssociationMixin<EventModel, EventId>;
+    choices: EventPackPlayerModel[];
+    getChoices: Sequelize.HasManyGetAssociationsMixin<EventPackPlayerModel>;
+    picked: PlayerModel;
+    getPicked: Sequelize.BelongsToGetAssociationMixin<PlayerModel>;
+    setPicked: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof EventPackModel;
+}

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

@@ -0,0 +1,51 @@
+import { DataTypes, Model } from 'sequelize';
+export class EventPackModel extends Model {
+    static initModel(sequelize) {
+        return EventPackModel.init({
+            pack_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                defaultValue: DataTypes.UUIDV4
+            },
+            event_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                references: { model: 'Event', key: 'event_id' }
+            },
+            user_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                references: { model: 'AuthUser', key: 'user_id' }
+            },
+            index: {
+                type: DataTypes.INTEGER,
+                allowNull: false
+            },
+            role: {
+                type: DataTypes.TEXT,
+                allowNull: false
+            },
+            opened_at: {
+                type: DataTypes.DATE,
+                allowNull: false,
+                defaultValue: DataTypes.NOW
+            },
+            picked_player_id: {
+                type: DataTypes.UUID,
+                allowNull: true,
+                references: { model: 'Player', key: 'player_id' }
+            }
+        }, {
+            sequelize,
+            tableName: 'EventPack',
+            schema: 'public',
+            timestamps: false,
+            indexes: [
+                { name: 'EventPack_pk', unique: true, fields: [{ name: 'pack_id' }] },
+                // One pack per position per entrant: reopening returns the stored pack instead of generating a new one.
+                { name: 'EventPack_one_per_index', unique: true, fields: [{ name: 'event_id' }, { name: 'user_id' }, { name: 'index' }] }
+            ]
+        });
+    }
+}

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

@@ -0,0 +1,34 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import type { EventKey } from '../../service/competition/event-schedule';
+import { EventId, EventModel, TeamAttributes, TeamId, TeamModel } from '.';
+export interface EventResultAttributes {
+    event_id: string;
+    /** The user's permanent team, so their accolades page can find it. */
+    team_id: string;
+    /** Place in the FINAL table, or null for an entrant who never reached it (group stage). */
+    position: number | null;
+    entrants: number;
+    key: EventKey;
+    ended_at: Date;
+    Event?: EventModel;
+    team?: TeamAttributes;
+}
+export type EventResultPk = 'event_id' | 'team_id';
+export type EventResultId = EventResultModel[EventResultPk];
+export type EventResultCreationAttributes = EventResultAttributes;
+export declare class EventResultModel extends Model<EventResultAttributes, EventResultCreationAttributes> implements EventResultAttributes {
+    event_id: string;
+    team_id: string;
+    position: number | null;
+    entrants: number;
+    key: EventKey;
+    ended_at: Date;
+    Event: EventModel;
+    getEvent: Sequelize.BelongsToGetAssociationMixin<EventModel>;
+    setEvent: Sequelize.BelongsToSetAssociationMixin<EventModel, EventId>;
+    team: TeamModel;
+    getTeam: Sequelize.BelongsToGetAssociationMixin<TeamModel>;
+    setTeam: Sequelize.BelongsToSetAssociationMixin<TeamModel, TeamId>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof EventResultModel;
+}

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

@@ -0,0 +1,44 @@
+import { DataTypes, Model } from 'sequelize';
+export class EventResultModel extends Model {
+    static initModel(sequelize) {
+        return EventResultModel.init({
+            event_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: { model: 'Event', key: 'event_id' }
+            },
+            team_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: { model: 'Team', key: 'team_id' }
+            },
+            position: {
+                type: DataTypes.INTEGER,
+                allowNull: true
+            },
+            entrants: {
+                type: DataTypes.INTEGER,
+                allowNull: false
+            },
+            key: {
+                type: DataTypes.TEXT,
+                allowNull: false
+            },
+            ended_at: {
+                type: DataTypes.DATE,
+                allowNull: false
+            }
+        }, {
+            sequelize,
+            tableName: 'EventResult',
+            schema: 'public',
+            timestamps: false,
+            indexes: [
+                { name: 'EventResult_pk', unique: true, fields: [{ name: 'event_id' }, { name: 'team_id' }] },
+                { name: 'EventResult_team_id_idx', fields: [{ name: 'team_id' }] }
+            ]
+        });
+    }
+}

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

@@ -0,0 +1,30 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import { EventId, EventModel, TeamAttributes, TeamId, TeamModel } from '.';
+export interface EventSquadAttributes {
+    event_id: string;
+    user_id: string;
+    /** The throwaway Team (active = false) holding the drafted players. Deleted at purge. */
+    team_id: string;
+    complete: boolean;
+    drafted_at: Date | null;
+    team?: TeamAttributes;
+}
+export type EventSquadPk = 'event_id' | 'user_id';
+export type EventSquadId = EventSquadModel[EventSquadPk];
+export type EventSquadOptionalAttributes = 'complete' | 'drafted_at';
+export type EventSquadCreationAttributes = Optional<EventSquadAttributes, EventSquadOptionalAttributes>;
+export declare class EventSquadModel extends Model<EventSquadAttributes, EventSquadCreationAttributes> implements EventSquadAttributes {
+    event_id: string;
+    user_id: string;
+    team_id: string;
+    complete: boolean;
+    drafted_at: Date | null;
+    Event: EventModel;
+    getEvent: Sequelize.BelongsToGetAssociationMixin<EventModel>;
+    setEvent: Sequelize.BelongsToSetAssociationMixin<EventModel, EventId>;
+    team: TeamModel;
+    getTeam: Sequelize.BelongsToGetAssociationMixin<TeamModel>;
+    setTeam: Sequelize.BelongsToSetAssociationMixin<TeamModel, TeamId>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof EventSquadModel;
+}

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

@@ -0,0 +1,42 @@
+import { DataTypes, Model } from 'sequelize';
+export class EventSquadModel extends Model {
+    static initModel(sequelize) {
+        return EventSquadModel.init({
+            event_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: { model: 'Event', key: 'event_id' }
+            },
+            user_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: { model: 'AuthUser', key: 'user_id' }
+            },
+            team_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                references: { model: 'Team', key: 'team_id' }
+            },
+            complete: {
+                type: DataTypes.BOOLEAN,
+                allowNull: false,
+                defaultValue: false
+            },
+            drafted_at: {
+                type: DataTypes.DATE,
+                allowNull: true
+            }
+        }, {
+            sequelize,
+            tableName: 'EventSquad',
+            schema: 'public',
+            timestamps: false,
+            indexes: [
+                { name: 'EventSquad_pk', unique: true, fields: [{ name: 'event_id' }, { name: 'user_id' }] },
+                { name: 'EventSquad_team_id_idx', fields: [{ name: 'team_id' }] }
+            ]
+        });
+    }
+}

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

@@ -0,0 +1,51 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { EventFormat, EventKey, EventStatus } from '../../service/competition/event-schedule';
+import { EventCompetitionAttributes, EventCompetitionModel, EventSquadAttributes, EventSquadModel } from '.';
+export interface EventAttributes {
+    event_id: string;
+    key: EventKey;
+    format: EventFormat;
+    /** The rarity every player in an entrant's lineup must be. */
+    restriction: string;
+    status: EventStatus;
+    registration_opens_at: Date;
+    registration_closes_at: Date;
+    starts_at: Date;
+    final_starts_at: Date;
+    ends_at: Date;
+    purge_at: Date;
+    /** Set when the event's data was deleted; null while it still has competitions and matches. */
+    purged_at: Date | null;
+    /**
+     * Which of this event's notifications have already gone out, keyed by notification type. The tick runs every
+     * ~60 seconds, so without a marker every phase transition would re-send on every pass.
+     */
+    notified: Record<string, boolean>;
+    EventCompetitions?: EventCompetitionAttributes[];
+    EventSquads?: EventSquadAttributes[];
+}
+export type EventPk = 'event_id';
+export type EventId = EventModel[EventPk];
+export type EventOptionalAttributes = 'event_id' | 'purged_at' | 'notified';
+export type EventCreationAttributes = Optional<EventAttributes, EventOptionalAttributes>;
+export declare class EventModel extends Model<EventAttributes, EventCreationAttributes> implements EventAttributes {
+    event_id: string;
+    key: EventKey;
+    format: EventFormat;
+    restriction: string;
+    status: EventStatus;
+    registration_opens_at: Date;
+    registration_closes_at: Date;
+    starts_at: Date;
+    final_starts_at: Date;
+    ends_at: Date;
+    purge_at: Date;
+    purged_at: Date | null;
+    notified: Record<string, boolean>;
+    EventCompetitions: EventCompetitionModel[];
+    getEventCompetitions: Sequelize.HasManyGetAssociationsMixin<EventCompetitionModel>;
+    EventSquads: EventSquadModel[];
+    getEventSquads: Sequelize.HasManyGetAssociationsMixin<EventSquadModel>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof EventModel;
+}

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

@@ -0,0 +1,78 @@
+import { DataTypes, Model } from 'sequelize';
+export class EventModel extends Model {
+    static initModel(sequelize) {
+        return EventModel.init({
+            event_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                defaultValue: DataTypes.UUIDV4
+            },
+            key: {
+                type: DataTypes.TEXT,
+                allowNull: false
+            },
+            format: {
+                type: DataTypes.TEXT,
+                allowNull: false
+            },
+            restriction: {
+                type: DataTypes.TEXT,
+                allowNull: false
+            },
+            status: {
+                type: DataTypes.TEXT,
+                allowNull: false
+            },
+            registration_opens_at: {
+                type: DataTypes.DATE,
+                allowNull: false
+            },
+            registration_closes_at: {
+                type: DataTypes.DATE,
+                allowNull: false
+            },
+            starts_at: {
+                type: DataTypes.DATE,
+                allowNull: false
+            },
+            final_starts_at: {
+                type: DataTypes.DATE,
+                allowNull: false
+            },
+            ends_at: {
+                type: DataTypes.DATE,
+                allowNull: false
+            },
+            purge_at: {
+                type: DataTypes.DATE,
+                allowNull: false
+            },
+            purged_at: {
+                type: DataTypes.DATE,
+                allowNull: true
+            },
+            notified: {
+                type: DataTypes.JSONB,
+                allowNull: false,
+                defaultValue: {}
+            }
+        }, {
+            sequelize,
+            tableName: 'Event',
+            schema: 'public',
+            timestamps: false,
+            indexes: [
+                {
+                    name: 'Event_pk',
+                    unique: true,
+                    fields: [{ name: 'event_id' }]
+                },
+                {
+                    name: 'Event_starts_at_idx',
+                    fields: [{ name: 'starts_at' }]
+                }
+            ]
+        });
+    }
+}

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

@@ -38,6 +38,13 @@ export * from './team';
 export * from './team-replacement';
 export * from './tactics';
 export * from './lineup-preset';
+export * from './event';
+export * from './event-competition';
+export * from './event-bot-team';
+export * from './event-squad';
+export * from './event-pack';
+export * from './event-pack-player';
+export * from './event-result';
 export * from './match-preset';
 export * from './user-currency';
 export * from './user-player-progress';

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

@@ -38,6 +38,13 @@ export * from './team';
 export * from './team-replacement';
 export * from './tactics';
 export * from './lineup-preset';
+export * from './event';
+export * from './event-competition';
+export * from './event-bot-team';
+export * from './event-squad';
+export * from './event-pack';
+export * from './event-pack-player';
+export * from './event-result';
 export * from './match-preset';
 export * from './user-currency';
 export * from './user-player-progress';

package/dist/esm/src/data/models/lineup-preset.d.ts

@@ -9,10 +9,11 @@ export interface LineupPresetAttributes {
     is_active: boolean;
     order_index: number;
     config: ApiTactics;
+    event_id: string | null;
 }
 export type LineupPresetPk = 'preset_id';
 export type LineupPresetId = LineupPresetModel[LineupPresetPk];
-export type LineupPresetOptionalAttributes = 'preset_id' | 'is_active';
+export type LineupPresetOptionalAttributes = 'preset_id' | 'is_active' | 'event_id';
 export type LineupPresetCreationAttributes = Optional<LineupPresetAttributes, LineupPresetOptionalAttributes>;
 export declare class LineupPresetModel extends Model<LineupPresetAttributes, LineupPresetCreationAttributes> implements LineupPresetAttributes {
     preset_id: string;
@@ -21,6 +22,7 @@ export declare class LineupPresetModel extends Model<LineupPresetAttributes, Lin
     is_active: boolean;
     order_index: number;
     config: ApiTactics;
+    event_id: string | null;
     team: TeamModel;
     getTeam: Sequelize.BelongsToGetAssociationMixin<TeamModel>;
     setTeam: Sequelize.BelongsToSetAssociationMixin<TeamModel, TeamId>;

package/dist/esm/src/data/models/lineup-preset.js

@@ -1,3 +1,4 @@
+import * as Sequelize from 'sequelize';
 import { DataTypes, Model } from 'sequelize';
 export class LineupPresetModel extends Model {
     static initModel(sequelize) {
@@ -32,6 +33,15 @@ export class LineupPresetModel extends Model {
             config: {
                 type: DataTypes.JSONB,
                 allowNull: false
+            },
+            event_id: {
+                type: DataTypes.UUID,
+                allowNull: true,
+                defaultValue: null,
+                references: {
+                    model: 'Event',
+                    key: 'event_id'
+                }
             }
         }, {
             sequelize,
@@ -60,6 +70,16 @@ export class LineupPresetModel extends Model {
                         { name: 'team_id' }
                     ],
                     where: { is_active: true }
+                },
+                {
+                    // At most one event lineup per team per event, so the save endpoint can upsert safely.
+                    name: 'LineupPreset_one_per_team_event',
+                    unique: true,
+                    fields: [
+                        { name: 'team_id' },
+                        { name: 'event_id' }
+                    ],
+                    where: { event_id: { [Sequelize.Op.ne]: null } }
                 }
             ]
         });

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

@@ -1,7 +1,7 @@
 import * as Sequelize from 'sequelize';
 import { Model, Optional } from 'sequelize';
 import { PlayerId, TeamId, TeamModel } from '.';
-import { ConditionLogic, CourtPosition, EnergyBand, PinchCondition, RoleEnum, RotationSystemEnum, SubBackMode, SubBand, SubMode } from '../../service';
+import { BlockingAssignment, ConditionLogic, CourtPosition, EnergyBand, PinchCondition, RotationSystemEnum, SubBackMode, SubBand, SubMode } from '../../service';
 export interface TacticsLineupAttributes {
     [CourtPosition.LIBERO_ZONE]?: PlayerId;
     [CourtPosition.LEFT_BACK]: PlayerId;
@@ -36,7 +36,7 @@ export interface OffensivePreferenceAttributes {
 }
 export interface BlockingPreferenceAttributes {
     rotation: number;
-    targets: Record<PlayerId, RoleEnum>;
+    targets: Record<PlayerId, BlockingAssignment>;
 }
 export interface SystemSetAttributes {
     rotationSystem: RotationSystemEnum;

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

@@ -1,6 +1,6 @@
 import { describe, it, expect } from '@jest/globals';
 import { tacticsColumnsToApiDto, transformFromTactics, transformToTactics } from './tactics';
-import { CourtPosition, EnergyBand, RoleEnum, RotationSystemEnum, Tactics } from '../../service';
+import { CourtPosition, EnergyBand, NO_BLOCK, RoleEnum, RotationSystemEnum, Tactics } from '../../service';
 import { makeCountry, makePlayer } from '../../service/test-helpers';
 // Minimal TacticsModel-shaped object; cast through unknown since the transformer only reads columns.
 function makeTactics(designatedSubs) {
@@ -214,6 +214,25 @@ describe('per-set tactics — service <-> row round-trip', () => {
         const back = transformToTactics(attrs, roster);
         expect(back.blockingPreferences[0].targets).toEqual({ [p4.id]: RoleEnum.OUTSIDE_HITTER, [p3.id]: RoleEnum.MIDDLE_BLOCKER });
     });
+    // NO_BLOCK rides in the same targets map as a commit assignment, so the transformers copy it wholesale with no
+    // mapping code. This pins that: the sentinel must survive the row round-trip verbatim, mixed with a commit, and
+    // in the per-set overrides. If it ever gets translated or dropped, a player silently starts blocking again.
+    it('round-trips a NO_BLOCK assignment, mixed with a commit and in per-set overrides', () => {
+        const withNoBlock = Tactics.create({
+            lineup: { 4: p4, 3: p3, 2: p2, 5: p5, 6: p6, 1: p1, bench: [] },
+            liberoReplacements: [],
+            blockingPreferences: [{ rotation: 1, targets: { [p4.id]: NO_BLOCK, [p3.id]: RoleEnum.MIDDLE_BLOCKER } }],
+            blockingPreferenceSets: [[{ rotation: 2, targets: { [p2.id]: NO_BLOCK } }]]
+        });
+        const attrs = transformFromTactics(withNoBlock, 'team-1');
+        expect(attrs.blocking_preferences).toEqual([
+            { rotation: 1, targets: { [p4.id]: NO_BLOCK, [p3.id]: RoleEnum.MIDDLE_BLOCKER } }
+        ]);
+        expect(attrs.blocking_preference_sets).toEqual([[{ rotation: 2, targets: { [p2.id]: NO_BLOCK } }]]);
+        const back = transformToTactics(attrs, roster);
+        expect(back.blockingPreferences[0].targets).toEqual({ [p4.id]: NO_BLOCK, [p3.id]: RoleEnum.MIDDLE_BLOCKER });
+        expect(back.blockingPreferenceSets?.[0][0].targets).toEqual({ [p2.id]: NO_BLOCK });
+    });
 });
 describe('libero injuries — service <-> row round-trip + lenient heal', () => {
     const country = makeCountry();

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

@@ -1,3 +1,4 @@
 export * from './service';
 export * from './data';
 export * from './stat-config';
+export { collectTacticsPlayerIds } from './api/tactics-player-refs';

package/dist/esm/src/index.js

@@ -1,3 +1,7 @@
 export * from './service';
 export * from './data';
 export * from './stat-config';
+// Named rather than `export * from './api'`: the api module re-declares Tactics/Player/Team/Match as DTO
+// shapes, which would collide with the service classes of the same name at the root. Consumers that want the
+// DTO types import them from the `volleyballsimtypes/api` subpath.
+export { collectTacticsPlayerIds } from './api/tactics-player-refs';

package/dist/esm/src/service/competition/event-draft.d.ts

@@ -0,0 +1,46 @@
+import { Country } from '../country';
+import { Player, Rarity, Role } from '../player';
+/** A pack targets one role, or ANY for the single free pick at the end. */
+export type DraftRole = Role | 'ANY';
+/** How many players an opened pack offers. */
+export declare const PACK_SIZE = 4;
+/**
+ * The pack sequence, in the order they are opened. One pick each, so this is also the squad: 2 setters,
+ * 4 outsides, 3 middles, 2 opposites, 2 liberos, plus one free pick, for a squad of 14 like every other team.
+ *
+ * Role-targeted rather than free choice on purpose: it makes a positionally valid squad impossible to get
+ * wrong, so nobody drafts six liberos and then cannot field a legal lineup.
+ */
+export declare const DRAFT_PLAN: readonly DraftRole[];
+/** The size of a drafted squad: one pick per pack. */
+export declare const DRAFT_SQUAD_SIZE: number;
+/**
+ * How far a pack's players may sit from the median for their rarity, as a fraction of the role score.
+ *
+ * The whole point of a generated draft is that the material is comparable: without this, one entrant opens a
+ * pack of duds while another opens a pack of stars and the event is decided before a ball is served. A player
+ * whose role score falls outside the band is rerolled.
+ */
+export declare const PACK_QUALITY_TOLERANCE = 0.08;
+export interface PackQualityBand {
+    readonly role: Role;
+    readonly min: number;
+    readonly max: number;
+}
+/**
+ * The in-band range for a role at a rarity, measured from a sample of freshly generated players rather than
+ * from hardcoded numbers, so it tracks the generator instead of drifting away from it whenever stats are
+ * retuned. Deterministic enough in aggregate: the sample is large and the band is a fraction of its median.
+ */
+export declare function packQualityBand(country: Country, rarity: Rarity, role: Role, sampleSize?: number): PackQualityBand;
+/**
+ * The players a pack offers: `PACK_SIZE` of the pack's role at the event's rarity, every one of them inside
+ * the fairness band.
+ *
+ * `pickRole` decides what an ANY pack rolls; it is passed in rather than chosen here so the caller controls the
+ * randomness (and a test can make it deterministic).
+ */
+export declare function generatePack(country: Country, rarity: Rarity, packRole: DraftRole, band: (role: Role) => PackQualityBand, pickRole: (roles: readonly Role[]) => Role): Player[];
+/** The role of the pack at `index`, or undefined once the draft is complete. */
+export declare function draftPackRole(index: number): DraftRole | undefined;
+export declare function isDraftComplete(picks: number): boolean;

package/dist/esm/src/service/competition/event-draft.js

@@ -0,0 +1,78 @@
+import { PlayerGenerator, RoleEnum, calculateRoleScore } from '../player';
+/** How many players an opened pack offers. */
+export const PACK_SIZE = 4;
+/**
+ * The pack sequence, in the order they are opened. One pick each, so this is also the squad: 2 setters,
+ * 4 outsides, 3 middles, 2 opposites, 2 liberos, plus one free pick, for a squad of 14 like every other team.
+ *
+ * Role-targeted rather than free choice on purpose: it makes a positionally valid squad impossible to get
+ * wrong, so nobody drafts six liberos and then cannot field a legal lineup.
+ */
+export const DRAFT_PLAN = [
+    RoleEnum.SETTER, RoleEnum.SETTER,
+    RoleEnum.OUTSIDE_HITTER, RoleEnum.OUTSIDE_HITTER, RoleEnum.OUTSIDE_HITTER, RoleEnum.OUTSIDE_HITTER,
+    RoleEnum.MIDDLE_BLOCKER, RoleEnum.MIDDLE_BLOCKER, RoleEnum.MIDDLE_BLOCKER,
+    RoleEnum.OPPOSITE_HITTER, RoleEnum.OPPOSITE_HITTER,
+    RoleEnum.LIBERO, RoleEnum.LIBERO,
+    'ANY'
+];
+/** The size of a drafted squad: one pick per pack. */
+export const DRAFT_SQUAD_SIZE = DRAFT_PLAN.length;
+/** The role a free pack rolls its choices at, so an ANY pack still offers a coherent set. */
+const ANY_PACK_ROLES = [
+    RoleEnum.SETTER, RoleEnum.OUTSIDE_HITTER, RoleEnum.MIDDLE_BLOCKER, RoleEnum.OPPOSITE_HITTER, RoleEnum.LIBERO
+];
+/**
+ * How far a pack's players may sit from the median for their rarity, as a fraction of the role score.
+ *
+ * The whole point of a generated draft is that the material is comparable: without this, one entrant opens a
+ * pack of duds while another opens a pack of stars and the event is decided before a ball is served. A player
+ * whose role score falls outside the band is rerolled.
+ */
+export const PACK_QUALITY_TOLERANCE = 0.08;
+/** Give up rerolling after this many attempts and take what we have, so generation can never spin forever. */
+const MAX_REROLLS = 40;
+/**
+ * The in-band range for a role at a rarity, measured from a sample of freshly generated players rather than
+ * from hardcoded numbers, so it tracks the generator instead of drifting away from it whenever stats are
+ * retuned. Deterministic enough in aggregate: the sample is large and the band is a fraction of its median.
+ */
+export function packQualityBand(country, rarity, role, sampleSize = 60) {
+    const scores = Array.from({ length: sampleSize }, () => calculateRoleScore(PlayerGenerator.generatePlayer(country, rarity, role, false, 1).stats, role)).sort((a, b) => a - b);
+    const median = scores[Math.floor(scores.length / 2)];
+    return {
+        role,
+        min: median * (1 - PACK_QUALITY_TOLERANCE),
+        max: median * (1 + PACK_QUALITY_TOLERANCE)
+    };
+}
+/**
+ * The players a pack offers: `PACK_SIZE` of the pack's role at the event's rarity, every one of them inside
+ * the fairness band.
+ *
+ * `pickRole` decides what an ANY pack rolls; it is passed in rather than chosen here so the caller controls the
+ * randomness (and a test can make it deterministic).
+ */
+export function generatePack(country, rarity, packRole, band, pickRole) {
+    const role = packRole === 'ANY' ? pickRole(ANY_PACK_ROLES) : packRole;
+    const { min, max } = band(role);
+    const players = [];
+    for (let i = 0; i < PACK_SIZE; i++) {
+        let player = PlayerGenerator.generatePlayer(country, rarity, role, false, 1);
+        for (let attempt = 0; attempt < MAX_REROLLS; attempt++) {
+            const score = calculateRoleScore(player.stats, role);
+            if (score >= min && score <= max)
+                break;
+            player = PlayerGenerator.generatePlayer(country, rarity, role, false, 1);
+        }
+        players.push(player);
+    }
+    return players;
+}
+/** The role of the pack at `index`, or undefined once the draft is complete. */
+export function draftPackRole(index) {
+    return DRAFT_PLAN[index];
+}
+export function isDraftComplete(picks) {
+    return picks >= DRAFT_SQUAD_SIZE;
+}

package/dist/esm/src/service/competition/event-draft.test.d.ts

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