volleyballsimtypes 0.0.480 → 0.0.482

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

@@ -1,4 +1,4 @@
-import { BoxScore, DataProps, DeclineStatus, Division as _Division, League as _League, Match as _Match, MatchSet as _MatchSet, Player as _Player, PlayerPosition, Qualifier as _Qualifier, QualifierMatch as _QualifierMatch, Rally as _Rally, RallyEvent as _RallyEvent, PointBreakdown, RallyMetrics, Season as _Season, Standing as _Standing, Team as _Team, Tournament as _Tournament, TournamentMatch as _TournamentMatch, National as _National, NationalMatch as _NationalMatch, Country as _Country, CourtPosition, ConditionLogic, EnergyBand, LiberoSubMode, MatchForfeitType, PerformanceStats, PinchCondition, RotationSystemEnum, SubBackMode, SubBand, SubMode } from '../service';
+import { BoxScore, DataProps, DeclineStatus, Division as _Division, League as _League, Match as _Match, MatchSet as _MatchSet, Player as _Player, PlayerPosition, Qualifier as _Qualifier, QualifierMatch as _QualifierMatch, Rally as _Rally, RallyEvent as _RallyEvent, PointBreakdown, RallyMetrics, Season as _Season, Standing as _Standing, Team as _Team, Tournament as _Tournament, TournamentMatch as _TournamentMatch, National as _National, NationalMatch as _NationalMatch, Country as _Country, CourtPosition, ConditionLogic, EnergyBand, LiberoSubMode, MatchForfeitType, PerformanceStats, PinchCondition, RoleEnum, RotationSystemEnum, SubBackMode, SubBand, SubMode } from '../service';
 export type Rally = DataProps<_Rally> & {
     homePlayerPosition: PlayerPosition[];
     awayPlayerPosition: PlayerPosition[];
@@ -108,9 +108,13 @@ export interface ApiDesignatedSub {
 }
 export interface ApiOffensivePreference {
     rotation: number;
-    order: string[];
+    weights: Record<string, number>;
     tempos?: Record<string, 'FAST' | 'HIGH'>;
 }
+export interface ApiBlockingPreference {
+    rotation: number;
+    targets: Record<string, RoleEnum>;
+}
 export interface ApiSystemSet {
     rotationSystem: RotationSystemEnum;
     designatedSetters: string[];
@@ -148,6 +152,8 @@ export interface Tactics {
     offensivePreferences: ApiOffensivePreference[];
     systemSets?: ApiSystemSet[];
     offensivePreferenceSets?: ApiOffensivePreference[][];
+    blockingPreferences: ApiBlockingPreference[];
+    blockingPreferenceSets?: ApiBlockingPreference[][];
     replaceKnockedImmediately?: Record<string, boolean>;
     injuryReplacements?: ApiInjuryReplacement[];
     liberoInjury?: ApiLiberoInjury;

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

@@ -1,7 +1,7 @@
 import * as Sequelize from 'sequelize';
 import { Model, Optional } from 'sequelize';
 import { PlayerId, TeamId, TeamModel } from '.';
-import { ConditionLogic, CourtPosition, EnergyBand, LiberoSubMode, PinchCondition, RotationSystemEnum, SubBackMode, SubBand, SubMode } from '../../service';
+import { ConditionLogic, CourtPosition, EnergyBand, LiberoSubMode, PinchCondition, RoleEnum, RotationSystemEnum, SubBackMode, SubBand, SubMode } from '../../service';
 export interface TacticsLineupAttributes {
     [CourtPosition.LIBERO_ZONE]?: PlayerId;
     [CourtPosition.LEFT_BACK]: PlayerId;
@@ -41,9 +41,13 @@ export interface DesignatedSubAttributes {
 }
 export interface OffensivePreferenceAttributes {
     rotation: number;
-    order: PlayerId[];
+    weights: Record<PlayerId, number>;
     tempos?: Record<PlayerId, 'FAST' | 'HIGH'>;
 }
+export interface BlockingPreferenceAttributes {
+    rotation: number;
+    targets: Record<PlayerId, RoleEnum>;
+}
 export interface SystemSetAttributes {
     rotationSystem: RotationSystemEnum;
     designatedSetters: PlayerId[];
@@ -85,10 +89,12 @@ export interface TacticsAttributes {
     replace_knocked_immediately?: Record<PlayerId, boolean>;
     injury_replacements?: InjuryReplacementAttributes[];
     libero_injury?: LiberoInjuryAttributes;
+    blocking_preferences: BlockingPreferenceAttributes[];
+    blocking_preference_sets?: BlockingPreferenceAttributes[][];
 }
 export type TacticsPk = 'team_id';
 export type TacticsId = TacticsModel[TacticsPk];
-export type TacticsOptionalAttributes = 'lineup' | 'libero_replacements' | 'receive_rotation_offset' | 'designated_subs' | 'substitution_band' | 'second_libero' | 'libero_sub' | 'libero_replacement_sets' | 'rotation_system' | 'designated_setters' | 'offensive_preferences' | 'system_sets' | 'offensive_preference_sets' | 'replace_knocked_immediately' | 'injury_replacements' | 'libero_injury';
+export type TacticsOptionalAttributes = 'lineup' | 'libero_replacements' | 'receive_rotation_offset' | 'designated_subs' | 'substitution_band' | 'second_libero' | 'libero_sub' | 'libero_replacement_sets' | 'rotation_system' | 'designated_setters' | 'offensive_preferences' | 'system_sets' | 'offensive_preference_sets' | 'replace_knocked_immediately' | 'injury_replacements' | 'libero_injury' | 'blocking_preferences' | 'blocking_preference_sets';
 export type TacticsCreationAttributes = Optional<TacticsAttributes, TacticsOptionalAttributes>;
 export declare class TacticsModel extends Model<TacticsAttributes, TacticsCreationAttributes> implements TacticsAttributes {
     team_id: string;
@@ -108,6 +114,8 @@ export declare class TacticsModel extends Model<TacticsAttributes, TacticsCreati
     replace_knocked_immediately?: Record<PlayerId, boolean>;
     injury_replacements?: InjuryReplacementAttributes[];
     libero_injury?: LiberoInjuryAttributes;
+    blocking_preferences: BlockingPreferenceAttributes[];
+    blocking_preference_sets?: BlockingPreferenceAttributes[][];
     team: TeamModel;
     getTeam: Sequelize.BelongsToGetAssociationMixin<TeamModel>;
     setTeam: Sequelize.BelongsToSetAssociationMixin<TeamModel, TeamId>;

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

@@ -86,6 +86,15 @@ class TacticsModel extends sequelize_1.Model {
             libero_injury: {
                 type: sequelize_1.DataTypes.JSONB,
                 allowNull: true
+            },
+            blocking_preferences: {
+                type: sequelize_1.DataTypes.JSONB,
+                allowNull: false,
+                defaultValue: []
+            },
+            blocking_preference_sets: {
+                type: sequelize_1.DataTypes.JSONB,
+                allowNull: true
             }
         }, {
             sequelize,

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

@@ -92,7 +92,7 @@ function transformToAttributes(tactics, teamId) {
         designated_setters: tactics.designatedSetters.map((s) => s.id),
         offensive_preferences: tactics.offensivePreferences.map(p => ({
             rotation: p.rotation,
-            order: p.order.map((a) => a.id),
+            weights: p.weights,
             tempos: p.tempos
         })),
         system_sets: tactics.systemSets?.map(s => ({
@@ -101,9 +101,11 @@ function transformToAttributes(tactics, teamId) {
         })),
         offensive_preference_sets: tactics.offensivePreferenceSets?.map(prefs => prefs.map(p => ({
             rotation: p.rotation,
-            order: p.order.map((a) => a.id),
+            weights: p.weights,
             tempos: p.tempos
         }))),
+        blocking_preferences: tactics.blockingPreferences.map(p => ({ rotation: p.rotation, targets: p.targets })),
+        blocking_preference_sets: tactics.blockingPreferenceSets?.map(prefs => prefs.map(p => ({ rotation: p.rotation, targets: p.targets }))),
         replace_knocked_immediately: tactics.replaceKnockedImmediately,
         injury_replacements: tactics.injuryReplacements.map(ir => ({
             starterId: ir.starter.id,
@@ -192,7 +194,7 @@ function transformToObject(model, roster) {
         designatedSetters: (model.designated_setters ?? []).map((id) => findPlayer(id, roster)),
         offensivePreferences: (model.offensive_preferences ?? []).map(p => ({
             rotation: p.rotation,
-            order: p.order.map((id) => findPlayer(id, roster)),
+            weights: p.weights,
             tempos: p.tempos
         })),
         systemSets: model.system_sets?.map(s => ({
@@ -201,9 +203,11 @@ function transformToObject(model, roster) {
         })),
         offensivePreferenceSets: model.offensive_preference_sets?.map(prefs => prefs.map(p => ({
             rotation: p.rotation,
-            order: p.order.map((id) => findPlayer(id, roster)),
+            weights: p.weights,
             tempos: p.tempos
         }))),
+        blockingPreferences: (model.blocking_preferences ?? []).map(p => ({ rotation: p.rotation, targets: p.targets })),
+        blockingPreferenceSets: model.blocking_preference_sets?.map(prefs => prefs.map(p => ({ rotation: p.rotation, targets: p.targets }))),
         // LENIENT: keep only boolean entries keyed by a court starter or, when a second libero exists, the starting
         // libero (the libero knock toggle is an L2-only feature, owner 2026-07-06) so stale jsonb (an ex-starter's
         // key, a non-boolean value, a libero key left after the L2 was removed) can never fail schema validation
@@ -360,6 +364,8 @@ function tacticsColumnsToApiDto(model) {
         offensivePreferences: model.offensive_preferences,
         systemSets: model.system_sets,
         offensivePreferenceSets: model.offensive_preference_sets,
+        blockingPreferences: model.blocking_preferences,
+        blockingPreferenceSets: model.blocking_preference_sets,
         // Same stale-data policy as the heals below: only boolean entries keyed by a court starter or, when a second
         // libero exists, the starting libero (the libero knock toggle is an L2-only feature, owner 2026-07-06)
         // survive; an empty map surfaces as absent (missing key = ON).
@@ -465,6 +471,8 @@ function apiTacticsConfigToAttributes(config, teamId) {
         offensive_preferences: config.offensivePreferences,
         system_sets: config.systemSets,
         offensive_preference_sets: config.offensivePreferenceSets,
+        blocking_preferences: config.blockingPreferences ?? [],
+        blocking_preference_sets: config.blockingPreferenceSets,
         replace_knocked_immediately: config.replaceKnockedImmediately,
         injury_replacements: config.injuryReplacements,
         libero_injury: config.liberoInjury

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

@@ -26,7 +26,8 @@ function makeTactics(designatedSubs) {
         libero_replacement_sets: undefined,
         rotation_system: '5-1',
         designated_setters: ['lf'],
-        offensive_preferences: [{ rotation: 1, order: ['lf', 'rf'] }]
+        offensive_preferences: [{ rotation: 1, weights: { lf: 60, rf: 40 } }],
+        blocking_preferences: []
     };
 }
 (0, globals_1.describe)('tacticsColumnsToApiDto()', () => {
@@ -37,7 +38,7 @@ function makeTactics(designatedSubs) {
         (0, globals_1.expect)(dto.rotationSystem).toBe('5-1');
         (0, globals_1.expect)(dto.liberoReplacements).toEqual(['lf']);
         (0, globals_1.expect)(dto.lineup.bench).toEqual(['b1', 'b2']);
-        (0, globals_1.expect)(dto.offensivePreferences).toEqual([{ rotation: 1, order: ['lf', 'rf'] }]);
+        (0, globals_1.expect)(dto.offensivePreferences).toEqual([{ rotation: 1, weights: { lf: 60, rf: 40 } }]);
     });
     (0, globals_1.it)("resolves a legacy isPinchServer entry to mode 'PINCH'", () => {
         const dto = (0, tactics_1.tacticsColumnsToApiDto)(makeTactics([
@@ -127,10 +128,10 @@ function makeTactics(designatedSubs) {
     (0, globals_1.it)('passes per-set tactics columns through to the API DTO shape', () => {
         const model = makeTactics([]);
         model.system_sets = [{ rotationSystem: service_1.RotationSystemEnum.FIVE_ONE, designatedSetters: ['lf'] }];
-        model.offensive_preference_sets = [[{ rotation: 1, order: ['rf', 'mf'] }]];
+        model.offensive_preference_sets = [[{ rotation: 1, weights: { rf: 55, mf: 45 } }]];
         const dto = (0, tactics_1.tacticsColumnsToApiDto)(model);
         (0, globals_1.expect)(dto.systemSets).toEqual([{ rotationSystem: '5-1', designatedSetters: ['lf'] }]);
-        (0, globals_1.expect)(dto.offensivePreferenceSets).toEqual([[{ rotation: 1, order: ['rf', 'mf'] }]]);
+        (0, globals_1.expect)(dto.offensivePreferenceSets).toEqual([[{ rotation: 1, weights: { rf: 55, mf: 45 } }]]);
     });
     (0, globals_1.it)('leaves the per-set DTO fields undefined when the columns are absent', () => {
         const dto = (0, tactics_1.tacticsColumnsToApiDto)(makeTactics([]));
@@ -154,7 +155,7 @@ function makeTactics(designatedSubs) {
             { rotationSystem: service_1.RotationSystemEnum.FIVE_ONE, designatedSetters: [p1] },
             { rotationSystem: service_1.RotationSystemEnum.SIX_ZERO, designatedSetters: [] }
         ],
-        offensivePreferenceSets: [[{ rotation: 1, order: [p2, p3] }]]
+        offensivePreferenceSets: [[{ rotation: 1, weights: { [p2.id]: 60, [p3.id]: 40 } }]]
     });
     (0, globals_1.it)('transformFromTactics writes the per-set overrides as id-based jsonb columns', () => {
         const attrs = (0, tactics_1.transformFromTactics)(tactics, 'team-1');
@@ -162,7 +163,7 @@ function makeTactics(designatedSubs) {
             { rotationSystem: '5-1', designatedSetters: [p1.id] },
             { rotationSystem: '6-0', designatedSetters: [] }
         ]);
-        (0, globals_1.expect)(attrs.offensive_preference_sets).toEqual([[{ rotation: 1, order: [p2.id, p3.id] }]]);
+        (0, globals_1.expect)(attrs.offensive_preference_sets).toEqual([[{ rotation: 1, weights: { [p2.id]: 60, [p3.id]: 40 } }]]);
     });
     (0, globals_1.it)('transformToTactics resolves the stored ids back to roster players', () => {
         const attrs = (0, tactics_1.transformFromTactics)(tactics, 'team-1');
@@ -170,7 +171,7 @@ function makeTactics(designatedSubs) {
         (0, globals_1.expect)(back.systemSets?.[0].rotationSystem).toBe(service_1.RotationSystemEnum.FIVE_ONE);
         (0, globals_1.expect)(back.systemSets?.[0].designatedSetters[0].id).toBe(p1.id);
         (0, globals_1.expect)(back.systemSets?.[1].designatedSetters).toEqual([]);
-        (0, globals_1.expect)(back.offensivePreferenceSets?.[0][0].order.map(p => p.id)).toEqual([p2.id, p3.id]);
+        (0, globals_1.expect)(back.offensivePreferenceSets?.[0][0].weights).toEqual({ [p2.id]: 60, [p3.id]: 40 });
     });
     (0, globals_1.it)('omits the per-set columns entirely for an all-sets config', () => {
         const flat = service_1.Tactics.create({
@@ -188,15 +189,28 @@ function makeTactics(designatedSubs) {
         const withTempos = service_1.Tactics.create({
             lineup: { 4: p4, 3: p3, 2: p2, 5: p5, 6: p6, 1: p1, bench: [] },
             liberoReplacements: [],
-            offensivePreferences: [{ rotation: 1, order: [p2, p3], tempos: { [p2.id]: 'FAST', [p3.id]: 'HIGH' } }]
+            offensivePreferences: [{ rotation: 1, weights: { [p2.id]: 60, [p3.id]: 40 }, tempos: { [p2.id]: 'FAST', [p3.id]: 'HIGH' } }]
         });
         const attrs = (0, tactics_1.transformFromTactics)(withTempos, 'team-1');
         (0, globals_1.expect)(attrs.offensive_preferences).toEqual([
-            { rotation: 1, order: [p2.id, p3.id], tempos: { [p2.id]: 'FAST', [p3.id]: 'HIGH' } }
+            { rotation: 1, weights: { [p2.id]: 60, [p3.id]: 40 }, tempos: { [p2.id]: 'FAST', [p3.id]: 'HIGH' } }
         ]);
         const back = (0, tactics_1.transformToTactics)(attrs, roster);
         (0, globals_1.expect)(back.offensivePreferences[0].tempos).toEqual({ [p2.id]: 'FAST', [p3.id]: 'HIGH' });
     });
+    (0, globals_1.it)('round-trips blocking preferences as id-keyed function maps', () => {
+        const withBlocking = service_1.Tactics.create({
+            lineup: { 4: p4, 3: p3, 2: p2, 5: p5, 6: p6, 1: p1, bench: [] },
+            liberoReplacements: [],
+            blockingPreferences: [{ rotation: 1, targets: { [p4.id]: service_1.RoleEnum.OUTSIDE_HITTER, [p3.id]: service_1.RoleEnum.MIDDLE_BLOCKER } }]
+        });
+        const attrs = (0, tactics_1.transformFromTactics)(withBlocking, 'team-1');
+        (0, globals_1.expect)(attrs.blocking_preferences).toEqual([
+            { rotation: 1, targets: { [p4.id]: service_1.RoleEnum.OUTSIDE_HITTER, [p3.id]: service_1.RoleEnum.MIDDLE_BLOCKER } }
+        ]);
+        const back = (0, tactics_1.transformToTactics)(attrs, roster);
+        (0, globals_1.expect)(back.blockingPreferences[0].targets).toEqual({ [p4.id]: service_1.RoleEnum.OUTSIDE_HITTER, [p3.id]: service_1.RoleEnum.MIDDLE_BLOCKER });
+    });
 });
 (0, globals_1.describe)('libero injuries — service <-> row round-trip + lenient heal', () => {
     const country = (0, test_helpers_1.makeCountry)();

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

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

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

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

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

@@ -0,0 +1,5 @@
+import { LineupFunction } from './lineup-function';
+export interface BlockingPreference {
+    readonly rotation: number;
+    readonly targets: Record<string, LineupFunction>;
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -11,5 +11,6 @@ export * from './rotation-system';
 export * from './lineup-function';
 export * from './base-position';
 export * from './offensive-preference';
+export * from './blocking-preference';
 export * from './injury-replacement';
 export * from './libero-injury';

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

@@ -27,5 +27,6 @@ __exportStar(require("./rotation-system"), exports);
 __exportStar(require("./lineup-function"), exports);
 __exportStar(require("./base-position"), exports);
 __exportStar(require("./offensive-preference"), exports);
+__exportStar(require("./blocking-preference"), exports);
 __exportStar(require("./injury-replacement"), exports);
 __exportStar(require("./libero-injury"), exports);

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

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

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

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { Player } from '../../player';
+import { Player, RoleEnum } from '../../player';
 import { EnergyBand } from '../energy-band';
 import { RotationSystemEnum } from '../rotation-system';
 export declare const TacticsInputSchema: z.ZodObject<{
@@ -269,7 +269,7 @@ 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;
-        order: z.ZodArray<z.ZodCustom<Player, Player>>;
+        weights: z.ZodRecord<z.ZodString, z.ZodNumber>;
         tempos: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
             FAST: "FAST";
             HIGH: "HIGH";
@@ -281,12 +281,20 @@ export declare const TacticsInputSchema: z.ZodObject<{
     }, z.core.$strip>>>;
     offensivePreferenceSets: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodObject<{
         rotation: z.ZodNumber;
-        order: z.ZodArray<z.ZodCustom<Player, Player>>;
+        weights: z.ZodRecord<z.ZodString, z.ZodNumber>;
         tempos: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
             FAST: "FAST";
             HIGH: "HIGH";
         }>>>;
     }, z.core.$strip>>>>;
+    blockingPreferences: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        rotation: z.ZodNumber;
+        targets: z.ZodRecord<z.ZodString, 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.core.$strip>>>;
+    blockingPreferenceSets: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodObject<{
+        rotation: z.ZodNumber;
+        targets: z.ZodRecord<z.ZodString, 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.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/cjs/src/service/team/schemas/tactics.z.js

@@ -50,14 +50,23 @@ const lineupSchema = zod_1.z.object({
 });
 // Per-player tempo preference (set-tempo rework): absent key = Auto.
 const tempoPreferenceSchema = zod_1.z.enum(['FAST', 'HIGH']);
-// One rotation's ranked attacker priority. `rotation` is the main setter's rotational slot (1..6); `order` lists
-// the attackers ranked best-first. `tempos` optionally forces a per-starter tempo (Auto when absent). Cross-field
-// checks (starters only in both order and tempos, no dupes) live in the superRefine below.
+// 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.
 const offensivePreferenceSchema = zod_1.z.object({
     rotation: zod_1.z.number().int().min(1).max(6),
-    order: zod_1.z.array(playerInstanceSchema),
+    weights: zod_1.z.record(zod_1.z.string(), zod_1.z.number().int().min(0)),
     tempos: zod_1.z.record(zod_1.z.string(), tempoPreferenceSchema).optional()
 });
+// The opposing attacking functions a dedicated blocker can commit to: every RoleEnum except the libero.
+const blockingFunctionSchema = zod_1.z.nativeEnum(player_1.RoleEnum).refine((v) => v !== player_1.RoleEnum.LIBERO, { message: 'BLOCKING_TARGET_CANNOT_BE_LIBERO' });
+// 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 blockingPreferenceSchema = zod_1.z.object({
+    rotation: zod_1.z.number().int().min(1).max(6),
+    targets: zod_1.z.record(zod_1.z.string(), blockingFunctionSchema)
+});
 // One set's rotation-system override (per-set tactics): system + its designated setters travel together.
 const systemSetSchema = zod_1.z.object({
     rotationSystem: zod_1.z.nativeEnum(rotation_system_1.RotationSystemEnum),
@@ -85,6 +94,9 @@ exports.TacticsInputSchema = zod_1.z.object({
     // validated with the same cross-field rules as the flat fields (see superRefine below).
     systemSets: zod_1.z.array(systemSetSchema).max(5).optional(),
     offensivePreferenceSets: zod_1.z.array(zod_1.z.array(offensivePreferenceSchema)).max(5).optional(),
+    // Blocking preferences (dedicated blocking). Defaults keep every existing Tactics.create({...}) call valid.
+    blockingPreferences: zod_1.z.array(blockingPreferenceSchema).default([]),
+    blockingPreferenceSets: zod_1.z.array(zod_1.z.array(blockingPreferenceSchema)).max(5).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
@@ -153,16 +165,17 @@ exports.TacticsInputSchema = zod_1.z.object({
                 ctx.addIssue({ code: 'custom', message: 'OFFENSIVE_PREFERENCE_DUPLICATE_ROTATION', path });
             }
             seenRotations.add(pref.rotation);
-            const ids = pref.order.map(p => p.id);
-            if (new Set(ids).size !== ids.length) {
-                ctx.addIssue({ code: 'custom', message: 'OFFENSIVE_PREFERENCE_DUPLICATE_ATTACKER', path });
-            }
-            for (const id of ids) {
+            // 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)) {
                     ctx.addIssue({ code: 'custom', message: 'OFFENSIVE_PREFERENCE_ATTACKER_NOT_A_STARTER', path });
                 }
             }
-            // Tempo preference keys are starter ids too (same rule as order).
+            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)) {
                     ctx.addIssue({ code: 'custom', message: 'OFFENSIVE_PREFERENCE_TEMPO_NOT_A_STARTER', path });
@@ -170,6 +183,22 @@ exports.TacticsInputSchema = zod_1.z.object({
             }
         }
     };
+    // Blocking preferences: unique rotations; each assignment keys an on-court starter (the UI only offers front-row
+    // players, the schema checks starters). The target function is validated by blockingFunctionSchema.
+    const validateBlockingPreferences = (preferences, path) => {
+        const seenRotations = new Set();
+        for (const pref of preferences) {
+            if (seenRotations.has(pref.rotation)) {
+                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 });
+                }
+            }
+        }
+    };
     validateSystem(data.rotationSystem, data.designatedSetters, ['designatedSetters']);
     for (const [i, systemSet] of (data.systemSets ?? []).entries()) {
         validateSystem(systemSet.rotationSystem, systemSet.designatedSetters, ['systemSets', i]);
@@ -178,6 +207,10 @@ exports.TacticsInputSchema = zod_1.z.object({
     for (const [i, preferences] of (data.offensivePreferenceSets ?? []).entries()) {
         validateOffensivePreferences(preferences, ['offensivePreferenceSets', i]);
     }
+    validateBlockingPreferences(data.blockingPreferences, ['blockingPreferences']);
+    for (const [i, preferences] of (data.blockingPreferenceSets ?? []).entries()) {
+        validateBlockingPreferences(preferences, ['blockingPreferenceSets', i]);
+    }
     // Second libero (L2). The second libero is a reserve (not a starter, the libero, or a bench player). A swap
     // rule (FATIGUE/ALWAYS in any set) needs someone to swap in, so it requires a second libero, and a second
     // libero needs a starting libero to replace ("no L2 without an L"). Per-set libero replacements, like the

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const globals_1 = require("@jest/globals");
 const tactics_z_1 = require("./tactics.z");
+const player_1 = require("../../player");
 const test_helpers_1 = require("../../test-helpers");
 (0, globals_1.describe)('TacticsInputSchema — second libero rules', () => {
     const country = (0, test_helpers_1.makeCountry)();
@@ -95,7 +96,7 @@ const test_helpers_1 = require("../../test-helpers");
                 { rotationSystem: '4-2', designatedSetters: [p1, p4] }
             ],
             offensivePreferenceSets: [
-                [{ rotation: 1, order: [p2, p3] }],
+                [{ rotation: 1, weights: { [p2.id]: 60, [p3.id]: 40 } }],
                 []
             ]
         }));
@@ -104,7 +105,7 @@ const test_helpers_1 = require("../../test-helpers");
     (0, globals_1.it)('carries the per-set fields through Tactics.create parsing', () => {
         const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
             systemSets: [{ rotationSystem: '5-1', designatedSetters: [p1] }],
-            offensivePreferenceSets: [[{ rotation: 2, order: [p3] }]]
+            offensivePreferenceSets: [[{ rotation: 2, weights: { [p3.id]: 100 } }]]
         }));
         (0, globals_1.expect)(res.success).toBe(true);
         if (res.success) {
@@ -153,7 +154,7 @@ const test_helpers_1 = require("../../test-helpers");
     });
     (0, globals_1.it)('rejects a per-set preferences list with a duplicate rotation', () => {
         const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
-            offensivePreferenceSets: [[{ rotation: 1, order: [p2] }, { rotation: 1, order: [p3] }]]
+            offensivePreferenceSets: [[{ rotation: 1, weights: { [p2.id]: 100 } }, { rotation: 1, weights: { [p3.id]: 100 } }]]
         }));
         (0, globals_1.expect)(res.success).toBe(false);
         if (!res.success) {
@@ -161,18 +162,27 @@ const test_helpers_1 = require("../../test-helpers");
             (0, globals_1.expect)(issue?.path).toEqual(['offensivePreferenceSets', 0]);
         }
     });
-    (0, globals_1.it)('rejects a per-set preferences order that lists a non-starter', () => {
+    (0, globals_1.it)('rejects a per-set preferences map that keys a non-starter', () => {
         const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
-            offensivePreferenceSets: [[{ rotation: 1, order: [reserve] }]]
+            offensivePreferenceSets: [[{ rotation: 1, weights: { [reserve.id]: 100 } }]]
         }));
         (0, globals_1.expect)(res.success).toBe(false);
         if (!res.success) {
             (0, globals_1.expect)(res.error.issues.some(i => i.message === 'OFFENSIVE_PREFERENCE_ATTACKER_NOT_A_STARTER')).toBe(true);
         }
     });
+    (0, globals_1.it)('rejects offensive preference weights that do not sum to 100', () => {
+        const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
+            offensivePreferences: [{ rotation: 1, weights: { [p2.id]: 50, [p3.id]: 40 } }]
+        }));
+        (0, globals_1.expect)(res.success).toBe(false);
+        if (!res.success) {
+            (0, globals_1.expect)(res.error.issues.some(i => i.message === 'OFFENSIVE_PREFERENCE_WEIGHTS_MUST_SUM_TO_100')).toBe(true);
+        }
+    });
     (0, globals_1.it)('accepts offensive preferences with a starter-keyed tempos map', () => {
         const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
-            offensivePreferences: [{ rotation: 1, order: [p2, p3], tempos: { [p2.id]: 'FAST', [p3.id]: 'HIGH' } }]
+            offensivePreferences: [{ rotation: 1, weights: { [p2.id]: 60, [p3.id]: 40 }, tempos: { [p2.id]: 'FAST', [p3.id]: 'HIGH' } }]
         }));
         (0, globals_1.expect)(res.success).toBe(true);
         if (res.success) {
@@ -181,7 +191,7 @@ const test_helpers_1 = require("../../test-helpers");
     });
     (0, globals_1.it)('rejects a tempos map keyed by a non-starter', () => {
         const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
-            offensivePreferences: [{ rotation: 1, order: [p2], tempos: { [reserve.id]: 'FAST' } }]
+            offensivePreferences: [{ rotation: 1, weights: { [p2.id]: 100 }, tempos: { [reserve.id]: 'FAST' } }]
         }));
         (0, globals_1.expect)(res.success).toBe(false);
         if (!res.success) {
@@ -190,7 +200,7 @@ const test_helpers_1 = require("../../test-helpers");
     });
     (0, globals_1.it)('rejects an invalid tempo value', () => {
         const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
-            offensivePreferences: [{ rotation: 1, order: [p2], tempos: { [p2.id]: 'SLOW' } }]
+            offensivePreferences: [{ rotation: 1, weights: { [p2.id]: 100 }, tempos: { [p2.id]: 'SLOW' } }]
         }));
         (0, globals_1.expect)(res.success).toBe(false);
     });
@@ -208,3 +218,66 @@ const test_helpers_1 = require("../../test-helpers");
         }
     });
 });
+(0, globals_1.describe)('TacticsInputSchema — blocking preferences', () => {
+    const country = (0, test_helpers_1.makeCountry)();
+    const p1 = (0, test_helpers_1.makePlayer)(country);
+    const p2 = (0, test_helpers_1.makePlayer)(country);
+    const p3 = (0, test_helpers_1.makePlayer)(country);
+    const p4 = (0, test_helpers_1.makePlayer)(country);
+    const p5 = (0, test_helpers_1.makePlayer)(country);
+    const p6 = (0, test_helpers_1.makePlayer)(country);
+    const reserve = (0, test_helpers_1.makePlayer)(country);
+    // Front-row starters (zones 2/3/4) are p2, p3, p4; the validator only requires target keys to be starters.
+    function baseInput(overrides = {}) {
+        return {
+            lineup: { 4: p4, 3: p3, 2: p2, 5: p5, 6: p6, 1: p1, bench: [] },
+            liberoReplacements: [],
+            ...overrides
+        };
+    }
+    (0, globals_1.it)('accepts a blocking preference that keys starters to attacking functions', () => {
+        const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
+            blockingPreferences: [{ rotation: 1, targets: { [p4.id]: player_1.RoleEnum.OUTSIDE_HITTER, [p3.id]: player_1.RoleEnum.MIDDLE_BLOCKER } }]
+        }));
+        (0, globals_1.expect)(res.success).toBe(true);
+        if (res.success) {
+            (0, globals_1.expect)(res.data.blockingPreferences[0].targets[p4.id]).toBe(player_1.RoleEnum.OUTSIDE_HITTER);
+        }
+    });
+    (0, globals_1.it)('rejects a blocking target that is not a starter', () => {
+        const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
+            blockingPreferences: [{ rotation: 1, targets: { [reserve.id]: player_1.RoleEnum.OUTSIDE_HITTER } }]
+        }));
+        (0, globals_1.expect)(res.success).toBe(false);
+        if (!res.success) {
+            (0, globals_1.expect)(res.error.issues.some(i => i.message === 'BLOCKING_PREFERENCE_BLOCKER_NOT_A_STARTER')).toBe(true);
+        }
+    });
+    (0, globals_1.it)('rejects a blocking target function of libero', () => {
+        const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
+            blockingPreferences: [{ rotation: 1, targets: { [p4.id]: player_1.RoleEnum.LIBERO } }]
+        }));
+        (0, globals_1.expect)(res.success).toBe(false);
+        if (!res.success) {
+            (0, globals_1.expect)(res.error.issues.some(i => i.message === 'BLOCKING_TARGET_CANNOT_BE_LIBERO')).toBe(true);
+        }
+    });
+    (0, globals_1.it)('rejects a duplicate rotation in blocking preferences', () => {
+        const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
+            blockingPreferences: [
+                { rotation: 1, targets: { [p4.id]: player_1.RoleEnum.OUTSIDE_HITTER } },
+                { rotation: 1, targets: { [p3.id]: player_1.RoleEnum.MIDDLE_BLOCKER } }
+            ]
+        }));
+        (0, globals_1.expect)(res.success).toBe(false);
+        if (!res.success) {
+            (0, globals_1.expect)(res.error.issues.some(i => i.message === 'BLOCKING_PREFERENCE_DUPLICATE_ROTATION')).toBe(true);
+        }
+    });
+    (0, globals_1.it)('accepts per-set blocking preference overrides', () => {
+        const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
+            blockingPreferenceSets: [[{ rotation: 1, targets: { [p4.id]: player_1.RoleEnum.OPPOSITE_HITTER } }], []]
+        }));
+        (0, globals_1.expect)(res.success).toBe(true);
+    });
+});