volleyballsimtypes 0.0.387 → 0.0.389

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

@@ -61,6 +61,7 @@ export interface Tactics {
     substitutionTolerance: number;
     liberoReplacements: string[];
     pinchServerSubs: Record<string, string>;
+    receiveRotationOffset: boolean;
 }
 export type Team = Omit<DataProps<_Team>, 'roster' | '_rating' | 'rating' | 'tactics'> & {
     roster: Player[];

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

@@ -19,10 +19,11 @@ export interface TacticsAttributes {
     lineup: TacticsLineupAttributes;
     libero_replacements: PlayerId[];
     pinch_server_subs: PinchServerSubsAttributes;
+    receive_rotation_offset: boolean;
 }
 export type TacticsPk = 'team_id';
 export type TacticsId = TacticsModel[TacticsPk];
-export type TacticsOptionalAttributes = 'substitution_tolerance' | 'lineup' | 'libero_replacements' | 'pinch_server_subs';
+export type TacticsOptionalAttributes = 'substitution_tolerance' | 'lineup' | 'libero_replacements' | 'pinch_server_subs' | 'receive_rotation_offset';
 export type TacticsCreationAttributes = Optional<TacticsAttributes, TacticsOptionalAttributes>;
 export declare class TacticsModel extends Model<TacticsAttributes, TacticsCreationAttributes> implements TacticsAttributes {
     team_id: string;
@@ -30,6 +31,7 @@ export declare class TacticsModel extends Model<TacticsAttributes, TacticsCreati
     lineup: TacticsLineupAttributes;
     libero_replacements: PlayerId[];
     pinch_server_subs: PinchServerSubsAttributes;
+    receive_rotation_offset: boolean;
     team: TeamModel;
     getTeam: Sequelize.BelongsToGetAssociationMixin<TeamModel>;
     setTeam: Sequelize.BelongsToSetAssociationMixin<TeamModel, TeamId>;

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

@@ -34,6 +34,11 @@ class TacticsModel extends sequelize_1.Model {
                 type: sequelize_1.DataTypes.JSONB,
                 allowNull: false,
                 defaultValue: {}
+            },
+            receive_rotation_offset: {
+                type: sequelize_1.DataTypes.BOOLEAN,
+                allowNull: false,
+                defaultValue: false
             }
         }, {
             sequelize,

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

@@ -37,6 +37,7 @@ function transformToAttributes(tactics, teamId) {
     return {
         team_id: teamId,
         substitution_tolerance: tactics.substitutionTolerance ?? 0,
+        receive_rotation_offset: tactics.receiveRotationOffset ?? false,
         lineup: transformFromLineup(tactics.lineup),
         libero_replacements: tactics.liberoReplacements.map((lr) => lr.id),
         pinch_server_subs: Object.fromEntries([...tactics.pinchServerSubs].map(([k, v]) => [k.id, v.id]))
@@ -52,6 +53,7 @@ function buildPinchServerSubs(pinchServerSubs, roster) {
 function transformToObject(model, roster) {
     return service_1.Tactics.create({
         substitutionTolerance: model.substitution_tolerance,
+        receiveRotationOffset: model.receive_rotation_offset,
         lineup: transformToLineup(model.lineup, roster),
         liberoReplacements: model.libero_replacements.map((lr) => findPlayer(lr, roster)),
         pinchServerSubs: buildPinchServerSubs(model.pinch_server_subs, roster)

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

@@ -36,20 +36,28 @@ class Standing {
         this.totalMatches = this.matchesWon + this.matchesLost;
     }
     static sortFn(matches) {
+        // A zero denominator (no sets/points lost) is the BEST possible ratio, not the worst. The stored
+        // setsRatio/pointsRatio fall back to 0 in that case (and the table shows "MAX"), so we compare an
+        // 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) => {
             if (standingB.points > standingA.points)
                 return 1;
-            else if (standingA.points > standingB.points)
+            if (standingA.points > standingB.points)
                 return -1;
-            else if (standingB.setsRatio > standingA.setsRatio)
+            const setRatioA = effectiveRatio(standingA.setsWon, standingA.setsLost);
+            const setRatioB = effectiveRatio(standingB.setsWon, standingB.setsLost);
+            if (setRatioB > setRatioA)
                 return 1;
-            else if (standingA.setsRatio > standingB.setsRatio)
+            if (setRatioA > setRatioB)
                 return -1;
-            else if (standingB.pointsRatio > standingA.pointsRatio)
+            const pointRatioA = effectiveRatio(standingA.pointsWon, standingA.pointsLost);
+            const pointRatioB = effectiveRatio(standingB.pointsWon, standingB.pointsLost);
+            if (pointRatioB > pointRatioA)
                 return 1;
-            else if (standingA.pointsRatio > standingB.pointsRatio)
+            if (pointRatioA > pointRatioB)
                 return -1;
-            else if (matches.length > 0) {
+            if (matches.length > 0) {
                 const ab = matches.find((match) => match.homeTeam.id === standingA.teamId && match.awayTeam.id === standingB.teamId);
                 const ba = matches.find((match) => match.awayTeam.id === standingA.teamId && match.homeTeam.id === standingB.teamId);
                 if (ba == null && ab == null)
@@ -66,8 +74,7 @@ class Standing {
                 const b = (ba.homeScore ?? 0) + (ab.awayScore ?? 0);
                 return b - a;
             }
-            else
-                return 0;
+            return 0;
         };
     }
     calculateStanding(matches) {

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

@@ -136,6 +136,18 @@ function makeStanding(teamId, opts = {}) {
             const sorted = [b, a].sort(standing_1.Standing.sortFn([]));
             (0, globals_1.expect)(sorted[0].teamId).toBe(idA);
         });
+        (0, globals_1.it)('ranks a team with no sets lost (MAX ratio) above a finite setsRatio when points tie', () => {
+            const idA = (0, uuid_1.v4)();
+            const idB = (0, uuid_1.v4)();
+            // Both 6 points. A swept its matches (won30=2 → setsWon=6, setsLost=0 → ratio is MAX/infinite);
+            // B also has 6 points but conceded sets (won31=2 → setsWon=6, setsLost=2 → setsRatio=3).
+            // The undefeated-in-sets team must rank FIRST, not last (the divide-by-zero bug ranked it last).
+            const a = makeStanding(idA, { won30: 2 });
+            const b = makeStanding(idB, { won31: 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)('falls back to pointsRatio when points and setsRatio are equal', () => {
             const idA = (0, uuid_1.v4)();
             const idB = (0, uuid_1.v4)();

package/dist/cjs/src/service/match/court-position.d.ts

@@ -29,6 +29,7 @@ export declare enum CourtTarget {
 }
 export declare function getPositions(): CourtPosition[];
 export declare function rotatePosition(position: number): CourtPosition;
+export declare function rotatePositionBack(position: number): CourtPosition;
 export declare function isFrontRow(position: number): boolean;
 export declare function isBackRow(position: number): boolean;
 export declare function getCourtRow(row: CourtRow): CourtPosition[];

package/dist/cjs/src/service/match/court-position.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CourtTarget = exports.CourtPosition = exports.CourtRow = void 0;
 exports.getPositions = getPositions;
 exports.rotatePosition = rotatePosition;
+exports.rotatePositionBack = rotatePositionBack;
 exports.isFrontRow = isFrontRow;
 exports.isBackRow = isBackRow;
 exports.getCourtRow = getCourtRow;
@@ -53,6 +54,16 @@ function rotatePosition(position) {
     else
         return CourtPosition.MIDDLE_BACK;
 }
+// Inverse of rotatePosition (one rotation counter-clockwise): 1->2, 2->3, ... 5->6, 6->1.
+// Used to start a receiving team "one rotation behind" so the chosen server serves first after side-out.
+function rotatePositionBack(position) {
+    if (position < 1 || position > 6)
+        throw new Error('POSITION_INDEX_OUT_OF_BOUNDS');
+    if (position === CourtPosition.MIDDLE_BACK)
+        return CourtPosition.RIGHT_BACK;
+    else
+        return position + 1;
+}
 function isFrontRow(position) {
     if (position < 1 || position > 6)
         throw new Error('POSITION_INDEX_OUT_OF_BOUNDS');

package/dist/cjs/src/service/match/court-position.test.d.ts

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

package/dist/cjs/src/service/match/court-position.test.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+const court_position_1 = require("./court-position");
+(0, globals_1.describe)('rotatePositionBack', () => {
+    (0, globals_1.it)('rotates one step counter-clockwise (1->2, 2->3, 3->4, 4->5, 5->6, 6->1)', () => {
+        (0, globals_1.expect)((0, court_position_1.rotatePositionBack)(court_position_1.CourtPosition.RIGHT_BACK)).toBe(court_position_1.CourtPosition.RIGHT_FRONT); // 1 -> 2
+        (0, globals_1.expect)((0, court_position_1.rotatePositionBack)(court_position_1.CourtPosition.RIGHT_FRONT)).toBe(court_position_1.CourtPosition.MIDDLE_FRONT); // 2 -> 3
+        (0, globals_1.expect)((0, court_position_1.rotatePositionBack)(court_position_1.CourtPosition.MIDDLE_FRONT)).toBe(court_position_1.CourtPosition.LEFT_FRONT); // 3 -> 4
+        (0, globals_1.expect)((0, court_position_1.rotatePositionBack)(court_position_1.CourtPosition.LEFT_FRONT)).toBe(court_position_1.CourtPosition.LEFT_BACK); // 4 -> 5
+        (0, globals_1.expect)((0, court_position_1.rotatePositionBack)(court_position_1.CourtPosition.LEFT_BACK)).toBe(court_position_1.CourtPosition.MIDDLE_BACK); // 5 -> 6
+        (0, globals_1.expect)((0, court_position_1.rotatePositionBack)(court_position_1.CourtPosition.MIDDLE_BACK)).toBe(court_position_1.CourtPosition.RIGHT_BACK); // 6 -> 1
+    });
+    (0, globals_1.it)('is the exact inverse of rotatePosition for every court position', () => {
+        for (let p = 1; p <= 6; p++) {
+            (0, globals_1.expect)((0, court_position_1.rotatePosition)((0, court_position_1.rotatePositionBack)(p))).toBe(p);
+            (0, globals_1.expect)((0, court_position_1.rotatePositionBack)((0, court_position_1.rotatePosition)(p))).toBe(p);
+        }
+    });
+    (0, globals_1.it)('throws POSITION_INDEX_OUT_OF_BOUNDS outside 1..6', () => {
+        (0, globals_1.expect)(() => (0, court_position_1.rotatePositionBack)(0)).toThrow('POSITION_INDEX_OUT_OF_BOUNDS');
+        (0, globals_1.expect)(() => (0, court_position_1.rotatePositionBack)(7)).toThrow('POSITION_INDEX_OUT_OF_BOUNDS');
+        (0, globals_1.expect)(() => (0, court_position_1.rotatePositionBack)(-1)).toThrow('POSITION_INDEX_OUT_OF_BOUNDS');
+    });
+});

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

@@ -13,6 +13,7 @@ export declare const TacticsInputSchema: z.ZodObject<{
     }, z.core.$strip>;
     substitutionTolerance: z.ZodNumber;
     liberoReplacements: z.ZodArray<z.ZodCustom<Player, Player>>;
+    receiveRotationOffset: z.ZodDefault<z.ZodBoolean>;
     pinchServerSubs: z.ZodCustom<Map<Player, Player>, Map<Player, Player>>;
 }, z.core.$strip>;
 export type TacticsInput = z.infer<typeof TacticsInputSchema>;

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

@@ -47,6 +47,8 @@ exports.TacticsInputSchema = zod_1.z.object({
     lineup: lineupSchema,
     substitutionTolerance: zod_1.z.number().int().min(1).max(50),
     liberoReplacements: zod_1.z.array(playerInstanceSchema),
+    // Default false keeps every existing Tactics.create({...}) call (that omits this) valid.
+    receiveRotationOffset: zod_1.z.boolean().default(false),
     pinchServerSubs: zod_1.z.custom((v) => v instanceof Map &&
         Array.from(v.entries()).every(([k, val]) => k instanceof player_1.Player && val instanceof player_1.Player), { message: 'INVALID_PINCH_SERVER_SUBS' })
 });

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

@@ -22,6 +22,7 @@ export declare const TeamInputSchema: z.ZodObject<{
         }, z.core.$strip>;
         substitutionTolerance: z.ZodNumber;
         liberoReplacements: z.ZodArray<z.ZodCustom<Player, Player>>;
+        receiveRotationOffset: z.ZodDefault<z.ZodBoolean>;
         pinchServerSubs: z.ZodCustom<Map<Player, Player>, Map<Player, Player>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;

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

@@ -15,12 +15,14 @@ export interface TacticsOpts {
     readonly substitutionTolerance: number;
     readonly liberoReplacements: Player[];
     readonly pinchServerSubs: Map<Player, Player>;
+    readonly receiveRotationOffset: boolean;
 }
 export declare class Tactics {
     readonly lineup: StartingLineup;
     readonly substitutionTolerance: number;
     readonly liberoReplacements: Player[];
     readonly pinchServerSubs: Map<Player, Player>;
+    readonly receiveRotationOffset: boolean;
     static create(input: unknown): Tactics;
     private constructor();
     findPlayerInLineup(id: string): CourtPosition | undefined;

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

@@ -16,11 +16,12 @@ class Tactics {
         }
         return new Tactics(result.data);
     }
-    constructor({ lineup, pinchServerSubs, liberoReplacements, substitutionTolerance = 1 }) {
+    constructor({ lineup, pinchServerSubs, liberoReplacements, substitutionTolerance = 1, receiveRotationOffset = false }) {
         this.lineup = lineup;
         this.substitutionTolerance = substitutionTolerance;
         this.pinchServerSubs = pinchServerSubs;
         this.liberoReplacements = liberoReplacements;
+        this.receiveRotationOffset = receiveRotationOffset;
     }
     findPlayerInLineup(id) {
         if (this.lineup.bench.some(p => p.id === id))

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

@@ -61,6 +61,7 @@ export interface Tactics {
     substitutionTolerance: number;
     liberoReplacements: string[];
     pinchServerSubs: Record<string, string>;
+    receiveRotationOffset: boolean;
 }
 export type Team = Omit<DataProps<_Team>, 'roster' | '_rating' | 'rating' | 'tactics'> & {
     roster: Player[];

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

@@ -19,10 +19,11 @@ export interface TacticsAttributes {
     lineup: TacticsLineupAttributes;
     libero_replacements: PlayerId[];
     pinch_server_subs: PinchServerSubsAttributes;
+    receive_rotation_offset: boolean;
 }
 export type TacticsPk = 'team_id';
 export type TacticsId = TacticsModel[TacticsPk];
-export type TacticsOptionalAttributes = 'substitution_tolerance' | 'lineup' | 'libero_replacements' | 'pinch_server_subs';
+export type TacticsOptionalAttributes = 'substitution_tolerance' | 'lineup' | 'libero_replacements' | 'pinch_server_subs' | 'receive_rotation_offset';
 export type TacticsCreationAttributes = Optional<TacticsAttributes, TacticsOptionalAttributes>;
 export declare class TacticsModel extends Model<TacticsAttributes, TacticsCreationAttributes> implements TacticsAttributes {
     team_id: string;
@@ -30,6 +31,7 @@ export declare class TacticsModel extends Model<TacticsAttributes, TacticsCreati
     lineup: TacticsLineupAttributes;
     libero_replacements: PlayerId[];
     pinch_server_subs: PinchServerSubsAttributes;
+    receive_rotation_offset: boolean;
     team: TeamModel;
     getTeam: Sequelize.BelongsToGetAssociationMixin<TeamModel>;
     setTeam: Sequelize.BelongsToSetAssociationMixin<TeamModel, TeamId>;

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

@@ -31,6 +31,11 @@ export class TacticsModel extends Model {
                 type: DataTypes.JSONB,
                 allowNull: false,
                 defaultValue: {}
+            },
+            receive_rotation_offset: {
+                type: DataTypes.BOOLEAN,
+                allowNull: false,
+                defaultValue: false
             }
         }, {
             sequelize,

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

@@ -33,6 +33,7 @@ function transformToAttributes(tactics, teamId) {
     return {
         team_id: teamId,
         substitution_tolerance: tactics.substitutionTolerance ?? 0,
+        receive_rotation_offset: tactics.receiveRotationOffset ?? false,
         lineup: transformFromLineup(tactics.lineup),
         libero_replacements: tactics.liberoReplacements.map((lr) => lr.id),
         pinch_server_subs: Object.fromEntries([...tactics.pinchServerSubs].map(([k, v]) => [k.id, v.id]))
@@ -48,6 +49,7 @@ function buildPinchServerSubs(pinchServerSubs, roster) {
 function transformToObject(model, roster) {
     return Tactics.create({
         substitutionTolerance: model.substitution_tolerance,
+        receiveRotationOffset: model.receive_rotation_offset,
         lineup: transformToLineup(model.lineup, roster),
         liberoReplacements: model.libero_replacements.map((lr) => findPlayer(lr, roster)),
         pinchServerSubs: buildPinchServerSubs(model.pinch_server_subs, roster)

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

@@ -33,20 +33,28 @@ export class Standing {
         this.totalMatches = this.matchesWon + this.matchesLost;
     }
     static sortFn(matches) {
+        // A zero denominator (no sets/points lost) is the BEST possible ratio, not the worst. The stored
+        // setsRatio/pointsRatio fall back to 0 in that case (and the table shows "MAX"), so we compare an
+        // 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) => {
             if (standingB.points > standingA.points)
                 return 1;
-            else if (standingA.points > standingB.points)
+            if (standingA.points > standingB.points)
                 return -1;
-            else if (standingB.setsRatio > standingA.setsRatio)
+            const setRatioA = effectiveRatio(standingA.setsWon, standingA.setsLost);
+            const setRatioB = effectiveRatio(standingB.setsWon, standingB.setsLost);
+            if (setRatioB > setRatioA)
                 return 1;
-            else if (standingA.setsRatio > standingB.setsRatio)
+            if (setRatioA > setRatioB)
                 return -1;
-            else if (standingB.pointsRatio > standingA.pointsRatio)
+            const pointRatioA = effectiveRatio(standingA.pointsWon, standingA.pointsLost);
+            const pointRatioB = effectiveRatio(standingB.pointsWon, standingB.pointsLost);
+            if (pointRatioB > pointRatioA)
                 return 1;
-            else if (standingA.pointsRatio > standingB.pointsRatio)
+            if (pointRatioA > pointRatioB)
                 return -1;
-            else if (matches.length > 0) {
+            if (matches.length > 0) {
                 const ab = matches.find((match) => match.homeTeam.id === standingA.teamId && match.awayTeam.id === standingB.teamId);
                 const ba = matches.find((match) => match.awayTeam.id === standingA.teamId && match.homeTeam.id === standingB.teamId);
                 if (ba == null && ab == null)
@@ -63,8 +71,7 @@ export class Standing {
                 const b = (ba.homeScore ?? 0) + (ab.awayScore ?? 0);
                 return b - a;
             }
-            else
-                return 0;
+            return 0;
         };
     }
     calculateStanding(matches) {

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

@@ -134,6 +134,18 @@ describe('Standing', () => {
             const sorted = [b, a].sort(Standing.sortFn([]));
             expect(sorted[0].teamId).toBe(idA);
         });
+        it('ranks a team with no sets lost (MAX ratio) above a finite setsRatio when points tie', () => {
+            const idA = uuidv4();
+            const idB = uuidv4();
+            // Both 6 points. A swept its matches (won30=2 → setsWon=6, setsLost=0 → ratio is MAX/infinite);
+            // B also has 6 points but conceded sets (won31=2 → setsWon=6, setsLost=2 → setsRatio=3).
+            // The undefeated-in-sets team must rank FIRST, not last (the divide-by-zero bug ranked it last).
+            const a = makeStanding(idA, { won30: 2 });
+            const b = makeStanding(idB, { won31: 2 });
+            const sorted = [b, a].sort(Standing.sortFn([]));
+            expect(sorted[0].teamId).toBe(idA);
+            expect(sorted[1].teamId).toBe(idB);
+        });
         it('falls back to pointsRatio when points and setsRatio are equal', () => {
             const idA = uuidv4();
             const idB = uuidv4();

package/dist/esm/src/service/match/court-position.d.ts

@@ -29,6 +29,7 @@ export declare enum CourtTarget {
 }
 export declare function getPositions(): CourtPosition[];
 export declare function rotatePosition(position: number): CourtPosition;
+export declare function rotatePositionBack(position: number): CourtPosition;
 export declare function isFrontRow(position: number): boolean;
 export declare function isBackRow(position: number): boolean;
 export declare function getCourtRow(row: CourtRow): CourtPosition[];

package/dist/esm/src/service/match/court-position.js

@@ -45,6 +45,16 @@ export function rotatePosition(position) {
     else
         return CourtPosition.MIDDLE_BACK;
 }
+// Inverse of rotatePosition (one rotation counter-clockwise): 1->2, 2->3, ... 5->6, 6->1.
+// Used to start a receiving team "one rotation behind" so the chosen server serves first after side-out.
+export function rotatePositionBack(position) {
+    if (position < 1 || position > 6)
+        throw new Error('POSITION_INDEX_OUT_OF_BOUNDS');
+    if (position === CourtPosition.MIDDLE_BACK)
+        return CourtPosition.RIGHT_BACK;
+    else
+        return position + 1;
+}
 export function isFrontRow(position) {
     if (position < 1 || position > 6)
         throw new Error('POSITION_INDEX_OUT_OF_BOUNDS');

package/dist/esm/src/service/match/court-position.test.d.ts

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

package/dist/esm/src/service/match/court-position.test.js

@@ -0,0 +1,23 @@
+import { describe, it, expect } from '@jest/globals';
+import { CourtPosition, rotatePosition, rotatePositionBack } from './court-position';
+describe('rotatePositionBack', () => {
+    it('rotates one step counter-clockwise (1->2, 2->3, 3->4, 4->5, 5->6, 6->1)', () => {
+        expect(rotatePositionBack(CourtPosition.RIGHT_BACK)).toBe(CourtPosition.RIGHT_FRONT); // 1 -> 2
+        expect(rotatePositionBack(CourtPosition.RIGHT_FRONT)).toBe(CourtPosition.MIDDLE_FRONT); // 2 -> 3
+        expect(rotatePositionBack(CourtPosition.MIDDLE_FRONT)).toBe(CourtPosition.LEFT_FRONT); // 3 -> 4
+        expect(rotatePositionBack(CourtPosition.LEFT_FRONT)).toBe(CourtPosition.LEFT_BACK); // 4 -> 5
+        expect(rotatePositionBack(CourtPosition.LEFT_BACK)).toBe(CourtPosition.MIDDLE_BACK); // 5 -> 6
+        expect(rotatePositionBack(CourtPosition.MIDDLE_BACK)).toBe(CourtPosition.RIGHT_BACK); // 6 -> 1
+    });
+    it('is the exact inverse of rotatePosition for every court position', () => {
+        for (let p = 1; p <= 6; p++) {
+            expect(rotatePosition(rotatePositionBack(p))).toBe(p);
+            expect(rotatePositionBack(rotatePosition(p))).toBe(p);
+        }
+    });
+    it('throws POSITION_INDEX_OUT_OF_BOUNDS outside 1..6', () => {
+        expect(() => rotatePositionBack(0)).toThrow('POSITION_INDEX_OUT_OF_BOUNDS');
+        expect(() => rotatePositionBack(7)).toThrow('POSITION_INDEX_OUT_OF_BOUNDS');
+        expect(() => rotatePositionBack(-1)).toThrow('POSITION_INDEX_OUT_OF_BOUNDS');
+    });
+});

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

@@ -13,6 +13,7 @@ export declare const TacticsInputSchema: z.ZodObject<{
     }, z.core.$strip>;
     substitutionTolerance: z.ZodNumber;
     liberoReplacements: z.ZodArray<z.ZodCustom<Player, Player>>;
+    receiveRotationOffset: z.ZodDefault<z.ZodBoolean>;
     pinchServerSubs: z.ZodCustom<Map<Player, Player>, Map<Player, Player>>;
 }, z.core.$strip>;
 export type TacticsInput = z.infer<typeof TacticsInputSchema>;

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

@@ -44,6 +44,8 @@ export const TacticsInputSchema = z.object({
     lineup: lineupSchema,
     substitutionTolerance: z.number().int().min(1).max(50),
     liberoReplacements: z.array(playerInstanceSchema),
+    // Default false keeps every existing Tactics.create({...}) call (that omits this) valid.
+    receiveRotationOffset: z.boolean().default(false),
     pinchServerSubs: z.custom((v) => v instanceof Map &&
         Array.from(v.entries()).every(([k, val]) => k instanceof Player && val instanceof Player), { message: 'INVALID_PINCH_SERVER_SUBS' })
 });

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

@@ -22,6 +22,7 @@ export declare const TeamInputSchema: z.ZodObject<{
         }, z.core.$strip>;
         substitutionTolerance: z.ZodNumber;
         liberoReplacements: z.ZodArray<z.ZodCustom<Player, Player>>;
+        receiveRotationOffset: z.ZodDefault<z.ZodBoolean>;
         pinchServerSubs: z.ZodCustom<Map<Player, Player>, Map<Player, Player>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;

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

@@ -15,12 +15,14 @@ export interface TacticsOpts {
     readonly substitutionTolerance: number;
     readonly liberoReplacements: Player[];
     readonly pinchServerSubs: Map<Player, Player>;
+    readonly receiveRotationOffset: boolean;
 }
 export declare class Tactics {
     readonly lineup: StartingLineup;
     readonly substitutionTolerance: number;
     readonly liberoReplacements: Player[];
     readonly pinchServerSubs: Map<Player, Player>;
+    readonly receiveRotationOffset: boolean;
     static create(input: unknown): Tactics;
     private constructor();
     findPlayerInLineup(id: string): CourtPosition | undefined;

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

@@ -13,11 +13,12 @@ export class Tactics {
         }
         return new Tactics(result.data);
     }
-    constructor({ lineup, pinchServerSubs, liberoReplacements, substitutionTolerance = 1 }) {
+    constructor({ lineup, pinchServerSubs, liberoReplacements, substitutionTolerance = 1, receiveRotationOffset = false }) {
         this.lineup = lineup;
         this.substitutionTolerance = substitutionTolerance;
         this.pinchServerSubs = pinchServerSubs;
         this.liberoReplacements = liberoReplacements;
+        this.receiveRotationOffset = receiveRotationOffset;
     }
     findPlayerInLineup(id) {
         if (this.lineup.bench.some(p => p.id === id))

package/package.json

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