volleyballsimtypes 0.0.531 → 0.0.532

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

@@ -31,24 +31,35 @@ export declare const TARGETED_PACK_COUNT: number;
 /** How many players the free pack offers: one per position. */
 export declare const FREE_PACK_SIZE: number;
 /**
- * How hard each rarity's recruits are skewed toward the top of their range when drafted in an event.
+ * How hard each rarity's recruits are skewed toward the top of their range when drafted in an event, on top of the
+ * pairing design (see generatePack). The number is a generator skew strength, see randomIntSkewed: 0 is the plain
+ * uniform draw over the rarity band.
  *
- * Owner decision (2026-07-23): commons and rares are generated NEAR THEIR BEST, so a lower-rarity event still
- * fields strong squads, while legendaries (and up) stay uniform, so a legendary event fields average
- * legendaries rather than peak ones. The number is a generator skew strength (see randomIntSkewed): 0 is the
- * plain uniform draw, and 2 was measured to land the typical common/rare recruit around the 80th percentile of
- * its normal role-score distribution (the top fifth) while keeping real spread and never forcing a maxed
- * player. This replaces the old reject-and-reroll fairness band: the skew lives in the generator, so the
- * material is comparable in one draw.
+ * 0 everywhere (owner 2026-09-03, measured). The pairing already puts BOTH of a recruit's specialities inside the
+ * rarity band, which is far above what an untargeted pull gives, and skewing on top of that pinned the composites
+ * to the ceiling: half a pack came out maxed. On the mythic band (80-89), for a dominant composite:
+ *
+ *   skew 0  mean 84.6    6% at 88+    0% maxed
+ *   skew 1  mean 86.1   17% at 88+    1% maxed
+ *   skew 2  mean 86.8   34% at 88+    4% maxed
+ *   skew 4  mean 87.6   61% at 88+   13% maxed
+ *
+ * Uniform keeps a pack of four spread across its band rather than clustered at the top, so the four pairings differ
+ * in strength as well as in shape. Raise a rarity here to bend its recruits upward again.
  */
 export declare const EVENT_DRAFT_TOP_SKEW: Record<Rarity, number>;
 /**
- * The players a pack offers, at the event's rarity. A role-targeted pack offers `PACK_SIZE` of that one role;
- * the free pack offers `FREE_PACK_SIZE`, one per position, so the choice is which position to add to.
+ * The players a pack offers, at the event's rarity.
+ *
+ * A role-targeted pack offers one recruit per ROLE PAIRING (owner 2026-09-03): the targeted role plus each of the
+ * four others, so the pick is which second role to take on and the four options are genuinely different players
+ * rather than four rolls of the same thing. The free pack offers one per position, each with a random second role.
+ * Every recruit carries the maximum traits its rarity allows, from its own roles' pool.
  *
- * The lower rarities are generated with a top-end skew (EVENT_DRAFT_TOP_SKEW) so their recruits cluster near
- * the best; legendaries are left uniform.
+ * COMMON is the exception: one role and no traits, so its packs are plain draws of the target role.
  */
+/** The four roles a pack's target can be paired with, in a stable order. */
+export declare function pairingsFor(role: Role): Role[];
 export declare function generatePack(country: Country, rarity: Rarity, packRole: DraftRole): Player[];
 /** The role of the pack at `index`, or undefined once the draft is complete. */
 export declare function draftPackRole(index: number): DraftRole | undefined;

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

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EVENT_DRAFT_TOP_SKEW = exports.FREE_PACK_SIZE = exports.TARGETED_PACK_COUNT = exports.DRAFT_SQUAD_SIZE = exports.DRAFT_PLAN = exports.PACK_SIZE = exports.FREE_PACK_ROLE = void 0;
+exports.pairingsFor = pairingsFor;
 exports.generatePack = generatePack;
 exports.draftPackRole = draftPackRole;
 exports.isDraftComplete = isDraftComplete;
+const node_crypto_1 = require("node:crypto");
 const player_1 = require("../player");
 // The event draft. An entrant does not bring their own squad: they open a fixed sequence of role-targeted
 // packs, keep one player from each, and the resulting team is thrown away when the event ends.
