volleyballsimtypes 0.0.489 → 0.0.492

package/dist/cjs/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/cjs/src/data/models/event-result.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventResultModel = void 0;
+const sequelize_1 = require("sequelize");
+class EventResultModel extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return EventResultModel.init({
+            event_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: { model: 'Event', key: 'event_id' }
+            },
+            team_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: { model: 'Team', key: 'team_id' }
+            },
+            position: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: true
+            },
+            entrants: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false
+            },
+            key: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: false
+            },
+            ended_at: {
+                type: sequelize_1.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' }] }
+            ]
+        });
+    }
+}
+exports.EventResultModel = EventResultModel;

package/dist/cjs/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/cjs/src/data/models/event-squad.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventSquadModel = void 0;
+const sequelize_1 = require("sequelize");
+class EventSquadModel extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return EventSquadModel.init({
+            event_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: { model: 'Event', key: 'event_id' }
+            },
+            user_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: { model: 'AuthUser', key: 'user_id' }
+            },
+            team_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: { model: 'Team', key: 'team_id' }
+            },
+            complete: {
+                type: sequelize_1.DataTypes.BOOLEAN,
+                allowNull: false,
+                defaultValue: false
+            },
+            drafted_at: {
+                type: sequelize_1.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' }] }
+            ]
+        });
+    }
+}
+exports.EventSquadModel = EventSquadModel;

package/dist/cjs/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/cjs/src/data/models/event.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventModel = void 0;
+const sequelize_1 = require("sequelize");
+class EventModel extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return EventModel.init({
+            event_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                defaultValue: sequelize_1.DataTypes.UUIDV4
+            },
+            key: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: false
+            },
+            format: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: false
+            },
+            restriction: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: false
+            },
+            status: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: false
+            },
+            registration_opens_at: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false
+            },
+            registration_closes_at: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false
+            },
+            starts_at: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false
+            },
+            final_starts_at: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false
+            },
+            ends_at: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false
+            },
+            purge_at: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false
+            },
+            purged_at: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: true
+            },
+            notified: {
+                type: sequelize_1.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' }]
+                }
+            ]
+        });
+    }
+}
+exports.EventModel = EventModel;

package/dist/cjs/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/cjs/src/data/models/index.js

@@ -54,6 +54,13 @@ __exportStar(require("./team"), exports);
 __exportStar(require("./team-replacement"), exports);
 __exportStar(require("./tactics"), exports);
 __exportStar(require("./lineup-preset"), exports);
+__exportStar(require("./event"), exports);
+__exportStar(require("./event-competition"), exports);
+__exportStar(require("./event-bot-team"), exports);
+__exportStar(require("./event-squad"), exports);
+__exportStar(require("./event-pack"), exports);
+__exportStar(require("./event-pack-player"), exports);
+__exportStar(require("./event-result"), exports);
 __exportStar(require("./match-preset"), exports);
 __exportStar(require("./user-currency"), exports);
 __exportStar(require("./user-player-progress"), exports);

package/dist/cjs/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/cjs/src/data/models/lineup-preset.js

