volleyballsimtypes 0.0.514 → 0.0.516

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

@@ -24,7 +24,7 @@ function makeTactics(designatedSubs) {
         libero_replacement_sets: undefined,
         rotation_system: '5-1',
         designated_setters: ['lf'],
-        offensive_preferences: [{ rotation: 1, weights: { lf: 60, rf: 40 } }],
+        offensive_preferences: [{ rotation: 1, priorities: { lf: 'HIGH', rf: 'MID' } }],
         blocking_preferences: []
     };
 }
@@ -36,7 +36,7 @@ describe('tacticsColumnsToApiDto()', () => {
         expect(dto.rotationSystem).toBe('5-1');
         expect(dto.liberoReplacements).toEqual(['lf']);
         expect(dto.lineup.bench).toEqual(['b1', 'b2']);
-        expect(dto.offensivePreferences).toEqual([{ rotation: 1, weights: { lf: 60, rf: 40 } }]);
+        expect(dto.offensivePreferences).toEqual([{ rotation: 1, priorities: { lf: 'HIGH', rf: 'MID' } }]);
     });
     it('converts a legacy isPinchServer entry to a unified pinch server (conditions kept, no mode)', () => {
         const dto = tacticsColumnsToApiDto(makeTactics([
@@ -131,32 +131,16 @@ describe('tacticsColumnsToApiDto()', () => {
     it('passes per-set tactics columns through to the API DTO shape', () => {
         const model = makeTactics([]);
         model.system_sets = [{ rotationSystem: RotationSystemEnum.FIVE_ONE, designatedSetters: ['lf'] }];
-        model.offensive_preference_sets = [[{ rotation: 1, weights: { rf: 55, mf: 45 } }]];
+        model.offensive_preference_sets = [[{ rotation: 1, priorities: { rf: 'HIGH', mf: 'MID' } }]];
         const dto = tacticsColumnsToApiDto(model);
         expect(dto.systemSets).toEqual([{ rotationSystem: '5-1', designatedSetters: ['lf'] }]);
-        expect(dto.offensivePreferenceSets).toEqual([[{ rotation: 1, weights: { rf: 55, mf: 45 } }]]);
+        expect(dto.offensivePreferenceSets).toEqual([[{ rotation: 1, priorities: { rf: 'HIGH', mf: 'MID' } }]]);
     });
     it('leaves the per-set DTO fields undefined when the columns are absent', () => {
         const dto = tacticsColumnsToApiDto(makeTactics([]));
         expect(dto.systemSets).toBeUndefined();
         expect(dto.offensivePreferenceSets).toBeUndefined();
     });
-    it('surfaces serve attack shares keyed by a libero replacement', () => {
-        const model = makeTactics([]);
-        model.serve_attack_shares = { lf: 30 }; // lf is the configured libero_replacement
-        const dto = tacticsColumnsToApiDto(model);
-        expect(dto.serveAttackShares).toEqual({ lf: 30 });
-    });
-    it('drops a serve attack share keyed by a non-libero-replacement (stale heal)', () => {
-        const model = makeTactics([]);
-        model.serve_attack_shares = { lf: 30, rf: 40 }; // rf is not in libero_replacements (['lf'])
-        const dto = tacticsColumnsToApiDto(model);
-        expect(dto.serveAttackShares).toEqual({ lf: 30 });
-    });
-    it('leaves serveAttackShares undefined when the column is empty', () => {
-        const dto = tacticsColumnsToApiDto(makeTactics([]));
-        expect(dto.serveAttackShares).toBeUndefined();
-    });
 });
 describe('per-set tactics — service <-> row round-trip', () => {
     const country = makeCountry();
@@ -174,7 +158,7 @@ describe('per-set tactics — service <-> row round-trip', () => {
             { rotationSystem: RotationSystemEnum.FIVE_ONE, designatedSetters: [p1] },
             { rotationSystem: RotationSystemEnum.SIX_ZERO, designatedSetters: [] }
         ],
-        offensivePreferenceSets: [[{ rotation: 1, weights: { [p2.id]: 60, [p3.id]: 40 } }]]
+        offensivePreferenceSets: [[{ rotation: 1, priorities: { [p2.id]: 'HIGH', [p3.id]: 'MID' } }]]
     });
     it('transformFromTactics writes the per-set overrides as id-based jsonb columns', () => {
         const attrs = transformFromTactics(tactics, 'team-1');
@@ -182,7 +166,7 @@ describe('per-set tactics — service <-> row round-trip', () => {
             { rotationSystem: '5-1', designatedSetters: [p1.id] },
             { rotationSystem: '6-0', designatedSetters: [] }
         ]);
-        expect(attrs.offensive_preference_sets).toEqual([[{ rotation: 1, weights: { [p2.id]: 60, [p3.id]: 40 } }]]);
+        expect(attrs.offensive_preference_sets).toEqual([[{ rotation: 1, priorities: { [p2.id]: 'HIGH', [p3.id]: 'MID' } }]]);
     });
     it('transformToTactics resolves the stored ids back to roster players', () => {
         const attrs = transformFromTactics(tactics, 'team-1');
@@ -190,7 +174,7 @@ describe('per-set tactics — service <-> row round-trip', () => {
         expect(back.systemSets?.[0].rotationSystem).toBe(RotationSystemEnum.FIVE_ONE);
         expect(back.systemSets?.[0].designatedSetters[0].id).toBe(p1.id);
         expect(back.systemSets?.[1].designatedSetters).toEqual([]);
-        expect(back.offensivePreferenceSets?.[0][0].weights).toEqual({ [p2.id]: 60, [p3.id]: 40 });
+        expect(back.offensivePreferenceSets?.[0][0].priorities).toEqual({ [p2.id]: 'HIGH', [p3.id]: 'MID' });
     });
     it('omits the per-set columns entirely for an all-sets config', () => {
         const flat = Tactics.create({
@@ -204,27 +188,6 @@ describe('per-set tactics — service <-> row round-trip', () => {
         expect(back.systemSets).toBeUndefined();
         expect(back.offensivePreferenceSets).toBeUndefined();
     });
-    it('round-trips serve attack shares keyed by a libero replacement', () => {
-        const withServe = Tactics.create({
-            lineup: { 4: p4, 3: p3, 2: p2, 5: p5, 6: p6, 1: p1, bench: [] },
-            liberoReplacements: [p5],
-            serveAttackShares: { [p5.id]: 35 }
-        });
-        const attrs = transformFromTactics(withServe, 'team-1');
-        expect(attrs.serve_attack_shares).toEqual({ [p5.id]: 35 });
-        const back = transformToTactics(attrs, roster);
-        expect(back.serveAttackShares).toEqual({ [p5.id]: 35 });
-    });
-    it('drops a stale serve attack share key on load (lenient heal, no crash)', () => {
-        const attrs = transformFromTactics(Tactics.create({
-            lineup: { 4: p4, 3: p3, 2: p2, 5: p5, 6: p6, 1: p1, bench: [] },
-            liberoReplacements: [p5],
-            serveAttackShares: { [p5.id]: 35 }
-        }), 'team-1');
-        attrs.libero_replacements = [];
-        const back = transformToTactics(attrs, roster);
-        expect(back.serveAttackShares).toEqual({});
-    });
     it('round-trips base positions (coords + reception participation)', () => {
         const config = {
             coords: { RECEIVE: { 1: { 5: { d: 5.5, r: -3 }, 6: { d: 6.5, r: 0 } } }, DEFENCE: { 3: { 2: { d: 0.9, r: 3 } } } },
@@ -253,11 +216,11 @@ describe('per-set tactics — service <-> row round-trip', () => {
         const withTempos = Tactics.create({
             lineup: { 4: p4, 3: p3, 2: p2, 5: p5, 6: p6, 1: p1, bench: [] },
             liberoReplacements: [],
-            offensivePreferences: [{ rotation: 1, weights: { [p2.id]: 60, [p3.id]: 40 }, tempos: { [p2.id]: 'FAST', [p3.id]: 'HIGH' } }]
+            offensivePreferences: [{ rotation: 1, priorities: { [p2.id]: 'HIGH', [p3.id]: 'MID' }, tempos: { [p2.id]: 'FAST', [p3.id]: 'HIGH' } }]
         });
         const attrs = transformFromTactics(withTempos, 'team-1');
         expect(attrs.offensive_preferences).toEqual([
-            { rotation: 1, weights: { [p2.id]: 60, [p3.id]: 40 }, tempos: { [p2.id]: 'FAST', [p3.id]: 'HIGH' } }
+            { rotation: 1, priorities: { [p2.id]: 'HIGH', [p3.id]: 'MID' }, tempos: { [p2.id]: 'FAST', [p3.id]: 'HIGH' } }
         ]);
         const back = transformToTactics(attrs, roster);
         expect(back.offensivePreferences[0].tempos).toEqual({ [p2.id]: 'FAST', [p3.id]: 'HIGH' });

package/dist/esm/src/service/team/attack-priority.d.ts

@@ -0,0 +1,3 @@
+export type AttackPriority = 'HIGH' | 'MID' | 'LOW' | 'NONE';
+export declare const ATTACK_PRIORITIES: readonly AttackPriority[];
+export declare const PRIORITY_WEIGHT: Record<AttackPriority, number>;

package/dist/esm/src/service/team/attack-priority.js

@@ -0,0 +1,8 @@
+export const ATTACK_PRIORITIES = ['HIGH', 'MID', 'LOW', 'NONE'];
+// The relative pull of each priority. Tunable in one place; the engine reads these to weight the setter's target.
+export const PRIORITY_WEIGHT = {
+    HIGH: 20,
+    MID: 10,
+    LOW: 5,
+    NONE: 0
+};

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

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

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

@@ -84,11 +84,40 @@ const COORDS = {
         6: { 1: { d: 5.35, r: 2.35 }, 2: { d: 2.05, r: 2.1 }, 3: { d: 0.8, r: 4 }, 4: { d: 2.1, r: -1.95 }, 5: { d: 4.9, r: -1.4 }, 6: { d: 0.4, r: 1.3 } }
     }
 };
+// Per-attacker attack subbases (owner 2026-08-12): the point-of-attack ATK_L/M/R coverage shapes are replaced by ONE
+// subbase per attacker, keyed by the attacker's ZONE (ATK_Z1..ATK_Z6). Each is the whole-team formation used when the
+// attacker at that zone gets the ball. A FRONT-row zone (2/3/4) reuses its lane's old ATK_L/M/R shape, where the lane
+// is ranked by that zone's ATTACK-base lateral this rotation (leftmost r -> ATK_L, middle -> ATK_M, rightmost -> ATK_R);
+// a BACK-row zone (1/5/6) replicates the ATTACK base. Derived from COORDS so the code default and the migration agree.
+// The old ATK_L/M/R stay in COORDS as the derivation SOURCE but are NOT exposed in the default (below).
+const FRONT_ZONES = [2, 3, 4];
+const BACK_ZONES = [1, 5, 6];
+function defaultAttackSubbases() {
+    const cloneFormation = (zones) => {
+        const out = {};
+        for (const [zone, c] of Object.entries(zones))
+            out[zone] = { d: c.d, r: c.r };
+        return out;
+    };
+    const out = { ATK_Z1: {}, ATK_Z2: {}, ATK_Z3: {}, ATK_Z4: {}, ATK_Z5: {}, ATK_Z6: {} };
+    for (let rot = 1; rot <= 6; rot++) {
+        const ranked = [...FRONT_ZONES].sort((a, b) => COORDS.ATTACK[rot][a].r - COORDS.ATTACK[rot][b].r);
+        const laneFor = { [ranked[0]]: 'ATK_L', [ranked[1]]: 'ATK_M', [ranked[2]]: 'ATK_R' };
+        for (const z of FRONT_ZONES)
+            out['ATK_Z' + String(z)][String(rot)] = cloneFormation(COORDS[laneFor[z]][rot]);
+        for (const z of BACK_ZONES)
+            out['ATK_Z' + String(z)][String(rot)] = cloneFormation(COORDS.ATTACK[rot]);
+    }
+    return out;
+}
 // 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.
+// serialized) per team on save, so sharing the reference in memory is safe. ATK_L/M/R are dropped from the exposed
+// default (replaced by ATK_Z<n>); everything else is copied verbatim from COORDS.
 const DEFAULT_COORDS = (() => {
     const out = {};
     for (const [formation, rotations] of Object.entries(COORDS)) {
+        if (formation === 'ATK_L' || formation === 'ATK_M' || formation === 'ATK_R')
+            continue; // replaced by ATK_Z<n>
         out[formation] = {};
         for (const [rotation, zones] of Object.entries(rotations)) {
             out[formation][rotation] = {};
@@ -96,8 +125,35 @@ const DEFAULT_COORDS = (() => {
                 out[formation][rotation][zone] = { d: coord.d, r: coord.r };
         }
     }
-    return out;
+    return { ...out, ...defaultAttackSubbases() };
 })();
+// The default desired-contact per attacker (trajectory-set, owner 2026-08-12 decision D9): a near-net hitting point
+// in each attacker's lane, NOT the old "set to the standing dot" location. `contact.d` = a near-net depth for the
+// front row or the pipe depth for the back row; `contact.r` = the attacker's ATTACK-dot lateral clamped to the
+// antenna. Keyed [rotation][zone] -> {d,r}. The near-net depth + antenna are first-cut calibration knobs. The sim
+// does not read this yet (added with the engine phase); storing it here is inert. See plans/trajectory-set-and-approach.md.
+const NEAR_NET_CONTACT_DEPTH = 0.5; // front-row contact, m off the net
+const PIPE_CONTACT_DEPTH = 1.8; // back-row (pipe) contact, m off the net (matches the sim's BACKROW_SET_DEPTH)
+const CONTACT_ANTENNA = 4.3; // keep the contact just inside the sideline / antenna
+// LAZY + memoized (not an eager IIFE): `isBackRow` lives in the match module, which sits in a load cycle with the
+// team barrel, so calling it at module-load time hits an uninitialised import. Computed once on first use, then the
+// shared readonly reference is reused (like DEFAULT_COORDS; serialized per team on save, so sharing is safe).
+let cachedAttackContact;
+function defaultAttackContact() {
+    if (cachedAttackContact != null)
+        return cachedAttackContact;
+    const out = {};
+    for (const [rotation, zones] of Object.entries(COORDS.ATTACK)) {
+        out[rotation] = {};
+        for (const [zone, coord] of Object.entries(zones)) {
+            const backRow = isBackRow(Number(zone));
+            const r = Math.max(-CONTACT_ANTENNA, Math.min(CONTACT_ANTENNA, coord.r));
+            out[rotation][zone] = { d: backRow ? PIPE_CONTACT_DEPTH : NEAR_NET_CONTACT_DEPTH, r };
+        }
+    }
+    cachedAttackContact = out;
+    return out;
+}
 // The owner's corrected per-point-of-attack block map for the 5-1 (exported 2026-08-09), 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 the front-row zones in play for the rotation are tagged. Same
@@ -163,5 +219,5 @@ export function defaultReceiveMap(system) {
 // 5-1 uses the owner's exported receive map, the other systems derive their receive map per system.
 export function defaultBaseConfig(system) {
     const receive = system === RotationSystemEnum.FIVE_ONE ? DEFAULT_5_1_RECEIVE : defaultReceiveMap(system);
-    return { coords: DEFAULT_COORDS, receive, blocking: DEFAULT_BLOCKING };
+    return { coords: DEFAULT_COORDS, receive, blocking: DEFAULT_BLOCKING, attackContact: defaultAttackContact() };
 }

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

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

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

@@ -0,0 +1,42 @@
+import { RotationSystemEnum } from './rotation-system';
+import { defaultBaseConfig } from './default-base-config';
+// Back-row rotational zones (right/left/middle back). Front row is {2,3,4}.
+const BACK_ROW = new Set([1, 5, 6]);
+// The trajectory-set default desired-contact (owner D9, 2026-08-12): a near-net hitting point in each attacker's
+// lane, NOT the old set-to-the-standing-dot location. Front row contacts sit ~0.5 m off the net; back row on the
+// ~1.8 m pipe line; the lateral is the ATTACK-dot's r clamped inside the antenna (|r| <= 4.3).
+describe('defaultBaseConfig attackContact (trajectory-set default)', () => {
+    const cfg = defaultBaseConfig(RotationSystemEnum.FIVE_ONE);
+    it('provides a finite desired contact for every rotation and zone', () => {
+        expect(cfg.attackContact).toBeDefined();
+        for (let rot = 1; rot <= 6; rot++) {
+            for (let zone = 1; zone <= 6; zone++) {
+                const c = cfg.attackContact?.[String(rot)]?.[String(zone)];
+                expect(c).toBeDefined();
+                expect(Number.isFinite(c?.d)).toBe(true);
+                expect(Number.isFinite(c?.r)).toBe(true);
+            }
+        }
+    });
+    it('places front-row contacts near the net (0.5 m) and back-row on the pipe line (1.8 m)', () => {
+        for (let rot = 1; rot <= 6; rot++) {
+            for (let zone = 1; zone <= 6; zone++) {
+                const c = cfg.attackContact?.[String(rot)]?.[String(zone)];
+                expect(c.d).toBeCloseTo(BACK_ROW.has(zone) ? 1.8 : 0.5);
+            }
+        }
+    });
+    it('clamps every contact inside the antenna (|r| <= 4.3), even for a wide-pin attack dot', () => {
+        for (let rot = 1; rot <= 6; rot++) {
+            for (let zone = 1; zone <= 6; zone++) {
+                const c = cfg.attackContact?.[String(rot)]?.[String(zone)];
+                expect(Math.abs(c.r)).toBeLessThanOrEqual(4.3 + 1e-9);
+            }
+        }
+    });
+    it('keeps the contact on the attacker approach-lane side (rotation 1 OH wide dot r=5 -> +4.3)', () => {
+        const c = cfg.attackContact?.['1']?.['4'];
+        expect(c.d).toBeCloseTo(0.5); // front row, near the net
+        expect(c.r).toBeCloseTo(4.3); // clamped from the OH's wide ATTACK dot (r=5), same (positive) side
+    });
+});

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 './attack-priority';
 export * from './default-base-config';
 export * from './receive-overlap';
 export * from './team-name';

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 './attack-priority';
 export * from './default-base-config';
 export * from './receive-overlap';
 export * from './team-name';

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

@@ -1,6 +1,7 @@
+import { AttackPriority } from './attack-priority';
 export type TempoPreference = 'FAST' | 'HIGH';
 export interface OffensivePreference {
     readonly rotation: number;
-    readonly weights: Record<string, number>;
+    readonly priorities: Record<string, AttackPriority>;
     readonly tempos?: Record<string, TempoPreference>;
 }

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

@@ -261,23 +261,32 @@ export declare const TacticsInputSchema: z.ZodObject<{
     designatedSetters: z.ZodDefault<z.ZodArray<z.ZodCustom<Player, Player>>>;
     offensivePreferences: z.ZodDefault<z.ZodArray<z.ZodObject<{
         rotation: z.ZodNumber;
-        weights: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        priorities: z.ZodRecord<z.ZodString, z.ZodEnum<{
+            HIGH: "HIGH";
+            MID: "MID";
+            LOW: "LOW";
+            NONE: "NONE";
+        }>>;
         tempos: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
-            FAST: "FAST";
             HIGH: "HIGH";
+            FAST: "FAST";
         }>>>;
     }, z.core.$strip>>>;
-    serveAttackShares: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
     systemSets: z.ZodOptional<z.ZodArray<z.ZodObject<{
         rotationSystem: z.ZodEnum<typeof RotationSystemEnum>;
         designatedSetters: z.ZodArray<z.ZodCustom<Player, Player>>;
     }, z.core.$strip>>>;
     offensivePreferenceSets: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodObject<{
         rotation: z.ZodNumber;
-        weights: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        priorities: z.ZodRecord<z.ZodString, z.ZodEnum<{
+            HIGH: "HIGH";
+            MID: "MID";
+            LOW: "LOW";
+            NONE: "NONE";
+        }>>;
         tempos: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
-            FAST: "FAST";
             HIGH: "HIGH";
+            FAST: "FAST";
         }>>>;
     }, z.core.$strip>>>>;
     blockingPreferences: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -304,7 +313,12 @@ export declare const TacticsInputSchema: z.ZodObject<{
             r: z.ZodNumber;
         }, z.core.$strip>>>>;
         receive: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+        receiveByPlayer: z.ZodOptional<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>>>>;
+        attackContact: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{
+            d: z.ZodNumber;
+            r: z.ZodNumber;
+        }, z.core.$strip>>>>;
     }, 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

@@ -47,13 +47,14 @@ const lineupSchema = z.object({
 });
 // Per-player tempo preference (set-tempo rework): absent key = Auto.
 const tempoPreferenceSchema = z.enum(['FAST', 'HIGH']);
-// One rotation's attacker weighting. `rotation` is the main setter's rotational slot (1..6); `weights` maps each
-// attacker's starter id to an integer percentage share (values sum to 100; 0 removes an attacker). `tempos`
-// optionally forces a per-starter tempo (Auto when absent). Cross-field checks (keys are starters, weights sum to
-// 100) live in the superRefine below.
+// One rotation's attacker weighting. `rotation` is the main setter's rotational slot (1..6); `priorities` maps a
+// player id (a starter, or a designated substitute that overrides its slot once on court) to an AttackPriority.
+// `tempos` optionally forces a per-player tempo (Auto when absent). Cross-field checks (keys are starters or
+// designated subs) live in the superRefine below. No sum constraint: the setter weights by PRIORITY_WEIGHT.
+const attackPrioritySchema = z.enum(['HIGH', 'MID', 'LOW', 'NONE']);
 const offensivePreferenceSchema = z.object({
     rotation: z.number().int().min(1).max(6),
-    weights: z.record(z.string(), z.number().int().min(0)),
+    priorities: z.record(z.string(), attackPrioritySchema),
     tempos: z.record(z.string(), tempoPreferenceSchema).optional()
 });
 // An opposing attacking function a front-row starter can commit to (every RoleEnum except the libero, which never
@@ -87,9 +88,15 @@ 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())),
+    // Optional per-player receive override (owner 2026-08-13): [rotation][playerId] -> passes. Keys (designated subs)
+    // are validated in the superRefine. Optional so configs saved before this field validate unchanged.
+    receiveByPlayer: z.record(z.string(), z.record(z.string(), z.boolean())).optional(),
     // 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()
+    blocking: z.record(z.string(), z.record(z.string(), z.record(z.string(), z.boolean()))).optional(),
+    // Desired attack contact per attacker (trajectory-set, owner 2026-08-12): [rotation][zone] -> {d,r}. Optional so
+    // configs saved before this field validate unchanged.
+    attackContact: z.record(z.string(), z.record(z.string(), baseCoordSchema)).optional()
 });
 export const TacticsInputSchema = z.object({
     lineup: lineupSchema,
@@ -111,9 +118,6 @@ export const TacticsInputSchema = z.object({
     offensivePreferences: z.array(offensivePreferenceSchema).default([]),
     // Attack shares on serve (libero-serve feature): per-player attack share the sim applies when a
     // libero-replaced player is on court unreplaced (serving, or through a libero injury). Keyed by starter id.
-    // This is NOT part of the offensivePreferences sum-to-100; its band (0-100) and libero-replacement-key rules
-    // are validated independently in the superRefine below.
-    serveAttackShares: z.record(z.string(), z.number().int()).default({}),
     // Per-set overrides (5 entries, index 0 = set 1; absent => the flat fields apply to all sets). Each entry is
     // validated with the same cross-field rules as the flat fields (see superRefine below).
     systemSets: z.array(systemSetSchema).max(5).optional(),
@@ -161,6 +165,11 @@ export const TacticsInputSchema = z.object({
     const starters = slots.map(([position, player]) => ({ position, id: player.id }));
     const starterIds = new Set(starters.map(s => s.id));
     const positionById = new Map(starters.map(s => [s.id, s.position]));
+    // Any bench player may carry its OWN per-player attack priority / tempo / block / receive (owner 2026-08-13):
+    // those maps are keyed by a player id, and the engine resolves them for whoever is on court. So the attack /
+    // block / receive key checks accept a starter OR any bench player (every bench player gets its own settings, not
+    // just the designated subs).
+    const allowedPlayerKeys = new Set([...starterIds, ...data.lineup.bench.map(p => p.id)]);
     // Designated setters: count must match the system, each must be an on-court starter, and in 4-2 / 6-2 the two
     // setters sit in opposite slots (3 rotations apart). Run on the flat fields and on every per-set entry.
     const validateSystem = (rotationSystem, designatedSetters, path) => {
@@ -191,19 +200,15 @@ export const TacticsInputSchema = z.object({
                 ctx.addIssue({ code: 'custom', message: 'OFFENSIVE_PREFERENCE_DUPLICATE_ROTATION', path });
             }
             seenRotations.add(pref.rotation);
-            // Weight keys are on-court starters, and the percentages must sum to exactly 100 (0 removes an attacker).
-            for (const id of Object.keys(pref.weights)) {
-                if (!starterIds.has(id)) {
+            // Priority + tempo keys are an on-court starter or a designated sub (no sum-to-100: the setter weights by
+            // PRIORITY_WEIGHT and normalizes by the real total).
+            for (const id of Object.keys(pref.priorities)) {
+                if (!allowedPlayerKeys.has(id)) {
                     ctx.addIssue({ code: 'custom', message: 'OFFENSIVE_PREFERENCE_ATTACKER_NOT_A_STARTER', path });
                 }
             }
-            const total = Object.values(pref.weights).reduce((sum, w) => sum + w, 0);
-            if (total !== 100) {
-                ctx.addIssue({ code: 'custom', message: 'OFFENSIVE_PREFERENCE_WEIGHTS_MUST_SUM_TO_100', path });
-            }
-            // Tempo preference keys are starter ids too.
             for (const id of Object.keys(pref.tempos ?? {})) {
-                if (!starterIds.has(id)) {
+                if (!allowedPlayerKeys.has(id)) {
                     ctx.addIssue({ code: 'custom', message: 'OFFENSIVE_PREFERENCE_TEMPO_NOT_A_STARTER', path });
                 }
             }
@@ -220,13 +225,13 @@ export const TacticsInputSchema = z.object({
             }
             seenRotations.add(pref.rotation);
             for (const id of Object.keys(pref.commit)) {
-                if (!starterIds.has(id)) {
+                if (!allowedPlayerKeys.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 pref.noBlock[form] ?? []) {
-                    if (!starterIds.has(id)) {
+                    if (!allowedPlayerKeys.has(id)) {
                         ctx.addIssue({ code: 'custom', message: 'BLOCKING_PREFERENCE_BLOCKER_NOT_A_STARTER', path });
                     }
                 }
@@ -245,19 +250,13 @@ export const TacticsInputSchema = z.object({
     for (const [i, preferences] of (data.blockingPreferenceSets ?? []).entries()) {
         validateBlockingPreferences(preferences, ['blockingPreferenceSets', i]);
     }
-    // Serve attack shares (libero-serve feature): only a current libero-replacement starter (flat or per-set) may
-    // carry one, and each value must be in the 0-100 band. Validated independently of the offensive-preference
-    // sum-to-100 (a serve share never enters that total).
-    const liberoReplacementIds = new Set([
-        ...data.liberoReplacements.map(p => p.id),
-        ...(data.liberoReplacementSets ?? []).flatMap(set => set.map(p => p.id))
-    ]);
-    for (const [id, value] of Object.entries(data.serveAttackShares)) {
-        if (!liberoReplacementIds.has(id)) {
-            ctx.addIssue({ code: 'custom', message: 'SERVE_ATTACK_SHARE_NOT_A_LIBERO_REPLACEMENT', path: ['serveAttackShares'] });
-        }
-        if (value < 0 || value > 100) {
-            ctx.addIssue({ code: 'custom', message: 'SERVE_ATTACK_SHARE_OUT_OF_BAND', path: ['serveAttackShares'] });
+    // Per-player receive override (substitute settings, owner 2026-08-13): [rotation][playerId] -> passes. Each inner
+    // key is an on-court starter or a designated sub.
+    for (const byPlayer of Object.values(data.basePositions?.receiveByPlayer ?? {})) {
+        for (const id of Object.keys(byPlayer)) {
+            if (!allowedPlayerKeys.has(id)) {
+                ctx.addIssue({ code: 'custom', message: 'RECEIVE_OVERRIDE_NOT_A_STARTER', path: ['basePositions', 'receiveByPlayer'] });
+            }
         }
     }
     // Second libero (L2). The second libero is a reserve (not a starter, the libero, or a bench player). A swap