volleyballsimtypes 0.0.504 → 0.0.506

package/dist/esm/src/service/competition/league-rewards.test.js

@@ -0,0 +1,48 @@
+import { describe, it, expect } from '@jest/globals';
+import { leaguePayoutFor, leagueRewardTier, LEAGUE_REWARDS } from './league-rewards';
+// The cumulative per-tier totals the owner specified (2026-08-07). Every entry is the coins a team finishing at
+// that position earns, summing its band and every band below it. Positions past the lowest band earn 0.
+describe('leaguePayoutFor', () => {
+    const TIER1 = {
+        1: 3000, 2: 2500, 3: 2250, 4: 2000, 5: 1500, 6: 1500, 7: 1500, 8: 1500, 9: 1000, 10: 1000, 11: 1000, 12: 1000, 13: 0, 14: 0, 15: 0, 16: 0
+    };
+    const TIER2 = {
+        1: 1500, 2: 1250, 3: 1000, 4: 1000, 5: 500, 6: 500, 7: 500, 8: 500, 9: 0, 12: 0, 16: 0
+    };
+    const TIER3 = {
+        1: 1000, 2: 750, 3: 500, 4: 500, 5: 0, 8: 0, 16: 0
+    };
+    it('matches the owner cumulative totals for tier 1', () => {
+        for (const [pos, total] of Object.entries(TIER1)) {
+            expect(leaguePayoutFor(1, Number(pos))).toBe(total);
+        }
+    });
+    it('matches the owner cumulative totals for tier 2', () => {
+        for (const [pos, total] of Object.entries(TIER2)) {
+            expect(leaguePayoutFor(2, Number(pos))).toBe(total);
+        }
+    });
+    it('matches the owner cumulative totals for tier 3', () => {
+        for (const [pos, total] of Object.entries(TIER3)) {
+            expect(leaguePayoutFor(3, Number(pos))).toBe(total);
+        }
+    });
+    it('treats division 3 and lower with the tier-3 table', () => {
+        for (const tier of [3, 4, 5, 10]) {
+            expect(leagueRewardTier(tier)).toBe(3);
+            expect(leaguePayoutFor(tier, 1)).toBe(1000);
+            expect(leaguePayoutFor(tier, 4)).toBe(500);
+            expect(leaguePayoutFor(tier, 5)).toBe(0);
+        }
+    });
+    it('clamps tier 0 or negative to tier 1', () => {
+        expect(leagueRewardTier(0)).toBe(1);
+        expect(leaguePayoutFor(0, 1)).toBe(3000);
+    });
+    it('each tier band table sums to the champion total', () => {
+        const sum = (t) => LEAGUE_REWARDS[t].reduce((s, r) => s + r.coins, 0);
+        expect(sum(1)).toBe(3000);
+        expect(sum(2)).toBe(1500);
+        expect(sum(3)).toBe(1000);
+    });
+});

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

@@ -2,7 +2,9 @@ import { z } from 'zod';
 import { TraitEnum } from '../../player';
 import { EventIncidentSchema } from './incident.z';
 import { positionalEventFields } from './positional.z';
