volleyballsimtypes 0.0.481 → 0.0.483

package/dist/esm/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, PinchCondition, RoleEnum, RotationSystemEnum, SubBackMode, SubBand, SubMode } from '../../service';
 export interface TacticsLineupAttributes {
     [CourtPosition.LIBERO_ZONE]?: PlayerId;
     [CourtPosition.LEFT_BACK]: PlayerId;
@@ -13,37 +13,31 @@ export interface TacticsLineupAttributes {
     bench: PlayerId[];
 }
 export interface SetSubConfigAttributes {
-    mode: SubMode;
     benchId?: PlayerId;
-    fatigueBand?: EnergyBand;
-    benchFatigueBand?: EnergyBand;
     conditions?: PinchCondition[];
     conditionLogic?: ConditionLogic;
     pinchServer?: boolean;
+    benchFatigueBand?: EnergyBand;
     subBackMode?: SubBackMode;
     subBackConditions?: PinchCondition[];
     subBackConditionLogic?: ConditionLogic;
+    mode?: SubMode;
+    fatigueBand?: SubBand;
 }
-export interface DesignatedSubAttributes {
+export interface DesignatedSubAttributes extends SetSubConfigAttributes {
     starterId: PlayerId;
-    benchId?: PlayerId;
-    mode?: SubMode;
     isPinchServer?: boolean;
-    fatigueBand?: SubBand;
-    benchFatigueBand?: EnergyBand;
-    conditions?: PinchCondition[];
-    conditionLogic?: ConditionLogic;
-    pinchServer?: boolean;
-    subBackMode?: SubBackMode;
-    subBackConditions?: PinchCondition[];
-    subBackConditionLogic?: ConditionLogic;
     sets?: SetSubConfigAttributes[];
 }
 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[];
@@ -59,10 +53,10 @@ export interface LiberoInjuryAttributes {
     inMatchDesignateId?: PlayerId;
 }
 export interface LiberoSetSubConfigAttributes {
-    mode: LiberoSubMode;
-    fatigueBand?: EnergyBand;
     conditions?: PinchCondition[];
     conditionLogic?: ConditionLogic;
+    mode?: string;
+    fatigueBand?: EnergyBand;
 }
 export interface LiberoSubConfigAttributes extends LiberoSetSubConfigAttributes {
     sets?: LiberoSetSubConfigAttributes[];
@@ -85,10 +79,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 +104,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/esm/src/data/models/tactics.js

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

package/dist/esm/src/data/transformers/match-preset-override.test.js

@@ -148,7 +148,16 @@ describe('apiTacticsConfigToTacticsAttributes()', () => {
         expect(back.lineup).toEqual(full.lineup);
         expect(back.libero_replacements).toEqual(full.libero_replacements);
         expect(back.receive_rotation_offset).toBe(true);
-        expect(back.designated_subs).toEqual(full.designated_subs);
+        // The dto path converts legacy mode-shaped subs to the unified condition engine, so the round-trip lands
+        // in the converted (unified) shape rather than the legacy input.
+        expect(back.designated_subs).toEqual([{
+                starterId: ids[0],
+                conditions: [{ type: 'FATIGUE', band: 'WORN' }],
+                conditionLogic: 'ALL',
+                pinchServer: false,
+                subBackMode: 'FATIGUE',
+                sets: [{ conditions: [] }]
+            }]);
         expect(back.libero_replacement_sets).toEqual(full.libero_replacement_sets);
         expect(back.rotation_system).toBe('5-1');
         expect(back.designated_setters).toEqual(full.designated_setters);

package/dist/esm/src/data/transformers/rally-event.d.ts

@@ -1,4 +1,4 @@
-import { Block, LiberoReplacement, RallyEvent, Reception, Serve, Set, Spike, Substitution } from '../../service';
+import { Block, FreeBall, LiberoReplacement, RallyEvent, Reception, Serve, Set, Spike, Substitution } from '../../service';
 export interface CompactEvent {
     p: number;
     e: number;
@@ -21,4 +21,5 @@ export declare function transformToReception(event: CompactEvent, roster: string
 export declare function transformToServe(event: CompactEvent, roster: string[]): Serve;
 export declare function transformToSet(event: CompactEvent, roster: string[]): Set;
 export declare function transformToSpike(event: CompactEvent, roster: string[]): Spike;
+export declare function transformToFreeBall(event: CompactEvent, roster: string[]): FreeBall;
 export declare function transformToSubstitution(event: CompactEvent, roster: string[]): Substitution;

package/dist/esm/src/data/transformers/rally-event.js

@@ -1,4 +1,4 @@
-import { Block, InPlayEvent, LiberoReplacement, Reception, Serve, Set, Spike, Substitution } from '../../service';
+import { Block, FreeBall, InPlayEvent, LiberoReplacement, Reception, Serve, Set, Spike, Substitution } from '../../service';
 // Incident packing for the compact key 'i': values below 10 are injury severities, 10+ are knock tiers.
 function incidentToCompact(incident) {
     if (incident == null)
@@ -108,6 +108,17 @@ export function transformToSpike(event, roster) {
         incident: incidentFromCompact(event.i, event.h, roster)
     });
 }
+// FreeBall (Last Resort save) is a plain InPlayEvent with no incident of its own, so it decodes from f/t/a/s
+// exactly like a spike minus the incident. Must stay in lockstep with the case 7 branch in rally.ts.
+export function transformToFreeBall(event, roster) {
+    return FreeBall.create({
+        failure: event.f,
+        type: event.t,
+        playerId: roster[event.p],
+        target: event.a,
+        score: event.s
+    });
+}
 export function transformToSubstitution(event, roster) {
     return Substitution.create({
         playerId: roster[event.p],

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

@@ -1,8 +1,8 @@
 import { pack, unpack } from 'msgpackr';
 import { deflateRawSync, inflateRawSync } from 'zlib';
 import { decompressFromBase64 } from 'lz-string';
-import { Block, LiberoReplacement, Rally, Reception, Serve, Set as VolleySet, Spike, Substitution } from '../../service';
-import { transformToBlock, transformToCompact, transformToLiberoReplacement, transformToReception, transformToServe, transformToSet, transformToSpike, transformToSubstitution } from './rally-event';
+import { Block, FreeBall, LiberoReplacement, Rally, Reception, Serve, Set as VolleySet, Spike, Substitution } from '../../service';
+import { transformToBlock, transformToCompact, transformToFreeBall, transformToLiberoReplacement, transformToReception, transformToServe, transformToSet, transformToSpike, transformToSubstitution } from './rally-event';
 const VERSION_BYTE = 0x01;
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function deflate(data) { return deflateRawSync(data); }
@@ -57,6 +57,7 @@ function decodeCompactEvent(event, roster) {
         case 4: return transformToSet(event, roster);
         case 5: return transformToSpike(event, roster);
         case 6: return transformToBlock(event, roster);
+        case 7: return transformToFreeBall(event, roster);
         default: throw new Error(`UNKNOWN_EVENT_TYPE: ${String(event.e)}`);
     }
 }
@@ -69,6 +70,7 @@ function decodeLegacyEvent(event) {
         case 4: return VolleySet.create({ failure: event.f, type: event.t, playerId: event.p, target: event.a, score: event.s });
         case 5: return Spike.create({ failure: event.f, type: event.t, playerId: event.p, target: event.a, score: event.s });
         case 6: return Block.create({ failure: event.f, type: event.t, playerId: event.p, target: event.a, blockers: event.b ?? [], score: event.s });
+        case 7: return FreeBall.create({ failure: event.f, type: event.t, playerId: event.p, target: event.a, score: event.s });
         default: throw new Error(`UNKNOWN_EVENT_TYPE: ${String(event.e)}`);
     }
 }

package/dist/esm/src/data/transformers/rally.test.d.ts

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

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

@@ -0,0 +1,60 @@
+import { describe, it, expect } from '@jest/globals';
+import { v4 as uuidv4 } from 'uuid';
+import { Block, BlockFailureEnum, BlockTypeEnum, EventTypeEnum, FreeBall, FreeBallFailureEnum, FreeBallTypeEnum, LiberoReplacement, LiberoReplacementTypeEnum, Rally, Reception, ReceptionFailureEnum, ReceptionTypeEnum, Serve, ServeFailureEnum, ServeTypeEnum, Set as VolleySet, SetFailureEnum, SetTempoEnum, SetTypeEnum, Spike, SpikeFailureEnum, SpikeTypeEnum, Substitution } from '../../service';
+import { transformFromRally, transformToRally } from './rally';
+// End-to-end rally round trip (encode -> bytea -> decode) exercising the decodeCompactEvent switch, with one
+// event of EVERY EventTypeEnum member. This is the guard that would have caught the FREE_BALL decoder gap: the
+// encoder is generic (out.e = evt.eventType) but the decoder is a hardcoded switch, so a new event type that is
+// not wired into the switch throws UNKNOWN_EVENT_TYPE here. The coverage test forces new members into this list.
+describe('rally compact round trip — every event type', () => {
+    const pA = uuidv4();
+    const pB = uuidv4();
+    const pC = uuidv4();
+    const setId = uuidv4();
+    const events = [
+        LiberoReplacement.create({ playerId: pA, libero: pB, type: LiberoReplacementTypeEnum.LIBERO_IN }),
+        Substitution.create({ playerId: pA, playerOut: pC, injury: true }),
+        Serve.create({ playerId: pA, target: 6, score: 55, failure: ServeFailureEnum.NO_FAILURE, type: ServeTypeEnum.JUMP_TOPSPIN }),
+        Reception.create({ playerId: pB, target: 5, score: 50, failure: ReceptionFailureEnum.NO_FAILURE, type: ReceptionTypeEnum.DIG }),
+        VolleySet.create({ playerId: pC, target: 3, score: 48, failure: SetFailureEnum.NO_FAILURE, type: SetTypeEnum.OVERHAND, tempo: SetTempoEnum.FIRST }),
+        Spike.create({ playerId: pA, target: 4, score: 62.5, failure: SpikeFailureEnum.NO_FAILURE, type: SpikeTypeEnum.CROSS_SHOT }),
+        Block.create({ playerId: pB, blockers: [pB, pC], target: 8, score: 48, failure: BlockFailureEnum.NO_FAILURE, type: BlockTypeEnum.DOUBLE }),
+        FreeBall.create({ playerId: pC, target: 6, score: 45, failure: FreeBallFailureEnum.NO_FAILURE, type: FreeBallTypeEnum.OVER })
+    ];
+    const rally = Rally.create({ id: uuidv4(), order: 0, servingTeamId: uuidv4(), events });
+    it('covers every EventTypeEnum member (adding a new event type must extend this list)', () => {
+        const numericTypes = Object.values(EventTypeEnum).filter((v) => typeof v === 'number');
+        const present = new Set(events.map(e => e.eventType));
+        for (const t of numericTypes)
+            expect(present.has(t)).toBe(true);
+        expect(present.size).toBe(numericTypes.length);
+    });
+    it('encodes then decodes every event type back to an equal event (guards the decoder switch)', () => {
+        const attrs = transformFromRally(rally, setId);
+        const decoded = transformToRally(attrs);
+        expect(decoded.events).toHaveLength(events.length);
+        expect(decoded.events.map(e => e.eventType)).toEqual(events.map(e => e.eventType));
+        const [lib, sub, serve, rec, set, spike, block, free] = decoded.events;
+        expect(lib.playerId).toBe(pA);
+        expect(lib.libero).toBe(pB);
+        expect(lib.type).toBe(LiberoReplacementTypeEnum.LIBERO_IN);
+        expect(sub.playerOut).toBe(pC);
+        expect(sub.injury).toBe(true);
+        expect(serve.target).toBe(6);
+        expect(serve.score).toBe(55);
+        expect(serve.type).toBe(ServeTypeEnum.JUMP_TOPSPIN);
+        expect(rec.target).toBe(5);
+        expect(rec.type).toBe(ReceptionTypeEnum.DIG);
+        expect(set.type).toBe(SetTypeEnum.OVERHAND);
+        expect(set.tempo).toBe(SetTempoEnum.FIRST);
+        expect(spike.type).toBe(SpikeTypeEnum.CROSS_SHOT);
+        expect(spike.score).toBe(62.5);
+        expect(block.type).toBe(BlockTypeEnum.DOUBLE);
+        expect(block.blockers).toEqual([pB, pC]);
+        expect(free.playerId).toBe(pC);
+        expect(free.target).toBe(6);
+        expect(free.score).toBe(45);
+        expect(free.type).toBe(FreeBallTypeEnum.OVER);
+        expect(free.failure).toBe(FreeBallFailureEnum.NO_FAILURE);
+    });
+});

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

@@ -1,22 +1,7 @@
-import { CourtPosition, Tactics } from '../../service';
-// Back-compat: new rows persist `mode`; rows written before the mode change persist `isPinchServer` (+ a
-// 'NEVER' fatigueBand for the old "never fatigue-sub" state). Derive the mode so existing data keeps working
-// until the next tactics save rewrites it in the new shape.
-function subModeFromAttributes(d) {
-    if (d.mode != null)
-        return d.mode;
-    if (d.isPinchServer === true)
-        return 'PINCH';
-    if (d.fatigueBand === 'NEVER')
-        return 'NEVER';
-    return 'FATIGUE';
-}
-// pinchServer only applies to PINCH ("Conditions") mode. A LEGACY PINCH row (no flag) defaults to true so
-// existing pinch servers keep serve-and-return behavior; a new conditional sub persists an explicit false. This
-// default must resolve identically on every READ path (both transformToObject and tacticsColumnsToApiDto).
-function effectivePinchServer(mode, pinchServer) {
-    return mode === 'PINCH' ? (pinchServer ?? true) : undefined;
-}
+import { convertLegacyLiberoSubConfig, convertLegacySetSubConfig, CourtPosition, Tactics } from '../../service';
+// Unified condition engine (owner 2026-07-11): the READ path passes legacy fields (mode / fatigueBand /
+// isPinchServer) through RAW; the schema preprocess in Tactics.create converts every legacy shape (see
+// service/team/sub-config-convert.ts). The WRITE path persists only the unified shape.
 function findPlayer(id, roster) {
     const player = roster.find((p) => p.id === id);
     if (player == null)
@@ -60,23 +45,19 @@ function transformToAttributes(tactics, teamId) {
         designated_subs: tactics.designatedSubs.map(ds => ({
             starterId: ds.starter.id,
             benchId: ds.bench?.id,
-            mode: ds.mode,
-            fatigueBand: ds.fatigueBand,
-            benchFatigueBand: ds.benchFatigueBand,
             conditions: ds.conditions,
             conditionLogic: ds.conditionLogic,
             pinchServer: ds.pinchServer,
+            benchFatigueBand: ds.benchFatigueBand,
             subBackMode: ds.subBackMode,
             subBackConditions: ds.subBackConditions,
             subBackConditionLogic: ds.subBackConditionLogic,
             sets: ds.sets?.map(s => ({
-                mode: s.mode,
                 benchId: s.bench?.id,
-                fatigueBand: s.fatigueBand,
-                benchFatigueBand: s.benchFatigueBand,
                 conditions: s.conditions,
                 conditionLogic: s.conditionLogic,
                 pinchServer: s.pinchServer,
+                benchFatigueBand: s.benchFatigueBand,
                 subBackMode: s.subBackMode,
                 subBackConditions: s.subBackConditions,
                 subBackConditionLogic: s.subBackConditionLogic
@@ -86,7 +67,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 => ({
@@ -95,9 +76,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,
@@ -157,15 +140,19 @@ function transformToObject(model, roster) {
         secondLibero,
         liberoSub: secondLibero != null ? (model.libero_sub ?? undefined) : undefined,
         liberoReplacementSets,
+        // Legacy fields (mode / fatigueBand / isPinchServer) pass through RAW: the DesignatedSubSchema preprocess
+        // inside Tactics.create converts every legacy shape (mode-era AND isPinchServer-era rows) to the unified
+        // condition engine. Only the player references are resolved here.
         designatedSubs: (model.designated_subs ?? []).map(d => ({
             starter: findPlayer(d.starterId, roster),
             bench: d.benchId != null ? findPlayer(d.benchId, roster) : undefined,
-            mode: subModeFromAttributes(d),
-            fatigueBand: d.fatigueBand === 'NEVER' ? undefined : d.fatigueBand,
+            mode: d.mode,
+            isPinchServer: d.isPinchServer,
+            fatigueBand: d.fatigueBand,
             benchFatigueBand: d.benchFatigueBand,
             conditions: d.conditions,
             conditionLogic: d.conditionLogic,
-            pinchServer: effectivePinchServer(subModeFromAttributes(d), d.pinchServer),
+            pinchServer: d.pinchServer,
             subBackMode: d.subBackMode,
             subBackConditions: d.subBackConditions,
             subBackConditionLogic: d.subBackConditionLogic,
@@ -176,7 +163,7 @@ function transformToObject(model, roster) {
                 benchFatigueBand: s.benchFatigueBand,
                 conditions: s.conditions,
                 conditionLogic: s.conditionLogic,
-                pinchServer: effectivePinchServer(s.mode, s.pinchServer),
+                pinchServer: s.pinchServer,
                 subBackMode: s.subBackMode,
                 subBackConditions: s.subBackConditions,
                 subBackConditionLogic: s.subBackConditionLogic
@@ -186,7 +173,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 => ({
@@ -195,9 +182,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
@@ -322,38 +311,27 @@ function tacticsColumnsToApiDto(model) {
         receiveRotationOffset: model.receive_rotation_offset,
         substitutionBand: model.substitution_band,
         secondLibero: validSecondLibero,
-        liberoSub: validSecondLibero != null ? model.libero_sub : undefined,
+        // The API surfaces the UNIFIED condition-engine shape: legacy rows (mode-era / isPinchServer-era) convert
+        // here via the same service converters the schema preprocess uses, so clients never see a mode.
+        liberoSub: validSecondLibero != null
+            ? (model.libero_sub != null ? convertLegacyLiberoSubConfig(model.libero_sub) : undefined)
+            : undefined,
         liberoReplacementSets: validLiberoReplacementSets,
-        designatedSubs: (model.designated_subs ?? []).map(d => ({
-            starterId: d.starterId,
-            benchId: d.benchId,
-            mode: subModeFromAttributes(d),
-            fatigueBand: d.fatigueBand === 'NEVER' ? undefined : d.fatigueBand,
-            benchFatigueBand: d.benchFatigueBand,
-            conditions: d.conditions,
-            conditionLogic: d.conditionLogic,
-            pinchServer: effectivePinchServer(subModeFromAttributes(d), d.pinchServer),
-            subBackMode: d.subBackMode,
-            subBackConditions: d.subBackConditions,
-            subBackConditionLogic: d.subBackConditionLogic,
-            sets: d.sets?.map(s => ({
-                mode: s.mode,
-                benchId: s.benchId,
-                fatigueBand: s.fatigueBand,
-                benchFatigueBand: s.benchFatigueBand,
-                conditions: s.conditions,
-                conditionLogic: s.conditionLogic,
-                pinchServer: effectivePinchServer(s.mode, s.pinchServer),
-                subBackMode: s.subBackMode,
-                subBackConditions: s.subBackConditions,
-                subBackConditionLogic: s.subBackConditionLogic
-            }))
-        })),
+        designatedSubs: (model.designated_subs ?? []).map(d => {
+            const { starterId, sets, ...cfg } = d;
+            return {
+                ...convertLegacySetSubConfig(cfg),
+                starterId,
+                sets: sets?.map(s => convertLegacySetSubConfig(s))
+            };
+        }),
         rotationSystem: model.rotation_system,
         designatedSetters: model.designated_setters,
         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).
@@ -459,6 +437,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/esm/src/data/transformers/tactics.test.js

@@ -1,6 +1,6 @@
 import { describe, it, expect } from '@jest/globals';
 import { tacticsColumnsToApiDto, transformFromTactics, transformToTactics } from './tactics';
-import { CourtPosition, EnergyBand, RotationSystemEnum, Tactics } from '../../service';
+import { CourtPosition, EnergyBand, RoleEnum, RotationSystemEnum, Tactics } from '../../service';
 import { makeCountry, makePlayer } from '../../service/test-helpers';
 // Minimal TacticsModel-shaped object; cast through unknown since the transformer only reads columns.
 function makeTactics(designatedSubs) {
@@ -24,7 +24,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: []
     };
 }
 describe('tacticsColumnsToApiDto()', () => {
@@ -35,27 +36,30 @@ 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, order: ['lf', 'rf'] }]);
+        expect(dto.offensivePreferences).toEqual([{ rotation: 1, weights: { lf: 60, rf: 40 } }]);
     });
-    it("resolves a legacy isPinchServer entry to mode 'PINCH'", () => {
+    it('converts a legacy isPinchServer entry to a unified pinch server (conditions kept, no mode)', () => {
         const dto = tacticsColumnsToApiDto(makeTactics([
             { starterId: 's1', benchId: 'b1', isPinchServer: true, conditions: [{ type: 'ASAP' }] }
         ]));
-        expect(dto.designatedSubs[0].mode).toBe('PINCH');
+        expect(dto.designatedSubs[0].pinchServer).toBe(true);
+        expect(dto.designatedSubs[0].conditions).toEqual([{ type: 'ASAP' }]);
+        expect(dto.designatedSubs[0].mode).toBeUndefined();
     });
-    it("resolves a legacy 'NEVER' fatigueBand to mode NEVER and drops the band", () => {
+    it("converts a legacy 'NEVER' fatigueBand to an explicit empty condition list", () => {
         const dto = tacticsColumnsToApiDto(makeTactics([
             { starterId: 's1', fatigueBand: 'NEVER' }
         ]));
-        expect(dto.designatedSubs[0].mode).toBe('NEVER');
+        expect(dto.designatedSubs[0].conditions).toEqual([]);
         expect(dto.designatedSubs[0].fatigueBand).toBeUndefined();
     });
-    it('passes a fatigue entry with its own bands through unchanged', () => {
+    it('converts a legacy fatigue entry to a FATIGUE condition carrying its band', () => {
         const dto = tacticsColumnsToApiDto(makeTactics([
             { starterId: 's1', benchId: 'b1', mode: 'FATIGUE', fatigueBand: EnergyBand.WORN, benchFatigueBand: EnergyBand.TIRED }
         ]));
-        expect(dto.designatedSubs[0].mode).toBe('FATIGUE');
-        expect(dto.designatedSubs[0].fatigueBand).toBe(EnergyBand.WORN);
+        expect(dto.designatedSubs[0].conditions).toEqual([{ type: 'FATIGUE', band: EnergyBand.WORN }]);
+        expect(dto.designatedSubs[0].subBackMode).toBe('FATIGUE');
+        expect(dto.designatedSubs[0].pinchServer).toBe(false);
         expect(dto.designatedSubs[0].benchFatigueBand).toBe(EnergyBand.TIRED);
     });
     it('defaults a legacy PINCH row (no pinchServer flag) to pinchServer true', () => {
@@ -64,11 +68,12 @@ describe('tacticsColumnsToApiDto()', () => {
         ]));
         expect(dto.designatedSubs[0].pinchServer).toBe(true);
     });
-    it('leaves pinchServer undefined for a non-PINCH row', () => {
+    it('passes an already-unified entry through untouched', () => {
         const dto = tacticsColumnsToApiDto(makeTactics([
-            { starterId: 's1', benchId: 'b1', mode: 'FATIGUE', fatigueBand: EnergyBand.TIRED }
+            { starterId: 's1', benchId: 'b1', conditions: [{ type: 'FATIGUE', band: EnergyBand.TIRED }], conditionLogic: 'ALL', pinchServer: false, subBackMode: 'FATIGUE' }
         ]));
-        expect(dto.designatedSubs[0].pinchServer).toBeUndefined();
+        expect(dto.designatedSubs[0].conditions).toEqual([{ type: 'FATIGUE', band: EnergyBand.TIRED }]);
+        expect(dto.designatedSubs[0].pinchServer).toBe(false);
     });
     it('passes a conditional regular sub (pinchServer false + condition sub-back) through unchanged', () => {
         const dto = tacticsColumnsToApiDto(makeTactics([
@@ -105,7 +110,8 @@ describe('tacticsColumnsToApiDto()', () => {
         model.libero_sub = { mode: 'FATIGUE' };
         const dto = tacticsColumnsToApiDto(model);
         expect(dto.secondLibero).toBe('reserve1');
-        expect(dto.liberoSub).toEqual({ mode: 'FATIGUE' });
+        // Legacy FATIGUE libero rule converts to the unified condition shape on the API read path.
+        expect(dto.liberoSub).toEqual({ conditions: [{ type: 'FATIGUE' }], conditionLogic: 'ALL' });
     });
     it('keeps a libero-keyed replaceKnockedImmediately entry when a second libero exists (L2-only feature)', () => {
         const model = makeTactics([]);
@@ -125,10 +131,10 @@ 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, order: ['rf', 'mf'] }]];
+        model.offensive_preference_sets = [[{ rotation: 1, weights: { rf: 55, mf: 45 } }]];
         const dto = tacticsColumnsToApiDto(model);
         expect(dto.systemSets).toEqual([{ rotationSystem: '5-1', designatedSetters: ['lf'] }]);
-        expect(dto.offensivePreferenceSets).toEqual([[{ rotation: 1, order: ['rf', 'mf'] }]]);
+        expect(dto.offensivePreferenceSets).toEqual([[{ rotation: 1, weights: { rf: 55, mf: 45 } }]]);
     });
     it('leaves the per-set DTO fields undefined when the columns are absent', () => {
         const dto = tacticsColumnsToApiDto(makeTactics([]));
@@ -152,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, order: [p2, p3] }]]
+        offensivePreferenceSets: [[{ rotation: 1, weights: { [p2.id]: 60, [p3.id]: 40 } }]]
     });
     it('transformFromTactics writes the per-set overrides as id-based jsonb columns', () => {
         const attrs = transformFromTactics(tactics, 'team-1');
@@ -160,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, order: [p2.id, p3.id] }]]);
+        expect(attrs.offensive_preference_sets).toEqual([[{ rotation: 1, weights: { [p2.id]: 60, [p3.id]: 40 } }]]);
     });
     it('transformToTactics resolves the stored ids back to roster players', () => {
         const attrs = transformFromTactics(tactics, 'team-1');
@@ -168,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].order.map(p => p.id)).toEqual([p2.id, p3.id]);
+        expect(back.offensivePreferenceSets?.[0][0].weights).toEqual({ [p2.id]: 60, [p3.id]: 40 });
     });
     it('omits the per-set columns entirely for an all-sets config', () => {
         const flat = Tactics.create({
@@ -186,15 +192,28 @@ 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, 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 = transformFromTactics(withTempos, 'team-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 = 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', () => {
+        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 } }]
+        });
+        const attrs = transformFromTactics(withBlocking, 'team-1');
+        expect(attrs.blocking_preferences).toEqual([
+            { rotation: 1, targets: { [p4.id]: RoleEnum.OUTSIDE_HITTER, [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 });
+    });
 });
 describe('libero injuries — service <-> row round-trip + lenient heal', () => {
     const country = makeCountry();

package/dist/esm/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/esm/src/service/team/blocking-preference.js

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

package/dist/esm/src/service/team/designated-sub.d.ts

@@ -1,15 +1,13 @@
 import { Player } from '../player';
-import { EnergyBand, SubMode } from './energy-band';
+import { EnergyBand } from './energy-band';
 import { ConditionLogic, PinchCondition } from './pinch-condition';
 export type SubBackMode = 'FATIGUE' | 'CONDITIONS';
 export interface SetSubConfig {
-    readonly mode: SubMode;
     readonly bench?: Player;
-    readonly fatigueBand?: EnergyBand;
-    readonly benchFatigueBand?: EnergyBand;
     readonly conditions?: PinchCondition[];
     readonly conditionLogic?: ConditionLogic;
     readonly pinchServer?: boolean;
+    readonly benchFatigueBand?: EnergyBand;
     readonly subBackMode?: SubBackMode;
     readonly subBackConditions?: PinchCondition[];
     readonly subBackConditionLogic?: ConditionLogic;

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

@@ -7,9 +7,11 @@ export * from './energy-band';
 export * from './pinch-condition';
 export * from './designated-sub';
 export * from './libero-sub';
+export * from './sub-config-convert';
 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';