@@ -57,36 +59,64 @@ const ANY_PACK_ROLES = [
 /** How many players the free pack offers: one per position. */
 exports.FREE_PACK_SIZE = ANY_PACK_ROLES.length;
 /**
- * How hard each rarity's recruits are skewed toward the top of their range when drafted in an event.
+ * How hard each rarity's recruits are skewed toward the top of their range when drafted in an event, on top of the
+ * pairing design (see generatePack). The number is a generator skew strength, see randomIntSkewed: 0 is the plain
+ * uniform draw over the rarity band.
  *
- * Owner decision (2026-07-23): commons and rares are generated NEAR THEIR BEST, so a lower-rarity event still
- * fields strong squads, while legendaries (and up) stay uniform, so a legendary event fields average
- * legendaries rather than peak ones. The number is a generator skew strength (see randomIntSkewed): 0 is the
- * plain uniform draw, and 2 was measured to land the typical common/rare recruit around the 80th percentile of
- * its normal role-score distribution (the top fifth) while keeping real spread and never forcing a maxed
- * player. This replaces the old reject-and-reroll fairness band: the skew lives in the generator, so the
- * material is comparable in one draw.
+ * 0 everywhere (owner 2026-09-03, measured). The pairing already puts BOTH of a recruit's specialities inside the
+ * rarity band, which is far above what an untargeted pull gives, and skewing on top of that pinned the composites
+ * to the ceiling: half a pack came out maxed. On the mythic band (80-89), for a dominant composite:
+ *
+ *   skew 0  mean 84.6    6% at 88+    0% maxed
+ *   skew 1  mean 86.1   17% at 88+    1% maxed
+ *   skew 2  mean 86.8   34% at 88+    4% maxed
+ *   skew 4  mean 87.6   61% at 88+   13% maxed
+ *
+ * Uniform keeps a pack of four spread across its band rather than clustered at the top, so the four pairings differ
+ * in strength as well as in shape. Raise a rarity here to bend its recruits upward again.
  */
 exports.EVENT_DRAFT_TOP_SKEW = {
-    [player_1.RarityEnum.COMMON]: 2,
-    [player_1.RarityEnum.RARE]: 2,
+    [player_1.RarityEnum.COMMON]: 0,
+    [player_1.RarityEnum.RARE]: 0,
     [player_1.RarityEnum.LEGENDARY]: 0,
     [player_1.RarityEnum.MYTHIC]: 0,
     [player_1.RarityEnum.SPECIAL]: 0
 };
 /**
- * The players a pack offers, at the event's rarity. A role-targeted pack offers `PACK_SIZE` of that one role;
- * the free pack offers `FREE_PACK_SIZE`, one per position, so the choice is which position to add to.
+ * The players a pack offers, at the event's rarity.
  *
- * The lower rarities are generated with a top-end skew (EVENT_DRAFT_TOP_SKEW) so their recruits cluster near
- * the best; legendaries are left uniform.
+ * A role-targeted pack offers one recruit per ROLE PAIRING (owner 2026-09-03): the targeted role plus each of the
+ * four others, so the pick is which second role to take on and the four options are genuinely different players
+ * rather than four rolls of the same thing. The free pack offers one per position, each with a random second role.
+ * Every recruit carries the maximum traits its rarity allows, from its own roles' pool.
+ *
+ * COMMON is the exception: one role and no traits, so its packs are plain draws of the target role.
  */
+/** The four roles a pack's target can be paired with, in a stable order. */
+function pairingsFor(role) {
+    return ANY_PACK_ROLES.filter((other) => other !== role);
+}
 function generatePack(country, rarity, packRole) {
     const skew = exports.EVENT_DRAFT_TOP_SKEW[rarity] ?? 0;
-    const roll = (role) => player_1.PlayerGenerator.generatePlayer(country, rarity, role, false, 1, skew);
-    if (packRole === exports.FREE_PACK_ROLE)
-        return ANY_PACK_ROLES.map(roll);
-    return Array.from({ length: exports.PACK_SIZE }, () => roll(packRole));
+    const roll = (roles) => player_1.PlayerGenerator.generateEventPlayer(country, rarity, roles, skew);
+    // COMMON holds ONE role and no traits (owner 2026-09-03), so there is no second role to vary: the pack is
+    // PACK_SIZE draws of the target role and the choice is purely which stat line to take.
+    const single = rarity === player_1.RarityEnum.COMMON;
+    if (packRole === exports.FREE_PACK_ROLE) {
+        // One recruit per position, so the choice is which position to add to. Each still gets a second role (drawn at
+        // random, since no pairing was targeted) unless the rarity is single-role.
+        return ANY_PACK_ROLES.map((role) => {
+            if (single)
+                return roll([role]);
+            const partners = pairingsFor(role);
+            return roll([role, partners[(0, node_crypto_1.randomInt)(0, partners.length)]]);
+        });
+    }
+    if (single)
+        return Array.from({ length: exports.PACK_SIZE }, () => roll([packRole]));
+    // One recruit per pairing: a SETTER pack offers (S,L), (S,OH), (S,OP) and (S,MB), so the pick is which second
+    // role to take on. There are exactly four other roles, which is PACK_SIZE.
+    return pairingsFor(packRole).map((partner) => roll([packRole, partner]));
 }
 /** The role of the pack at `index`, or undefined once the draft is complete. */
 function draftPackRole(index) {

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

@@ -5,29 +5,6 @@ const event_draft_1 = require("./event-draft");
 const player_1 = require("../player");
 const test_helpers_1 = require("../test-helpers");
 const COUNTRY = (0, test_helpers_1.makeCountry)();
-// Aggregate helpers: skew is statistical, so the behaviour tests use large samples and generous margins to stay
-// off the flaky edge while still failing loudly if the skew were removed.
-function median(values) {
-    const sorted = [...values].sort((a, b) => a - b);
-    return sorted[Math.floor(sorted.length / 2)];
-}
-function percentile(values, p) {
-    const sorted = [...values].sort((a, b) => a - b);
-    return sorted[Math.floor((sorted.length - 1) * p)];
-}
-/** Role scores of `n` recruits drawn the way the DRAFT does (generatePack applies EVENT_DRAFT_TOP_SKEW). */
-function draftScores(rarity, role, n) {
-    const out = [];
-    while (out.length < n) {
-        for (const p of (0, event_draft_1.generatePack)(COUNTRY, rarity, role))
-            out.push((0, player_1.calculateRoleScore)(p.stats, role));
-    }
-    return out.slice(0, n);
-}
-/** Role scores of `n` recruits drawn UNIFORMLY (the generator's historic behaviour, skew 0). */
-function uniformScores(rarity, role, n) {
-    return Array.from({ length: n }, () => (0, player_1.calculateRoleScore)(player_1.PlayerGenerator.generatePlayer(COUNTRY, rarity, role, false, 1, 0).stats, role));
-}
 (0, globals_1.describe)('DRAFT_PLAN', () => {
     (0, globals_1.it)('drafts a 15-player squad, one pick per pack', () => {
         (0, globals_1.expect)(event_draft_1.DRAFT_SQUAD_SIZE).toBe(15);
@@ -96,39 +73,114 @@ function uniformScores(rarity, role, n) {
     });
 });
 (0, globals_1.describe)('EVENT_DRAFT_TOP_SKEW', () => {
-    (0, globals_1.it)('skews commons and rares toward the top and leaves legendaries (and up) uniform', () => {
-        (0, globals_1.expect)(event_draft_1.EVENT_DRAFT_TOP_SKEW[player_1.RarityEnum.COMMON]).toBeGreaterThan(0);
-        (0, globals_1.expect)(event_draft_1.EVENT_DRAFT_TOP_SKEW[player_1.RarityEnum.RARE]).toBeGreaterThan(0);
-        (0, globals_1.expect)(event_draft_1.EVENT_DRAFT_TOP_SKEW[player_1.RarityEnum.LEGENDARY]).toBe(0);
-        (0, globals_1.expect)(event_draft_1.EVENT_DRAFT_TOP_SKEW[player_1.RarityEnum.MYTHIC]).toBe(0);
-        (0, globals_1.expect)(event_draft_1.EVENT_DRAFT_TOP_SKEW[player_1.RarityEnum.SPECIAL]).toBe(0);
+    // The pairing already puts both of a recruit's specialities inside the rarity band, so skewing on top of that
+    // pinned the composites to the ceiling and half a pack came out maxed (owner 2026-09-03). Uniform keeps a pack
+    // spread across its band. The constant stays as the dial; the measured alternatives are in its comment.
+    (0, globals_1.it)('draws every rarity uniformly across its band', () => {
+        for (const rarity of [player_1.RarityEnum.COMMON, player_1.RarityEnum.RARE, player_1.RarityEnum.LEGENDARY, player_1.RarityEnum.MYTHIC, player_1.RarityEnum.SPECIAL]) {
+            (0, globals_1.expect)(event_draft_1.EVENT_DRAFT_TOP_SKEW[rarity]).toBe(0);
+        }
+    });
+    (0, globals_1.it)('rarely pins a composite to the top of the band, so a pack is not clustered at the ceiling', () => {
+        // The regression this guards: at skew 4 61% of dominant composites reached 88 and 13% hit the 89 ceiling, so
+        // half a pack came out maxed. Uniform measures ~6% at 88+ and ~0% maxed. A rate, not an absolute, because a
+        // uniform draw can of course still land on the ceiling now and then.
+        const [, max] = player_1.RarityRanges[player_1.RarityEnum.MYTHIC];
+        let composites = 0;
+        let nearMax = 0;
+        for (let i = 0; i < 300; i++) {
+            for (const p of (0, event_draft_1.generatePack)(COUNTRY, player_1.RarityEnum.MYTHIC, player_1.RoleEnum.OUTSIDE_HITTER)) {
+                for (const s of p.generalStats) {
+                    composites++;
+                    if (s.value >= max - 1)
+                        nearMax++;
+                }
+            }
+        }
+        (0, globals_1.expect)(nearMax / composites).toBeLessThan(0.15);
+    });
+});
+(0, globals_1.describe)('event recruits are role PAIRINGS (owner 2026-09-03)', () => {
+    const NON_COMMON = [player_1.RarityEnum.RARE, player_1.RarityEnum.LEGENDARY, player_1.RarityEnum.MYTHIC, player_1.RarityEnum.SPECIAL];
+    const ROLES = [player_1.RoleEnum.SETTER, player_1.RoleEnum.LIBERO, player_1.RoleEnum.OUTSIDE_HITTER, player_1.RoleEnum.OPPOSITE_HITTER, player_1.RoleEnum.MIDDLE_BLOCKER];
+    globals_1.it.each(NON_COMMON)('a %s pack offers the target role paired with each of the four others, exactly once', (rarity) => {
+        for (const role of ROLES) {
+            const pack = (0, event_draft_1.generatePack)(COUNTRY, rarity, role);
+            (0, globals_1.expect)(pack).toHaveLength(event_draft_1.PACK_SIZE);
+            for (const p of pack) {
+                (0, globals_1.expect)(p.roles).toHaveLength(2);
+                (0, globals_1.expect)(p.roles[0]).toBe(role); // the drafted role is always primary
+            }
+            // One recruit per partner, no repeats: the four options are different players, not four rolls of one.
+            const partners = pack.map(p => p.roles[1]);
+            (0, globals_1.expect)(new Set(partners).size).toBe(event_draft_1.PACK_SIZE);
+            (0, globals_1.expect)([...partners].sort()).toEqual([...(0, event_draft_1.pairingsFor)(role)].sort());
+        }
+    });
+    globals_1.it.each(NON_COMMON)('gives every %s recruit the MAXIMUM traits its rarity allows, from its own roles pool', (rarity) => {
+        const expected = (0, player_1.assignTraits)([player_1.RoleEnum.SETTER], rarity, true).length;
+        (0, globals_1.expect)(expected).toBeGreaterThan(0);
+        for (const role of ROLES) {
+            for (const p of (0, event_draft_1.generatePack)(COUNTRY, rarity, role)) {
+                (0, globals_1.expect)(p.traits).toHaveLength(expected);
+                // Every trait belongs to one of the two roles the player actually holds.
+                for (const t of p.traits) {
+                    const def = player_1.traitMap.get(t);
+                    (0, globals_1.expect)(def?.roles.some((r) => p.roles.includes(r))).toBe(true);
+                }
+            }
+        }
+    });
+    // COMMON is the stated exception: one role, no traits, so there is no second role to vary.
+    (0, globals_1.it)('a COMMON pack is single-role and trait-free', () => {
+        for (const role of ROLES) {
+            const pack = (0, event_draft_1.generatePack)(COUNTRY, player_1.RarityEnum.COMMON, role);
+            (0, globals_1.expect)(pack).toHaveLength(event_draft_1.PACK_SIZE);
+            for (const p of pack) {
+                (0, globals_1.expect)(p.roles).toEqual([role]);
+                (0, globals_1.expect)(p.traits).toHaveLength(0);
+            }
+        }
+    });
+    (0, globals_1.it)('the free pack still offers one recruit per position', () => {
+        const pack = (0, event_draft_1.generatePack)(COUNTRY, player_1.RarityEnum.MYTHIC, event_draft_1.FREE_PACK_ROLE);
+        (0, globals_1.expect)(pack).toHaveLength(event_draft_1.FREE_PACK_SIZE);
+        (0, globals_1.expect)(new Set(pack.map(p => p.roles[0])).size).toBe(event_draft_1.FREE_PACK_SIZE); // one per position
+        for (const p of pack)
+            (0, globals_1.expect)(p.roles).toHaveLength(2); // each still picks up a second role
     });
 });
-(0, globals_1.describe)('draft skew behaviour', () => {
-    const N = 2500;
-    const role = player_1.RoleEnum.OUTSIDE_HITTER;
-    globals_1.it.each([player_1.RarityEnum.COMMON, player_1.RarityEnum.RARE])('draws %s recruits near the top: the typical recruit outscores a uniform draw, and most land in its top fifth', (rarity) => {
-        const uniform = uniformScores(rarity, role, N);
-        const drafted = draftScores(rarity, role, N);
-        // The 80th percentile of a UNIFORM draw is the entry to the top fifth of the range.
-        const topFifthFloor = percentile(uniform, 0.80);
-        const draftedInTopFifth = drafted.filter(s => s >= topFifthFloor).length / drafted.length;
-        // A uniform draw puts ~20% here; the skew must push well past that (measured ~65-88% at skew 2).
-        (0, globals_1.expect)(draftedInTopFifth).toBeGreaterThan(0.45);
-        // The typical drafted recruit clearly outscores the typical uniform one.
-        (0, globals_1.expect)(median(drafted)).toBeGreaterThan(median(uniform));
-        // But it is a skew, not a clamp to the maximum: recruits still spread out, and the typical one sits
-        // below the best in the sample rather than everyone landing on the ceiling.
-        (0, globals_1.expect)(percentile(drafted, 0.10)).toBeLessThan(percentile(drafted, 0.90));
-        (0, globals_1.expect)(median(drafted)).toBeLessThan(Math.max(...drafted));
-    });
-    (0, globals_1.it)('leaves legendary recruits uniform: no top-end lift over a plain draw', () => {
-        const uniform = uniformScores(player_1.RarityEnum.LEGENDARY, role, N);
-        const drafted = draftScores(player_1.RarityEnum.LEGENDARY, role, N);
-        const topFifthFloor = percentile(uniform, 0.80);
-        const draftedInTopFifth = drafted.filter(s => s >= topFifthFloor).length / drafted.length;
-        // Same distribution as uniform (skew 0), so it stays near the ~20% a plain draw produces, nowhere near the
-        // >45% the skewed lower rarities reach.
-        (0, globals_1.expect)(draftedInTopFifth).toBeLessThan(0.35);
+(0, globals_1.describe)('a pairing is SHARP: elite at both roles, with real holes', () => {
+    const N = 400;
+    // The stat groups each role is FOR, so a recruit can be checked against what it claims to be.
+    const DOMINANT = {
+        [player_1.RoleEnum.SETTER]: player_1.StatsEnum.SET,
+        [player_1.RoleEnum.LIBERO]: player_1.StatsEnum.RECEIVE,
+        [player_1.RoleEnum.OUTSIDE_HITTER]: player_1.StatsEnum.ATTACK,
+        [player_1.RoleEnum.OPPOSITE_HITTER]: player_1.StatsEnum.ATTACK,
+        [player_1.RoleEnum.MIDDLE_BLOCKER]: player_1.StatsEnum.BLOCK
+    };
+    const rating = (p, g) => p.generalStats.find(s => s.name === g)?.value ?? 0;
+    (0, globals_1.it)('puts BOTH roles dominant ratings inside the rarity band', () => {
+        // The floor is the band MINIMUM, not its top fifth: a rating is a weighted blend, and a few of its inputs
+        // (ATTACK's focus and awareness, BLOCK's defense) are supporting stats for the role, which pulls the rating a
+        // little below the raw stats. What matters is that both of a pairing's specialities land in mythic territory.
+        const [min] = player_1.RarityRanges[player_1.RarityEnum.MYTHIC];
+        for (let i = 0; i < N; i++) {
+            for (const role of [player_1.RoleEnum.SETTER, player_1.RoleEnum.OUTSIDE_HITTER, player_1.RoleEnum.MIDDLE_BLOCKER]) {
+                for (const p of (0, event_draft_1.generatePack)(COUNTRY, player_1.RarityEnum.MYTHIC, role)) {
+                    for (const held of p.roles)
+                        (0, globals_1.expect)(rating(p, DOMINANT[held])).toBeGreaterThanOrEqual(min);
+                }
+            }
+        }
+    });
+    (0, globals_1.it)('leaves a real hole where NEITHER role reaches, so the four options are a genuine choice', () => {
+        // A (OUTSIDE_HITTER, MIDDLE_BLOCKER) is elite at attacking and blocking and cannot set: neither role touches
+        // the SET group, so it keeps the near-common draw and lands far below the band.
+        const pack = (0, event_draft_1.generatePack)(COUNTRY, player_1.RarityEnum.MYTHIC, player_1.RoleEnum.OUTSIDE_HITTER);
+        const withMiddle = pack.find(p => p.roles[1] === player_1.RoleEnum.MIDDLE_BLOCKER);
+        (0, globals_1.expect)(withMiddle).toBeDefined();
+        (0, globals_1.expect)(rating(withMiddle, player_1.StatsEnum.SET)).toBeLessThan(player_1.RarityRanges[player_1.RarityEnum.MYTHIC][0]);
     });
 });

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

@@ -42,6 +42,28 @@ export declare function rollRarity(pity: PityState, config?: GachaPullConfig): R
 export declare class PlayerGenerator {
     private constructor();
     private static generatePerformance;
+    /**
+     * The stat block for an EVENT DRAFT recruit, built from the exact roles it will hold (owner 2026-09-03).
+     *
+     * Each role's DOMINANT rating group is drawn from the rarity band bent toward its top fifth, so the player is
+     * genuinely elite at what each of its roles is for. The roles' SUPPORTING groups drop two rarity tiers, so a
+     * pairing is sharp rather than good at everything: a (OUTSIDE_HITTER, MIDDLE_BLOCKER) is elite at attacking and
+     * blocking, ordinary at receiving and serving, and has a real hole at setting. Anything neither role touches
+     * keeps the historic near-common draw, and stamina keeps its own per-rarity floor.
+     */
+    private static generateEventPerformance;
+    /**
+     * An EVENT DRAFT recruit (owner 2026-09-03). `roles` is exactly what the player will hold, `roles[0]` being the
+     * role the pack targeted; the draft offers one recruit per pairing so the choice is which second role to take.
+     *
+     * Traits are always the MAXIMUM the rarity allows, drawn from these roles' pool (assignTraits already filters by
+     * role), so an event recruit is a finished, interesting player rather than a stat line. A COMMON holds one role
+     * and, by that same table, no traits.
+     *
+     * Deliberately separate from generatePlayer: the gacha, bot teams and the seeds keep their own generation
+     * untouched. This shape is for events only.
+     */
+    static generateEventPlayer(country: Country, rarity: Rarity, roles: Role[], topSkew?: number, birthIteration?: number): Player;
     static generatePlayer(country: Country, _rarity?: Rarity, role?: Role, maxTraits?: boolean, birthIteration?: number, topSkew?: number): Player;
     static generatePlayers(count: number, countries: Country[]): Player[];
 }

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

@@ -317,6 +317,51 @@ class PlayerGenerator {
             }
         }
     }
+    /**
+     * The stat block for an EVENT DRAFT recruit, built from the exact roles it will hold (owner 2026-09-03).
+     *
+     * Each role's DOMINANT rating group is drawn from the rarity band bent toward its top fifth, so the player is
+     * genuinely elite at what each of its roles is for. The roles' SUPPORTING groups drop two rarity tiers, so a
+     * pairing is sharp rather than good at everything: a (OUTSIDE_HITTER, MIDDLE_BLOCKER) is elite at attacking and
+     * blocking, ordinary at receiving and serving, and has a real hole at setting. Anything neither role touches
+     * keeps the historic near-common draw, and stamina keeps its own per-rarity floor.
+     */
+    static generateEventPerformance(rarity, roles, topSkew) {
+        const [min, max] = rarity_1.RarityRanges[rarity];
+        const [supportMin, supportMax] = rarity_1.RarityRanges[(0, rarity_1.rarityBelow)(rarity, 2)];
+        const { dominant, supporting } = (0, role_1.roleStatTiers)(roles);
+        return performance_stats_1.PerformanceStats.create(Object.fromEntries(performance_stats_1.performanceStatKeys.map((key) => {
+            if (key === 'stamina')
+                return [key, rollStamina(rarity)];
+            if (dominant.has(key))
+                return [key, randomIntSkewed(min, max, topSkew)];
+            if (supporting.has(key))
+                return [key, (0, node_crypto_1.randomInt)(supportMin, supportMax + 1)];
+            return [key, (0, node_crypto_1.randomInt)(rarity_1.RarityRanges.COMMON[0], Math.max(min - 1, rarity_1.RarityRanges.COMMON[0] + 1))];
+        })));
+    }
+    /**
+     * An EVENT DRAFT recruit (owner 2026-09-03). `roles` is exactly what the player will hold, `roles[0]` being the
+     * role the pack targeted; the draft offers one recruit per pairing so the choice is which second role to take.
+     *
+     * Traits are always the MAXIMUM the rarity allows, drawn from these roles' pool (assignTraits already filters by
+     * role), so an event recruit is a finished, interesting player rather than a stat line. A COMMON holds one role
+     * and, by that same table, no traits.
+     *
+     * Deliberately separate from generatePlayer: the gacha, bot teams and the seeds keep their own generation
+     * untouched. This shape is for events only.
+     */
+    static generateEventPlayer(country, rarity, roles, topSkew = 0, birthIteration = 1) {
+        if (roles.length === 0)
+            throw new Error('EVENT_PLAYER_NEEDS_A_ROLE');
+        const name = (0, utils_1.generatePlayerName)(country.locales, 1)[0];
+        const stats = PlayerGenerator.generateEventPerformance(rarity, roles, topSkew);
+        const traits = (0, trait_1.assignTraits)(roles, rarity, true);
+        const birthAge = (0, node_crypto_1.randomInt)(15, 21);
+        const declineProfile = decline_1.declineProfiles[(0, node_crypto_1.randomInt)(0, decline_1.declineProfiles.length)];
+        const injuryProneProfile = (0, node_crypto_1.randomInt)(0, 101) / 100;
+        return player_1.Player.create({ id: (0, uuid_1.v4)(), name, country, stats, roles, traits, rarity, age: birthAge, birthAge, birthIteration, declineProfile, injuryProneProfile });
+    }
     static generatePlayer(country, _rarity, role, maxTraits, birthIteration = 1, topSkew = 0) {
         const rarity = _rarity ?? rollRarity({ legendaryPity: 0, mythicPity: 0, specialPity: 0 }).rarity;
         const name = (0, utils_1.generatePlayerName)(country.locales, 1)[0];

package/dist/cjs/src/service/player/rarity.d.ts

@@ -13,6 +13,10 @@ export declare const RarityRanges: {
     MYTHIC: number[];
     SPECIAL: number[];
 };
+/** The rarity ladder, lowest first. Used to step a band down a tier. */
+export declare const RARITY_LADDER: Rarity[];
+/** `steps` tiers below `rarity`, floored at COMMON. */
+export declare function rarityBelow(rarity: Rarity, steps: number): Rarity;
 export declare const StaminaRanges: {
     COMMON: number[];
     RARE: number[];

package/dist/cjs/src/service/player/rarity.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StaminaRanges = exports.RarityRanges = exports.RarityEnum = void 0;
+exports.StaminaRanges = exports.RARITY_LADDER = exports.RarityRanges = exports.RarityEnum = void 0;
+exports.rarityBelow = rarityBelow;
 var RarityEnum;
 (function (RarityEnum) {
     RarityEnum["COMMON"] = "COMMON";
@@ -16,6 +17,15 @@ exports.RarityRanges = {
     [RarityEnum.MYTHIC]: [80, 89],
     [RarityEnum.SPECIAL]: [90, 99]
 };
+/** The rarity ladder, lowest first. Used to step a band down a tier. */
+exports.RARITY_LADDER = [
+    RarityEnum.COMMON, RarityEnum.RARE, RarityEnum.LEGENDARY, RarityEnum.MYTHIC, RarityEnum.SPECIAL
+];
+/** `steps` tiers below `rarity`, floored at COMMON. */
+function rarityBelow(rarity, steps) {
+    const i = exports.RARITY_LADDER.indexOf(rarity);
+    return exports.RARITY_LADDER[Math.max(0, i - steps)];
+}
 // Stamina has its own per-rarity range with a guaranteed floor, applied identically in both the
 // role-weighted and the generic generation paths (stamina is otherwise a secondary stat that would
 // bottom out near 1 in the generic path). Floors: RARE 15, LEGENDARY 30, MYTHIC 45, SPECIAL 60.

package/dist/cjs/src/service/player/role.d.ts

@@ -1,4 +1,5 @@
-import { PerformanceStats, PerformanceStatsParams } from './performance-stats';
+import { PerformanceStats, PerformanceStatsKey, PerformanceStatsParams } from './performance-stats';
+import { Stats } from './stats';
 import { Rarity } from './rarity';
 export declare enum RoleEnum {
     SETTER = "SETTER",
@@ -14,6 +15,23 @@ export interface RolesFormula {
     weight: PerformanceStatsParams;
 }
 export declare function calculateRoleScore(stats: PerformanceStats, role: Role): number;
+/**
+ * How much a role cares about each rating group: the sum of its roles.json weights over the stats inside that
+ * group. An outside hitter is spike 0.3 + backAttack 0.1 = 0.4 on ATTACK, then 0.2 on RECEIVE and 0.2 on BLOCK,
+ * so ATTACK is what it is FOR. Groups the role has no weight in are absent.
+ */
+export declare function roleGroupWeights(role: Role): Map<Stats, number>;
+/**
+ * Split the stats of a role SET into the ones the players are FOR and the ones they merely support.
+ *
+ * A role's DOMINANT group is the one it weighs most (a middle blocker's BLOCK, a libero's RECEIVE); every stat
+ * feeding it is a dominant stat. The role's other groups are supporting. Union across the given roles, dominant
+ * winning any overlap, so a two-role player is elite at both roles' specialities and merely useful around them.
+ */
+export declare function roleStatTiers(roles: Role[]): {
+    dominant: Set<PerformanceStatsKey>;
+    supporting: Set<PerformanceStatsKey>;
+};
 export declare function assignRoles(stats: PerformanceStats, rarity: Rarity, forcedRole?: Role): Role[];
 /**
  * Returns the role-based multiplier for a player performing a given action.

package/dist/cjs/src/service/player/role.js

@@ -5,9 +5,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RoleEnum = void 0;
 exports.calculateRoleScore = calculateRoleScore;
+exports.roleGroupWeights = roleGroupWeights;
+exports.roleStatTiers = roleStatTiers;
 exports.assignRoles = assignRoles;
 exports.getRoleEventPenalty = getRoleEventPenalty;
 exports.getBlockRolePenalty = getBlockRolePenalty;
+const stats_1 = require("./stats");
 const rarity_1 = require("./rarity");
 const roles_json_1 = __importDefault(require("../../stat-config/roles.json"));
 var RoleEnum;
@@ -43,6 +46,54 @@ function getRoleCountRange(rarity) {
         default: return [1, 1];
     }
 }
+/** The five rating groups a role can care about (STAMINA is excluded: it has its own per-rarity floor). */
+const RATING_GROUPS = [stats_1.StatsEnum.ATTACK, stats_1.StatsEnum.SET, stats_1.StatsEnum.RECEIVE, stats_1.StatsEnum.SERVE, stats_1.StatsEnum.BLOCK];
+/**
+ * How much a role cares about each rating group: the sum of its roles.json weights over the stats inside that
+ * group. An outside hitter is spike 0.3 + backAttack 0.1 = 0.4 on ATTACK, then 0.2 on RECEIVE and 0.2 on BLOCK,
+ * so ATTACK is what it is FOR. Groups the role has no weight in are absent.
+ */
+function roleGroupWeights(role) {
+    const weights = rolesFormula.find(r => r.role === role)?.weight;
+    if (weights == null)
+        throw new Error('COULD_NOT_FIND_ROLE_WEIGHT');
+    const out = new Map();
+    for (const group of RATING_GROUPS) {
+        const total = Object.keys((0, stats_1.getMultipliers)(group))
+            .reduce((sum, key) => sum + (key === 'stamina' ? 0 : (weights[key] ?? 0)), 0);
+        if (total > 0)
+            out.set(group, total);
+    }
+    return out;
+}
+/**
+ * Split the stats of a role SET into the ones the players are FOR and the ones they merely support.
+ *
+ * A role's DOMINANT group is the one it weighs most (a middle blocker's BLOCK, a libero's RECEIVE); every stat
+ * feeding it is a dominant stat. The role's other groups are supporting. Union across the given roles, dominant
+ * winning any overlap, so a two-role player is elite at both roles' specialities and merely useful around them.
+ */
+function roleStatTiers(roles) {
+    const dominant = new Set();
+    const supporting = new Set();
+    for (const role of roles) {
+        const groups = roleGroupWeights(role);
+        const best = Math.max(...groups.values());
+        for (const [group, weight] of groups) {
+            for (const key of Object.keys((0, stats_1.getMultipliers)(group))) {
+                if (key === 'stamina')
+                    continue;
+                if (weight === best)
+                    dominant.add(key);
+                else
+                    supporting.add(key);
+            }
+        }
+    }
+    for (const key of dominant)
+        supporting.delete(key);
+    return { dominant, supporting };
+}
 function assignRoles(stats, rarity, forcedRole) {
     const scores = Object.values(RoleEnum)
         .map((role) => ({

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

@@ -31,24 +31,35 @@ export declare const TARGETED_PACK_COUNT: number;
 /** How many players the free pack offers: one per position. */
 export declare const FREE_PACK_SIZE: number;
 /**
- * How hard each rarity's recruits are skewed toward the top of their range when drafted in an event.
+ * How hard each rarity's recruits are skewed toward the top of their range when drafted in an event, on top of the
+ * pairing design (see generatePack). The number is a generator skew strength, see randomIntSkewed: 0 is the plain
+ * uniform draw over the rarity band.
  *
- * Owner decision (2026-07-23): commons and rares are generated NEAR THEIR BEST, so a lower-rarity event still
- * fields strong squads, while legendaries (and up) stay uniform, so a legendary event fields average
- * legendaries rather than peak ones. The number is a generator skew strength (see randomIntSkewed): 0 is the
- * plain uniform draw, and 2 was measured to land the typical common/rare recruit around the 80th percentile of
- * its normal role-score distribution (the top fifth) while keeping real spread and never forcing a maxed
- * player. This replaces the old reject-and-reroll fairness band: the skew lives in the generator, so the
- * material is comparable in one draw.
+ * 0 everywhere (owner 2026-09-03, measured). The pairing already puts BOTH of a recruit's specialities inside the
+ * rarity band, which is far above what an untargeted pull gives, and skewing on top of that pinned the composites
+ * to the ceiling: half a pack came out maxed. On the mythic band (80-89), for a dominant composite:
+ *
+ *   skew 0  mean 84.6    6% at 88+    0% maxed
+ *   skew 1  mean 86.1   17% at 88+    1% maxed
+ *   skew 2  mean 86.8   34% at 88+    4% maxed
+ *   skew 4  mean 87.6   61% at 88+   13% maxed
+ *
+ * Uniform keeps a pack of four spread across its band rather than clustered at the top, so the four pairings differ
+ * in strength as well as in shape. Raise a rarity here to bend its recruits upward again.
  */
 export declare const EVENT_DRAFT_TOP_SKEW: Record<Rarity, number>;
 /**
- * The players a pack offers, at the event's rarity. A role-targeted pack offers `PACK_SIZE` of that one role;
- * the free pack offers `FREE_PACK_SIZE`, one per position, so the choice is which position to add to.
+ * The players a pack offers, at the event's rarity.
+ *
+ * A role-targeted pack offers one recruit per ROLE PAIRING (owner 2026-09-03): the targeted role plus each of the
+ * four others, so the pick is which second role to take on and the four options are genuinely different players
+ * rather than four rolls of the same thing. The free pack offers one per position, each with a random second role.
+ * Every recruit carries the maximum traits its rarity allows, from its own roles' pool.
  *
- * The lower rarities are generated with a top-end skew (EVENT_DRAFT_TOP_SKEW) so their recruits cluster near
- * the best; legendaries are left uniform.
+ * COMMON is the exception: one role and no traits, so its packs are plain draws of the target role.
  */
+/** The four roles a pack's target can be paired with, in a stable order. */
+export declare function pairingsFor(role: Role): Role[];
 export declare function generatePack(country: Country, rarity: Rarity, packRole: DraftRole): Player[];
 /** The role of the pack at `index`, or undefined once the draft is complete. */
 export declare function draftPackRole(index: number): DraftRole | undefined;

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

@@ -1,3 +1,4 @@
+import { randomInt } from 'node:crypto';
 import { PlayerGenerator, RarityEnum, RoleEnum } from '../player';
 // The event draft. An entrant does not bring their own squad: they open a fixed sequence of role-targeted
 // packs, keep one player from each, and the resulting team is thrown away when the event ends.
@@ -51,36 +52,64 @@ const ANY_PACK_ROLES = [
 /** How many players the free pack offers: one per position. */
 export const FREE_PACK_SIZE = ANY_PACK_ROLES.length;
 /**
- * How hard each rarity's recruits are skewed toward the top of their range when drafted in an event.
+ * How hard each rarity's recruits are skewed toward the top of their range when drafted in an event, on top of the
+ * pairing design (see generatePack). The number is a generator skew strength, see randomIntSkewed: 0 is the plain
+ * uniform draw over the rarity band.
  *
- * Owner decision (2026-07-23): commons and rares are generated NEAR THEIR BEST, so a lower-rarity event still
- * fields strong squads, while legendaries (and up) stay uniform, so a legendary event fields average
- * legendaries rather than peak ones. The number is a generator skew strength (see randomIntSkewed): 0 is the
- * plain uniform draw, and 2 was measured to land the typical common/rare recruit around the 80th percentile of
- * its normal role-score distribution (the top fifth) while keeping real spread and never forcing a maxed
- * player. This replaces the old reject-and-reroll fairness band: the skew lives in the generator, so the
- * material is comparable in one draw.
+ * 0 everywhere (owner 2026-09-03, measured). The pairing already puts BOTH of a recruit's specialities inside the
+ * rarity band, which is far above what an untargeted pull gives, and skewing on top of that pinned the composites
+ * to the ceiling: half a pack came out maxed. On the mythic band (80-89), for a dominant composite:
+ *
+ *   skew 0  mean 84.6    6% at 88+    0% maxed
+ *   skew 1  mean 86.1   17% at 88+    1% maxed
+ *   skew 2  mean 86.8   34% at 88+    4% maxed
+ *   skew 4  mean 87.6   61% at 88+   13% maxed
+ *
+ * Uniform keeps a pack of four spread across its band rather than clustered at the top, so the four pairings differ
+ * in strength as well as in shape. Raise a rarity here to bend its recruits upward again.
  */
 export const EVENT_DRAFT_TOP_SKEW = {
-    [RarityEnum.COMMON]: 2,
-    [RarityEnum.RARE]: 2,
+    [RarityEnum.COMMON]: 0,
+    [RarityEnum.RARE]: 0,
     [RarityEnum.LEGENDARY]: 0,
     [RarityEnum.MYTHIC]: 0,
     [RarityEnum.SPECIAL]: 0
 };
 /**
- * The players a pack offers, at the event's rarity. A role-targeted pack offers `PACK_SIZE` of that one role;
- * the free pack offers `FREE_PACK_SIZE`, one per position, so the choice is which position to add to.
+ * The players a pack offers, at the event's rarity.
  *
- * The lower rarities are generated with a top-end skew (EVENT_DRAFT_TOP_SKEW) so their recruits cluster near
- * the best; legendaries are left uniform.
+ * A role-targeted pack offers one recruit per ROLE PAIRING (owner 2026-09-03): the targeted role plus each of the
+ * four others, so the pick is which second role to take on and the four options are genuinely different players
+ * rather than four rolls of the same thing. The free pack offers one per position, each with a random second role.
+ * Every recruit carries the maximum traits its rarity allows, from its own roles' pool.
+ *
+ * COMMON is the exception: one role and no traits, so its packs are plain draws of the target role.
  */
+/** The four roles a pack's target can be paired with, in a stable order. */
+export function pairingsFor(role) {
+    return ANY_PACK_ROLES.filter((other) => other !== role);
+}
 export function generatePack(country, rarity, packRole) {
     const skew = EVENT_DRAFT_TOP_SKEW[rarity] ?? 0;
-    const roll = (role) => PlayerGenerator.generatePlayer(country, rarity, role, false, 1, skew);
-    if (packRole === FREE_PACK_ROLE)
-        return ANY_PACK_ROLES.map(roll);
-    return Array.from({ length: PACK_SIZE }, () => roll(packRole));
+    const roll = (roles) => PlayerGenerator.generateEventPlayer(country, rarity, roles, skew);
+    // COMMON holds ONE role and no traits (owner 2026-09-03), so there is no second role to vary: the pack is
+    // PACK_SIZE draws of the target role and the choice is purely which stat line to take.
+    const single = rarity === RarityEnum.COMMON;
+    if (packRole === FREE_PACK_ROLE) {
+        // One recruit per position, so the choice is which position to add to. Each still gets a second role (drawn at
+        // random, since no pairing was targeted) unless the rarity is single-role.
+        return ANY_PACK_ROLES.map((role) => {
+            if (single)
+                return roll([role]);
+            const partners = pairingsFor(role);
+            return roll([role, partners[randomInt(0, partners.length)]]);
+        });
+    }
+    if (single)
+        return Array.from({ length: PACK_SIZE }, () => roll([packRole]));
+    // One recruit per pairing: a SETTER pack offers (S,L), (S,OH), (S,OP) and (S,MB), so the pick is which second
+    // role to take on. There are exactly four other roles, which is PACK_SIZE.
+    return pairingsFor(packRole).map((partner) => roll([packRole, partner]));
 }
 /** The role of the pack at `index`, or undefined once the draft is complete. */
 export function draftPackRole(index) {

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

@@ -1,31 +1,8 @@
 import { describe, it, expect } from '@jest/globals';
-import { DRAFT_PLAN, DRAFT_SQUAD_SIZE, EVENT_DRAFT_TOP_SKEW, FREE_PACK_ROLE, FREE_PACK_SIZE, PACK_SIZE, TARGETED_PACK_COUNT, draftPackRole, generatePack, isDraftComplete } from './event-draft';
-import { PlayerGenerator, RarityEnum, RoleEnum, calculateRoleScore } from '../player';
+import { DRAFT_PLAN, DRAFT_SQUAD_SIZE, EVENT_DRAFT_TOP_SKEW, FREE_PACK_ROLE, FREE_PACK_SIZE, PACK_SIZE, TARGETED_PACK_COUNT, draftPackRole, generatePack, isDraftComplete, pairingsFor } from './event-draft';
+import { RarityEnum, RarityRanges, RoleEnum, StatsEnum, assignTraits, traitMap } from '../player';
 import { makeCountry } from '../test-helpers';
 const COUNTRY = makeCountry();
-// Aggregate helpers: skew is statistical, so the behaviour tests use large samples and generous margins to stay
-// off the flaky edge while still failing loudly if the skew were removed.
-function median(values) {
-    const sorted = [...values].sort((a, b) => a - b);
-    return sorted[Math.floor(sorted.length / 2)];
-}
-function percentile(values, p) {
-    const sorted = [...values].sort((a, b) => a - b);
-    return sorted[Math.floor((sorted.length - 1) * p)];
-}
-/** Role scores of `n` recruits drawn the way the DRAFT does (generatePack applies EVENT_DRAFT_TOP_SKEW). */
-function draftScores(rarity, role, n) {
-    const out = [];
-    while (out.length < n) {
-        for (const p of generatePack(COUNTRY, rarity, role))
-            out.push(calculateRoleScore(p.stats, role));
-    }
-    return out.slice(0, n);
-}
-/** Role scores of `n` recruits drawn UNIFORMLY (the generator's historic behaviour, skew 0). */
-function uniformScores(rarity, role, n) {
-    return Array.from({ length: n }, () => calculateRoleScore(PlayerGenerator.generatePlayer(COUNTRY, rarity, role, false, 1, 0).stats, role));
-}
 describe('DRAFT_PLAN', () => {
     it('drafts a 15-player squad, one pick per pack', () => {
         expect(DRAFT_SQUAD_SIZE).toBe(15);
@@ -94,39 +71,114 @@ describe('generatePack()', () => {
     });
 });
 describe('EVENT_DRAFT_TOP_SKEW', () => {
-    it('skews commons and rares toward the top and leaves legendaries (and up) uniform', () => {
-        expect(EVENT_DRAFT_TOP_SKEW[RarityEnum.COMMON]).toBeGreaterThan(0);
-        expect(EVENT_DRAFT_TOP_SKEW[RarityEnum.RARE]).toBeGreaterThan(0);
-        expect(EVENT_DRAFT_TOP_SKEW[RarityEnum.LEGENDARY]).toBe(0);
-        expect(EVENT_DRAFT_TOP_SKEW[RarityEnum.MYTHIC]).toBe(0);
-        expect(EVENT_DRAFT_TOP_SKEW[RarityEnum.SPECIAL]).toBe(0);
+    // The pairing already puts both of a recruit's specialities inside the rarity band, so skewing on top of that
+    // pinned the composites to the ceiling and half a pack came out maxed (owner 2026-09-03). Uniform keeps a pack
+    // spread across its band. The constant stays as the dial; the measured alternatives are in its comment.
+    it('draws every rarity uniformly across its band', () => {
+        for (const rarity of [RarityEnum.COMMON, RarityEnum.RARE, RarityEnum.LEGENDARY, RarityEnum.MYTHIC, RarityEnum.SPECIAL]) {
+            expect(EVENT_DRAFT_TOP_SKEW[rarity]).toBe(0);
+        }
+    });
+    it('rarely pins a composite to the top of the band, so a pack is not clustered at the ceiling', () => {
+        // The regression this guards: at skew 4 61% of dominant composites reached 88 and 13% hit the 89 ceiling, so
+        // half a pack came out maxed. Uniform measures ~6% at 88+ and ~0% maxed. A rate, not an absolute, because a
+        // uniform draw can of course still land on the ceiling now and then.
+        const [, max] = RarityRanges[RarityEnum.MYTHIC];
+        let composites = 0;
+        let nearMax = 0;
+        for (let i = 0; i < 300; i++) {
+            for (const p of generatePack(COUNTRY, RarityEnum.MYTHIC, RoleEnum.OUTSIDE_HITTER)) {
+                for (const s of p.generalStats) {
+                    composites++;
+                    if (s.value >= max - 1)
+                        nearMax++;
+                }
+            }
+        }
+        expect(nearMax / composites).toBeLessThan(0.15);
+    });
+});
+describe('event recruits are role PAIRINGS (owner 2026-09-03)', () => {
+    const NON_COMMON = [RarityEnum.RARE, RarityEnum.LEGENDARY, RarityEnum.MYTHIC, RarityEnum.SPECIAL];
+    const ROLES = [RoleEnum.SETTER, RoleEnum.LIBERO, RoleEnum.OUTSIDE_HITTER, RoleEnum.OPPOSITE_HITTER, RoleEnum.MIDDLE_BLOCKER];
+    it.each(NON_COMMON)('a %s pack offers the target role paired with each of the four others, exactly once', (rarity) => {
+        for (const role of ROLES) {
+            const pack = generatePack(COUNTRY, rarity, role);
+            expect(pack).toHaveLength(PACK_SIZE);
+            for (const p of pack) {
+                expect(p.roles).toHaveLength(2);
+                expect(p.roles[0]).toBe(role); // the drafted role is always primary
+            }
+            // One recruit per partner, no repeats: the four options are different players, not four rolls of one.
+            const partners = pack.map(p => p.roles[1]);
+            expect(new Set(partners).size).toBe(PACK_SIZE);
+            expect([...partners].sort()).toEqual([...pairingsFor(role)].sort());
+        }
+    });
+    it.each(NON_COMMON)('gives every %s recruit the MAXIMUM traits its rarity allows, from its own roles pool', (rarity) => {
+        const expected = assignTraits([RoleEnum.SETTER], rarity, true).length;
+        expect(expected).toBeGreaterThan(0);
+        for (const role of ROLES) {
+            for (const p of generatePack(COUNTRY, rarity, role)) {
+                expect(p.traits).toHaveLength(expected);
+                // Every trait belongs to one of the two roles the player actually holds.
+                for (const t of p.traits) {
+                    const def = traitMap.get(t);
+                    expect(def?.roles.some((r) => p.roles.includes(r))).toBe(true);
+                }
+            }
+        }
+    });
+    // COMMON is the stated exception: one role, no traits, so there is no second role to vary.
+    it('a COMMON pack is single-role and trait-free', () => {
+        for (const role of ROLES) {
+            const pack = generatePack(COUNTRY, RarityEnum.COMMON, role);
+            expect(pack).toHaveLength(PACK_SIZE);
+            for (const p of pack) {
+                expect(p.roles).toEqual([role]);
+                expect(p.traits).toHaveLength(0);
+            }
+        }
+    });
+    it('the free pack still offers one recruit per position', () => {
+        const pack = generatePack(COUNTRY, RarityEnum.MYTHIC, FREE_PACK_ROLE);
+        expect(pack).toHaveLength(FREE_PACK_SIZE);
+        expect(new Set(pack.map(p => p.roles[0])).size).toBe(FREE_PACK_SIZE); // one per position
+        for (const p of pack)
+            expect(p.roles).toHaveLength(2); // each still picks up a second role
     });
 });
-describe('draft skew behaviour', () => {
-    const N = 2500;
-    const role = RoleEnum.OUTSIDE_HITTER;
-    it.each([RarityEnum.COMMON, RarityEnum.RARE])('draws %s recruits near the top: the typical recruit outscores a uniform draw, and most land in its top fifth', (rarity) => {
-        const uniform = uniformScores(rarity, role, N);
-        const drafted = draftScores(rarity, role, N);
-        // The 80th percentile of a UNIFORM draw is the entry to the top fifth of the range.
-        const topFifthFloor = percentile(uniform, 0.80);
-        const draftedInTopFifth = drafted.filter(s => s >= topFifthFloor).length / drafted.length;
-        // A uniform draw puts ~20% here; the skew must push well past that (measured ~65-88% at skew 2).
-        expect(draftedInTopFifth).toBeGreaterThan(0.45);
-        // The typical drafted recruit clearly outscores the typical uniform one.
-        expect(median(drafted)).toBeGreaterThan(median(uniform));
-        // But it is a skew, not a clamp to the maximum: recruits still spread out, and the typical one sits
-        // below the best in the sample rather than everyone landing on the ceiling.
-        expect(percentile(drafted, 0.10)).toBeLessThan(percentile(drafted, 0.90));
-        expect(median(drafted)).toBeLessThan(Math.max(...drafted));
-    });
-    it('leaves legendary recruits uniform: no top-end lift over a plain draw', () => {
-        const uniform = uniformScores(RarityEnum.LEGENDARY, role, N);
-        const drafted = draftScores(RarityEnum.LEGENDARY, role, N);
-        const topFifthFloor = percentile(uniform, 0.80);
-        const draftedInTopFifth = drafted.filter(s => s >= topFifthFloor).length / drafted.length;
-        // Same distribution as uniform (skew 0), so it stays near the ~20% a plain draw produces, nowhere near the
-        // >45% the skewed lower rarities reach.
-        expect(draftedInTopFifth).toBeLessThan(0.35);
+describe('a pairing is SHARP: elite at both roles, with real holes', () => {
+    const N = 400;
+    // The stat groups each role is FOR, so a recruit can be checked against what it claims to be.
+    const DOMINANT = {
+        [RoleEnum.SETTER]: StatsEnum.SET,
+        [RoleEnum.LIBERO]: StatsEnum.RECEIVE,
+        [RoleEnum.OUTSIDE_HITTER]: StatsEnum.ATTACK,
+        [RoleEnum.OPPOSITE_HITTER]: StatsEnum.ATTACK,
+        [RoleEnum.MIDDLE_BLOCKER]: StatsEnum.BLOCK
+    };
+    const rating = (p, g) => p.generalStats.find(s => s.name === g)?.value ?? 0;
+    it('puts BOTH roles dominant ratings inside the rarity band', () => {
+        // The floor is the band MINIMUM, not its top fifth: a rating is a weighted blend, and a few of its inputs
+        // (ATTACK's focus and awareness, BLOCK's defense) are supporting stats for the role, which pulls the rating a
+        // little below the raw stats. What matters is that both of a pairing's specialities land in mythic territory.
+        const [min] = RarityRanges[RarityEnum.MYTHIC];
+        for (let i = 0; i < N; i++) {
+            for (const role of [RoleEnum.SETTER, RoleEnum.OUTSIDE_HITTER, RoleEnum.MIDDLE_BLOCKER]) {
+                for (const p of generatePack(COUNTRY, RarityEnum.MYTHIC, role)) {
+                    for (const held of p.roles)
+                        expect(rating(p, DOMINANT[held])).toBeGreaterThanOrEqual(min);
+                }
+            }
+        }
+    });
+    it('leaves a real hole where NEITHER role reaches, so the four options are a genuine choice', () => {
+        // A (OUTSIDE_HITTER, MIDDLE_BLOCKER) is elite at attacking and blocking and cannot set: neither role touches
+        // the SET group, so it keeps the near-common draw and lands far below the band.
+        const pack = generatePack(COUNTRY, RarityEnum.MYTHIC, RoleEnum.OUTSIDE_HITTER);
+        const withMiddle = pack.find(p => p.roles[1] === RoleEnum.MIDDLE_BLOCKER);
+        expect(withMiddle).toBeDefined();
+        expect(rating(withMiddle, StatsEnum.SET)).toBeLessThan(RarityRanges[RarityEnum.MYTHIC][0]);
     });
 });

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

@@ -42,6 +42,28 @@ export declare function rollRarity(pity: PityState, config?: GachaPullConfig): R
 export declare class PlayerGenerator {
     private constructor();
     private static generatePerformance;
+    /**
+     * The stat block for an EVENT DRAFT recruit, built from the exact roles it will hold (owner 2026-09-03).
+     *
+     * Each role's DOMINANT rating group is drawn from the rarity band bent toward its top fifth, so the player is
+     * genuinely elite at what each of its roles is for. The roles' SUPPORTING groups drop two rarity tiers, so a
+     * pairing is sharp rather than good at everything: a (OUTSIDE_HITTER, MIDDLE_BLOCKER) is elite at attacking and
+     * blocking, ordinary at receiving and serving, and has a real hole at setting. Anything neither role touches
+     * keeps the historic near-common draw, and stamina keeps its own per-rarity floor.
+     */
+    private static generateEventPerformance;
+    /**
+     * An EVENT DRAFT recruit (owner 2026-09-03). `roles` is exactly what the player will hold, `roles[0]` being the
+     * role the pack targeted; the draft offers one recruit per pairing so the choice is which second role to take.
+     *
+     * Traits are always the MAXIMUM the rarity allows, drawn from these roles' pool (assignTraits already filters by
+     * role), so an event recruit is a finished, interesting player rather than a stat line. A COMMON holds one role
+     * and, by that same table, no traits.
+     *
+     * Deliberately separate from generatePlayer: the gacha, bot teams and the seeds keep their own generation
+     * untouched. This shape is for events only.
+     */
+    static generateEventPlayer(country: Country, rarity: Rarity, roles: Role[], topSkew?: number, birthIteration?: number): Player;
     static generatePlayer(country: Country, _rarity?: Rarity, role?: Role, maxTraits?: boolean, birthIteration?: number, topSkew?: number): Player;
     static generatePlayers(count: number, countries: Country[]): Player[];
 }

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

@@ -1,8 +1,8 @@
 import { v4 as uuidv4 } from 'uuid';
 import { randomInt } from 'node:crypto';
-import { RarityEnum, RarityRanges, StaminaRanges } from './rarity';
+import { RarityEnum, RarityRanges, rarityBelow, StaminaRanges } from './rarity';
 import { performanceStatKeys, PerformanceStats } from './performance-stats';
-import { assignRoles } from './role';
+import { assignRoles, roleStatTiers } from './role';
 import { getMultipliers, StatsEnum } from './stats';
 import { rolesJSON } from '../../stat-config';
 import { shuffle, generatePlayerName } from '../utils';
@@ -311,6 +311,51 @@ export class PlayerGenerator {
             }
         }
     }
+    /**
+     * The stat block for an EVENT DRAFT recruit, built from the exact roles it will hold (owner 2026-09-03).
+     *
+     * Each role's DOMINANT rating group is drawn from the rarity band bent toward its top fifth, so the player is
+     * genuinely elite at what each of its roles is for. The roles' SUPPORTING groups drop two rarity tiers, so a
+     * pairing is sharp rather than good at everything: a (OUTSIDE_HITTER, MIDDLE_BLOCKER) is elite at attacking and
+     * blocking, ordinary at receiving and serving, and has a real hole at setting. Anything neither role touches
+     * keeps the historic near-common draw, and stamina keeps its own per-rarity floor.
+     */
+    static generateEventPerformance(rarity, roles, topSkew) {
+        const [min, max] = RarityRanges[rarity];
+        const [supportMin, supportMax] = RarityRanges[rarityBelow(rarity, 2)];
+        const { dominant, supporting } = roleStatTiers(roles);
+        return PerformanceStats.create(Object.fromEntries(performanceStatKeys.map((key) => {
+            if (key === 'stamina')
+                return [key, rollStamina(rarity)];
+            if (dominant.has(key))
+                return [key, randomIntSkewed(min, max, topSkew)];
+            if (supporting.has(key))
+                return [key, randomInt(supportMin, supportMax + 1)];
+            return [key, randomInt(RarityRanges.COMMON[0], Math.max(min - 1, RarityRanges.COMMON[0] + 1))];
+        })));
+    }
+    /**
+     * An EVENT DRAFT recruit (owner 2026-09-03). `roles` is exactly what the player will hold, `roles[0]` being the
+     * role the pack targeted; the draft offers one recruit per pairing so the choice is which second role to take.
+     *
+     * Traits are always the MAXIMUM the rarity allows, drawn from these roles' pool (assignTraits already filters by
+     * role), so an event recruit is a finished, interesting player rather than a stat line. A COMMON holds one role
+     * and, by that same table, no traits.
+     *
+     * Deliberately separate from generatePlayer: the gacha, bot teams and the seeds keep their own generation
+     * untouched. This shape is for events only.
+     */
+    static generateEventPlayer(country, rarity, roles, topSkew = 0, birthIteration = 1) {
+        if (roles.length === 0)
+            throw new Error('EVENT_PLAYER_NEEDS_A_ROLE');
+        const name = generatePlayerName(country.locales, 1)[0];
+        const stats = PlayerGenerator.generateEventPerformance(rarity, roles, topSkew);
+        const traits = assignTraits(roles, rarity, true);
+        const birthAge = randomInt(15, 21);
+        const declineProfile = declineProfiles[randomInt(0, declineProfiles.length)];
+        const injuryProneProfile = randomInt(0, 101) / 100;
+        return Player.create({ id: uuidv4(), name, country, stats, roles, traits, rarity, age: birthAge, birthAge, birthIteration, declineProfile, injuryProneProfile });
+    }
     static generatePlayer(country, _rarity, role, maxTraits, birthIteration = 1, topSkew = 0) {
         const rarity = _rarity ?? rollRarity({ legendaryPity: 0, mythicPity: 0, specialPity: 0 }).rarity;
         const name = generatePlayerName(country.locales, 1)[0];

package/dist/esm/src/service/player/rarity.d.ts

@@ -13,6 +13,10 @@ export declare const RarityRanges: {
     MYTHIC: number[];
     SPECIAL: number[];
 };
+/** The rarity ladder, lowest first. Used to step a band down a tier. */
+export declare const RARITY_LADDER: Rarity[];
+/** `steps` tiers below `rarity`, floored at COMMON. */
+export declare function rarityBelow(rarity: Rarity, steps: number): Rarity;
 export declare const StaminaRanges: {
     COMMON: number[];
     RARE: number[];

package/dist/esm/src/service/player/rarity.js

@@ -13,6 +13,15 @@ export const RarityRanges = {
     [RarityEnum.MYTHIC]: [80, 89],
     [RarityEnum.SPECIAL]: [90, 99]
 };
+/** The rarity ladder, lowest first. Used to step a band down a tier. */
+export const RARITY_LADDER = [
+    RarityEnum.COMMON, RarityEnum.RARE, RarityEnum.LEGENDARY, RarityEnum.MYTHIC, RarityEnum.SPECIAL
+];
+/** `steps` tiers below `rarity`, floored at COMMON. */
+export function rarityBelow(rarity, steps) {
+    const i = RARITY_LADDER.indexOf(rarity);
+    return RARITY_LADDER[Math.max(0, i - steps)];
+}
 // Stamina has its own per-rarity range with a guaranteed floor, applied identically in both the
 // role-weighted and the generic generation paths (stamina is otherwise a secondary stat that would
 // bottom out near 1 in the generic path). Floors: RARE 15, LEGENDARY 30, MYTHIC 45, SPECIAL 60.

package/dist/esm/src/service/player/role.d.ts

@@ -1,4 +1,5 @@
-import { PerformanceStats, PerformanceStatsParams } from './performance-stats';
+import { PerformanceStats, PerformanceStatsKey, PerformanceStatsParams } from './performance-stats';
+import { Stats } from './stats';
 import { Rarity } from './rarity';
 export declare enum RoleEnum {
     SETTER = "SETTER",
@@ -14,6 +15,23 @@ export interface RolesFormula {
     weight: PerformanceStatsParams;
 }
 export declare function calculateRoleScore(stats: PerformanceStats, role: Role): number;
+/**
+ * How much a role cares about each rating group: the sum of its roles.json weights over the stats inside that
+ * group. An outside hitter is spike 0.3 + backAttack 0.1 = 0.4 on ATTACK, then 0.2 on RECEIVE and 0.2 on BLOCK,
+ * so ATTACK is what it is FOR. Groups the role has no weight in are absent.
+ */
+export declare function roleGroupWeights(role: Role): Map<Stats, number>;
+/**
+ * Split the stats of a role SET into the ones the players are FOR and the ones they merely support.
+ *
+ * A role's DOMINANT group is the one it weighs most (a middle blocker's BLOCK, a libero's RECEIVE); every stat
+ * feeding it is a dominant stat. The role's other groups are supporting. Union across the given roles, dominant
+ * winning any overlap, so a two-role player is elite at both roles' specialities and merely useful around them.
+ */
+export declare function roleStatTiers(roles: Role[]): {
+    dominant: Set<PerformanceStatsKey>;
+    supporting: Set<PerformanceStatsKey>;
+};
 export declare function assignRoles(stats: PerformanceStats, rarity: Rarity, forcedRole?: Role): Role[];
 /**
  * Returns the role-based multiplier for a player performing a given action.

package/dist/esm/src/service/player/role.js

@@ -1,3 +1,4 @@
+import { getMultipliers, StatsEnum } from './stats';
 import { RarityEnum } from './rarity';
 import roles from '../../stat-config/roles.json';
 export var RoleEnum;
@@ -33,6 +34,54 @@ function getRoleCountRange(rarity) {
         default: return [1, 1];
     }
 }
+/** The five rating groups a role can care about (STAMINA is excluded: it has its own per-rarity floor). */
+const RATING_GROUPS = [StatsEnum.ATTACK, StatsEnum.SET, StatsEnum.RECEIVE, StatsEnum.SERVE, StatsEnum.BLOCK];
+/**
+ * How much a role cares about each rating group: the sum of its roles.json weights over the stats inside that
+ * group. An outside hitter is spike 0.3 + backAttack 0.1 = 0.4 on ATTACK, then 0.2 on RECEIVE and 0.2 on BLOCK,
+ * so ATTACK is what it is FOR. Groups the role has no weight in are absent.
+ */
+export function roleGroupWeights(role) {
+    const weights = rolesFormula.find(r => r.role === role)?.weight;
+    if (weights == null)
+        throw new Error('COULD_NOT_FIND_ROLE_WEIGHT');
+    const out = new Map();
+    for (const group of RATING_GROUPS) {
+        const total = Object.keys(getMultipliers(group))
+            .reduce((sum, key) => sum + (key === 'stamina' ? 0 : (weights[key] ?? 0)), 0);
+        if (total > 0)
+            out.set(group, total);
+    }
+    return out;
+}
+/**
+ * Split the stats of a role SET into the ones the players are FOR and the ones they merely support.
+ *
+ * A role's DOMINANT group is the one it weighs most (a middle blocker's BLOCK, a libero's RECEIVE); every stat
+ * feeding it is a dominant stat. The role's other groups are supporting. Union across the given roles, dominant
+ * winning any overlap, so a two-role player is elite at both roles' specialities and merely useful around them.
+ */
+export function roleStatTiers(roles) {
+    const dominant = new Set();
+    const supporting = new Set();
+    for (const role of roles) {
+        const groups = roleGroupWeights(role);
+        const best = Math.max(...groups.values());
+        for (const [group, weight] of groups) {
+            for (const key of Object.keys(getMultipliers(group))) {
+                if (key === 'stamina')
+                    continue;
+                if (weight === best)
+                    dominant.add(key);
+                else
+                    supporting.add(key);
+            }
+        }
+    }
+    for (const key of dominant)
+        supporting.delete(key);
+    return { dominant, supporting };
+}
 export function assignRoles(stats, rarity, forcedRole) {
     const scores = Object.values(RoleEnum)
         .map((role) => ({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "volleyballsimtypes",
-  "version": "0.0.531",
+  "version": "0.0.532",
   "description": "vbsim types",
   "main": "./dist/cjs/src/index.js",
   "module": "./dist/esm/src/index.js",