-const spikeTypeValues = [0, 1, 2, 3, 4, 5, 6];
+// SPIKE(0), TIP(3), DOWN_BALL(4), OVERHAND(5), TOOL(6). 1/2 (legacy LINE_SHOT/REVERSE_CROSS) are retired; the
+// codec (transformToSpike) maps them to 0 before this validates, so they never reach here.
+const spikeTypeValues = [0, 3, 4, 5, 6];
 const spikeFailureValues = [0, 1, 2, 3, 4];
 const courtTargetValues = Array.from({ length: 13 }, (_, i) => i);
 export const SpikeInputSchema = z.object({

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

@@ -1,14 +1,12 @@
 import { InPlayEvent } from './in-play-event';
 export declare enum SpikeTypeEnum {
-    CROSS_SHOT = 0,
-    LINE_SHOT = 1,
-    REVERSE_CROSS = 2,
+    SPIKE = 0,
     TIP = 3,
     DOWN_BALL = 4,
     OVERHAND = 5,
     TOOL = 6
 }
-export type SpikeType = SpikeTypeEnum.CROSS_SHOT | SpikeTypeEnum.LINE_SHOT | SpikeTypeEnum.REVERSE_CROSS | SpikeTypeEnum.TIP | SpikeTypeEnum.DOWN_BALL | SpikeTypeEnum.OVERHAND | SpikeTypeEnum.TOOL;
+export type SpikeType = SpikeTypeEnum.SPIKE | SpikeTypeEnum.TIP | SpikeTypeEnum.DOWN_BALL | SpikeTypeEnum.OVERHAND | SpikeTypeEnum.TOOL;
 export declare enum SpikeFailureEnum {
     NO_FAILURE = 0,
     FAULT = 1,

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

@@ -3,9 +3,11 @@ import { InPlayEvent } from './in-play-event';
 import { SpikeInputSchema } from './schemas/spike.z';
 export var SpikeTypeEnum;
 (function (SpikeTypeEnum) {
-    SpikeTypeEnum[SpikeTypeEnum["CROSS_SHOT"] = 0] = "CROSS_SHOT";
-    SpikeTypeEnum[SpikeTypeEnum["LINE_SHOT"] = 1] = "LINE_SHOT";
-    SpikeTypeEnum[SpikeTypeEnum["REVERSE_CROSS"] = 2] = "REVERSE_CROSS";
+    // A hard swing (owner 2026-08-03). The cross / line / reverse DIRECTION is not stored: it is fully derivable
+    // from the persisted contact + landing coordinates, so a single SPIKE value replaces the old CROSS_SHOT(0) /
+    // LINE_SHOT(1) / REVERSE_CROSS(2). 1 and 2 are retired (left as gaps); the codec maps any legacy 1/2 back to
+    // SPIKE(0), so existing (zone-engine) matches keep decoding.
+    SpikeTypeEnum[SpikeTypeEnum["SPIKE"] = 0] = "SPIKE";
     SpikeTypeEnum[SpikeTypeEnum["TIP"] = 3] = "TIP";
     SpikeTypeEnum[SpikeTypeEnum["DOWN_BALL"] = 4] = "DOWN_BALL";
     SpikeTypeEnum[SpikeTypeEnum["OVERHAND"] = 5] = "OVERHAND";

package/dist/esm/src/service/team/base-config.d.ts

@@ -0,0 +1,10 @@
+export type BaseFormation = 'SERVE' | 'RECEIVE' | 'DEFENCE' | 'DEF_L' | 'DEF_M' | 'DEF_R' | 'ATTACK';
+export declare const BASE_FORMATIONS: readonly BaseFormation[];
+export interface BaseCoord {
+    readonly d: number;
+    readonly r: number;
+}
+export interface BaseConfig {
+    readonly coords: Record<string, Record<string, Record<string, BaseCoord>>>;
+    readonly receive: Record<string, Record<string, boolean>>;
+}

package/dist/esm/src/service/team/base-config.js

@@ -0,0 +1,11 @@
+// Per-team base-position configuration (owner 2026-08-03). Generalises the sim's hardcoded 5-1 preset into a
+// system-agnostic, per-team shape: for each formation, rotation and rotational ZONE, where that zone's player
+// stands, plus (serve-receive only) whether that zone's player passes the serve. Authored in the UI base editor
+// (and populated from a picked default preset); consumed by the positional engine to place players. A team with no
+// `basePositions` falls back to the default preset for its `rotationSystem`.
+//
+// KEYING: rotation 1..6 and zone 1..6 are the ROTATIONAL (at-the-whistle) slots. The stored rotation convention is
+// the ENGINE's (SETTER_ZONE_TO_ROTATION); the UI editor re-keys the mapper's setter-zone rotation to it on save.
+// `coords[formation][rotation][zone]` is the standing coordinate for that formation; `receive[rotation][zone]` is
+// the reception-participation flag (absent zone => default to participating).
+export const BASE_FORMATIONS = ['SERVE', 'RECEIVE', 'DEFENCE', 'DEF_L', 'DEF_M', 'DEF_R', 'ATTACK'];

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

@@ -1,7 +1,9 @@
 import { LineupFunction } from './lineup-function';
 export declare const NO_BLOCK: "NO_BLOCK";
 export type BlockingAssignment = LineupFunction | typeof NO_BLOCK;
+export type DefenceFormation = 'DEF_L' | 'DEF_M' | 'DEF_R';
+export declare const DEFENCE_FORMATIONS: readonly DefenceFormation[];
 export interface BlockingPreference {
     readonly rotation: number;
-    readonly targets: Record<string, BlockingAssignment>;
+    readonly targets: Record<DefenceFormation, Record<string, BlockingAssignment>>;
 }

package/dist/esm/src/service/team/blocking-preference.js

@@ -4,3 +4,4 @@
 // roll are all suppressed, as is a dedicated-blocking commit. Sits in the same `targets` map as a commit
 // assignment, so the two are mutually exclusive by construction: a player is reading, committed, or out.
 export const NO_BLOCK = 'NO_BLOCK';
+export const DEFENCE_FORMATIONS = ['DEF_L', 'DEF_M', 'DEF_R'];

package/dist/esm/src/service/team/default-base-config.d.ts

@@ -0,0 +1,4 @@
+import { BaseConfig } from './base-config';
+import { RotationSystemEnum } from './rotation-system';
+export declare function defaultReceiveMap(system: RotationSystemEnum): BaseConfig['receive'];
+export declare function defaultBaseConfig(system: RotationSystemEnum): BaseConfig;

package/dist/esm/src/service/team/default-base-config.js

@@ -0,0 +1,124 @@
+import { slotFunctionAt } from './lineup-function';
+import { RoleEnum } from '../player';
+import { isBackRow } from '../match';
+const COORDS = {
+    SERVE: {
+        1: { 1: { d: 9.90, r: 3.15 }, 2: { d: 0.30, r: -2.55 }, 3: { d: 0.40, r: 0.00 }, 4: { d: 0.30, r: 2.55 }, 5: { d: 6.90, r: -0.15 }, 6: { d: 5.20, r: -2.35 } },
+        2: { 1: { d: 10.10, r: 3.00 }, 2: { d: 0.45, r: 0.00 }, 3: { d: 0.55, r: 2.95 }, 4: { d: 0.45, r: -2.95 }, 5: { d: 5.20, r: -2.95 }, 6: { d: 5.25, r: 3.35 } },
+        3: { 1: { d: 10.45, r: -3.40 }, 2: { d: 0.35, r: 2.70 }, 3: { d: 0.25, r: -3.00 }, 4: { d: 0.30, r: 0.00 }, 5: { d: 5.35, r: 2.55 }, 6: { d: 6.90, r: -0.05 } },
+        4: { 1: { d: 10.50, r: 3.40 }, 2: { d: 0.35, r: -3.05 }, 3: { d: 0.45, r: 0.00 }, 4: { d: 0.45, r: 2.55 }, 5: { d: 7.25, r: 0.15 }, 6: { d: 6.25, r: -2.55 } },
+        5: { 1: { d: 10.05, r: 3.50 }, 2: { d: 0.30, r: 0.10 }, 3: { d: 0.25, r: 2.85 }, 4: { d: 0.25, r: -2.80 }, 5: { d: 5.10, r: -2.65 }, 6: { d: 5.15, r: 2.70 } },
+        6: { 1: { d: 10.30, r: -3.50 }, 2: { d: 0.65, r: 2.60 }, 3: { d: 0.50, r: -2.55 }, 4: { d: 0.55, r: 0.05 }, 5: { d: 6.45, r: 2.65 }, 6: { d: 6.90, r: 0.10 } }
+    },
+    RECEIVE: {
+        1: { 1: { d: 6.75, r: 2.85 }, 2: { d: 6.25, r: 2.05 }, 3: { d: 3.10, r: -3.65 }, 4: { d: 3.80, r: -4.10 }, 5: { d: 6.40, r: -2.80 }, 6: { d: 6.50, r: 0.00 } },
+        2: { 1: { d: 6.00, r: 2.50 }, 2: { d: 3.15, r: 4.00 }, 3: { d: 0.50, r: 0.40 }, 4: { d: 5.85, r: -2.85 }, 5: { d: 6.20, r: -0.05 }, 6: { d: 1.50, r: 0.65 } },
+        3: { 1: { d: 6.10, r: 2.55 }, 2: { d: 3.15, r: 4.10 }, 3: { d: 6.50, r: -2.80 }, 4: { d: 0.80, r: -3.70 }, 5: { d: 1.10, r: -1.00 }, 6: { d: 6.65, r: -0.10 } },
+        4: { 1: { d: 8.45, r: 3.20 }, 2: { d: 6.25, r: -2.85 }, 3: { d: 1.35, r: -3.70 }, 4: { d: 0.50, r: -4.05 }, 5: { d: 6.75, r: -0.35 }, 6: { d: 6.55, r: 2.40 } },
+        5: { 1: { d: 5.90, r: 2.65 }, 2: { d: 2.60, r: 3.90 }, 3: { d: 0.65, r: 1.50 }, 4: { d: 6.05, r: -3.05 }, 5: { d: 6.10, r: 0.10 }, 6: { d: 8.45, r: 0.65 } },
+        6: { 1: { d: 6.25, r: 2.60 }, 2: { d: 0.80, r: 1.50 }, 3: { d: 6.40, r: -2.60 }, 4: { d: 3.30, r: -4.30 }, 5: { d: 8.65, r: -2.15 }, 6: { d: 6.70, r: 0.00 } }
+    },
+    DEFENCE: {
+        1: { 1: { d: 5.95, r: 2.65 }, 2: { d: 0.55, r: -2.95 }, 3: { d: 0.50, r: -0.20 }, 4: { d: 0.45, r: 2.70 }, 5: { d: 6.30, r: -0.30 }, 6: { d: 5.90, r: -3.15 } },
+        2: { 1: { d: 6.30, r: -0.40 }, 2: { d: 0.05, r: -0.10 }, 3: { d: 0.05, r: 2.70 }, 4: { d: 0.05, r: -2.85 }, 5: { d: 5.50, r: -3.00 }, 6: { d: 5.55, r: 2.80 } },
+        3: { 1: { d: 5.25, r: -2.65 }, 2: { d: 0.05, r: 3.05 }, 3: { d: 0.05, r: -2.80 }, 4: { d: 0.05, r: 0.30 }, 5: { d: 5.35, r: 2.95 }, 6: { d: 6.45, r: 0.20 } },
+        4: { 1: { d: 6.00, r: 2.90 }, 2: { d: 0.35, r: -3.10 }, 3: { d: 0.25, r: -0.05 }, 4: { d: 0.35, r: 3.10 }, 5: { d: 6.35, r: -0.10 }, 6: { d: 6.00, r: -2.60 } },
+        5: { 1: { d: 6.30, r: 0.00 }, 2: { d: 0.10, r: -0.05 }, 3: { d: 0.05, r: 3.00 }, 4: { d: 0.05, r: -3.05 }, 5: { d: 5.90, r: -2.90 }, 6: { d: 6.15, r: 3.25 } },
+        6: { 1: { d: 5.70, r: -2.85 }, 2: { d: 0.55, r: 2.50 }, 3: { d: 0.50, r: -2.95 }, 4: { d: 0.50, r: -0.25 }, 5: { d: 5.80, r: 2.90 }, 6: { d: 6.95, r: 0.00 } }
+    },
+    DEF_L: {
+        1: { 1: { d: 5.80, r: 1.50 }, 2: { d: 0.05, r: -3.40 }, 3: { d: 0.05, r: -2.85 }, 4: { d: 1.80, r: 1.30 }, 5: { d: 8.00, r: 0.65 }, 6: { d: 4.50, r: -4.20 } },
+        2: { 1: { d: 7.95, r: 0.70 }, 2: { d: 0.05, r: -2.85 }, 3: { d: 1.80, r: 1.30 }, 4: { d: 0.10, r: -3.40 }, 5: { d: 4.50, r: -4.20 }, 6: { d: 5.80, r: 1.50 } },
+        3: { 1: { d: 0.05, r: -2.85 }, 2: { d: 1.80, r: 1.30 }, 3: { d: 0.05, r: -3.45 }, 4: { d: 4.50, r: -4.20 }, 5: { d: 5.80, r: 1.50 }, 6: { d: 8.05, r: 0.70 } },
+        4: { 1: { d: 5.85, r: 1.50 }, 2: { d: 0.05, r: -3.45 }, 3: { d: 4.50, r: -4.20 }, 4: { d: 1.80, r: 1.30 }, 5: { d: 8.00, r: 0.95 }, 6: { d: 0.05, r: -2.85 } },
+        5: { 1: { d: 8.10, r: 0.80 }, 2: { d: 4.50, r: -4.20 }, 3: { d: 1.80, r: 1.30 }, 4: { d: 0.05, r: -3.45 }, 5: { d: 0.05, r: -2.85 }, 6: { d: 5.85, r: 1.50 } },
+        6: { 1: { d: 4.50, r: -4.20 }, 2: { d: 1.80, r: 1.30 }, 3: { d: 0.05, r: -3.45 }, 4: { d: 0.05, r: -2.85 }, 5: { d: 5.85, r: 1.50 }, 6: { d: 8.10, r: 0.80 } }
+    },
+    DEF_M: {
+        1: { 1: { d: 4.95, r: 2.35 }, 2: { d: 1.70, r: -2.60 }, 3: { d: 0.05, r: -0.15 }, 4: { d: 2.00, r: 2.80 }, 5: { d: 7.20, r: 1.00 }, 6: { d: 4.70, r: -2.35 } },
+        2: { 1: { d: 7.15, r: 1.00 }, 2: { d: 0.05, r: -0.15 }, 3: { d: 2.00, r: 2.80 }, 4: { d: 1.70, r: -2.60 }, 5: { d: 4.70, r: -2.35 }, 6: { d: 4.95, r: 2.35 } },
+        3: { 1: { d: 4.95, r: -2.35 }, 2: { d: 2.00, r: 2.80 }, 3: { d: 2.35, r: -2.65 }, 4: { d: 0.05, r: 0.00 }, 5: { d: 4.95, r: 2.35 }, 6: { d: 7.00, r: 1.20 } },
+        4: { 1: { d: 4.95, r: 2.15 }, 2: { d: 1.70, r: -2.60 }, 3: { d: 0.15, r: -0.10 }, 4: { d: 2.00, r: 2.85 }, 5: { d: 7.15, r: 1.00 }, 6: { d: 4.95, r: -2.25 } },
+        5: { 1: { d: 7.25, r: 1.10 }, 2: { d: 0.05, r: 0.00 }, 3: { d: 1.95, r: 2.60 }, 4: { d: 1.70, r: -2.50 }, 5: { d: 4.85, r: -2.05 }, 6: { d: 5.00, r: 2.15 } },
+        6: { 1: { d: 4.70, r: -2.35 }, 2: { d: 2.00, r: 2.75 }, 3: { d: 1.80, r: -2.65 }, 4: { d: 0.05, r: -0.15 }, 5: { d: 4.80, r: 2.40 }, 6: { d: 7.40, r: 1.00 } }
+    },
+    DEF_R: {
+        1: { 1: { d: 4.45, r: 4.20 }, 2: { d: 1.90, r: -1.50 }, 3: { d: 0.10, r: 2.90 }, 4: { d: 0.10, r: 3.45 }, 5: { d: 8.80, r: 0.45 }, 6: { d: 5.25, r: -1.45 } },
+        2: { 1: { d: 8.55, r: -0.65 }, 2: { d: 0.05, r: 2.90 }, 3: { d: 0.05, r: 3.50 }, 4: { d: 2.00, r: -2.20 }, 5: { d: 4.80, r: -1.60 }, 6: { d: 4.50, r: 4.15 } },
+        3: { 1: { d: 4.75, r: -1.70 }, 2: { d: 0.05, r: 3.45 }, 3: { d: 1.60, r: -1.75 }, 4: { d: 0.05, r: 2.85 }, 5: { d: 4.55, r: 4.15 }, 6: { d: 8.40, r: -0.35 } },
+        4: { 1: { d: 5.20, r: 4.15 }, 2: { d: 1.75, r: -1.85 }, 3: { d: 0.05, r: 3.20 }, 4: { d: 0.05, r: 3.75 }, 5: { d: 8.45, r: -0.65 }, 6: { d: 5.15, r: -1.85 } },
+        5: { 1: { d: 8.35, r: -0.75 }, 2: { d: 0.05, r: 2.90 }, 3: { d: 0.05, r: 3.50 }, 4: { d: 1.80, r: -1.25 }, 5: { d: 5.25, r: -1.70 }, 6: { d: 5.00, r: 4.15 } },
+        6: { 1: { d: 5.15, r: -1.50 }, 2: { d: 0.05, r: 3.45 }, 3: { d: 2.55, r: -2.40 }, 4: { d: 0.05, r: 2.90 }, 5: { d: 4.60, r: 4.10 }, 6: { d: 8.75, r: 0.25 } }
+    },
+    ATTACK: {
+        1: { 1: { d: 0.50, r: 1.55 }, 2: { d: 3.40, r: -5.15 }, 3: { d: 1.15, r: 0.40 }, 4: { d: 4.80, r: 5.20 }, 5: { d: 6.50, r: 0.20 }, 6: { d: 4.85, r: -2.90 } },
+        2: { 1: { d: 6.50, r: -0.40 }, 2: { d: 1.60, r: 0.75 }, 3: { d: 3.65, r: 5.05 }, 4: { d: 3.50, r: -5.05 }, 5: { d: 4.45, r: -2.60 }, 6: { d: 0.50, r: 1.60 } },
+        3: { 1: { d: 5.05, r: -1.90 }, 2: { d: 3.95, r: 5.00 }, 3: { d: 3.95, r: -4.90 }, 4: { d: 1.80, r: 1.10 }, 5: { d: 0.35, r: 1.55 }, 6: { d: 6.45, r: 0.15 } },
+        4: { 1: { d: 6.15, r: 4.95 }, 2: { d: 3.95, r: -5.05 }, 3: { d: 1.45, r: 1.05 }, 4: { d: 0.45, r: 1.80 }, 5: { d: 6.45, r: -0.50 }, 6: { d: 4.95, r: -2.00 } },
+        5: { 1: { d: 6.50, r: -0.40 }, 2: { d: 1.80, r: 1.10 }, 3: { d: 0.25, r: 1.85 }, 4: { d: 3.45, r: -4.95 }, 5: { d: 5.35, r: -2.55 }, 6: { d: 6.50, r: 4.90 } },
+        6: { 1: { d: 5.85, r: -2.20 }, 2: { d: 0.55, r: 2.00 }, 3: { d: 4.00, r: -4.85 }, 4: { d: 1.35, r: 1.40 }, 5: { d: 6.85, r: 4.90 }, 6: { d: 6.60, r: 0.35 } }
+    },
+    ATK_L: {
+        1: { 1: { d: 0.75, r: 0.10 }, 2: { d: 0.50, r: -4.05 }, 3: { d: 0.95, r: -2.55 }, 4: { d: 3.45, r: 0.80 }, 5: { d: 6.25, r: -0.75 }, 6: { d: 3.60, r: -3.95 } },
+        2: { 1: { d: 0.50, r: -4.05 }, 2: { d: 0.95, r: -2.55 }, 3: { d: 3.75, r: 1.05 }, 4: { d: 6.25, r: -0.75 }, 5: { d: 3.60, r: -3.95 }, 6: { d: 0.75, r: 0.10 } },
+        3: { 1: { d: 0.95, r: -2.55 }, 2: { d: 3.45, r: 0.80 }, 3: { d: 6.25, r: -0.75 }, 4: { d: 3.60, r: -3.95 }, 5: { d: 0.75, r: 0.10 }, 6: { d: 0.50, r: -4.05 } },
+        4: { 1: { d: 3.60, r: 0.90 }, 2: { d: 0.55, r: -4.05 }, 3: { d: 1.15, r: -2.60 }, 4: { d: 0.85, r: 0.25 }, 5: { d: 6.25, r: -0.80 }, 6: { d: 3.45, r: -4.10 } },
+        5: { 1: { d: 6.25, r: -0.65 }, 2: { d: 1.20, r: -2.55 }, 3: { d: 0.80, r: 0.10 }, 4: { d: 0.50, r: -4.10 }, 5: { d: 3.90, r: -4.00 }, 6: { d: 3.75, r: 0.80 } },
+        6: { 1: { d: 3.60, r: -3.95 }, 2: { d: 0.75, r: 0.10 }, 3: { d: 0.50, r: -4.05 }, 4: { d: 0.95, r: -2.55 }, 5: { d: 3.45, r: 0.80 }, 6: { d: 6.25, r: -0.75 } }
+    },
+    ATK_M: {
+        1: { 1: { d: 0.60, r: 1.25 }, 2: { d: 1.20, r: -2.00 }, 3: { d: 0.70, r: 0.50 }, 4: { d: 2.25, r: 2.60 }, 5: { d: 6.40, r: 1.40 }, 6: { d: 4.05, r: -1.55 } },
+        2: { 1: { d: 6.65, r: 1.55 }, 2: { d: 0.70, r: 0.50 }, 3: { d: 2.25, r: 2.60 }, 4: { d: 1.40, r: -1.90 }, 5: { d: 4.05, r: -1.55 }, 6: { d: 0.60, r: 1.25 } },
+        3: { 1: { d: 4.05, r: -1.55 }, 2: { d: 2.25, r: 2.60 }, 3: { d: 1.20, r: -2.00 }, 4: { d: 0.70, r: 0.45 }, 5: { d: 0.65, r: 1.15 }, 6: { d: 6.40, r: 1.40 } },
+        4: { 1: { d: 2.25, r: 2.60 }, 2: { d: 1.35, r: -1.90 }, 3: { d: 0.65, r: 0.50 }, 4: { d: 0.60, r: 1.25 }, 5: { d: 6.40, r: 1.45 }, 6: { d: 4.15, r: -1.45 } },
+        5: { 1: { d: 6.40, r: 1.40 }, 2: { d: 0.65, r: 0.50 }, 3: { d: 0.60, r: 1.25 }, 4: { d: 1.20, r: -2.00 }, 5: { d: 4.15, r: -1.40 }, 6: { d: 2.25, r: 2.60 } },
+        6: { 1: { d: 4.05, r: -1.55 }, 2: { d: 0.60, r: 1.25 }, 3: { d: 1.20, r: -2.00 }, 4: { d: 0.70, r: 0.50 }, 5: { d: 2.25, r: 2.60 }, 6: { d: 6.40, r: 1.40 } }
+    },
+    ATK_R: {
+        1: { 1: { d: 1.75, r: 2.60 }, 2: { d: 1.60, r: -1.75 }, 3: { d: 0.75, r: 1.80 }, 4: { d: 0.60, r: 3.90 }, 5: { d: 4.90, r: 3.25 }, 6: { d: 5.85, r: -1.90 } },
+        2: { 1: { d: 5.15, r: 3.20 }, 2: { d: 0.75, r: 1.80 }, 3: { d: 0.60, r: 3.90 }, 4: { d: 1.60, r: -1.40 }, 5: { d: 5.85, r: -1.90 }, 6: { d: 1.75, r: 2.60 } },
+        3: { 1: { d: 6.05, r: -2.00 }, 2: { d: 0.60, r: 3.90 }, 3: { d: 1.55, r: -1.55 }, 4: { d: 0.75, r: 1.70 }, 5: { d: 1.75, r: 2.60 }, 6: { d: 5.05, r: 3.15 } },
+        4: { 1: { d: 2.25, r: 4.20 }, 2: { d: 2.40, r: -1.65 }, 3: { d: 0.85, r: 1.40 }, 4: { d: 1.40, r: 2.30 }, 5: { d: 6.00, r: 1.85 }, 6: { d: 5.25, r: -0.90 } },
+        5: { 1: { d: 5.95, r: 2.35 }, 2: { d: 0.85, r: 1.40 }, 3: { d: 1.40, r: 2.30 }, 4: { d: 2.20, r: -1.80 }, 5: { d: 5.25, r: -0.90 }, 6: { d: 2.25, r: 4.20 } },
+        6: { 1: { d: 5.30, r: -0.90 }, 2: { d: 1.45, r: 2.30 }, 3: { d: 2.25, r: -1.80 }, 4: { d: 0.75, r: 1.40 }, 5: { d: 2.25, r: 4.05 }, 6: { d: 5.90, r: 2.35 } }
+    }
+};
+// The default coordinate table as a BaseConfig.coords (jsonb string keys). Shared, readonly; materialized (and so
+// serialized) per team on save, so sharing the reference in memory is safe.
+const DEFAULT_COORDS = (() => {
+    const out = {};
+    for (const [formation, rotations] of Object.entries(COORDS)) {
+        out[formation] = {};
+        for (const [rotation, zones] of Object.entries(rotations)) {
+            out[formation][rotation] = {};
+            for (const [zone, coord] of Object.entries(zones))
+                out[formation][rotation][zone] = { d: coord.d, r: coord.r };
+        }
+    }
+    return out;
+})();
+// Rotation index -> the setter's rotational zone (inverse of SETTER_ZONE_TO_ROTATION {1:1,6:2,5:3,4:4,3:5,2:6}).
+const ROTATION_TO_SETTER_ZONE = { 1: 1, 2: 6, 3: 5, 4: 4, 5: 3, 6: 2 };
+// The default serve-receive participation map: the standard 3-passer formation. A rotational slot passes iff its
+// slot function is an OUTSIDE_HITTER (either row) or a BACK-ROW MIDDLE_BLOCKER (the libero's slot). The setter, the
+// opposite and the front-row middle hide. slotFunctionAt maps the opposite slot to SETTER in 4-2/6-2, so the
+// second setter is excluded too, giving the same 3-passer map for every system.
+export function defaultReceiveMap(system) {
+    const receive = {};
+    for (let rotation = 1; rotation <= 6; rotation++) {
+        const setterZone = ROTATION_TO_SETTER_ZONE[rotation];
+        const perZone = {};
+        for (let zone = 1; zone <= 6; zone++) {
+            const fn = slotFunctionAt(system, setterZone, zone);
+            perZone[String(zone)] = fn === RoleEnum.OUTSIDE_HITTER || (fn === RoleEnum.MIDDLE_BLOCKER && isBackRow(zone));
+        }
+        receive[String(rotation)] = perZone;
+    }
+    return receive;
+}
+// The default base config a team of the given system starts with. Every team always has one (materialized on team
+// creation and by the backfill migration); the coordinates are the same 5-1 table for every system, only the
+// receive map is derived per system.
+export function defaultBaseConfig(system) {
+    return { coords: DEFAULT_COORDS, receive: defaultReceiveMap(system) };
+}

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

@@ -2,6 +2,8 @@ export * from './team';
 export * from './team-generator';
 export * from './formation';
 export * from './tactics';
+export * from './base-config';
+export * from './default-base-config';
 export * from './team-name';
 export * from './energy-band';
 export * from './pinch-condition';

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

@@ -2,6 +2,8 @@ export * from './team';
 export * from './team-generator';
 export * from './formation';
 export * from './tactics';
+export * from './base-config';
+export * from './default-base-config';
 export * from './team-name';
 export * from './energy-band';
 export * from './pinch-condition';

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

@@ -282,12 +282,27 @@ export declare const TacticsInputSchema: z.ZodObject<{
     }, z.core.$strip>>>>;
     blockingPreferences: z.ZodDefault<z.ZodArray<z.ZodObject<{
         rotation: z.ZodNumber;
-        targets: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<typeof RoleEnum> & z.ZodType<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum, z.core.$ZodTypeInternals<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum>>, z.ZodLiteral<"NO_BLOCK">]>>;
+        targets: z.ZodObject<{
+            DEF_L: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<typeof RoleEnum> & z.ZodType<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum, z.core.$ZodTypeInternals<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum>>, z.ZodLiteral<"NO_BLOCK">]>>>;
+            DEF_M: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<typeof RoleEnum> & z.ZodType<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum, z.core.$ZodTypeInternals<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum>>, z.ZodLiteral<"NO_BLOCK">]>>>;
+            DEF_R: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<typeof RoleEnum> & z.ZodType<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum, z.core.$ZodTypeInternals<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum>>, z.ZodLiteral<"NO_BLOCK">]>>>;
+        }, z.core.$strip>;
     }, z.core.$strip>>>;
     blockingPreferenceSets: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodObject<{
         rotation: z.ZodNumber;
-        targets: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<typeof RoleEnum> & z.ZodType<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum, z.core.$ZodTypeInternals<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum>>, z.ZodLiteral<"NO_BLOCK">]>>;
+        targets: z.ZodObject<{
+            DEF_L: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<typeof RoleEnum> & z.ZodType<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum, z.core.$ZodTypeInternals<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum>>, z.ZodLiteral<"NO_BLOCK">]>>>;
+            DEF_M: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<typeof RoleEnum> & z.ZodType<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum, z.core.$ZodTypeInternals<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum>>, z.ZodLiteral<"NO_BLOCK">]>>>;
+            DEF_R: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<typeof RoleEnum> & z.ZodType<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum, z.core.$ZodTypeInternals<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum>>, z.ZodLiteral<"NO_BLOCK">]>>>;
+        }, z.core.$strip>;
     }, z.core.$strip>>>>;