@@ -1,6 +1,40 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LineupPresetModel = void 0;
+const Sequelize = __importStar(require("sequelize"));
 const sequelize_1 = require("sequelize");
 class LineupPresetModel extends sequelize_1.Model {
     static initModel(sequelize) {
@@ -35,6 +69,15 @@ class LineupPresetModel extends sequelize_1.Model {
             config: {
                 type: sequelize_1.DataTypes.JSONB,
                 allowNull: false
+            },
+            event_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: true,
+                defaultValue: null,
+                references: {
+                    model: 'Event',
+                    key: 'event_id'
+                }
             }
         }, {
             sequelize,
@@ -63,6 +106,16 @@ class LineupPresetModel extends sequelize_1.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/cjs/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/cjs/src/data/transformers/tactics.test.js

@@ -216,6 +216,25 @@ function makeTactics(designatedSubs) {
         const back = (0, tactics_1.transformToTactics)(attrs, roster);
         (0, globals_1.expect)(back.blockingPreferences[0].targets).toEqual({ [p4.id]: service_1.RoleEnum.OUTSIDE_HITTER, [p3.id]: service_1.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.
+    (0, globals_1.it)('round-trips a NO_BLOCK assignment, mixed with a commit and in per-set overrides', () => {
+        const withNoBlock = service_1.Tactics.create({
+            lineup: { 4: p4, 3: p3, 2: p2, 5: p5, 6: p6, 1: p1, bench: [] },
+            liberoReplacements: [],
+            blockingPreferences: [{ rotation: 1, targets: { [p4.id]: service_1.NO_BLOCK, [p3.id]: service_1.RoleEnum.MIDDLE_BLOCKER } }],
+            blockingPreferenceSets: [[{ rotation: 2, targets: { [p2.id]: service_1.NO_BLOCK } }]]
+        });
+        const attrs = (0, tactics_1.transformFromTactics)(withNoBlock, 'team-1');
+        (0, globals_1.expect)(attrs.blocking_preferences).toEqual([
+            { rotation: 1, targets: { [p4.id]: service_1.NO_BLOCK, [p3.id]: service_1.RoleEnum.MIDDLE_BLOCKER } }
+        ]);
+        (0, globals_1.expect)(attrs.blocking_preference_sets).toEqual([[{ rotation: 2, targets: { [p2.id]: service_1.NO_BLOCK } }]]);
+        const back = (0, tactics_1.transformToTactics)(attrs, roster);
+        (0, globals_1.expect)(back.blockingPreferences[0].targets).toEqual({ [p4.id]: service_1.NO_BLOCK, [p3.id]: service_1.RoleEnum.MIDDLE_BLOCKER });
+        (0, globals_1.expect)(back.blockingPreferenceSets?.[0][0].targets).toEqual({ [p2.id]: service_1.NO_BLOCK });
+    });
 });
 (0, globals_1.describe)('libero injuries — service <-> row round-trip + lenient heal', () => {
     const country = (0, test_helpers_1.makeCountry)();

package/dist/cjs/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/cjs/src/index.js

@@ -14,6 +14,12 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectTacticsPlayerIds = void 0;
 __exportStar(require("./service"), exports);
 __exportStar(require("./data"), exports);
 __exportStar(require("./stat-config"), exports);
+// 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.
+var tactics_player_refs_1 = require("./api/tactics-player-refs");
+Object.defineProperty(exports, "collectTacticsPlayerIds", { enumerable: true, get: function () { return tactics_player_refs_1.collectTacticsPlayerIds; } });

package/dist/cjs/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/cjs/src/service/competition/event-draft.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PACK_QUALITY_TOLERANCE = exports.DRAFT_SQUAD_SIZE = exports.DRAFT_PLAN = exports.PACK_SIZE = void 0;
+exports.packQualityBand = packQualityBand;
+exports.generatePack = generatePack;
+exports.draftPackRole = draftPackRole;
+exports.isDraftComplete = isDraftComplete;
+const player_1 = require("../player");
+/** How many players an opened pack offers. */
+exports.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.
+ */
+exports.DRAFT_PLAN = [
+    player_1.RoleEnum.SETTER, player_1.RoleEnum.SETTER,
+    player_1.RoleEnum.OUTSIDE_HITTER, player_1.RoleEnum.OUTSIDE_HITTER, player_1.RoleEnum.OUTSIDE_HITTER, player_1.RoleEnum.OUTSIDE_HITTER,
+    player_1.RoleEnum.MIDDLE_BLOCKER, player_1.RoleEnum.MIDDLE_BLOCKER, player_1.RoleEnum.MIDDLE_BLOCKER,
+    player_1.RoleEnum.OPPOSITE_HITTER, player_1.RoleEnum.OPPOSITE_HITTER,
+    player_1.RoleEnum.LIBERO, player_1.RoleEnum.LIBERO,
+    'ANY'
+];
+/** The size of a drafted squad: one pick per pack. */
+exports.DRAFT_SQUAD_SIZE = exports.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 = [
+    player_1.RoleEnum.SETTER, player_1.RoleEnum.OUTSIDE_HITTER, player_1.RoleEnum.MIDDLE_BLOCKER, player_1.RoleEnum.OPPOSITE_HITTER, player_1.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.
+ */
+exports.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.
+ */
+function packQualityBand(country, rarity, role, sampleSize = 60) {
+    const scores = Array.from({ length: sampleSize }, () => (0, player_1.calculateRoleScore)(player_1.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 - exports.PACK_QUALITY_TOLERANCE),
+        max: median * (1 + exports.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).
+ */
+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 < exports.PACK_SIZE; i++) {
+        let player = player_1.PlayerGenerator.generatePlayer(country, rarity, role, false, 1);
+        for (let attempt = 0; attempt < MAX_REROLLS; attempt++) {
+            const score = (0, player_1.calculateRoleScore)(player.stats, role);
+            if (score >= min && score <= max)
+                break;
+            player = player_1.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. */
+function draftPackRole(index) {
+    return exports.DRAFT_PLAN[index];
+}
+function isDraftComplete(picks) {
+    return picks >= exports.DRAFT_SQUAD_SIZE;
+}

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

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