volleyballsimtypes 0.0.447 → 0.0.449

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

@@ -39,8 +39,7 @@ function transformToBlock(event, roster) {
         playerId: roster[event.p],
         target: event.a,
         blockers: (event.b ?? []).map(i => roster[i]),
-        score: event.s,
-        activeTraits: []
+        score: event.s
     });
 }
 function transformToLiberoReplacement(event, roster) {
@@ -56,8 +55,7 @@ function transformToReception(event, roster) {
         type: event.t,
         playerId: roster[event.p],
         target: event.a,
-        score: event.s,
-        activeTraits: []
+        score: event.s
     });
 }
 function transformToServe(event, roster) {
@@ -66,8 +64,7 @@ function transformToServe(event, roster) {
         type: event.t,
         playerId: roster[event.p],
         target: event.a,
-        score: event.s,
-        activeTraits: []
+        score: event.s
     });
 }
 function transformToSet(event, roster) {
@@ -76,8 +73,7 @@ function transformToSet(event, roster) {
         type: event.t,
         playerId: roster[event.p],
         target: event.a,
-        score: event.s,
-        activeTraits: []
+        score: event.s
     });
 }
 function transformToSpike(event, roster) {
@@ -86,8 +82,7 @@ function transformToSpike(event, roster) {
         type: event.t,
         playerId: roster[event.p],
         target: event.a,
-        score: event.s,
-        activeTraits: []
+        score: event.s
     });
 }
 function transformToSubstitution(event, roster) {

package/dist/cjs/src/data/transformers/rally.js

@@ -68,11 +68,11 @@ function decodeLegacyEvent(event) {
     switch (event.e) {
         case 0: return service_1.LiberoReplacement.create({ playerId: event.p, libero: event.l, type: event.t });
         case 1: return service_1.Substitution.create({ playerId: event.p, playerOut: event.o });
-        case 2: return service_1.Serve.create({ failure: event.f, type: event.t, playerId: event.p, target: event.a, score: event.s, activeTraits: [] });
-        case 3: return service_1.Reception.create({ failure: event.f, type: event.t, playerId: event.p, target: event.a, score: event.s, activeTraits: [] });
-        case 4: return service_1.Set.create({ failure: event.f, type: event.t, playerId: event.p, target: event.a, score: event.s, activeTraits: [] });
-        case 5: return service_1.Spike.create({ failure: event.f, type: event.t, playerId: event.p, target: event.a, score: event.s, activeTraits: [] });
-        case 6: return service_1.Block.create({ failure: event.f, type: event.t, playerId: event.p, target: event.a, blockers: event.b ?? [], score: event.s, activeTraits: [] });
+        case 2: return service_1.Serve.create({ failure: event.f, type: event.t, playerId: event.p, target: event.a, score: event.s });
+        case 3: return service_1.Reception.create({ failure: event.f, type: event.t, playerId: event.p, target: event.a, score: event.s });
+        case 4: return service_1.Set.create({ failure: event.f, type: event.t, playerId: event.p, target: event.a, score: event.s });
+        case 5: return service_1.Spike.create({ failure: event.f, type: event.t, playerId: event.p, target: event.a, score: event.s });
+        case 6: return service_1.Block.create({ failure: event.f, type: event.t, playerId: event.p, target: event.a, blockers: event.b ?? [], score: event.s });
         default: throw new Error(`UNKNOWN_EVENT_TYPE: ${String(event.e)}`);
     }
 }

package/dist/cjs/src/service/event/schemas/block.z.d.ts

@@ -4,7 +4,7 @@ export declare const BlockInputSchema: z.ZodObject<{
     playerId: z.ZodUUID;
     score: z.ZodNumber;
     target: z.ZodNumber;
-    activeTraits: z.ZodArray<z.ZodEnum<{
+    activeTraits: z.ZodDefault<z.ZodArray<z.ZodEnum<{
         MASTER_MIND: TraitEnum.MASTER_MIND;
         MOVING_WALL: TraitEnum.MOVING_WALL;
         SURPRISE_ATTACK: TraitEnum.SURPRISE_ATTACK;
@@ -14,7 +14,7 @@ export declare const BlockInputSchema: z.ZodObject<{
         GUARDIAN: TraitEnum.GUARDIAN;
         FLOAT_SERVE: TraitEnum.FLOAT_SERVE;
         DEFENSIVE_SPECIALIST: TraitEnum.DEFENSIVE_SPECIALIST;
-    }>>;
+    }>>>;
     failure: z.ZodNumber;
     type: z.ZodNumber;
     blockers: z.ZodArray<z.ZodUUID>;

package/dist/cjs/src/service/event/schemas/block.z.js

@@ -10,7 +10,7 @@ exports.BlockInputSchema = zod_1.z.object({
     playerId: zod_1.z.uuid(),
     score: zod_1.z.number().finite(),
     target: zod_1.z.number().int().refine((v) => courtTargetValues.includes(v), { message: 'INVALID_COURT_TARGET' }),
-    activeTraits: zod_1.z.array(zod_1.z.enum(Object.values(player_1.TraitEnum))),
+    activeTraits: zod_1.z.array(zod_1.z.enum(Object.values(player_1.TraitEnum))).default([]),
     failure: zod_1.z.number().int().refine((v) => blockFailureValues.includes(v), { message: 'INVALID_BLOCK_FAILURE' }),
     type: zod_1.z.number().int().refine((v) => blockTypeValues.includes(v), { message: 'INVALID_BLOCK_TYPE' }),
     blockers: zod_1.z.array(zod_1.z.uuid())

package/dist/cjs/src/service/event/schemas/reception.z.d.ts

@@ -4,7 +4,7 @@ export declare const ReceptionInputSchema: z.ZodObject<{
     playerId: z.ZodUUID;
     score: z.ZodNumber;
     target: z.ZodNumber;
-    activeTraits: z.ZodArray<z.ZodEnum<{
+    activeTraits: z.ZodDefault<z.ZodArray<z.ZodEnum<{
         MASTER_MIND: TraitEnum.MASTER_MIND;
         MOVING_WALL: TraitEnum.MOVING_WALL;
         SURPRISE_ATTACK: TraitEnum.SURPRISE_ATTACK;
@@ -14,7 +14,7 @@ export declare const ReceptionInputSchema: z.ZodObject<{
         GUARDIAN: TraitEnum.GUARDIAN;
         FLOAT_SERVE: TraitEnum.FLOAT_SERVE;
         DEFENSIVE_SPECIALIST: TraitEnum.DEFENSIVE_SPECIALIST;
-    }>>;
+    }>>>;
     failure: z.ZodNumber;
     type: z.ZodNumber;
 }, z.core.$strip>;

package/dist/cjs/src/service/event/schemas/reception.z.js

@@ -10,7 +10,7 @@ exports.ReceptionInputSchema = zod_1.z.object({
     playerId: zod_1.z.uuid(),
     score: zod_1.z.number().finite(),
     target: zod_1.z.number().int().refine((v) => courtTargetValues.includes(v), { message: 'INVALID_COURT_TARGET' }),
-    activeTraits: zod_1.z.array(zod_1.z.enum(Object.values(player_1.TraitEnum))),
+    activeTraits: zod_1.z.array(zod_1.z.enum(Object.values(player_1.TraitEnum))).default([]),
     failure: zod_1.z.number().int().refine((v) => receptionFailureValues.includes(v), { message: 'INVALID_RECEPTION_FAILURE' }),
     type: zod_1.z.number().int().refine((v) => receptionTypeValues.includes(v), { message: 'INVALID_RECEPTION_TYPE' })
 });

package/dist/cjs/src/service/event/schemas/serve.z.d.ts

@@ -4,7 +4,7 @@ export declare const ServeInputSchema: z.ZodObject<{
     playerId: z.ZodUUID;
     score: z.ZodNumber;
     target: z.ZodNumber;
-    activeTraits: z.ZodArray<z.ZodEnum<{
+    activeTraits: z.ZodDefault<z.ZodArray<z.ZodEnum<{
         MASTER_MIND: TraitEnum.MASTER_MIND;
         MOVING_WALL: TraitEnum.MOVING_WALL;
         SURPRISE_ATTACK: TraitEnum.SURPRISE_ATTACK;
@@ -14,7 +14,7 @@ export declare const ServeInputSchema: z.ZodObject<{
         GUARDIAN: TraitEnum.GUARDIAN;
         FLOAT_SERVE: TraitEnum.FLOAT_SERVE;
         DEFENSIVE_SPECIALIST: TraitEnum.DEFENSIVE_SPECIALIST;
-    }>>;
+    }>>>;
     failure: z.ZodNumber;
     type: z.ZodNumber;
 }, z.core.$strip>;

package/dist/cjs/src/service/event/schemas/serve.z.js

@@ -10,7 +10,7 @@ exports.ServeInputSchema = zod_1.z.object({
     playerId: zod_1.z.uuid(),
     score: zod_1.z.number().finite(),
     target: zod_1.z.number().int().refine((v) => courtTargetValues.includes(v), { message: 'INVALID_COURT_TARGET' }),
-    activeTraits: zod_1.z.array(zod_1.z.enum(Object.values(player_1.TraitEnum))),
+    activeTraits: zod_1.z.array(zod_1.z.enum(Object.values(player_1.TraitEnum))).default([]),
     failure: zod_1.z.number().int().refine((v) => serveFailureValues.includes(v), { message: 'INVALID_SERVE_FAILURE' }),
     type: zod_1.z.number().int().refine((v) => serveTypeValues.includes(v), { message: 'INVALID_SERVE_TYPE' })
 });

package/dist/cjs/src/service/event/schemas/set.z.d.ts

@@ -4,7 +4,7 @@ export declare const SetInputSchema: z.ZodObject<{
     playerId: z.ZodUUID;
     score: z.ZodNumber;
     target: z.ZodNumber;
-    activeTraits: z.ZodArray<z.ZodEnum<{
+    activeTraits: z.ZodDefault<z.ZodArray<z.ZodEnum<{
         MASTER_MIND: TraitEnum.MASTER_MIND;
         MOVING_WALL: TraitEnum.MOVING_WALL;
         SURPRISE_ATTACK: TraitEnum.SURPRISE_ATTACK;
@@ -14,7 +14,7 @@ export declare const SetInputSchema: z.ZodObject<{
         GUARDIAN: TraitEnum.GUARDIAN;
         FLOAT_SERVE: TraitEnum.FLOAT_SERVE;
         DEFENSIVE_SPECIALIST: TraitEnum.DEFENSIVE_SPECIALIST;
-    }>>;
+    }>>>;
     failure: z.ZodNumber;
     type: z.ZodNumber;
 }, z.core.$strip>;

package/dist/cjs/src/service/event/schemas/set.z.js

@@ -10,7 +10,7 @@ exports.SetInputSchema = zod_1.z.object({
     playerId: zod_1.z.uuid(),
     score: zod_1.z.number().finite(),
     target: zod_1.z.number().int().refine((v) => courtTargetValues.includes(v), { message: 'INVALID_COURT_TARGET' }),
-    activeTraits: zod_1.z.array(zod_1.z.enum(Object.values(player_1.TraitEnum))),
+    activeTraits: zod_1.z.array(zod_1.z.enum(Object.values(player_1.TraitEnum))).default([]),
     failure: zod_1.z.number().int().refine((v) => setFailureValues.includes(v), { message: 'INVALID_SET_FAILURE' }),
     type: zod_1.z.number().int().refine((v) => setTypeValues.includes(v), { message: 'INVALID_SET_TYPE' })
 });

package/dist/cjs/src/service/event/schemas/spike.z.d.ts

@@ -4,7 +4,7 @@ export declare const SpikeInputSchema: z.ZodObject<{
     playerId: z.ZodUUID;
     score: z.ZodNumber;
     target: z.ZodNumber;
-    activeTraits: z.ZodArray<z.ZodEnum<{
+    activeTraits: z.ZodDefault<z.ZodArray<z.ZodEnum<{
         MASTER_MIND: TraitEnum.MASTER_MIND;
         MOVING_WALL: TraitEnum.MOVING_WALL;
         SURPRISE_ATTACK: TraitEnum.SURPRISE_ATTACK;
@@ -14,7 +14,7 @@ export declare const SpikeInputSchema: z.ZodObject<{
         GUARDIAN: TraitEnum.GUARDIAN;
         FLOAT_SERVE: TraitEnum.FLOAT_SERVE;
         DEFENSIVE_SPECIALIST: TraitEnum.DEFENSIVE_SPECIALIST;
-    }>>;
+    }>>>;
     failure: z.ZodNumber;
     type: z.ZodNumber;
 }, z.core.$strip>;

package/dist/cjs/src/service/event/schemas/spike.z.js

@@ -10,7 +10,7 @@ exports.SpikeInputSchema = zod_1.z.object({
     playerId: zod_1.z.uuid(),
     score: zod_1.z.number().finite(),
     target: zod_1.z.number().int().refine((v) => courtTargetValues.includes(v), { message: 'INVALID_COURT_TARGET' }),
-    activeTraits: zod_1.z.array(zod_1.z.enum(Object.values(player_1.TraitEnum))),
+    activeTraits: zod_1.z.array(zod_1.z.enum(Object.values(player_1.TraitEnum))).default([]),
     failure: zod_1.z.number().int().refine((v) => spikeFailureValues.includes(v), { message: 'INVALID_SPIKE_FAILURE' }),
     type: zod_1.z.number().int().refine((v) => spikeTypeValues.includes(v), { message: 'INVALID_SPIKE_TYPE' })
 });

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

@@ -304,7 +304,7 @@ class PlayerGenerator {
         const rarity = _rarity ?? rollRarity({ legendaryPity: 0, mythicPity: 0, specialPity: 0 }).rarity;
         const name = (0, utils_1.generatePlayerName)(country.locales, 1)[0];
         const stats = PlayerGenerator.generatePerformance(rarity, role);
-        const roles = (0, role_1.assignRoles)(stats, rarity);
+        const roles = (0, role_1.assignRoles)(stats, rarity, role);
         const traits = (0, trait_1.assignTraits)(roles, rarity, maxTraits);
         const birthAge = (0, node_crypto_1.randomInt)(15, 21);
         const declineProfile = decline_1.declineProfiles[(0, node_crypto_1.randomInt)(0, decline_1.declineProfiles.length)];

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

@@ -14,7 +14,7 @@ export interface RolesFormula {
     weight: PerformanceStatsParams;
 }
 export declare function calculateRoleScore(stats: PerformanceStats, role: Role): number;
-export declare function assignRoles(stats: PerformanceStats, rarity: Rarity): Role[];
+export declare function assignRoles(stats: PerformanceStats, rarity: Rarity, forcedRole?: Role): Role[];
 /**
  * Returns the role-based multiplier for a player performing a given action.
  * When the player holds multiple roles, the least-penalising role wins.

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

@@ -43,7 +43,7 @@ function getRoleCountRange(rarity) {
         default: return [1, 1];
     }
 }
-function assignRoles(stats, rarity) {
+function assignRoles(stats, rarity, forcedRole) {
     const scores = Object.values(RoleEnum)
         .map((role) => ({
         role,
@@ -52,6 +52,12 @@ function assignRoles(stats, rarity) {
         .sort((x, y) => y.score - x.score);
     const [min, max] = getRoleCountRange(rarity);
     const count = min + Math.floor(Math.random() * (max - min + 1));
+    // A forced role (role pick, wishlist proc, team seeding) must be the player's primary role.
+    // Remaining slots fill with the top-scoring other roles so multi-role rarity flavour is kept.
+    if (forcedRole != null) {
+        const others = scores.map(s => s.role).filter(r => r !== forcedRole);
+        return [forcedRole, ...others].slice(0, count);
+    }
     return scores.slice(0, count).map(s => s.role);
 }
 // ─── Role event penalties ─────────────────────────────────────────────────────

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

@@ -29,8 +29,7 @@ export function transformToBlock(event, roster) {
         playerId: roster[event.p],
         target: event.a,
         blockers: (event.b ?? []).map(i => roster[i]),
-        score: event.s,
-        activeTraits: []
+        score: event.s
     });
 }
 export function transformToLiberoReplacement(event, roster) {
@@ -46,8 +45,7 @@ export function transformToReception(event, roster) {
         type: event.t,
         playerId: roster[event.p],
         target: event.a,
-        score: event.s,
-        activeTraits: []
+        score: event.s
     });
 }
 export function transformToServe(event, roster) {
@@ -56,8 +54,7 @@ export function transformToServe(event, roster) {
         type: event.t,
         playerId: roster[event.p],
         target: event.a,
-        score: event.s,
-        activeTraits: []
+        score: event.s
     });
 }
 export function transformToSet(event, roster) {
@@ -66,8 +63,7 @@ export function transformToSet(event, roster) {
         type: event.t,
         playerId: roster[event.p],
         target: event.a,
-        score: event.s,
-        activeTraits: []
+        score: event.s
     });
 }
 export function transformToSpike(event, roster) {
@@ -76,8 +72,7 @@ export function transformToSpike(event, roster) {
         type: event.t,
         playerId: roster[event.p],
         target: event.a,
-        score: event.s,
-        activeTraits: []
+        score: event.s
     });
 }
 export function transformToSubstitution(event, roster) {

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

@@ -64,11 +64,11 @@ function decodeLegacyEvent(event) {
     switch (event.e) {
         case 0: return LiberoReplacement.create({ playerId: event.p, libero: event.l, type: event.t });
         case 1: return Substitution.create({ playerId: event.p, playerOut: event.o });
-        case 2: return Serve.create({ failure: event.f, type: event.t, playerId: event.p, target: event.a, score: event.s, activeTraits: [] });
-        case 3: return Reception.create({ failure: event.f, type: event.t, playerId: event.p, target: event.a, score: event.s, activeTraits: [] });
-        case 4: return VolleySet.create({ failure: event.f, type: event.t, playerId: event.p, target: event.a, score: event.s, activeTraits: [] });
-        case 5: return Spike.create({ failure: event.f, type: event.t, playerId: event.p, target: event.a, score: event.s, activeTraits: [] });
-        case 6: return Block.create({ failure: event.f, type: event.t, playerId: event.p, target: event.a, blockers: event.b ?? [], score: event.s, activeTraits: [] });
+        case 2: return Serve.create({ failure: event.f, type: event.t, playerId: event.p, target: event.a, score: event.s });
+        case 3: return Reception.create({ failure: event.f, type: event.t, playerId: event.p, target: event.a, score: event.s });
+        case 4: return VolleySet.create({ failure: event.f, type: event.t, playerId: event.p, target: event.a, score: event.s });
+        case 5: return Spike.create({ failure: event.f, type: event.t, playerId: event.p, target: event.a, score: event.s });
+        case 6: return Block.create({ failure: event.f, type: event.t, playerId: event.p, target: event.a, blockers: event.b ?? [], score: event.s });
         default: throw new Error(`UNKNOWN_EVENT_TYPE: ${String(event.e)}`);
     }
 }

package/dist/esm/src/service/event/schemas/block.z.d.ts

@@ -4,7 +4,7 @@ export declare const BlockInputSchema: z.ZodObject<{
     playerId: z.ZodUUID;
     score: z.ZodNumber;
     target: z.ZodNumber;
-    activeTraits: z.ZodArray<z.ZodEnum<{
+    activeTraits: z.ZodDefault<z.ZodArray<z.ZodEnum<{
         MASTER_MIND: TraitEnum.MASTER_MIND;
         MOVING_WALL: TraitEnum.MOVING_WALL;
         SURPRISE_ATTACK: TraitEnum.SURPRISE_ATTACK;
@@ -14,7 +14,7 @@ export declare const BlockInputSchema: z.ZodObject<{
         GUARDIAN: TraitEnum.GUARDIAN;
         FLOAT_SERVE: TraitEnum.FLOAT_SERVE;
         DEFENSIVE_SPECIALIST: TraitEnum.DEFENSIVE_SPECIALIST;
-    }>>;
+    }>>>;
     failure: z.ZodNumber;
     type: z.ZodNumber;
     blockers: z.ZodArray<z.ZodUUID>;

package/dist/esm/src/service/event/schemas/block.z.js

@@ -7,7 +7,7 @@ export const BlockInputSchema = z.object({
     playerId: z.uuid(),
     score: z.number().finite(),
     target: z.number().int().refine((v) => courtTargetValues.includes(v), { message: 'INVALID_COURT_TARGET' }),
-    activeTraits: z.array(z.enum(Object.values(TraitEnum))),
+    activeTraits: z.array(z.enum(Object.values(TraitEnum))).default([]),
     failure: z.number().int().refine((v) => blockFailureValues.includes(v), { message: 'INVALID_BLOCK_FAILURE' }),
     type: z.number().int().refine((v) => blockTypeValues.includes(v), { message: 'INVALID_BLOCK_TYPE' }),
     blockers: z.array(z.uuid())

package/dist/esm/src/service/event/schemas/reception.z.d.ts

@@ -4,7 +4,7 @@ export declare const ReceptionInputSchema: z.ZodObject<{
     playerId: z.ZodUUID;
     score: z.ZodNumber;
     target: z.ZodNumber;
-    activeTraits: z.ZodArray<z.ZodEnum<{
+    activeTraits: z.ZodDefault<z.ZodArray<z.ZodEnum<{
         MASTER_MIND: TraitEnum.MASTER_MIND;
         MOVING_WALL: TraitEnum.MOVING_WALL;
         SURPRISE_ATTACK: TraitEnum.SURPRISE_ATTACK;
@@ -14,7 +14,7 @@ export declare const ReceptionInputSchema: z.ZodObject<{
         GUARDIAN: TraitEnum.GUARDIAN;
         FLOAT_SERVE: TraitEnum.FLOAT_SERVE;
         DEFENSIVE_SPECIALIST: TraitEnum.DEFENSIVE_SPECIALIST;
-    }>>;
+    }>>>;
     failure: z.ZodNumber;
     type: z.ZodNumber;
 }, z.core.$strip>;

package/dist/esm/src/service/event/schemas/reception.z.js

@@ -7,7 +7,7 @@ export const ReceptionInputSchema = z.object({
     playerId: z.uuid(),
     score: z.number().finite(),
     target: z.number().int().refine((v) => courtTargetValues.includes(v), { message: 'INVALID_COURT_TARGET' }),
-    activeTraits: z.array(z.enum(Object.values(TraitEnum))),
+    activeTraits: z.array(z.enum(Object.values(TraitEnum))).default([]),
     failure: z.number().int().refine((v) => receptionFailureValues.includes(v), { message: 'INVALID_RECEPTION_FAILURE' }),
     type: z.number().int().refine((v) => receptionTypeValues.includes(v), { message: 'INVALID_RECEPTION_TYPE' })
 });

package/dist/esm/src/service/event/schemas/serve.z.d.ts

@@ -4,7 +4,7 @@ export declare const ServeInputSchema: z.ZodObject<{
     playerId: z.ZodUUID;
     score: z.ZodNumber;
     target: z.ZodNumber;
-    activeTraits: z.ZodArray<z.ZodEnum<{
+    activeTraits: z.ZodDefault<z.ZodArray<z.ZodEnum<{
         MASTER_MIND: TraitEnum.MASTER_MIND;
         MOVING_WALL: TraitEnum.MOVING_WALL;
         SURPRISE_ATTACK: TraitEnum.SURPRISE_ATTACK;
@@ -14,7 +14,7 @@ export declare const ServeInputSchema: z.ZodObject<{
         GUARDIAN: TraitEnum.GUARDIAN;
         FLOAT_SERVE: TraitEnum.FLOAT_SERVE;
         DEFENSIVE_SPECIALIST: TraitEnum.DEFENSIVE_SPECIALIST;
-    }>>;
+    }>>>;
     failure: z.ZodNumber;
     type: z.ZodNumber;
 }, z.core.$strip>;

package/dist/esm/src/service/event/schemas/serve.z.js

@@ -7,7 +7,7 @@ export const ServeInputSchema = z.object({
     playerId: z.uuid(),
     score: z.number().finite(),
     target: z.number().int().refine((v) => courtTargetValues.includes(v), { message: 'INVALID_COURT_TARGET' }),
-    activeTraits: z.array(z.enum(Object.values(TraitEnum))),
+    activeTraits: z.array(z.enum(Object.values(TraitEnum))).default([]),
     failure: z.number().int().refine((v) => serveFailureValues.includes(v), { message: 'INVALID_SERVE_FAILURE' }),
     type: z.number().int().refine((v) => serveTypeValues.includes(v), { message: 'INVALID_SERVE_TYPE' })
 });

package/dist/esm/src/service/event/schemas/set.z.d.ts

@@ -4,7 +4,7 @@ export declare const SetInputSchema: z.ZodObject<{
     playerId: z.ZodUUID;
     score: z.ZodNumber;
     target: z.ZodNumber;
-    activeTraits: z.ZodArray<z.ZodEnum<{
+    activeTraits: z.ZodDefault<z.ZodArray<z.ZodEnum<{
         MASTER_MIND: TraitEnum.MASTER_MIND;
         MOVING_WALL: TraitEnum.MOVING_WALL;
         SURPRISE_ATTACK: TraitEnum.SURPRISE_ATTACK;
@@ -14,7 +14,7 @@ export declare const SetInputSchema: z.ZodObject<{
         GUARDIAN: TraitEnum.GUARDIAN;
         FLOAT_SERVE: TraitEnum.FLOAT_SERVE;
         DEFENSIVE_SPECIALIST: TraitEnum.DEFENSIVE_SPECIALIST;
-    }>>;
+    }>>>;
     failure: z.ZodNumber;
     type: z.ZodNumber;
 }, z.core.$strip>;

package/dist/esm/src/service/event/schemas/set.z.js

@@ -7,7 +7,7 @@ export const SetInputSchema = z.object({
     playerId: z.uuid(),
     score: z.number().finite(),
     target: z.number().int().refine((v) => courtTargetValues.includes(v), { message: 'INVALID_COURT_TARGET' }),
-    activeTraits: z.array(z.enum(Object.values(TraitEnum))),
+    activeTraits: z.array(z.enum(Object.values(TraitEnum))).default([]),
     failure: z.number().int().refine((v) => setFailureValues.includes(v), { message: 'INVALID_SET_FAILURE' }),
     type: z.number().int().refine((v) => setTypeValues.includes(v), { message: 'INVALID_SET_TYPE' })
 });

package/dist/esm/src/service/event/schemas/spike.z.d.ts

@@ -4,7 +4,7 @@ export declare const SpikeInputSchema: z.ZodObject<{
     playerId: z.ZodUUID;
     score: z.ZodNumber;
     target: z.ZodNumber;
-    activeTraits: z.ZodArray<z.ZodEnum<{
+    activeTraits: z.ZodDefault<z.ZodArray<z.ZodEnum<{
         MASTER_MIND: TraitEnum.MASTER_MIND;
         MOVING_WALL: TraitEnum.MOVING_WALL;
         SURPRISE_ATTACK: TraitEnum.SURPRISE_ATTACK;
@@ -14,7 +14,7 @@ export declare const SpikeInputSchema: z.ZodObject<{
         GUARDIAN: TraitEnum.GUARDIAN;
         FLOAT_SERVE: TraitEnum.FLOAT_SERVE;
         DEFENSIVE_SPECIALIST: TraitEnum.DEFENSIVE_SPECIALIST;
-    }>>;
+    }>>>;
     failure: z.ZodNumber;
     type: z.ZodNumber;
 }, z.core.$strip>;

package/dist/esm/src/service/event/schemas/spike.z.js

@@ -7,7 +7,7 @@ export const SpikeInputSchema = z.object({
     playerId: z.uuid(),
     score: z.number().finite(),
     target: z.number().int().refine((v) => courtTargetValues.includes(v), { message: 'INVALID_COURT_TARGET' }),
-    activeTraits: z.array(z.enum(Object.values(TraitEnum))),
+    activeTraits: z.array(z.enum(Object.values(TraitEnum))).default([]),
     failure: z.number().int().refine((v) => spikeFailureValues.includes(v), { message: 'INVALID_SPIKE_FAILURE' }),
     type: z.number().int().refine((v) => spikeTypeValues.includes(v), { message: 'INVALID_SPIKE_TYPE' })
 });

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

@@ -298,7 +298,7 @@ export class PlayerGenerator {
         const rarity = _rarity ?? rollRarity({ legendaryPity: 0, mythicPity: 0, specialPity: 0 }).rarity;
         const name = generatePlayerName(country.locales, 1)[0];
         const stats = PlayerGenerator.generatePerformance(rarity, role);
-        const roles = assignRoles(stats, rarity);
+        const roles = assignRoles(stats, rarity, role);
         const traits = assignTraits(roles, rarity, maxTraits);
         const birthAge = randomInt(15, 21);
         const declineProfile = declineProfiles[randomInt(0, declineProfiles.length)];

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

@@ -14,7 +14,7 @@ export interface RolesFormula {
     weight: PerformanceStatsParams;
 }
 export declare function calculateRoleScore(stats: PerformanceStats, role: Role): number;
-export declare function assignRoles(stats: PerformanceStats, rarity: Rarity): Role[];
+export declare function assignRoles(stats: PerformanceStats, rarity: Rarity, forcedRole?: Role): Role[];
 /**
  * Returns the role-based multiplier for a player performing a given action.
  * When the player holds multiple roles, the least-penalising role wins.

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

@@ -33,7 +33,7 @@ function getRoleCountRange(rarity) {
         default: return [1, 1];
     }
 }
-export function assignRoles(stats, rarity) {
+export function assignRoles(stats, rarity, forcedRole) {
     const scores = Object.values(RoleEnum)
         .map((role) => ({
         role,
@@ -42,6 +42,12 @@ export function assignRoles(stats, rarity) {
         .sort((x, y) => y.score - x.score);
     const [min, max] = getRoleCountRange(rarity);
     const count = min + Math.floor(Math.random() * (max - min + 1));
+    // A forced role (role pick, wishlist proc, team seeding) must be the player's primary role.
+    // Remaining slots fill with the top-scoring other roles so multi-role rarity flavour is kept.
+    if (forcedRole != null) {
+        const others = scores.map(s => s.role).filter(r => r !== forcedRole);
+        return [forcedRole, ...others].slice(0, count);
+    }
     return scores.slice(0, count).map(s => s.role);
 }
 // ─── Role event penalties ─────────────────────────────────────────────────────

package/package.json

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