volleyballsimtypes 0.0.479 → 0.0.481

package/dist/cjs/src/api/index.d.ts

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

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

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

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

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

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

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

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

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

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

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

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

@@ -92,7 +92,8 @@ function transformToAttributes(tactics, teamId) {
         designated_setters: tactics.designatedSetters.map((s) => s.id),
         offensive_preferences: tactics.offensivePreferences.map(p => ({
             rotation: p.rotation,
-            order: p.order.map((a) => a.id)
+            order: p.order.map((a) => a.id),
+            tempos: p.tempos
         })),
         system_sets: tactics.systemSets?.map(s => ({
             rotationSystem: s.rotationSystem,
@@ -100,7 +101,8 @@ function transformToAttributes(tactics, teamId) {
         })),
         offensive_preference_sets: tactics.offensivePreferenceSets?.map(prefs => prefs.map(p => ({
             rotation: p.rotation,
-            order: p.order.map((a) => a.id)
+            order: p.order.map((a) => a.id),
+            tempos: p.tempos
         }))),
         replace_knocked_immediately: tactics.replaceKnockedImmediately,
         injury_replacements: tactics.injuryReplacements.map(ir => ({
@@ -190,7 +192,8 @@ function transformToObject(model, roster) {
         designatedSetters: (model.designated_setters ?? []).map((id) => findPlayer(id, roster)),
         offensivePreferences: (model.offensive_preferences ?? []).map(p => ({
             rotation: p.rotation,
-            order: p.order.map((id) => findPlayer(id, roster))
+            order: p.order.map((id) => findPlayer(id, roster)),
+            tempos: p.tempos
         })),
         systemSets: model.system_sets?.map(s => ({
             rotationSystem: s.rotationSystem,
@@ -198,7 +201,8 @@ function transformToObject(model, roster) {
         })),
         offensivePreferenceSets: model.offensive_preference_sets?.map(prefs => prefs.map(p => ({
             rotation: p.rotation,
-            order: p.order.map((id) => findPlayer(id, roster))
+            order: p.order.map((id) => findPlayer(id, roster)),
+            tempos: p.tempos
         }))),
         // LENIENT: keep only boolean entries keyed by a court starter or, when a second libero exists, the starting
         // libero (the libero knock toggle is an L2-only feature, owner 2026-07-06) so stale jsonb (an ex-starter's

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

@@ -184,6 +184,19 @@ function makeTactics(designatedSubs) {
         (0, globals_1.expect)(back.systemSets).toBeUndefined();
         (0, globals_1.expect)(back.offensivePreferenceSets).toBeUndefined();
     });
+    (0, globals_1.it)('round-trips a per-starter tempos map on offensive preferences', () => {
+        const withTempos = service_1.Tactics.create({
+            lineup: { 4: p4, 3: p3, 2: p2, 5: p5, 6: p6, 1: p1, bench: [] },
+            liberoReplacements: [],
+            offensivePreferences: [{ rotation: 1, order: [p2, p3], tempos: { [p2.id]: 'FAST', [p3.id]: 'HIGH' } }]
+        });
+        const attrs = (0, tactics_1.transformFromTactics)(withTempos, 'team-1');
+        (0, globals_1.expect)(attrs.offensive_preferences).toEqual([
+            { rotation: 1, order: [p2.id, p3.id], tempos: { [p2.id]: 'FAST', [p3.id]: 'HIGH' } }
+        ]);
+        const back = (0, tactics_1.transformToTactics)(attrs, roster);
+        (0, globals_1.expect)(back.offensivePreferences[0].tempos).toEqual({ [p2.id]: 'FAST', [p3.id]: 'HIGH' });
+    });
 });
 (0, globals_1.describe)('libero injuries — service <-> row round-trip + lenient heal', () => {
     const country = (0, test_helpers_1.makeCountry)();

package/dist/cjs/src/service/competition/standing.js

@@ -41,6 +41,11 @@ class Standing {
         // effective ratio here that treats "won with nothing lost" as +Infinity, ranking it highest.
         const effectiveRatio = (won, lost) => lost > 0 ? won / lost : (won > 0 ? Infinity : 0);
         return (standingA, standingB) => {
+            // VNL/FIVB order: matches WON is the first criterion, then match points, then set ratio, point ratio, h2h.
+            if (standingB.matchesWon > standingA.matchesWon)
+                return 1;
+            if (standingA.matchesWon > standingB.matchesWon)
+                return -1;
             if (standingB.points > standingA.points)
                 return 1;
             if (standingA.points > standingB.points)

package/dist/cjs/src/service/competition/standing.test.js

@@ -115,23 +115,34 @@ function makeStanding(teamId, opts = {}) {
     });
     // ─── sortFn ──────────────────────────────────────────────────────────────────
     (0, globals_1.describe)('sortFn()', () => {
-        (0, globals_1.it)('sorts by points descending', () => {
+        (0, globals_1.it)('ranks by matches won ahead of points (VNL first criterion)', () => {
             const idA = (0, uuid_1.v4)();
             const idB = (0, uuid_1.v4)();
-            // A has 3 points (1 win 3-0), B has 0 points
+            // A: won32=2 → 2 wins, 4 points. B: won30=1 + lost23=2 → 1 win, 5 points.
+            // Wins is the first criterion, so A ranks above B even though B has more points.
+            const a = makeStanding(idA, { won32: 2 });
+            const b = makeStanding(idB, { won30: 1, lost23: 2 });
+            const sorted = [b, a].sort(standing_1.Standing.sortFn([]));
+            (0, globals_1.expect)(sorted[0].teamId).toBe(idA);
+            (0, globals_1.expect)(sorted[1].teamId).toBe(idB);
+        });
+        (0, globals_1.it)('breaks ties by points when wins are equal', () => {
+            const idA = (0, uuid_1.v4)();
+            const idB = (0, uuid_1.v4)();
+            // Both 1 win. A: won30=1 → 3 points. B: won32=1 → 2 points. Points decides once wins tie.
             const a = makeStanding(idA, { won30: 1 });
-            const b = makeStanding(idB);
+            const b = makeStanding(idB, { won32: 1 });
             const sorted = [b, a].sort(standing_1.Standing.sortFn([]));
             (0, globals_1.expect)(sorted[0].teamId).toBe(idA);
             (0, globals_1.expect)(sorted[1].teamId).toBe(idB);
         });
-        (0, globals_1.it)('breaks ties by setsRatio when points are equal', () => {
+        (0, globals_1.it)('breaks ties by setsRatio when wins and points are equal', () => {
             const idA = (0, uuid_1.v4)();
             const idB = (0, uuid_1.v4)();
-            // Both 4 points, but A has better setsRatio:
-            //   A: won32=2 → points=4, setsWon=6, setsLost=4, setsRatio=1.5
-            //   B: won31=1, lost23=1 → points=(1*3)+(1)=4, setsWon=5, setsLost=4, setsRatio=1.25
-            const a = makeStanding(idA, { won32: 2 });
+            // Both 1 win and 4 points, but A has the better setsRatio:
+            //   A: won30=1, lost23=1 → setsWon=5, setsLost=3, setsRatio≈1.67
+            //   B: won31=1, lost23=1 → setsWon=5, setsLost=4, setsRatio=1.25
+            const a = makeStanding(idA, { won30: 1, lost23: 1 });
             const b = makeStanding(idB, { won31: 1, lost23: 1 });
             const sorted = [b, a].sort(standing_1.Standing.sortFn([]));
             (0, globals_1.expect)(sorted[0].teamId).toBe(idA);

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

@@ -34,5 +34,6 @@ export declare const SetInputSchema: z.ZodObject<{
         severity: z.ZodNumber;
         playerId: z.ZodOptional<z.ZodUUID>;
     }, z.core.$strip>>;
+    tempo: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 export type SetInput = z.infer<typeof SetInputSchema>;

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

@@ -6,6 +6,7 @@ const player_1 = require("../../player");
 const incident_z_1 = require("./incident.z");
 const setTypeValues = [0, 1];
 const setFailureValues = [0, 1, 2, 3, 4];
+const setTempoValues = [0, 1, 2];
 const courtTargetValues = Array.from({ length: 13 }, (_, i) => i);
 exports.SetInputSchema = zod_1.z.object({
     playerId: zod_1.z.uuid(),
@@ -14,5 +15,7 @@ exports.SetInputSchema = zod_1.z.object({
     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' }),
-    incident: incident_z_1.EventIncidentSchema.optional()
+    incident: incident_z_1.EventIncidentSchema.optional(),
+    // Set tempo (FIRST=0, SECOND=1, HIGH=2). Optional: absent on dumps, failed sets, and every pre-tempo event.
+    tempo: zod_1.z.number().int().refine((v) => setTempoValues.includes(v), { message: 'INVALID_SET_TEMPO' }).optional()
 });

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

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

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+const set_z_1 = require("./set.z");
+const base = {
+    playerId: '11111111-1111-4111-8111-111111111111',
+    score: 90,
+    target: 4,
+    activeTraits: [],
+    failure: 0,
+    type: 0
+};
+(0, globals_1.describe)('SetInputSchema — tempo', () => {
+    (0, globals_1.it)('accepts every tempo 0-2 (FIRST / SECOND / HIGH)', () => {
+        for (const tempo of [0, 1, 2]) {
+            (0, globals_1.expect)(set_z_1.SetInputSchema.safeParse({ ...base, tempo }).success).toBe(true);
+        }
+    });
+    (0, globals_1.it)('accepts an absent tempo (Auto, dumps, failed sets)', () => {
+        (0, globals_1.expect)(set_z_1.SetInputSchema.safeParse(base).success).toBe(true);
+    });
+    (0, globals_1.it)('rejects an out-of-range tempo', () => {
+        (0, globals_1.expect)(set_z_1.SetInputSchema.safeParse({ ...base, tempo: 3 }).success).toBe(false);
+        (0, globals_1.expect)(set_z_1.SetInputSchema.safeParse({ ...base, tempo: -1 }).success).toBe(false);
+    });
+    (0, globals_1.it)('rejects a non-integer tempo', () => {
+        (0, globals_1.expect)(set_z_1.SetInputSchema.safeParse({ ...base, tempo: 1.5 }).success).toBe(false);
+    });
+});

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

@@ -4,6 +4,12 @@ export declare enum SetTypeEnum {
     DUMP = 1
 }
 export type SetType = SetTypeEnum.OVERHAND | SetTypeEnum.DUMP;
+export declare enum SetTempoEnum {
+    FIRST = 0,
+    SECOND = 1,
+    HIGH = 2
+}
+export type SetTempo = SetTempoEnum.FIRST | SetTempoEnum.SECOND | SetTempoEnum.HIGH;
 export declare enum SetFailureEnum {
     NO_FAILURE = 0,
     FAULT = 1,
@@ -15,6 +21,7 @@ export type SetFailure = SetFailureEnum.NO_FAILURE | SetFailureEnum.FAULT | SetF
 export declare class Set extends InPlayEvent<SetFailure, SetType> {
     readonly failure: SetFailure;
     readonly type: SetType;
+    readonly tempo?: SetTempo;
     static create(input: unknown): Set;
     private constructor();
     toString(): string;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Set = exports.SetFailureEnum = exports.SetTypeEnum = void 0;
+exports.Set = exports.SetFailureEnum = exports.SetTempoEnum = exports.SetTypeEnum = void 0;
 const rally_event_1 = require("./rally-event");
 const in_play_event_1 = require("./in-play-event");
 const set_z_1 = require("./schemas/set.z");
@@ -9,6 +9,16 @@ var SetTypeEnum;
     SetTypeEnum[SetTypeEnum["OVERHAND"] = 0] = "OVERHAND";
     SetTypeEnum[SetTypeEnum["DUMP"] = 1] = "DUMP";
 })(SetTypeEnum || (exports.SetTypeEnum = SetTypeEnum = {}));
+// The tempo of a set (set-tempo rework). Decided by the simulator (pass quality + target lane + setter skill)
+// or forced by a per-player offensive preference. FIRST = quick (swings the `quick` stat, hardest to nail,
+// hardest to block); SECOND = second tempo; HIGH = high ball (the fallback, easiest to block). Only present on
+// a successful overhand set; absent for dumps, failed sets, and free-ball/scramble attacks.
+var SetTempoEnum;
+(function (SetTempoEnum) {
+    SetTempoEnum[SetTempoEnum["FIRST"] = 0] = "FIRST";
+    SetTempoEnum[SetTempoEnum["SECOND"] = 1] = "SECOND";
+    SetTempoEnum[SetTempoEnum["HIGH"] = 2] = "HIGH";
+})(SetTempoEnum || (exports.SetTempoEnum = SetTempoEnum = {}));
 var SetFailureEnum;
 (function (SetFailureEnum) {
     SetFailureEnum[SetFailureEnum["NO_FAILURE"] = 0] = "NO_FAILURE";
@@ -31,15 +41,17 @@ class Set extends in_play_event_1.InPlayEvent {
         }
         return new Set(result.data);
     }
-    constructor({ score, playerId, target, failure, type, activeTraits, incident }) {
+    constructor({ score, playerId, target, failure, type, activeTraits, incident, tempo }) {
         super({ score, playerId, target, activeTraits, incident, eventType });
         this.type = type;
         this.failure = failure;
+        this.tempo = tempo;
     }
     toString() {
         const failure = `"failure":${this.failure}`;
         const type = `"type":${this.type}`;
-        return `{${this._toString()},${failure},${type}}`;
+        const tempo = this.tempo !== undefined ? `,"tempo":${this.tempo}` : '';
+        return `{${this._toString()},${failure},${type}${tempo}}`;
     }
 }
 exports.Set = Set;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -86,7 +86,8 @@ function transformToAttributes(tactics, teamId) {
         designated_setters: tactics.designatedSetters.map((s) => s.id),
         offensive_preferences: tactics.offensivePreferences.map(p => ({
             rotation: p.rotation,
-            order: p.order.map((a) => a.id)
+            order: p.order.map((a) => a.id),
+            tempos: p.tempos
         })),
         system_sets: tactics.systemSets?.map(s => ({
             rotationSystem: s.rotationSystem,
@@ -94,7 +95,8 @@ function transformToAttributes(tactics, teamId) {
         })),
         offensive_preference_sets: tactics.offensivePreferenceSets?.map(prefs => prefs.map(p => ({
             rotation: p.rotation,
-            order: p.order.map((a) => a.id)
+            order: p.order.map((a) => a.id),
+            tempos: p.tempos
         }))),
         replace_knocked_immediately: tactics.replaceKnockedImmediately,
         injury_replacements: tactics.injuryReplacements.map(ir => ({
@@ -184,7 +186,8 @@ function transformToObject(model, roster) {
         designatedSetters: (model.designated_setters ?? []).map((id) => findPlayer(id, roster)),
         offensivePreferences: (model.offensive_preferences ?? []).map(p => ({
             rotation: p.rotation,
-            order: p.order.map((id) => findPlayer(id, roster))
+            order: p.order.map((id) => findPlayer(id, roster)),
+            tempos: p.tempos
         })),
         systemSets: model.system_sets?.map(s => ({
             rotationSystem: s.rotationSystem,
@@ -192,7 +195,8 @@ function transformToObject(model, roster) {
         })),
         offensivePreferenceSets: model.offensive_preference_sets?.map(prefs => prefs.map(p => ({
             rotation: p.rotation,
-            order: p.order.map((id) => findPlayer(id, roster))
+            order: p.order.map((id) => findPlayer(id, roster)),
+            tempos: p.tempos
         }))),
         // LENIENT: keep only boolean entries keyed by a court starter or, when a second libero exists, the starting
         // libero (the libero knock toggle is an L2-only feature, owner 2026-07-06) so stale jsonb (an ex-starter's

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

@@ -182,6 +182,19 @@ describe('per-set tactics — service <-> row round-trip', () => {
         expect(back.systemSets).toBeUndefined();
         expect(back.offensivePreferenceSets).toBeUndefined();
     });
+    it('round-trips a per-starter tempos map on offensive preferences', () => {
+        const withTempos = Tactics.create({
+            lineup: { 4: p4, 3: p3, 2: p2, 5: p5, 6: p6, 1: p1, bench: [] },
+            liberoReplacements: [],
+            offensivePreferences: [{ rotation: 1, order: [p2, p3], tempos: { [p2.id]: 'FAST', [p3.id]: 'HIGH' } }]
+        });
+        const attrs = transformFromTactics(withTempos, 'team-1');
+        expect(attrs.offensive_preferences).toEqual([
+            { rotation: 1, order: [p2.id, p3.id], tempos: { [p2.id]: 'FAST', [p3.id]: 'HIGH' } }
+        ]);
+        const back = transformToTactics(attrs, roster);
+        expect(back.offensivePreferences[0].tempos).toEqual({ [p2.id]: 'FAST', [p3.id]: 'HIGH' });
+    });
 });
 describe('libero injuries — service <-> row round-trip + lenient heal', () => {
     const country = makeCountry();

package/dist/esm/src/service/competition/standing.js

@@ -38,6 +38,11 @@ export class Standing {
         // effective ratio here that treats "won with nothing lost" as +Infinity, ranking it highest.
         const effectiveRatio = (won, lost) => lost > 0 ? won / lost : (won > 0 ? Infinity : 0);
         return (standingA, standingB) => {
+            // VNL/FIVB order: matches WON is the first criterion, then match points, then set ratio, point ratio, h2h.
+            if (standingB.matchesWon > standingA.matchesWon)
+                return 1;
+            if (standingA.matchesWon > standingB.matchesWon)
+                return -1;
             if (standingB.points > standingA.points)
                 return 1;
             if (standingA.points > standingB.points)

package/dist/esm/src/service/competition/standing.test.js

@@ -113,23 +113,34 @@ describe('Standing', () => {
     });
     // ─── sortFn ──────────────────────────────────────────────────────────────────
     describe('sortFn()', () => {
-        it('sorts by points descending', () => {
+        it('ranks by matches won ahead of points (VNL first criterion)', () => {
             const idA = uuidv4();
             const idB = uuidv4();
-            // A has 3 points (1 win 3-0), B has 0 points
+            // A: won32=2 → 2 wins, 4 points. B: won30=1 + lost23=2 → 1 win, 5 points.
+            // Wins is the first criterion, so A ranks above B even though B has more points.
+            const a = makeStanding(idA, { won32: 2 });
+            const b = makeStanding(idB, { won30: 1, lost23: 2 });
+            const sorted = [b, a].sort(Standing.sortFn([]));
+            expect(sorted[0].teamId).toBe(idA);
+            expect(sorted[1].teamId).toBe(idB);
+        });
+        it('breaks ties by points when wins are equal', () => {
+            const idA = uuidv4();
+            const idB = uuidv4();
+            // Both 1 win. A: won30=1 → 3 points. B: won32=1 → 2 points. Points decides once wins tie.
             const a = makeStanding(idA, { won30: 1 });
-            const b = makeStanding(idB);
+            const b = makeStanding(idB, { won32: 1 });
             const sorted = [b, a].sort(Standing.sortFn([]));
             expect(sorted[0].teamId).toBe(idA);
             expect(sorted[1].teamId).toBe(idB);
         });
-        it('breaks ties by setsRatio when points are equal', () => {
+        it('breaks ties by setsRatio when wins and points are equal', () => {
             const idA = uuidv4();
             const idB = uuidv4();
-            // Both 4 points, but A has better setsRatio:
-            //   A: won32=2 → points=4, setsWon=6, setsLost=4, setsRatio=1.5
-            //   B: won31=1, lost23=1 → points=(1*3)+(1)=4, setsWon=5, setsLost=4, setsRatio=1.25
-            const a = makeStanding(idA, { won32: 2 });
+            // Both 1 win and 4 points, but A has the better setsRatio:
+            //   A: won30=1, lost23=1 → setsWon=5, setsLost=3, setsRatio≈1.67
+            //   B: won31=1, lost23=1 → setsWon=5, setsLost=4, setsRatio=1.25
+            const a = makeStanding(idA, { won30: 1, lost23: 1 });
             const b = makeStanding(idB, { won31: 1, lost23: 1 });
             const sorted = [b, a].sort(Standing.sortFn([]));
             expect(sorted[0].teamId).toBe(idA);

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

@@ -34,5 +34,6 @@ export declare const SetInputSchema: z.ZodObject<{
         severity: z.ZodNumber;
         playerId: z.ZodOptional<z.ZodUUID>;
     }, z.core.$strip>>;
+    tempo: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 export type SetInput = z.infer<typeof SetInputSchema>;

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

@@ -3,6 +3,7 @@ import { TraitEnum } from '../../player';
 import { EventIncidentSchema } from './incident.z';
 const setTypeValues = [0, 1];
 const setFailureValues = [0, 1, 2, 3, 4];
+const setTempoValues = [0, 1, 2];
 const courtTargetValues = Array.from({ length: 13 }, (_, i) => i);
 export const SetInputSchema = z.object({
     playerId: z.uuid(),
@@ -11,5 +12,7 @@ export const SetInputSchema = z.object({
     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' }),
-    incident: EventIncidentSchema.optional()
+    incident: EventIncidentSchema.optional(),
+    // Set tempo (FIRST=0, SECOND=1, HIGH=2). Optional: absent on dumps, failed sets, and every pre-tempo event.
+    tempo: z.number().int().refine((v) => setTempoValues.includes(v), { message: 'INVALID_SET_TEMPO' }).optional()
 });

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

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

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

@@ -0,0 +1,27 @@
+import { describe, it, expect } from '@jest/globals';
+import { SetInputSchema } from './set.z';
+const base = {
+    playerId: '11111111-1111-4111-8111-111111111111',
+    score: 90,
+    target: 4,
+    activeTraits: [],
+    failure: 0,
+    type: 0
+};
+describe('SetInputSchema — tempo', () => {
+    it('accepts every tempo 0-2 (FIRST / SECOND / HIGH)', () => {
+        for (const tempo of [0, 1, 2]) {
+            expect(SetInputSchema.safeParse({ ...base, tempo }).success).toBe(true);
+        }
+    });
+    it('accepts an absent tempo (Auto, dumps, failed sets)', () => {
+        expect(SetInputSchema.safeParse(base).success).toBe(true);
+    });
+    it('rejects an out-of-range tempo', () => {
+        expect(SetInputSchema.safeParse({ ...base, tempo: 3 }).success).toBe(false);
+        expect(SetInputSchema.safeParse({ ...base, tempo: -1 }).success).toBe(false);
+    });
+    it('rejects a non-integer tempo', () => {
+        expect(SetInputSchema.safeParse({ ...base, tempo: 1.5 }).success).toBe(false);
+    });
+});

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

@@ -4,6 +4,12 @@ export declare enum SetTypeEnum {
     DUMP = 1
 }
 export type SetType = SetTypeEnum.OVERHAND | SetTypeEnum.DUMP;
+export declare enum SetTempoEnum {
+    FIRST = 0,
+    SECOND = 1,
+    HIGH = 2
+}
+export type SetTempo = SetTempoEnum.FIRST | SetTempoEnum.SECOND | SetTempoEnum.HIGH;
 export declare enum SetFailureEnum {
     NO_FAILURE = 0,
     FAULT = 1,
@@ -15,6 +21,7 @@ export type SetFailure = SetFailureEnum.NO_FAILURE | SetFailureEnum.FAULT | SetF
 export declare class Set extends InPlayEvent<SetFailure, SetType> {
     readonly failure: SetFailure;
     readonly type: SetType;
+    readonly tempo?: SetTempo;
     static create(input: unknown): Set;
     private constructor();
     toString(): string;

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

@@ -6,6 +6,16 @@ export var SetTypeEnum;
     SetTypeEnum[SetTypeEnum["OVERHAND"] = 0] = "OVERHAND";
     SetTypeEnum[SetTypeEnum["DUMP"] = 1] = "DUMP";
 })(SetTypeEnum || (SetTypeEnum = {}));
+// The tempo of a set (set-tempo rework). Decided by the simulator (pass quality + target lane + setter skill)
+// or forced by a per-player offensive preference. FIRST = quick (swings the `quick` stat, hardest to nail,
+// hardest to block); SECOND = second tempo; HIGH = high ball (the fallback, easiest to block). Only present on
+// a successful overhand set; absent for dumps, failed sets, and free-ball/scramble attacks.
+export var SetTempoEnum;
+(function (SetTempoEnum) {
+    SetTempoEnum[SetTempoEnum["FIRST"] = 0] = "FIRST";
+    SetTempoEnum[SetTempoEnum["SECOND"] = 1] = "SECOND";
+    SetTempoEnum[SetTempoEnum["HIGH"] = 2] = "HIGH";
+})(SetTempoEnum || (SetTempoEnum = {}));
 export var SetFailureEnum;
 (function (SetFailureEnum) {
     SetFailureEnum[SetFailureEnum["NO_FAILURE"] = 0] = "NO_FAILURE";
@@ -28,14 +38,16 @@ export class Set extends InPlayEvent {
         }
         return new Set(result.data);
     }
-    constructor({ score, playerId, target, failure, type, activeTraits, incident }) {
+    constructor({ score, playerId, target, failure, type, activeTraits, incident, tempo }) {
         super({ score, playerId, target, activeTraits, incident, eventType });
         this.type = type;
         this.failure = failure;
+        this.tempo = tempo;
     }
     toString() {
         const failure = `"failure":${this.failure}`;
         const type = `"type":${this.type}`;
-        return `{${this._toString()},${failure},${type}}`;
+        const tempo = this.tempo !== undefined ? `,"tempo":${this.tempo}` : '';
+        return `{${this._toString()},${failure},${type}${tempo}}`;
     }
 }

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

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

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

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

package/dist/esm/src/service/team/schemas/tactics.z.js

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

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

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

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

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

package/package.json

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