volleyballsimtypes 0.0.505 → 0.0.507

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

@@ -262,18 +262,18 @@ describe('per-set tactics — service <-> row round-trip', () => {
         const back = transformToTactics(attrs, roster);
         expect(back.offensivePreferences[0].tempos).toEqual({ [p2.id]: 'FAST', [p3.id]: 'HIGH' });
     });
-    it('round-trips blocking preferences as id-keyed function maps', () => {
+    it('round-trips blocking preferences as per-defence-side id-keyed function maps', () => {
         const withBlocking = Tactics.create({
             lineup: { 4: p4, 3: p3, 2: p2, 5: p5, 6: p6, 1: p1, bench: [] },
             liberoReplacements: [],
-            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_R: { [p3.id]: RoleEnum.MIDDLE_BLOCKER } } }]
         });
         const attrs = transformFromTactics(withBlocking, 'team-1');
         expect(attrs.blocking_preferences).toEqual([
-            { rotation: 1, targets: { [p4.id]: RoleEnum.OUTSIDE_HITTER, [p3.id]: RoleEnum.MIDDLE_BLOCKER } }
+            { rotation: 1, targets: { DEF_L: { [p4.id]: RoleEnum.OUTSIDE_HITTER }, DEF_M: {}, DEF_R: { [p3.id]: RoleEnum.MIDDLE_BLOCKER } } }
         ]);
         const back = transformToTactics(attrs, roster);
-        expect(back.blockingPreferences[0].targets).toEqual({ [p4.id]: RoleEnum.OUTSIDE_HITTER, [p3.id]: RoleEnum.MIDDLE_BLOCKER });
+        expect(back.blockingPreferences[0].targets).toEqual({ DEF_L: { [p4.id]: RoleEnum.OUTSIDE_HITTER }, DEF_M: {}, DEF_R: { [p3.id]: RoleEnum.MIDDLE_BLOCKER } });
     });
     // NO_BLOCK rides in the same targets map as a commit assignment, so the transformers copy it wholesale with no
     // mapping code. This pins that: the sentinel must survive the row round-trip verbatim, mixed with a commit, and