+    basePositions: z.ZodOptional<z.ZodObject<{
+        coords: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{
+            d: z.ZodNumber;
+            r: z.ZodNumber;
+        }, z.core.$strip>>>>;
+        receive: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+    }, z.core.$strip>>;
     replaceKnockedImmediately: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
     injuryReplacements: z.ZodDefault<z.ZodArray<z.ZodObject<{
         starter: z.ZodCustom<Player, Player>;

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

@@ -65,15 +65,31 @@ const blockingFunctionSchema = z.union([
 ]);
 // One rotation's dedicated-blocking assignments: `targets` maps my front-row starter ids to the opposing function
 // each commits to block. Cross-field checks (keys are starters) live in the superRefine below.
+const blockingTargetsSchema = z.record(z.string(), blockingFunctionSchema);
+// Per point-of-attack defence (owner 2026-08-06): a separate front-row commit map for an attack from my left /
+// middle / right. Each defaults to {} so a partial config stays valid.
 const blockingPreferenceSchema = z.object({
     rotation: z.number().int().min(1).max(6),
-    targets: z.record(z.string(), blockingFunctionSchema)
+    targets: z.object({
+        DEF_L: blockingTargetsSchema.default({}),
+        DEF_M: blockingTargetsSchema.default({}),
+        DEF_R: blockingTargetsSchema.default({})
+    })
 });
 // One set's rotation-system override (per-set tactics): system + its designated setters travel together.
 const systemSetSchema = z.object({
     rotationSystem: z.nativeEnum(RotationSystemEnum),
     designatedSetters: z.array(playerInstanceSchema)
 });
+// Base positions (owner 2026-08-03): coords[formation][rotation][zone] -> {d,r} + receive[rotation][zone] -> bool.
+// jsonb keys are strings; the coordinate + boolean leaves are validated. Structural key ranges (formation names,
+// rotations 1-6, zones 1-6) are trusted from the UI editor / preset compiler, which write the engine rotation
+// convention. Out-of-court coordinates are allowed, so d/r are not range-clamped here.
+const baseCoordSchema = z.object({ d: z.number().finite(), r: z.number().finite() });
+const baseConfigSchema = z.object({
+    coords: z.record(z.string(), z.record(z.string(), z.record(z.string(), baseCoordSchema))),
+    receive: z.record(z.string(), z.record(z.string(), z.boolean()))
+});
 export const TacticsInputSchema = z.object({
     lineup: lineupSchema,
     liberoReplacements: z.array(playerInstanceSchema),
@@ -104,6 +120,8 @@ export const TacticsInputSchema = z.object({
     // Blocking preferences (dedicated blocking). Defaults keep every existing Tactics.create({...}) call valid.
     blockingPreferences: z.array(blockingPreferenceSchema).default([]),
     blockingPreferenceSets: z.array(z.array(blockingPreferenceSchema)).max(5).optional(),
+    // Base positions (owner 2026-08-03). Optional -> the sim falls back to the default preset for the system.
+    basePositions: baseConfigSchema.optional(),
     // Injuries. Defaults keep every existing Tactics.create({...}) call valid. replaceKnockedImmediately is
     // PER STARTER (owner order 2026-07-05): keyed by starter id, missing key = ON; keys validated against the
     // lineup in the superRefine below. injuryReplacements is the per-starter explicit replacement mapping
@@ -199,9 +217,11 @@ export const TacticsInputSchema = z.object({
                 ctx.addIssue({ code: 'custom', message: 'BLOCKING_PREFERENCE_DUPLICATE_ROTATION', path });
             }
             seenRotations.add(pref.rotation);
-            for (const id of Object.keys(pref.targets)) {
-                if (!starterIds.has(id)) {
-                    ctx.addIssue({ code: 'custom', message: 'BLOCKING_PREFERENCE_BLOCKER_NOT_A_STARTER', path });
+            for (const form of ['DEF_L', 'DEF_M', 'DEF_R']) {
+                for (const id of Object.keys(pref.targets[form] ?? {})) {
+                    if (!starterIds.has(id)) {
+                        ctx.addIssue({ code: 'custom', message: 'BLOCKING_PREFERENCE_BLOCKER_NOT_A_STARTER', path });
+                    }
                 }
             }
         }

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

@@ -234,18 +234,31 @@ describe('TacticsInputSchema — blocking preferences', () => {
             ...overrides
         };
     }
-    it('accepts a blocking preference that keys starters to attacking functions', () => {
+    it('accepts a blocking preference that keys starters to attacking functions, per defence side', () => {
         const res = TacticsInputSchema.safeParse(baseInput({
-            blockingPreferences: [{ rotation: 1, targets: { [p4.id]: RoleEnum.OUTSIDE_HITTER, [p3.id]: RoleEnum.MIDDLE_BLOCKER } }]
+            blockingPreferences: [{ rotation: 1, targets: { DEF_L: { [p4.id]: RoleEnum.OUTSIDE_HITTER }, DEF_M: {}, DEF_R: { [p3.id]: RoleEnum.MIDDLE_BLOCKER } } }]
         }));
         expect(res.success).toBe(true);
         if (res.success) {
-            expect(res.data.blockingPreferences[0].targets[p4.id]).toBe(RoleEnum.OUTSIDE_HITTER);
+            expect(res.data.blockingPreferences[0].targets.DEF_L[p4.id]).toBe(RoleEnum.OUTSIDE_HITTER);
+            expect(res.data.blockingPreferences[0].targets.DEF_R[p3.id]).toBe(RoleEnum.MIDDLE_BLOCKER);
+            expect(res.data.blockingPreferences[0].targets.DEF_M).toEqual({}); // the middle side is independent (empty here)
         }
     });
-    it('rejects a blocking target that is not a starter', () => {
+    it('defaults the omitted defence sides to empty maps', () => {
         const res = TacticsInputSchema.safeParse(baseInput({
-            blockingPreferences: [{ rotation: 1, targets: { [reserve.id]: RoleEnum.OUTSIDE_HITTER } }]
+            blockingPreferences: [{ rotation: 1, targets: { DEF_L: { [p4.id]: NO_BLOCK } } }]
+        }));
+        expect(res.success).toBe(true);
+        if (res.success) {
+            expect(res.data.blockingPreferences[0].targets.DEF_L[p4.id]).toBe(NO_BLOCK);
+            expect(res.data.blockingPreferences[0].targets.DEF_M).toEqual({});
+            expect(res.data.blockingPreferences[0].targets.DEF_R).toEqual({});
+        }
+    });
+    it('rejects a blocking target (on any side) that is not a starter', () => {
+        const res = TacticsInputSchema.safeParse(baseInput({
+            blockingPreferences: [{ rotation: 1, targets: { DEF_M: { [reserve.id]: RoleEnum.OUTSIDE_HITTER } } }]
         }));
         expect(res.success).toBe(false);
         if (!res.success) {
@@ -254,7 +267,7 @@ describe('TacticsInputSchema — blocking preferences', () => {
     });
     it('rejects a blocking target function of libero', () => {
         const res = TacticsInputSchema.safeParse(baseInput({
-            blockingPreferences: [{ rotation: 1, targets: { [p4.id]: RoleEnum.LIBERO } }]
+            blockingPreferences: [{ rotation: 1, targets: { DEF_L: { [p4.id]: RoleEnum.LIBERO } } }]
         }));
         expect(res.success).toBe(false);
         if (!res.success) {
@@ -264,8 +277,8 @@ describe('TacticsInputSchema — blocking preferences', () => {
     it('rejects a duplicate rotation in blocking preferences', () => {
         const res = TacticsInputSchema.safeParse(baseInput({
             blockingPreferences: [
-                { rotation: 1, targets: { [p4.id]: RoleEnum.OUTSIDE_HITTER } },
-                { rotation: 1, targets: { [p3.id]: RoleEnum.MIDDLE_BLOCKER } }
+                { rotation: 1, targets: { DEF_L: { [p4.id]: RoleEnum.OUTSIDE_HITTER } } },
+                { rotation: 1, targets: { DEF_M: { [p3.id]: RoleEnum.MIDDLE_BLOCKER } } }
             ]
         }));
         expect(res.success).toBe(false);
@@ -275,29 +288,29 @@ describe('TacticsInputSchema — blocking preferences', () => {
     });
     it('accepts per-set blocking preference overrides', () => {
         const res = TacticsInputSchema.safeParse(baseInput({
-            blockingPreferenceSets: [[{ rotation: 1, targets: { [p4.id]: RoleEnum.OPPOSITE_HITTER } }], []]
+            blockingPreferenceSets: [[{ rotation: 1, targets: { DEF_R: { [p4.id]: RoleEnum.OPPOSITE_HITTER } } }], []]
         }));
         expect(res.success).toBe(true);
     });
-    it('accepts NO_BLOCK as an assignment, alongside a commit on another starter', () => {
+    it('accepts NO_BLOCK as an assignment, alongside a commit on another starter, on the same side', () => {
         const res = TacticsInputSchema.safeParse(baseInput({
-            blockingPreferences: [{ rotation: 1, targets: { [p4.id]: NO_BLOCK, [p3.id]: RoleEnum.MIDDLE_BLOCKER } }]
+            blockingPreferences: [{ rotation: 1, targets: { DEF_L: { [p4.id]: NO_BLOCK, [p3.id]: RoleEnum.MIDDLE_BLOCKER } } }]
         }));
         expect(res.success).toBe(true);
         if (res.success) {
-            expect(res.data.blockingPreferences[0].targets[p4.id]).toBe(NO_BLOCK);
-            expect(res.data.blockingPreferences[0].targets[p3.id]).toBe(RoleEnum.MIDDLE_BLOCKER);
+            expect(res.data.blockingPreferences[0].targets.DEF_L[p4.id]).toBe(NO_BLOCK);
+            expect(res.data.blockingPreferences[0].targets.DEF_L[p3.id]).toBe(RoleEnum.MIDDLE_BLOCKER);
         }
     });
     it('accepts NO_BLOCK in a per-set override', () => {
         const res = TacticsInputSchema.safeParse(baseInput({
-            blockingPreferenceSets: [[{ rotation: 1, targets: { [p4.id]: NO_BLOCK } }], []]
+            blockingPreferenceSets: [[{ rotation: 1, targets: { DEF_M: { [p4.id]: NO_BLOCK } } }], []]
         }));
         expect(res.success).toBe(true);
     });
     it('still rejects a NO_BLOCK assignment on a player who is not a starter', () => {
         const res = TacticsInputSchema.safeParse(baseInput({
-            blockingPreferences: [{ rotation: 1, targets: { [reserve.id]: NO_BLOCK } }]
+            blockingPreferences: [{ rotation: 1, targets: { DEF_R: { [reserve.id]: NO_BLOCK } } }]
         }));
         expect(res.success).toBe(false);
         if (!res.success) {
@@ -306,7 +319,7 @@ describe('TacticsInputSchema — blocking preferences', () => {
     });
     it('rejects an unknown assignment string', () => {
         const res = TacticsInputSchema.safeParse(baseInput({
-            blockingPreferences: [{ rotation: 1, targets: { [p4.id]: 'NO_BLOCKING' } }]
+            blockingPreferences: [{ rotation: 1, targets: { DEF_L: { [p4.id]: 'NO_BLOCKING' } } }]
         }));
         expect(res.success).toBe(false);
     });

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

@@ -290,12 +290,27 @@ export declare const TeamInputSchema: z.ZodObject<{
         }, z.core.$strip>>>>;
         blockingPreferences: z.ZodDefault<z.ZodArray<z.ZodObject<{
             rotation: z.ZodNumber;
-            targets: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<typeof import("../../player").RoleEnum> & z.ZodType<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum, z.core.$ZodTypeInternals<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum>>, z.ZodLiteral<"NO_BLOCK">]>>;
+            targets: z.ZodObject<{
+                DEF_L: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<typeof import("../../player").RoleEnum> & z.ZodType<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum, z.core.$ZodTypeInternals<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum>>, z.ZodLiteral<"NO_BLOCK">]>>>;
+                DEF_M: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<typeof import("../../player").RoleEnum> & z.ZodType<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum, z.core.$ZodTypeInternals<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum>>, z.ZodLiteral<"NO_BLOCK">]>>>;
+                DEF_R: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<typeof import("../../player").RoleEnum> & z.ZodType<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum, z.core.$ZodTypeInternals<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum>>, z.ZodLiteral<"NO_BLOCK">]>>>;
+            }, z.core.$strip>;
         }, z.core.$strip>>>;
         blockingPreferenceSets: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodObject<{
             rotation: z.ZodNumber;
-            targets: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<typeof import("../../player").RoleEnum> & z.ZodType<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum, z.core.$ZodTypeInternals<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum>>, z.ZodLiteral<"NO_BLOCK">]>>;
+            targets: z.ZodObject<{
+                DEF_L: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<typeof import("../../player").RoleEnum> & z.ZodType<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum, z.core.$ZodTypeInternals<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum>>, z.ZodLiteral<"NO_BLOCK">]>>>;
+                DEF_M: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<typeof import("../../player").RoleEnum> & z.ZodType<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum, z.core.$ZodTypeInternals<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum>>, z.ZodLiteral<"NO_BLOCK">]>>>;
+                DEF_R: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<typeof import("../../player").RoleEnum> & z.ZodType<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum, z.core.$ZodTypeInternals<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum>>, z.ZodLiteral<"NO_BLOCK">]>>>;
+            }, z.core.$strip>;
         }, z.core.$strip>>>>;
+        basePositions: z.ZodOptional<z.ZodObject<{
+            coords: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{
+                d: z.ZodNumber;
+                r: z.ZodNumber;
+            }, z.core.$strip>>>>;
+            receive: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+        }, z.core.$strip>>;
         replaceKnockedImmediately: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
         injuryReplacements: z.ZodDefault<z.ZodArray<z.ZodObject<{
             starter: z.ZodCustom<Player, Player>;

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

@@ -8,6 +8,7 @@ import { OffensivePreference } from './offensive-preference';
 import { BlockingPreference } from './blocking-preference';
 import { InjuryReplacement } from './injury-replacement';
 import { LiberoInjuryConfig } from './libero-injury';
+import { BaseConfig } from './base-config';
 export interface StartingLineup {
     readonly [CourtPosition.LEFT_FRONT]: Player;
     readonly [CourtPosition.MIDDLE_FRONT]: Player;
@@ -42,6 +43,7 @@ export interface TacticsOpts {
     readonly liberoInjury?: LiberoInjuryConfig;
     readonly blockingPreferences: BlockingPreference[];
     readonly blockingPreferenceSets?: BlockingPreference[][];
+    readonly basePositions?: BaseConfig;
 }
 export declare class Tactics {
     readonly lineup: StartingLineup;
@@ -63,6 +65,7 @@ export declare class Tactics {
     readonly liberoInjury?: LiberoInjuryConfig;
     readonly blockingPreferences: BlockingPreference[];
     readonly blockingPreferenceSets?: BlockingPreference[][];
+    readonly basePositions?: BaseConfig;
     static create(input: unknown): Tactics;
     private constructor();
     findPlayerInLineup(id: string): CourtPosition | undefined;

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

@@ -15,7 +15,7 @@ export class Tactics {
         }
         return new Tactics(result.data);
     }
-    constructor({ lineup, liberoReplacements, receiveRotationOffset = false, designatedSubs = [], substitutionBand = EnergyBand.TIRED, secondLibero, liberoSub, liberoReplacementSets, rotationSystem = RotationSystemEnum.SIX_ZERO, designatedSetters = [], offensivePreferences = [], serveAttackShares = {}, systemSets, offensivePreferenceSets, replaceKnockedImmediately = {}, injuryReplacements = [], liberoInjury, blockingPreferences = [], blockingPreferenceSets }) {
+    constructor({ lineup, liberoReplacements, receiveRotationOffset = false, designatedSubs = [], substitutionBand = EnergyBand.TIRED, secondLibero, liberoSub, liberoReplacementSets, rotationSystem = RotationSystemEnum.SIX_ZERO, designatedSetters = [], offensivePreferences = [], serveAttackShares = {}, systemSets, offensivePreferenceSets, replaceKnockedImmediately = {}, injuryReplacements = [], liberoInjury, blockingPreferences = [], blockingPreferenceSets, basePositions }) {
         this.lineup = lineup;
         this.liberoReplacements = liberoReplacements;
         this.receiveRotationOffset = receiveRotationOffset;
@@ -35,6 +35,7 @@ export class Tactics {
         this.liberoInjury = liberoInjury;
         this.blockingPreferences = blockingPreferences;
         this.blockingPreferenceSets = blockingPreferenceSets;
+        this.basePositions = basePositions;
     }
     findPlayerInLineup(id) {
         if (this.lineup.bench.some(p => p.id === id))

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

@@ -5,6 +5,8 @@ import { Team } from './team';
 import { Tactics } from './tactics';
 import { EnergyBand } from './energy-band';
 import { Formation } from './formation';
+import { RotationSystemEnum } from './rotation-system';
+import { defaultBaseConfig } from './default-base-config';
 import { CourtPosition } from '../match';
 import logger from '../../logger';
 const buildBlock = (rarity, count) => Array.from({ length: count }, () => rarity);
@@ -62,7 +64,10 @@ export class TeamGenerator {
         return Tactics.create({
             lineup,
             liberoReplacements: [lineup[3], lineup[6]],
-            substitutionBand: TeamGenerator.BOT_SUB_BANDS[Math.floor(Math.random() * TeamGenerator.BOT_SUB_BANDS.length)]
+            substitutionBand: TeamGenerator.BOT_SUB_BANDS[Math.floor(Math.random() * TeamGenerator.BOT_SUB_BANDS.length)],
+            // basePositions is never null: a team always carries the default base config for its system. createTactics
+            // makes 6-0 teams (Tactics.create default); when a user picks another system the API re-materializes.
+            basePositions: defaultBaseConfig(RotationSystemEnum.SIX_ZERO)
         });
     }
     static createLineup(players, formation) {

package/package.json

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