@@ -282,17 +282,17 @@ describe('per-set tactics — service <-> row round-trip', () => {
         const withNoBlock = Tactics.create({
             lineup: { 4: p4, 3: p3, 2: p2, 5: p5, 6: p6, 1: p1, bench: [] },
             liberoReplacements: [],
-            blockingPreferences: [{ rotation: 1, targets: { [p4.id]: NO_BLOCK, [p3.id]: RoleEnum.MIDDLE_BLOCKER } }],
-            blockingPreferenceSets: [[{ rotation: 2, targets: { [p2.id]: NO_BLOCK } }]]
+            blockingPreferences: [{ rotation: 1, targets: { DEF_M: { [p4.id]: NO_BLOCK, [p3.id]: RoleEnum.MIDDLE_BLOCKER } } }],
+            blockingPreferenceSets: [[{ rotation: 2, targets: { DEF_L: { [p2.id]: NO_BLOCK } } }]]
         });
         const attrs = transformFromTactics(withNoBlock, 'team-1');
         expect(attrs.blocking_preferences).toEqual([
-            { rotation: 1, targets: { [p4.id]: NO_BLOCK, [p3.id]: RoleEnum.MIDDLE_BLOCKER } }
+            { rotation: 1, targets: { DEF_L: {}, DEF_M: { [p4.id]: NO_BLOCK, [p3.id]: RoleEnum.MIDDLE_BLOCKER }, DEF_R: {} } }
         ]);
-        expect(attrs.blocking_preference_sets).toEqual([[{ rotation: 2, targets: { [p2.id]: NO_BLOCK } }]]);
+        expect(attrs.blocking_preference_sets).toEqual([[{ rotation: 2, targets: { DEF_L: { [p2.id]: NO_BLOCK }, DEF_M: {}, DEF_R: {} } }]]);
         const back = transformToTactics(attrs, roster);
-        expect(back.blockingPreferences[0].targets).toEqual({ [p4.id]: NO_BLOCK, [p3.id]: RoleEnum.MIDDLE_BLOCKER });
-        expect(back.blockingPreferenceSets?.[0][0].targets).toEqual({ [p2.id]: NO_BLOCK });
+        expect(back.blockingPreferences[0].targets).toEqual({ DEF_L: {}, DEF_M: { [p4.id]: NO_BLOCK, [p3.id]: RoleEnum.MIDDLE_BLOCKER }, DEF_R: {} });
+        expect(back.blockingPreferenceSets?.[0][0].targets).toEqual({ DEF_L: { [p2.id]: NO_BLOCK }, DEF_M: {}, DEF_R: {} });
     });
 });
 describe('libero injuries — service <-> row round-trip + lenient heal', () => {

package/dist/esm/src/service/competition/competition-rewards.d.ts

@@ -0,0 +1,20 @@
+export type CompetitionRewardKind = 'REGIONAL' | 'NATIONAL' | 'WCC';
+export interface CompetitionRewardRow {
+    /** Best final position that still earns this row: the "Top N" band. */
+    readonly maxPosition: number;
+    /** Coins awarded by this row alone (the increment, not the running total). */
+    readonly coins: number;
+    /** Recruit-reward pulls awarded by this row alone (the competition's own pull type). */
+    readonly recruits: number;
+}
+/** Per-competition bands, widest band first (the order the docs list them, with a growing cumulative total). */
+export declare const COMPETITION_REWARDS: Readonly<Record<CompetitionRewardKind, readonly CompetitionRewardRow[]>>;
+export interface CompetitionPayout {
+    readonly coins: number;
+    readonly recruits: number;
+}
+/**
+ * Everything a finishing position earns in the given competition: the sum of every band that still includes the
+ * position (cumulative). Positions past the lowest band earn nothing. `position` is the 1-based final placement.
+ */
+export declare function competitionPayoutFor(kind: CompetitionRewardKind, position: number): CompetitionPayout;

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

@@ -0,0 +1,43 @@
+// What the knockout competitions (Regional Cup, National Cup, WCC) pay out by final placement. Owner-defined
+// 2026-08-07. Like the event and league rewards, these are CUMULATIVE: a finish earns its band and every band
+// below it. Each band gives coins and/or "recruit rewards" (the competition's own pull grant: a Regional
+// recruit is a QUALIFIER pull, a National recruit a NATIONAL pull, a WCC recruit a TOURNAMENT pull). Recruit
+// rewards stack, so a champion collects one per qualifying band.
+//
+// One source of truth for two consumers: the simulator grants from it and the UI competition docs render it.
+/** Per-competition bands, widest band first (the order the docs list them, with a growing cumulative total). */
+export const COMPETITION_REWARDS = {
+    REGIONAL: [
+        { maxPosition: 4, coins: 1000, recruits: 0 },
+        { maxPosition: 3, coins: 0, recruits: 1 },
+        { maxPosition: 2, coins: 1000, recruits: 0 },
+        { maxPosition: 1, coins: 500, recruits: 1 }
+    ],
+    NATIONAL: [
+        { maxPosition: 8, coins: 1000, recruits: 0 },
+        { maxPosition: 4, coins: 500, recruits: 1 },
+        { maxPosition: 2, coins: 500, recruits: 0 },
+        { maxPosition: 1, coins: 0, recruits: 1 }
+    ],
+    WCC: [
+        { maxPosition: 4, coins: 1000, recruits: 0 },
+        { maxPosition: 3, coins: 0, recruits: 1 },
+        { maxPosition: 2, coins: 500, recruits: 1 },
+        { maxPosition: 1, coins: 500, recruits: 1 }
+    ]
+};
+/**
+ * Everything a finishing position earns in the given competition: the sum of every band that still includes the
+ * position (cumulative). Positions past the lowest band earn nothing. `position` is the 1-based final placement.
+ */
+export function competitionPayoutFor(kind, position) {
+    let coins = 0;
+    let recruits = 0;
+    for (const row of COMPETITION_REWARDS[kind]) {
+        if (position <= row.maxPosition) {
+            coins += row.coins;
+            recruits += row.recruits;
+        }
+    }
+    return { coins, recruits };
+}

package/dist/esm/src/service/competition/competition-rewards.test.d.ts

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

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

@@ -0,0 +1,30 @@
+import { describe, it, expect } from '@jest/globals';
+import { competitionPayoutFor, COMPETITION_REWARDS } from './competition-rewards';
+// The cumulative per-position totals the owner specified (2026-08-07): { coins, recruits } a finish earns,
+// summing its band and every band below. Positions past the lowest band earn nothing.
+describe('competitionPayoutFor', () => {
+    const CASES = {
+        // position: [coins, recruits]
+        REGIONAL: { 1: [2500, 2], 2: [2000, 1], 3: [1000, 1], 4: [1000, 0], 5: [0, 0] },
+        NATIONAL: { 1: [2000, 2], 2: [2000, 1], 3: [1500, 1], 4: [1500, 1], 5: [1000, 0], 8: [1000, 0], 9: [0, 0] },
+        WCC: { 1: [2000, 3], 2: [1500, 2], 3: [1000, 1], 4: [1000, 0], 5: [0, 0] }
+    };
+    for (const kind of Object.keys(CASES)) {
+        it(`matches the owner totals for ${kind}`, () => {
+            for (const [pos, [coins, recruits]] of Object.entries(CASES[kind])) {
+                expect(competitionPayoutFor(kind, Number(pos))).toEqual({ coins, recruits });
+            }
+        });
+    }
+    it('champion collects one recruit per qualifying band', () => {
+        expect(competitionPayoutFor('REGIONAL', 1).recruits).toBe(2);
+        expect(competitionPayoutFor('NATIONAL', 1).recruits).toBe(2);
+        expect(competitionPayoutFor('WCC', 1).recruits).toBe(3);
+    });
+    it('champion coin total equals the sum of the band table', () => {
+        const sum = (k) => COMPETITION_REWARDS[k].reduce((s, r) => s + r.coins, 0);
+        expect(competitionPayoutFor('REGIONAL', 1).coins).toBe(sum('REGIONAL'));
+        expect(competitionPayoutFor('NATIONAL', 1).coins).toBe(sum('NATIONAL'));
+        expect(competitionPayoutFor('WCC', 1).coins).toBe(sum('WCC'));
+    });
+});

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

@@ -3,6 +3,8 @@ export * from './season';
 export * from './event-schedule';
 export * from './event-draft';
 export * from './event-rewards';
+export * from './league-rewards';
+export * from './competition-rewards';
 export * from './league';
 export * from './division';
 export * from './iteration';

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

@@ -3,6 +3,8 @@ export * from './season';
 export * from './event-schedule';
 export * from './event-draft';
 export * from './event-rewards';
+export * from './league-rewards';
+export * from './competition-rewards';
 export * from './league';
 export * from './division';
 export * from './iteration';

package/dist/esm/src/service/competition/league-rewards.d.ts

@@ -0,0 +1,21 @@
+export interface LeagueRewardRow {
+    /** Best final position that still earns this row: the "Top N" band. */
+    readonly maxPosition: number;
+    /** Coins awarded by this row alone (the increment, not the running total). */
+    readonly coins: number;
+}
+/** Division tiers that get their own reward table. Tier 3 covers "division 3 and lower". */
+export type LeagueRewardTier = 1 | 2 | 3;
+/**
+ * Per-tier bands, widest band first (the order the standings doc lists them, with a growing cumulative total).
+ * A team earns every row whose band still includes its finishing position, which is what "cumulative" means.
+ */
+export declare const LEAGUE_REWARDS: Readonly<Record<LeagueRewardTier, readonly LeagueRewardRow[]>>;
+/** Clamp any division tier to a reward table: tier 1, tier 2, and tier 3-and-lower share the tier-3 table. */
+export declare function leagueRewardTier(tier: number): LeagueRewardTier;
+/**
+ * Coins a finishing position earns in a division of the given tier: the sum of every band that still includes
+ * the position (cumulative). Positions past the lowest band earn 0. `position` is the 1-based final standings
+ * place.
+ */
+export declare function leaguePayoutFor(tier: number, position: number): number;

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

@@ -0,0 +1,53 @@
+// What a league season pays out at the end, by division tier and final standings position. Owner-defined
+// 2026-08-07. Like the event rewards, these are CUMULATIVE: a team collects its own band and every band below
+// it, so first place collects them all. Positions past the lowest band earn nothing.
+//
+// One source of truth for two consumers: the simulator grants from it (assignSeasonPayoutIfMissing) and the UI
+// standings doc renders it.
+/**
+ * Per-tier bands, widest band first (the order the standings doc lists them, with a growing cumulative total).
+ * A team earns every row whose band still includes its finishing position, which is what "cumulative" means.
+ */
+export const LEAGUE_REWARDS = {
+    1: [
+        { maxPosition: 12, coins: 1000 },
+        { maxPosition: 8, coins: 500 },
+        { maxPosition: 4, coins: 500 },
+        { maxPosition: 3, coins: 250 },
+        { maxPosition: 2, coins: 250 },
+        { maxPosition: 1, coins: 500 }
+    ],
+    2: [
+        { maxPosition: 8, coins: 500 },
+        { maxPosition: 4, coins: 500 },
+        { maxPosition: 2, coins: 250 },
+        { maxPosition: 1, coins: 250 }
+    ],
+    3: [
+        { maxPosition: 4, coins: 500 },
+        { maxPosition: 2, coins: 250 },
+        { maxPosition: 1, coins: 250 }
+    ]
+};
+/** Clamp any division tier to a reward table: tier 1, tier 2, and tier 3-and-lower share the tier-3 table. */
+export function leagueRewardTier(tier) {
+    const t = Math.trunc(tier);
+    if (t <= 1)
+        return 1;
+    if (t === 2)
+        return 2;
+    return 3;
+}
+/**
+ * Coins a finishing position earns in a division of the given tier: the sum of every band that still includes
+ * the position (cumulative). Positions past the lowest band earn 0. `position` is the 1-based final standings
+ * place.
+ */
+export function leaguePayoutFor(tier, position) {
+    let coins = 0;
+    for (const row of LEAGUE_REWARDS[leagueRewardTier(tier)]) {
+        if (position <= row.maxPosition)
+            coins += row.coins;
+    }
+    return coins;
+}

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

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

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/team/base-config.d.ts

@@ -7,4 +7,5 @@ export interface BaseCoord {
 export interface BaseConfig {
     readonly coords: Record<string, Record<string, Record<string, BaseCoord>>>;
     readonly receive: Record<string, Record<string, boolean>>;
+    readonly blocking?: Record<string, Record<string, Record<string, boolean>>>;
 }

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,154 @@
+import { slotFunctionAt } from './lineup-function';
+import { RoleEnum } from '../player';
+import { isBackRow } from '../match';
+const COORDS = {
+    SERVE: {
+        1: { 1: { d: 10.00, r: 3.50 }, 2: { d: 0.50, r: -2.50 }, 3: { d: 0.50, r: 0.00 }, 4: { d: 0.50, r: 2.50 }, 5: { d: 6.50, r: 0.00 }, 6: { d: 5.00, r: -2.50 } },
+        2: { 1: { d: 10.00, r: 3.50 }, 2: { d: 0.50, r: 0.00 }, 3: { d: 0.50, r: 2.50 }, 4: { d: 0.50, r: -2.50 }, 5: { d: 5.00, r: -2.50 }, 6: { d: 5.00, r: 2.50 } },
+        3: { 1: { d: 10.00, r: -3.50 }, 2: { d: 0.50, r: 2.50 }, 3: { d: 0.50, r: -2.50 }, 4: { d: 0.50, r: 0.00 }, 5: { d: 5.00, r: 2.50 }, 6: { d: 6.50, r: 0.00 } },
+        4: { 1: { d: 10.00, r: 3.50 }, 2: { d: 0.50, r: -2.50 }, 3: { d: 0.50, r: 0.00 }, 4: { d: 0.50, r: 2.50 }, 5: { d: 6.50, r: 0.00 }, 6: { d: 5.00, r: -2.50 } },
+        5: { 1: { d: 10.00, r: 3.50 }, 2: { d: 0.50, r: 0.00 }, 3: { d: 0.50, r: 2.50 }, 4: { d: 0.50, r: -2.50 }, 5: { d: 5.00, r: -2.50 }, 6: { d: 5.00, r: 2.50 } },
+        6: { 1: { d: 10.00, r: -3.50 }, 2: { d: 0.50, r: 2.50 }, 3: { d: 0.50, r: -2.50 }, 4: { d: 0.50, r: 0.00 }, 5: { d: 5.00, r: 2.50 }, 6: { d: 6.50, r: 0.00 } }
+    },
+    RECEIVE: {
+        1: { 1: { d: 6.50, r: 3.50 }, 2: { d: 6.00, r: 3.00 }, 3: { d: 3.00, r: -3.50 }, 4: { d: 3.50, r: -4.00 }, 5: { d: 6.00, r: -3.00 }, 6: { d: 6.50, r: 0.00 } },
+        2: { 1: { d: 6.00, r: 3.00 }, 2: { d: 3.00, r: 4.00 }, 3: { d: 0.50, r: 0.50 }, 4: { d: 6.00, r: -3.00 }, 5: { d: 6.50, r: 0.00 }, 6: { d: 1.25, r: 0.75 } },
+        3: { 1: { d: 6.00, r: 3.00 }, 2: { d: 3.00, r: 4.00 }, 3: { d: 6.00, r: -3.00 }, 4: { d: 0.95, r: -4.00 }, 5: { d: 1.00, r: -1.00 }, 6: { d: 6.50, r: 0.00 } },
+        4: { 1: { d: 8.50, r: 4.00 }, 2: { d: 6.00, r: -3.00 }, 3: { d: 1.25, r: -4.00 }, 4: { d: 0.75, r: -4.05 }, 5: { d: 6.50, r: 0.00 }, 6: { d: 6.00, r: 3.00 } },
+        5: { 1: { d: 6.00, r: 3.00 }, 2: { d: 2.50, r: 4.00 }, 3: { d: 1.00, r: 1.50 }, 4: { d: 6.00, r: -3.00 }, 5: { d: 6.50, r: 0.00 }, 6: { d: 8.50, r: 1.50 } },
+        6: { 1: { d: 6.00, r: 3.00 }, 2: { d: 1.00, r: 1.50 }, 3: { d: 6.00, r: -3.00 }, 4: { d: 3.00, r: -4.00 }, 5: { d: 8.50, r: -1.50 }, 6: { d: 6.50, r: 0.00 } }
+    },
+    DEFENCE: {
+        1: { 1: { d: 5.00, r: 3.00 }, 2: { d: 0.50, r: -2.50 }, 3: { d: 0.50, r: 0.00 }, 4: { d: 0.50, r: 2.50 }, 5: { d: 7.00, r: 0.00 }, 6: { d: 5.00, r: -3.00 } },
+        2: { 1: { d: 7.00, r: 0.00 }, 2: { d: 0.50, r: 0.00 }, 3: { d: 0.50, r: 2.50 }, 4: { d: 0.50, r: -2.50 }, 5: { d: 5.00, r: -3.00 }, 6: { d: 5.00, r: 3.00 } },
+        3: { 1: { d: 5.00, r: -3.00 }, 2: { d: 0.50, r: 2.50 }, 3: { d: 0.50, r: -2.50 }, 4: { d: 0.50, r: 0.00 }, 5: { d: 5.00, r: 3.00 }, 6: { d: 7.00, r: 0.00 } },
+        4: { 1: { d: 5.00, r: 3.00 }, 2: { d: 0.50, r: -2.50 }, 3: { d: 0.50, r: 0.00 }, 4: { d: 0.50, r: 2.50 }, 5: { d: 7.00, r: 0.00 }, 6: { d: 5.00, r: -3.00 } },
+        5: { 1: { d: 7.00, r: 0.00 }, 2: { d: 0.50, r: 0.00 }, 3: { d: 0.50, r: 2.50 }, 4: { d: 0.50, r: -2.50 }, 5: { d: 5.00, r: -3.00 }, 6: { d: 5.00, r: 3.00 } },
+        6: { 1: { d: 5.00, r: -3.00 }, 2: { d: 0.50, r: 2.50 }, 3: { d: 0.50, r: -2.50 }, 4: { d: 0.50, r: 0.00 }, 5: { d: 5.00, r: 3.00 }, 6: { d: 7.00, r: 0.00 } }
+    },
+    DEF_L: {
+        1: { 1: { d: 5.00, r: 1.50 }, 2: { d: 0.25, r: -4.00 }, 3: { d: 0.25, r: -3.25 }, 4: { d: 1.75, r: 1.25 }, 5: { d: 8.00, r: -0.50 }, 6: { d: 5.00, r: -4.20 } },
+        2: { 1: { d: 8.00, r: -0.50 }, 2: { d: 0.25, r: -3.25 }, 3: { d: 1.75, r: 1.25 }, 4: { d: 0.25, r: -4.00 }, 5: { d: 5.00, r: -4.20 }, 6: { d: 5.00, r: 1.50 } },
+        3: { 1: { d: 5.00, r: -4.20 }, 2: { d: 1.75, r: 1.25 }, 3: { d: 0.25, r: -4.00 }, 4: { d: 0.25, r: -3.25 }, 5: { d: 5.00, r: 1.50 }, 6: { d: 8.00, r: -0.50 } },
+        4: { 1: { d: 5.00, r: 1.50 }, 2: { d: 0.25, r: -4.00 }, 3: { d: 0.25, r: -3.25 }, 4: { d: 1.75, r: 1.25 }, 5: { d: 8.00, r: -0.50 }, 6: { d: 5.00, r: -4.20 } },
+        5: { 1: { d: 8.00, r: -0.50 }, 2: { d: 0.25, r: -3.25 }, 3: { d: 1.75, r: 1.25 }, 4: { d: 0.25, r: -4.00 }, 5: { d: 5.00, r: -4.20 }, 6: { d: 5.00, r: 1.50 } },
+        6: { 1: { d: 5.00, r: -4.20 }, 2: { d: 1.75, r: 1.25 }, 3: { d: 0.25, r: -4.00 }, 4: { d: 0.25, r: -3.25 }, 5: { d: 5.00, r: 1.50 }, 6: { d: 8.00, r: -0.50 } }
+    },
+    DEF_M: {
+        1: { 1: { d: 5.00, r: 2.50 }, 2: { d: 1.75, r: -2.50 }, 3: { d: 0.25, r: 0.00 }, 4: { d: 1.75, r: 2.50 }, 5: { d: 7.00, r: 0.00 }, 6: { d: 5.00, r: -2.50 } },
+        2: { 1: { d: 7.00, r: 0.00 }, 2: { d: 0.25, r: 0.00 }, 3: { d: 1.75, r: 2.50 }, 4: { d: 1.75, r: -2.50 }, 5: { d: 5.00, r: -2.50 }, 6: { d: 5.00, r: 2.50 } },
+        3: { 1: { d: 5.00, r: -2.50 }, 2: { d: 1.75, r: 2.50 }, 3: { d: 1.75, r: -2.50 }, 4: { d: 0.25, r: 0.00 }, 5: { d: 5.00, r: 2.50 }, 6: { d: 7.00, r: 0.00 } },
+        4: { 1: { d: 5.00, r: 2.50 }, 2: { d: 1.75, r: -2.50 }, 3: { d: 0.25, r: 0.00 }, 4: { d: 1.75, r: 2.50 }, 5: { d: 7.00, r: 0.00 }, 6: { d: 5.00, r: -2.50 } },
+        5: { 1: { d: 7.00, r: 0.00 }, 2: { d: 0.25, r: 0.00 }, 3: { d: 1.75, r: 2.50 }, 4: { d: 1.75, r: -2.50 }, 5: { d: 5.00, r: -2.50 }, 6: { d: 5.00, r: 2.50 } },
+        6: { 1: { d: 5.00, r: -2.50 }, 2: { d: 1.75, r: 2.50 }, 3: { d: 1.75, r: -2.50 }, 4: { d: 0.25, r: 0.00 }, 5: { d: 5.00, r: 2.50 }, 6: { d: 7.00, r: 0.00 } }
+    },
+    DEF_R: {
+        1: { 1: { d: 5.00, r: 4.20 }, 2: { d: 1.75, r: -1.25 }, 3: { d: 0.25, r: 3.25 }, 4: { d: 0.25, r: 4.00 }, 5: { d: 8.00, r: 0.50 }, 6: { d: 5.00, r: -1.50 } },
+        2: { 1: { d: 8.00, r: 0.50 }, 2: { d: 0.25, r: 3.25 }, 3: { d: 0.25, r: 4.00 }, 4: { d: 1.75, r: -1.25 }, 5: { d: 5.00, r: -1.50 }, 6: { d: 5.00, r: 4.20 } },
+        3: { 1: { d: 5.00, r: -1.50 }, 2: { d: 0.25, r: 4.00 }, 3: { d: 1.75, r: -1.25 }, 4: { d: 0.25, r: 3.25 }, 5: { d: 5.00, r: 4.20 }, 6: { d: 8.00, r: 0.50 } },
+        4: { 1: { d: 5.00, r: 4.20 }, 2: { d: 1.75, r: -1.25 }, 3: { d: 0.25, r: 3.25 }, 4: { d: 0.25, r: 4.00 }, 5: { d: 8.00, r: 0.50 }, 6: { d: 5.00, r: -1.50 } },
+        5: { 1: { d: 8.00, r: 0.50 }, 2: { d: 0.25, r: 3.25 }, 3: { d: 0.25, r: 4.00 }, 4: { d: 1.75, r: -1.25 }, 5: { d: 5.00, r: -1.50 }, 6: { d: 5.00, r: 4.20 } },
+        6: { 1: { d: 5.00, r: -1.50 }, 2: { d: 0.25, r: 4.00 }, 3: { d: 1.75, r: -1.25 }, 4: { d: 0.25, r: 3.25 }, 5: { d: 5.00, r: 4.20 }, 6: { d: 8.00, r: 0.50 } }
+    },
+    ATTACK: {
+        1: { 1: { d: 0.50, r: 1.50 }, 2: { d: 3.75, r: -5.00 }, 3: { d: 3.00, r: 0.25 }, 4: { d: 3.75, r: 5.00 }, 5: { d: 6.50, r: 0.00 }, 6: { d: 4.50, r: -2.50 } },
+        2: { 1: { d: 6.50, r: 0.00 }, 2: { d: 3.00, r: 0.25 }, 3: { d: 3.75, r: 5.00 }, 4: { d: 3.75, r: -5.00 }, 5: { d: 4.50, r: -2.50 }, 6: { d: 0.50, r: 1.50 } },
+        3: { 1: { d: 4.50, r: -2.50 }, 2: { d: 3.75, r: 5.00 }, 3: { d: 3.75, r: -5.00 }, 4: { d: 3.00, r: 0.25 }, 5: { d: 0.50, r: 1.50 }, 6: { d: 6.50, r: 0.00 } },
+        4: { 1: { d: 6.50, r: 4.90 }, 2: { d: 3.75, r: -5.00 }, 3: { d: 3.00, r: 0.25 }, 4: { d: 0.50, r: 1.50 }, 5: { d: 6.50, r: 0.00 }, 6: { d: 4.50, r: -2.50 } },
+        5: { 1: { d: 6.50, r: 0.00 }, 2: { d: 3.00, r: 0.25 }, 3: { d: 0.50, r: 1.50 }, 4: { d: 3.75, r: -5.00 }, 5: { d: 4.50, r: -2.50 }, 6: { d: 6.50, r: 4.90 } },
+        6: { 1: { d: 4.50, r: -2.50 }, 2: { d: 0.50, r: 1.50 }, 3: { d: 3.75, r: -5.00 }, 4: { d: 3.00, r: 0.25 }, 5: { d: 6.50, r: 4.90 }, 6: { d: 6.50, r: 0.00 } }
+    },
+    ATK_L: {
+        1: { 1: { d: 0.75, r: 0.00 }, 2: { d: 0.50, r: -4.00 }, 3: { d: 1.00, r: -2.50 }, 4: { d: 3.50, r: 0.75 }, 5: { d: 6.25, r: -0.75 }, 6: { d: 3.50, r: -4.00 } },
+        2: { 1: { d: 6.25, r: -0.75 }, 2: { d: 1.00, r: -2.50 }, 3: { d: 3.50, r: 0.75 }, 4: { d: 0.50, r: -4.00 }, 5: { d: 3.50, r: -4.00 }, 6: { d: 0.75, r: 0.00 } },
+        3: { 1: { d: 3.50, r: -4.00 }, 2: { d: 3.50, r: 0.75 }, 3: { d: 0.50, r: -4.00 }, 4: { d: 1.00, r: -2.50 }, 5: { d: 0.75, r: 0.00 }, 6: { d: 6.25, r: -0.75 } },
+        4: { 1: { d: 3.50, r: 0.75 }, 2: { d: 0.50, r: -4.00 }, 3: { d: 1.00, r: -2.50 }, 4: { d: 0.75, r: 0.00 }, 5: { d: 6.25, r: -0.75 }, 6: { d: 3.50, r: -4.00 } },
+        5: { 1: { d: 6.25, r: -0.75 }, 2: { d: 1.00, r: -2.50 }, 3: { d: 0.75, r: 0.00 }, 4: { d: 0.50, r: -4.00 }, 5: { d: 3.50, r: -4.00 }, 6: { d: 3.50, r: 0.75 } },
+        6: { 1: { d: 3.50, r: -4.00 }, 2: { d: 0.75, r: 0.00 }, 3: { d: 0.50, r: -4.00 }, 4: { d: 1.00, r: -2.50 }, 5: { d: 3.50, r: 0.75 }, 6: { d: 6.25, r: -0.75 } }
+    },
+    ATK_M: {
+        1: { 1: { d: 0.75, r: 1.25 }, 2: { d: 1.25, r: -2.00 }, 3: { d: 0.75, r: 0.50 }, 4: { d: 2.25, r: 2.60 }, 5: { d: 6.50, r: 1.50 }, 6: { d: 4.00, r: -1.50 } },
+        2: { 1: { d: 6.50, r: 1.50 }, 2: { d: 0.75, r: 0.50 }, 3: { d: 2.25, r: 2.60 }, 4: { d: 1.25, r: -2.00 }, 5: { d: 4.00, r: -1.50 }, 6: { d: 0.75, r: 1.25 } },
+        3: { 1: { d: 4.00, r: -1.50 }, 2: { d: 2.25, r: 2.60 }, 3: { d: 1.25, r: -2.00 }, 4: { d: 0.75, r: 0.50 }, 5: { d: 0.75, r: 1.25 }, 6: { d: 6.50, r: 1.50 } },
+        4: { 1: { d: 2.25, r: 2.60 }, 2: { d: 1.25, r: -2.00 }, 3: { d: 0.75, r: 0.50 }, 4: { d: 0.75, r: 1.25 }, 5: { d: 6.50, r: 1.50 }, 6: { d: 4.00, r: -1.50 } },
+        5: { 1: { d: 6.50, r: 1.50 }, 2: { d: 0.75, r: 0.50 }, 3: { d: 0.75, r: 1.25 }, 4: { d: 1.25, r: -2.00 }, 5: { d: 4.00, r: -1.50 }, 6: { d: 2.25, r: 2.60 } },
+        6: { 1: { d: 4.00, r: -1.50 }, 2: { d: 0.75, r: 1.25 }, 3: { d: 1.25, r: -2.00 }, 4: { d: 0.75, r: 0.50 }, 5: { d: 2.25, r: 2.60 }, 6: { d: 6.50, r: 1.50 } }
+    },
+    ATK_R: {
+        1: { 1: { d: 1.75, r: 2.50 }, 2: { d: 1.50, r: -1.75 }, 3: { d: 0.75, r: 1.75 }, 4: { d: 0.50, r: 4.00 }, 5: { d: 5.00, r: 3.25 }, 6: { d: 5.75, r: -2.00 } },
+        2: { 1: { d: 5.00, r: 3.25 }, 2: { d: 0.75, r: 1.75 }, 3: { d: 0.50, r: 4.00 }, 4: { d: 1.50, r: -1.75 }, 5: { d: 5.75, r: -2.00 }, 6: { d: 1.75, r: 2.50 } },
+        3: { 1: { d: 5.75, r: -2.00 }, 2: { d: 0.50, r: 4.00 }, 3: { d: 1.50, r: -1.75 }, 4: { d: 0.75, r: 1.75 }, 5: { d: 1.75, r: 2.50 }, 6: { d: 5.00, r: 3.25 } },
+        4: { 1: { d: 2.25, r: 4.00 }, 2: { d: 2.25, r: -1.75 }, 3: { d: 0.75, r: 1.50 }, 4: { d: 1.50, r: 2.25 }, 5: { d: 6.00, r: 2.25 }, 6: { d: 5.00, r: -0.75 } },
+        5: { 1: { d: 6.00, r: 2.25 }, 2: { d: 0.75, r: 1.50 }, 3: { d: 1.50, r: 2.25 }, 4: { d: 2.25, r: -1.75 }, 5: { d: 5.00, r: -0.75 }, 6: { d: 2.25, r: 4.00 } },
+        6: { 1: { d: 5.00, r: -0.75 }, 2: { d: 1.50, r: 2.25 }, 3: { d: 2.25, r: -1.75 }, 4: { d: 0.75, r: 1.50 }, 5: { d: 2.25, r: 4.00 }, 6: { d: 6.00, r: 2.25 } }
+    }
+};
+// 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;
+})();
+// The owner's authored per-point-of-attack block map for the 5-1 (owner 2026-08-07), keyed
+// [DEF_L|DEF_M|DEF_R][rotation][zone] -> canBlock. `false` = that front-row zone sits OUT of the block for an attack
+// from that side; `true` = reads/joins the wall. Only front-row zones (2/3/4) are tagged. Same rotation convention
+// as DEFAULT_COORDS. Generated from the finalized 5-1 sr-mapper preset's Def L/M/R block/noblock tags.
+const DEFAULT_BLOCKING = {
+    DEF_L: {
+        1: { 2: true, 3: true, 4: false },
+        2: { 2: true, 3: false, 4: true },
+        3: { 2: false, 3: true, 4: true },
+        4: { 2: true, 3: true, 4: false },
+        5: { 2: true, 3: false, 4: true },
+        6: { 2: false, 3: true, 4: true }
+    },
+    DEF_M: {
+        1: { 2: false, 3: true, 4: false },
+        2: { 2: true, 3: false, 4: false },
+        3: { 2: false, 3: false, 4: true },
+        4: { 2: false, 3: true, 4: false },
+        5: { 2: true, 3: false, 4: false },
+        6: { 2: false, 3: false, 4: true }
+    },
+    DEF_R: {
+        1: { 2: false, 3: true, 4: true },
+        2: { 2: true, 3: true, 4: false },
+        3: { 2: true, 3: false, 4: true },
+        4: { 2: false, 3: true, 4: true },
+        5: { 2: true, 3: true, 4: false },
+        6: { 2: true, 3: false, 4: true }
+    }
+};
+// 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), blocking: DEFAULT_BLOCKING };
+}

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

@@ -3,6 +3,7 @@ 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

@@ -3,6 +3,7 @@ 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,11 +282,19 @@ 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<{
@@ -294,6 +302,7 @@ export declare const TacticsInputSchema: z.ZodObject<{
             r: z.ZodNumber;
         }, z.core.$strip>>>>;
         receive: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+        blocking: z.ZodOptional<z.ZodRecord<z.ZodString, 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<{

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

@@ -65,9 +65,16 @@ 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({
@@ -81,7 +88,10 @@ const systemSetSchema = z.object({
 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()))
+    receive: z.record(z.string(), z.record(z.string(), z.boolean())),
+    // Optional per-point-of-attack blocking (owner 2026-08-07): [DEF_L|DEF_M|DEF_R][rotation][zone] -> canBlock.
+    // Optional so presets/tactics saved before this field validate unchanged.
+    blocking: z.record(z.string(), z.record(z.string(), z.record(z.string(), z.boolean()))).optional()
 });
 export const TacticsInputSchema = z.object({
     lineup: lineupSchema,
@@ -210,9 +220,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 });
+                    }
                 }
             }
         }