npm - volleyballsimtypes - Versions diffs - 0.0.511 → 0.0.513 - Mend

volleyballsimtypes 0.0.511 → 0.0.513

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (31) hide show

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

@@ -1,4 +1,4 @@
-import { BaseConfig, 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, BlockingAssignment, DefenceFormation, CourtPosition, ConditionLogic, EnergyBand, MatchForfeitType, PerformanceStats, PinchCondition, RotationSystemEnum, SubBackMode, SubBand } from '../service';
+import { BaseConfig, 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, DefenceFormation, LineupFunction, CourtPosition, ConditionLogic, EnergyBand, MatchForfeitType, PerformanceStats, PinchCondition, RotationSystemEnum, SubBackMode, SubBand } from '../service';
 export * from './tactics-player-refs';
 export type Rally = DataProps<_Rally> & {
     homePlayerPosition: PlayerPosition[];
@@ -102,7 +102,8 @@ export interface ApiOffensivePreference {
 }
 export interface ApiBlockingPreference {
     rotation: number;
-    targets: Record<DefenceFormation, Record<string, BlockingAssignment>>;
+    commit: Record<string, LineupFunction>;
+    noBlock: Record<DefenceFormation, string[]>;
 }
 export interface ApiSystemSet {
     rotationSystem: RotationSystemEnum;

package/dist/cjs/src/api/tactics-player-refs.d.ts CHANGED Viewed

@@ -2,8 +2,8 @@ import type { Tactics } from '.';
 /**
  * Every player id a tactics config references, anywhere: the six court slots and the libero, the bench, libero
  * replacements (flat and per-set), the second libero, designated subs and their per-set overrides, designated
- * setters (flat and per-set), the keys of the offensive-weight and blocking-target maps, injury replacements
- * and the libero-injury reserves.
+ * setters (flat and per-set), the keys of the offensive-weight map, the blocking commit + no-block ids, injury
+ * replacements and the libero-injury reserves.
  *
  * There is exactly ONE implementation of this on purpose. It backs three rules that must agree or a player
  * slips through: the dismiss/retire guard (a referenced player cannot be removed), the event rarity check

package/dist/cjs/src/api/tactics-player-refs.js CHANGED Viewed

@@ -4,8 +4,8 @@ exports.collectTacticsPlayerIds = collectTacticsPlayerIds;
 /**
  * Every player id a tactics config references, anywhere: the six court slots and the libero, the bench, libero
  * replacements (flat and per-set), the second libero, designated subs and their per-set overrides, designated
- * setters (flat and per-set), the keys of the offensive-weight and blocking-target maps, injury replacements
- * and the libero-injury reserves.
+ * setters (flat and per-set), the keys of the offensive-weight map, the blocking commit + no-block ids, injury
+ * replacements and the libero-injury reserves.
  *
  * There is exactly ONE implementation of this on purpose. It backs three rules that must agree or a player
  * slips through: the dismiss/retire guard (a referenced player cannot be removed), the event rarity check
@@ -29,8 +29,8 @@ function collectTacticsPlayerIds(config) {
         ...((config.offensivePreferences ?? []).flatMap(p => Object.keys(p.weights))),
         ...((config.systemSets ?? []).flatMap(s => s.designatedSetters)),
         ...((config.offensivePreferenceSets ?? []).flat().flatMap(p => Object.keys(p.weights))),
-        ...((config.blockingPreferences ?? []).flatMap(p => Object.values(p.targets).flatMap(m => Object.keys(m ?? {})))),
-        ...((config.blockingPreferenceSets ?? []).flat().flatMap(p => Object.values(p.targets).flatMap(m => Object.keys(m ?? {})))),
+        ...((config.blockingPreferences ?? []).flatMap(p => [...Object.keys(p.commit ?? {}), ...Object.values(p.noBlock ?? {}).flat()])),
+        ...((config.blockingPreferenceSets ?? []).flat().flatMap(p => [...Object.keys(p.commit ?? {}), ...Object.values(p.noBlock ?? {}).flat()])),
         // Injury replacements reference reserves (roster players outside the lineup); roster membership is the only
         // player check possible here (the schema enforces the bench/reserve role rules).
         ...((config.injuryReplacements ?? []).flatMap(ir => [ir.starterId, ir.replacementId, ir.benchBackfillId])),

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

@@ -1,7 +1,7 @@
 import * as Sequelize from 'sequelize';
 import { Model, Optional } from 'sequelize';
 import { PlayerId, TeamId, TeamModel } from '.';
-import { BaseConfig, BlockingAssignment, ConditionLogic, CourtPosition, DefenceFormation, EnergyBand, PinchCondition, RotationSystemEnum, SubBackMode, SubBand, SubMode } from '../../service';
+import { BaseConfig, ConditionLogic, CourtPosition, DefenceFormation, EnergyBand, LineupFunction, PinchCondition, RotationSystemEnum, SubBackMode, SubBand, SubMode } from '../../service';
 export interface TacticsLineupAttributes {
     [CourtPosition.LIBERO_ZONE]?: PlayerId;
     [CourtPosition.LEFT_BACK]: PlayerId;
@@ -36,7 +36,8 @@ export interface OffensivePreferenceAttributes {
 }
 export interface BlockingPreferenceAttributes {
     rotation: number;
-    targets: Record<DefenceFormation, Record<PlayerId, BlockingAssignment>>;
+    commit: Record<PlayerId, LineupFunction>;
+    noBlock: Record<DefenceFormation, PlayerId[]>;
 }
 export interface SystemSetAttributes {
     rotationSystem: RotationSystemEnum;

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

@@ -87,8 +87,8 @@ function transformToAttributes(tactics, teamId) {
         }))),
         serve_attack_shares: tactics.serveAttackShares ?? {},
         base_positions: tactics.basePositions,
-        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 }))),
+        blocking_preferences: tactics.blockingPreferences.map(p => ({ rotation: p.rotation, commit: p.commit, noBlock: p.noBlock })),
+        blocking_preference_sets: tactics.blockingPreferenceSets?.map(prefs => prefs.map(p => ({ rotation: p.rotation, commit: p.commit, noBlock: p.noBlock }))),
         replace_knocked_immediately: tactics.replaceKnockedImmediately,
         injury_replacements: tactics.injuryReplacements.map(ir => ({
             starterId: ir.starter.id,
@@ -209,8 +209,8 @@ function transformToObject(model, roster) {
             return healed;
         })(),
         basePositions: model.base_positions ?? undefined,
-        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 }))),
+        blockingPreferences: (model.blocking_preferences ?? []).map(p => ({ rotation: p.rotation, commit: p.commit, noBlock: p.noBlock })),
+        blockingPreferenceSets: model.blocking_preference_sets?.map(prefs => prefs.map(p => ({ rotation: p.rotation, commit: p.commit, noBlock: p.noBlock }))),
         // 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

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

@@ -264,37 +264,39 @@ function makeTactics(designatedSubs) {
         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 per-defence-side id-keyed function maps', () => {
+    (0, globals_1.it)('round-trips blocking preferences as a base commit map plus per-side no-block ids', () => {
         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: { DEF_L: { [p4.id]: service_1.RoleEnum.OUTSIDE_HITTER }, DEF_R: { [p3.id]: service_1.RoleEnum.MIDDLE_BLOCKER } } }]
+            blockingPreferences: [{ rotation: 1, commit: { [p4.id]: service_1.RoleEnum.OUTSIDE_HITTER, [p3.id]: service_1.RoleEnum.MIDDLE_BLOCKER }, noBlock: { DEF_L: [p2.id] } }]
         });
         const attrs = (0, tactics_1.transformFromTactics)(withBlocking, 'team-1');
         (0, globals_1.expect)(attrs.blocking_preferences).toEqual([
-            { rotation: 1, targets: { DEF_L: { [p4.id]: service_1.RoleEnum.OUTSIDE_HITTER }, DEF_M: {}, DEF_R: { [p3.id]: service_1.RoleEnum.MIDDLE_BLOCKER } } }
+            { rotation: 1, commit: { [p4.id]: service_1.RoleEnum.OUTSIDE_HITTER, [p3.id]: service_1.RoleEnum.MIDDLE_BLOCKER }, noBlock: { DEF_L: [p2.id], DEF_M: [], DEF_R: [] } }
         ]);
         const back = (0, tactics_1.transformToTactics)(attrs, roster);
-        (0, globals_1.expect)(back.blockingPreferences[0].targets).toEqual({ DEF_L: { [p4.id]: service_1.RoleEnum.OUTSIDE_HITTER }, DEF_M: {}, DEF_R: { [p3.id]: service_1.RoleEnum.MIDDLE_BLOCKER } });
+        (0, globals_1.expect)(back.blockingPreferences[0].commit).toEqual({ [p4.id]: service_1.RoleEnum.OUTSIDE_HITTER, [p3.id]: service_1.RoleEnum.MIDDLE_BLOCKER });
+        (0, globals_1.expect)(back.blockingPreferences[0].noBlock).toEqual({ DEF_L: [p2.id], DEF_M: [], DEF_R: [] });
     });
-    // NO_BLOCK rides in the same targets map as a commit assignment, so the transformers copy it wholesale with no
-    // mapping code. This pins that: the sentinel must survive the row round-trip verbatim, mixed with a commit, and
-    // in the per-set overrides. If it ever gets translated or dropped, a player silently starts blocking again.
-    (0, globals_1.it)('round-trips a NO_BLOCK assignment, mixed with a commit and in per-set overrides', () => {
+    // The base commit map (blind) and the per-side no-block ids are copied wholesale by the transformers with no
+    // mapping code. This pins that they survive the row round-trip verbatim, including in the per-set overrides. If a
+    // no-block id is ever translated or dropped, a player silently starts blocking again.
+    (0, globals_1.it)('round-trips a base commit plus per-side no-block ids, including per-set overrides', () => {
         const withNoBlock = service_1.Tactics.create({
             lineup: { 4: p4, 3: p3, 2: p2, 5: p5, 6: p6, 1: p1, bench: [] },
             liberoReplacements: [],
-            blockingPreferences: [{ rotation: 1, targets: { DEF_M: { [p4.id]: service_1.NO_BLOCK, [p3.id]: service_1.RoleEnum.MIDDLE_BLOCKER } } }],
-            blockingPreferenceSets: [[{ rotation: 2, targets: { DEF_L: { [p2.id]: service_1.NO_BLOCK } } }]]
+            blockingPreferences: [{ rotation: 1, commit: { [p3.id]: service_1.RoleEnum.MIDDLE_BLOCKER }, noBlock: { DEF_M: [p4.id] } }],
+            blockingPreferenceSets: [[{ rotation: 2, noBlock: { DEF_L: [p2.id] } }]]
         });
         const attrs = (0, tactics_1.transformFromTactics)(withNoBlock, 'team-1');
         (0, globals_1.expect)(attrs.blocking_preferences).toEqual([
-            { rotation: 1, targets: { DEF_L: {}, DEF_M: { [p4.id]: service_1.NO_BLOCK, [p3.id]: service_1.RoleEnum.MIDDLE_BLOCKER }, DEF_R: {} } }
+            { rotation: 1, commit: { [p3.id]: service_1.RoleEnum.MIDDLE_BLOCKER }, noBlock: { DEF_L: [], DEF_M: [p4.id], DEF_R: [] } }
         ]);
-        (0, globals_1.expect)(attrs.blocking_preference_sets).toEqual([[{ rotation: 2, targets: { DEF_L: { [p2.id]: service_1.NO_BLOCK }, DEF_M: {}, DEF_R: {} } }]]);
+        (0, globals_1.expect)(attrs.blocking_preference_sets).toEqual([[{ rotation: 2, commit: {}, noBlock: { DEF_L: [p2.id], DEF_M: [], DEF_R: [] } }]]);
         const back = (0, tactics_1.transformToTactics)(attrs, roster);
-        (0, globals_1.expect)(back.blockingPreferences[0].targets).toEqual({ DEF_L: {}, DEF_M: { [p4.id]: service_1.NO_BLOCK, [p3.id]: service_1.RoleEnum.MIDDLE_BLOCKER }, DEF_R: {} });
-        (0, globals_1.expect)(back.blockingPreferenceSets?.[0][0].targets).toEqual({ DEF_L: { [p2.id]: service_1.NO_BLOCK }, DEF_M: {}, DEF_R: {} });
+        (0, globals_1.expect)(back.blockingPreferences[0].commit).toEqual({ [p3.id]: service_1.RoleEnum.MIDDLE_BLOCKER });
+        (0, globals_1.expect)(back.blockingPreferences[0].noBlock).toEqual({ DEF_L: [], DEF_M: [p4.id], DEF_R: [] });
+        (0, globals_1.expect)(back.blockingPreferenceSets?.[0][0].noBlock).toEqual({ DEF_L: [p2.id], DEF_M: [], DEF_R: [] });
     });
 });
 (0, globals_1.describe)('libero injuries — service <-> row round-trip + lenient heal', () => {

package/dist/cjs/src/service/event/schemas/set.z.js CHANGED Viewed

@@ -5,7 +5,7 @@ const zod_1 = require("zod");
 const player_1 = require("../../player");
 const incident_z_1 = require("./incident.z");
 const positional_z_1 = require("./positional.z");
-const setTypeValues = [0, 1];
+const setTypeValues = [0, 1, 2]; // OVERHAND, DUMP, BUMP
 const setFailureValues = [0, 1, 2, 3, 4];
 const setTempoValues = [0, 1, 2];
 const courtTargetValues = Array.from({ length: 13 }, (_, i) => i);

package/dist/cjs/src/service/event/set.d.ts CHANGED Viewed

@@ -1,9 +1,10 @@
 import { InPlayEvent } from './in-play-event';
 export declare enum SetTypeEnum {
     OVERHAND = 0,
-    DUMP = 1
+    DUMP = 1,
+    BUMP = 2
 }
-export type SetType = SetTypeEnum.OVERHAND | SetTypeEnum.DUMP;
+export type SetType = SetTypeEnum.OVERHAND | SetTypeEnum.BUMP | SetTypeEnum.DUMP;
 export declare enum SetTempoEnum {
     FIRST = 0,
     SECOND = 1,

package/dist/cjs/src/service/event/set.js CHANGED Viewed

@@ -8,6 +8,10 @@ var SetTypeEnum;
 (function (SetTypeEnum) {
     SetTypeEnum[SetTypeEnum["OVERHAND"] = 0] = "OVERHAND";
     SetTypeEnum[SetTypeEnum["DUMP"] = 1] = "DUMP";
+    // A forearm (bump) set, used when the pass is off the net (owner 2026-08-11). OVERHAND and BUMP are both normal
+    // sets and behave identically for metrics (assist, first-attack); they differ only by technique (which stat graded
+    // the set) and their play-by-play label. DUMP remains the setter's own second-ball attack.
+    SetTypeEnum[SetTypeEnum["BUMP"] = 2] = "BUMP";
 })(SetTypeEnum || (exports.SetTypeEnum = SetTypeEnum = {}));
 // The tempo of a set (set-tempo rework). Decided by the simulator (pass quality + target lane + setter skill)
 // or forced by a per-player offensive preference. FIRST = quick (swings the `quick` stat, hardest to nail,

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

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

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

@@ -1,10 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFENCE_FORMATIONS = exports.NO_BLOCK = void 0;
-// A front-row player opted OUT of blocking for this rotation. They never join the wall under any circumstance:
-// not as the lead blocker (the lane's next-nearest front-row player leads instead), not as a side blocker, and
-// no trait can coerce them in -- MOVING_WALL's guaranteed lead hand, its beaten-read hand and its side-joiner
-// roll are all suppressed, as is a dedicated-blocking commit. Sits in the same `targets` map as a commit
-// assignment, so the two are mutually exclusive by construction: a player is reading, committed, or out.
-exports.NO_BLOCK = 'NO_BLOCK';
+exports.DEFENCE_FORMATIONS = void 0;
 exports.DEFENCE_FORMATIONS = ['DEF_L', 'DEF_M', 'DEF_R'];

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

@@ -282,19 +282,21 @@ export declare const TacticsInputSchema: z.ZodObject<{
     }, z.core.$strip>>>>;
     blockingPreferences: z.ZodDefault<z.ZodArray<z.ZodObject<{
         rotation: z.ZodNumber;
-        targets: z.ZodObject<{
-            DEF_L: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<typeof RoleEnum> & z.ZodType<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum, z.core.$ZodTypeInternals<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum>>, z.ZodLiteral<"NO_BLOCK">]>>>;
-            DEF_M: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<typeof RoleEnum> & z.ZodType<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum, z.core.$ZodTypeInternals<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum>>, z.ZodLiteral<"NO_BLOCK">]>>>;
-            DEF_R: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<typeof RoleEnum> & z.ZodType<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum, z.core.$ZodTypeInternals<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum>>, z.ZodLiteral<"NO_BLOCK">]>>>;
-        }, z.core.$strip>;
+        commit: z.ZodDefault<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>>>>;
+        noBlock: z.ZodDefault<z.ZodObject<{
+            DEF_L: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            DEF_M: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            DEF_R: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>>;
     blockingPreferenceSets: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodObject<{
         rotation: z.ZodNumber;
-        targets: z.ZodObject<{
-            DEF_L: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<typeof RoleEnum> & z.ZodType<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum, z.core.$ZodTypeInternals<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum>>, z.ZodLiteral<"NO_BLOCK">]>>>;
-            DEF_M: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<typeof RoleEnum> & z.ZodType<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum, z.core.$ZodTypeInternals<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum>>, z.ZodLiteral<"NO_BLOCK">]>>>;
-            DEF_R: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<typeof RoleEnum> & z.ZodType<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum, z.core.$ZodTypeInternals<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum>>, z.ZodLiteral<"NO_BLOCK">]>>>;
-        }, z.core.$strip>;
+        commit: z.ZodDefault<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>>>>;
+        noBlock: z.ZodDefault<z.ZodObject<{
+            DEF_L: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            DEF_M: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            DEF_R: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>>>;
     basePositions: z.ZodOptional<z.ZodObject<{
         coords: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{

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

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TacticsInputSchema = void 0;
 const zod_1 = require("zod");
 const player_1 = require("../../player");
-const blocking_preference_1 = require("../blocking-preference");
 const energy_band_1 = require("../energy-band");
 const rotation_system_1 = require("../rotation-system");
 const designated_sub_z_1 = require("./designated-sub.z");
@@ -60,24 +59,23 @@ const offensivePreferenceSchema = zod_1.z.object({
     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()
 });
-// What a front-row starter can be assigned: an opposing attacking function to commit to (every RoleEnum except
-// the libero, which never attacks), or NO_BLOCK to sit the rotation out of the block entirely.
-const blockingFunctionSchema = zod_1.z.union([
-    zod_1.z.nativeEnum(player_1.RoleEnum).refine((v) => v !== player_1.RoleEnum.LIBERO, { message: 'BLOCKING_TARGET_CANNOT_BE_LIBERO' }),
-    zod_1.z.literal(blocking_preference_1.NO_BLOCK)
-]);
-// One rotation's dedicated-blocking assignments: `targets` maps my front-row starter ids to the opposing function
-// each commits to block. Cross-field checks (keys are starters) live in the superRefine below.
-const blockingTargetsSchema = zod_1.z.record(zod_1.z.string(), blockingFunctionSchema);
-// Per point-of-attack defence (owner 2026-08-06): a separate front-row commit map for an attack from my left /
-// middle / right. Each defaults to {} so a partial config stays valid.
+// An opposing attacking function a front-row starter can commit to (every RoleEnum except the libero, which never
+// attacks). The commit is the BLIND, pre-set Defence-base choice (owner 2026-08-10).
+const commitFunctionSchema = zod_1.z.nativeEnum(player_1.RoleEnum).refine((v) => v !== player_1.RoleEnum.LIBERO, { message: 'BLOCKING_TARGET_CANNOT_BE_LIBERO' });
+// One rotation's blocking config (owner 2026-08-10). `commit` maps my front-row starter ids to the opposing function
+// each commits to (blind, rotation-wide; absent = reads); `noBlock` lists, per point-of-attack defence, the front-row
+// starters that sit out of the block for an attack from that side (overrides the commit for that side). Each side
+// defaults to [] so a partial config stays valid. Cross-field checks (keys/ids are starters) live in the superRefine.
+const commitSchema = zod_1.z.record(zod_1.z.string(), commitFunctionSchema);
+const noBlockSchema = zod_1.z.object({
+    DEF_L: zod_1.z.array(zod_1.z.string()).default([]),
+    DEF_M: zod_1.z.array(zod_1.z.string()).default([]),
+    DEF_R: zod_1.z.array(zod_1.z.string()).default([])
+});
 const blockingPreferenceSchema = zod_1.z.object({
     rotation: zod_1.z.number().int().min(1).max(6),
-    targets: zod_1.z.object({
-        DEF_L: blockingTargetsSchema.default({}),
-        DEF_M: blockingTargetsSchema.default({}),
-        DEF_R: blockingTargetsSchema.default({})
-    })
+    commit: commitSchema.default({}),
+    noBlock: noBlockSchema.default({ DEF_L: [], DEF_M: [], DEF_R: [] })
 });
 // One set's rotation-system override (per-set tactics): system + its designated setters travel together.
 const systemSetSchema = zod_1.z.object({
@@ -214,8 +212,9 @@ 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.
+    // Blocking preferences: unique rotations; every committer id (base commit) and every no-block id (per side) keys
+    // an on-court starter (the UI only offers front-row players, the schema checks starters). The commit function is
+    // validated by commitFunctionSchema.
     const validateBlockingPreferences = (preferences, path) => {
         const seenRotations = new Set();
         for (const pref of preferences) {
@@ -223,8 +222,13 @@ exports.TacticsInputSchema = zod_1.z.object({
                 ctx.addIssue({ code: 'custom', message: 'BLOCKING_PREFERENCE_DUPLICATE_ROTATION', path });
             }
             seenRotations.add(pref.rotation);
+            for (const id of Object.keys(pref.commit)) {
+                if (!starterIds.has(id)) {
+                    ctx.addIssue({ code: 'custom', message: 'BLOCKING_PREFERENCE_BLOCKER_NOT_A_STARTER', path });
+                }
+            }
             for (const form of ['DEF_L', 'DEF_M', 'DEF_R']) {
-                for (const id of Object.keys(pref.targets[form] ?? {})) {
+                for (const id of pref.noBlock[form] ?? []) {
                     if (!starterIds.has(id)) {
                         ctx.addIssue({ code: 'custom', message: 'BLOCKING_PREFERENCE_BLOCKER_NOT_A_STARTER', path });
                     }

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

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const globals_1 = require("@jest/globals");
 const tactics_z_1 = require("./tactics.z");
-const blocking_preference_1 = require("../blocking-preference");
 const player_1 = require("../../player");
 const test_helpers_1 = require("../../test-helpers");
 (0, globals_1.describe)('TacticsInputSchema — second libero rules', () => {
@@ -236,40 +235,49 @@ const test_helpers_1 = require("../../test-helpers");
             ...overrides
         };
     }
-    (0, globals_1.it)('accepts a blocking preference that keys starters to attacking functions, per defence side', () => {
+    (0, globals_1.it)('accepts a blocking preference that commits starters to attacking functions', () => {
         const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
-            blockingPreferences: [{ rotation: 1, targets: { DEF_L: { [p4.id]: player_1.RoleEnum.OUTSIDE_HITTER }, DEF_M: {}, DEF_R: { [p3.id]: player_1.RoleEnum.MIDDLE_BLOCKER } } }]
+            blockingPreferences: [{ rotation: 1, commit: { [p4.id]: player_1.RoleEnum.OUTSIDE_HITTER, [p3.id]: player_1.RoleEnum.MIDDLE_BLOCKER }, noBlock: { DEF_L: [], DEF_M: [], DEF_R: [] } }]
         }));
         (0, globals_1.expect)(res.success).toBe(true);
         if (res.success) {
-            (0, globals_1.expect)(res.data.blockingPreferences[0].targets.DEF_L[p4.id]).toBe(player_1.RoleEnum.OUTSIDE_HITTER);
-            (0, globals_1.expect)(res.data.blockingPreferences[0].targets.DEF_R[p3.id]).toBe(player_1.RoleEnum.MIDDLE_BLOCKER);
-            (0, globals_1.expect)(res.data.blockingPreferences[0].targets.DEF_M).toEqual({}); // the middle side is independent (empty here)
+            (0, globals_1.expect)(res.data.blockingPreferences[0].commit[p4.id]).toBe(player_1.RoleEnum.OUTSIDE_HITTER);
+            (0, globals_1.expect)(res.data.blockingPreferences[0].commit[p3.id]).toBe(player_1.RoleEnum.MIDDLE_BLOCKER);
         }
     });
-    (0, globals_1.it)('defaults the omitted defence sides to empty maps', () => {
+    (0, globals_1.it)('defaults an omitted commit to empty and omitted no-block sides to empty arrays', () => {
         const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
-            blockingPreferences: [{ rotation: 1, targets: { DEF_L: { [p4.id]: blocking_preference_1.NO_BLOCK } } }]
+            blockingPreferences: [{ rotation: 1, noBlock: { DEF_L: [p4.id] } }]
         }));
         (0, globals_1.expect)(res.success).toBe(true);
         if (res.success) {
-            (0, globals_1.expect)(res.data.blockingPreferences[0].targets.DEF_L[p4.id]).toBe(blocking_preference_1.NO_BLOCK);
-            (0, globals_1.expect)(res.data.blockingPreferences[0].targets.DEF_M).toEqual({});
-            (0, globals_1.expect)(res.data.blockingPreferences[0].targets.DEF_R).toEqual({});
+            (0, globals_1.expect)(res.data.blockingPreferences[0].commit).toEqual({});
+            (0, globals_1.expect)(res.data.blockingPreferences[0].noBlock.DEF_L).toEqual([p4.id]);
+            (0, globals_1.expect)(res.data.blockingPreferences[0].noBlock.DEF_M).toEqual([]);
+            (0, globals_1.expect)(res.data.blockingPreferences[0].noBlock.DEF_R).toEqual([]);
         }
     });
-    (0, globals_1.it)('rejects a blocking target (on any side) that is not a starter', () => {
+    (0, globals_1.it)('rejects a commit id that is not a starter', () => {
         const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
-            blockingPreferences: [{ rotation: 1, targets: { DEF_M: { [reserve.id]: player_1.RoleEnum.OUTSIDE_HITTER } } }]
+            blockingPreferences: [{ rotation: 1, commit: { [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', () => {
+    (0, globals_1.it)('rejects a no-block id (on any side) that is not a starter', () => {
         const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
-            blockingPreferences: [{ rotation: 1, targets: { DEF_L: { [p4.id]: player_1.RoleEnum.LIBERO } } }]
+            blockingPreferences: [{ rotation: 1, noBlock: { DEF_M: [reserve.id] } }]
+        }));
+        (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 commit function of libero', () => {
+        const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
+            blockingPreferences: [{ rotation: 1, commit: { [p4.id]: player_1.RoleEnum.LIBERO } }]
         }));
         (0, globals_1.expect)(res.success).toBe(false);
         if (!res.success) {
@@ -279,8 +287,8 @@ const test_helpers_1 = require("../../test-helpers");
     (0, globals_1.it)('rejects a duplicate rotation in blocking preferences', () => {
         const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
             blockingPreferences: [
-                { rotation: 1, targets: { DEF_L: { [p4.id]: player_1.RoleEnum.OUTSIDE_HITTER } } },
-                { rotation: 1, targets: { DEF_M: { [p3.id]: player_1.RoleEnum.MIDDLE_BLOCKER } } }
+                { rotation: 1, commit: { [p4.id]: player_1.RoleEnum.OUTSIDE_HITTER } },
+                { rotation: 1, commit: { [p3.id]: player_1.RoleEnum.MIDDLE_BLOCKER } }
             ]
         }));
         (0, globals_1.expect)(res.success).toBe(false);
@@ -290,38 +298,29 @@ const test_helpers_1 = require("../../test-helpers");
     });
     (0, globals_1.it)('accepts per-set blocking preference overrides', () => {
         const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
-            blockingPreferenceSets: [[{ rotation: 1, targets: { DEF_R: { [p4.id]: player_1.RoleEnum.OPPOSITE_HITTER } } }], []]
+            blockingPreferenceSets: [[{ rotation: 1, commit: { [p4.id]: player_1.RoleEnum.OPPOSITE_HITTER } }], []]
         }));
         (0, globals_1.expect)(res.success).toBe(true);
     });
-    (0, globals_1.it)('accepts NO_BLOCK as an assignment, alongside a commit on another starter, on the same side', () => {
+    (0, globals_1.it)('accepts a starter committed on the base AND no-blocked on a side (no-block overrides commit there)', () => {
         const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
-            blockingPreferences: [{ rotation: 1, targets: { DEF_L: { [p4.id]: blocking_preference_1.NO_BLOCK, [p3.id]: player_1.RoleEnum.MIDDLE_BLOCKER } } }]
+            blockingPreferences: [{ rotation: 1, commit: { [p3.id]: player_1.RoleEnum.MIDDLE_BLOCKER }, noBlock: { DEF_L: [p3.id] } }]
         }));
         (0, globals_1.expect)(res.success).toBe(true);
         if (res.success) {
-            (0, globals_1.expect)(res.data.blockingPreferences[0].targets.DEF_L[p4.id]).toBe(blocking_preference_1.NO_BLOCK);
-            (0, globals_1.expect)(res.data.blockingPreferences[0].targets.DEF_L[p3.id]).toBe(player_1.RoleEnum.MIDDLE_BLOCKER);
+            (0, globals_1.expect)(res.data.blockingPreferences[0].commit[p3.id]).toBe(player_1.RoleEnum.MIDDLE_BLOCKER);
+            (0, globals_1.expect)(res.data.blockingPreferences[0].noBlock.DEF_L).toEqual([p3.id]);
         }
     });
-    (0, globals_1.it)('accepts NO_BLOCK in a per-set override', () => {
+    (0, globals_1.it)('accepts a no-block in a per-set override', () => {
         const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
-            blockingPreferenceSets: [[{ rotation: 1, targets: { DEF_M: { [p4.id]: blocking_preference_1.NO_BLOCK } } }], []]
+            blockingPreferenceSets: [[{ rotation: 1, noBlock: { DEF_M: [p4.id] } }], []]
         }));
         (0, globals_1.expect)(res.success).toBe(true);
     });
-    (0, globals_1.it)('still rejects a NO_BLOCK assignment on a player who is not a starter', () => {
-        const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
-            blockingPreferences: [{ rotation: 1, targets: { DEF_R: { [reserve.id]: blocking_preference_1.NO_BLOCK } } }]
-        }));
-        (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 an unknown assignment string', () => {
+    (0, globals_1.it)('rejects an unknown commit function string', () => {
         const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
-            blockingPreferences: [{ rotation: 1, targets: { DEF_L: { [p4.id]: 'NO_BLOCKING' } } }]
+            blockingPreferences: [{ rotation: 1, commit: { [p4.id]: 'NOT_A_ROLE' } }]
         }));
         (0, globals_1.expect)(res.success).toBe(false);
     });

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

@@ -290,19 +290,21 @@ export declare const TeamInputSchema: z.ZodObject<{
         }, z.core.$strip>>>>;
         blockingPreferences: z.ZodDefault<z.ZodArray<z.ZodObject<{
             rotation: z.ZodNumber;
-            targets: z.ZodObject<{
-                DEF_L: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<typeof import("../../player").RoleEnum> & z.ZodType<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum, z.core.$ZodTypeInternals<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum>>, z.ZodLiteral<"NO_BLOCK">]>>>;
-                DEF_M: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<typeof import("../../player").RoleEnum> & z.ZodType<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum, z.core.$ZodTypeInternals<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum>>, z.ZodLiteral<"NO_BLOCK">]>>>;
-                DEF_R: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<typeof import("../../player").RoleEnum> & z.ZodType<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum, z.core.$ZodTypeInternals<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum>>, z.ZodLiteral<"NO_BLOCK">]>>>;
-            }, z.core.$strip>;
+            commit: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodEnum<typeof import("../../player").RoleEnum> & z.ZodType<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum, z.core.$ZodTypeInternals<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum>>>>;
+            noBlock: z.ZodDefault<z.ZodObject<{
+                DEF_L: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                DEF_M: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                DEF_R: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
         }, z.core.$strip>>>;
         blockingPreferenceSets: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodObject<{
             rotation: z.ZodNumber;
-            targets: z.ZodObject<{
-                DEF_L: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<typeof import("../../player").RoleEnum> & z.ZodType<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum, z.core.$ZodTypeInternals<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum>>, z.ZodLiteral<"NO_BLOCK">]>>>;
-                DEF_M: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<typeof import("../../player").RoleEnum> & z.ZodType<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum, z.core.$ZodTypeInternals<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum>>, z.ZodLiteral<"NO_BLOCK">]>>>;
-                DEF_R: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<typeof import("../../player").RoleEnum> & z.ZodType<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum, z.core.$ZodTypeInternals<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum>>, z.ZodLiteral<"NO_BLOCK">]>>>;
-            }, z.core.$strip>;
+            commit: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodEnum<typeof import("../../player").RoleEnum> & z.ZodType<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum, z.core.$ZodTypeInternals<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum>>>>;
+            noBlock: z.ZodDefault<z.ZodObject<{
+                DEF_L: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                DEF_M: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                DEF_R: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
         }, z.core.$strip>>>>;
         basePositions: z.ZodOptional<z.ZodObject<{
             coords: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{

package/dist/esm/src/api/index.d.ts CHANGED Viewed

@@ -1,4 +1,4 @@
-import { BaseConfig, 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, BlockingAssignment, DefenceFormation, CourtPosition, ConditionLogic, EnergyBand, MatchForfeitType, PerformanceStats, PinchCondition, RotationSystemEnum, SubBackMode, SubBand } from '../service';
+import { BaseConfig, 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, DefenceFormation, LineupFunction, CourtPosition, ConditionLogic, EnergyBand, MatchForfeitType, PerformanceStats, PinchCondition, RotationSystemEnum, SubBackMode, SubBand } from '../service';
 export * from './tactics-player-refs';
 export type Rally = DataProps<_Rally> & {
     homePlayerPosition: PlayerPosition[];
@@ -102,7 +102,8 @@ export interface ApiOffensivePreference {
 }
 export interface ApiBlockingPreference {
     rotation: number;
-    targets: Record<DefenceFormation, Record<string, BlockingAssignment>>;
+    commit: Record<string, LineupFunction>;
+    noBlock: Record<DefenceFormation, string[]>;
 }
 export interface ApiSystemSet {
     rotationSystem: RotationSystemEnum;

package/dist/esm/src/api/tactics-player-refs.d.ts CHANGED Viewed

@@ -2,8 +2,8 @@ import type { Tactics } from '.';
 /**
  * Every player id a tactics config references, anywhere: the six court slots and the libero, the bench, libero
  * replacements (flat and per-set), the second libero, designated subs and their per-set overrides, designated
- * setters (flat and per-set), the keys of the offensive-weight and blocking-target maps, injury replacements
- * and the libero-injury reserves.
+ * setters (flat and per-set), the keys of the offensive-weight map, the blocking commit + no-block ids, injury
+ * replacements and the libero-injury reserves.
  *
  * There is exactly ONE implementation of this on purpose. It backs three rules that must agree or a player
  * slips through: the dismiss/retire guard (a referenced player cannot be removed), the event rarity check

package/dist/esm/src/api/tactics-player-refs.js CHANGED Viewed

@@ -1,8 +1,8 @@
 /**
  * Every player id a tactics config references, anywhere: the six court slots and the libero, the bench, libero
  * replacements (flat and per-set), the second libero, designated subs and their per-set overrides, designated
- * setters (flat and per-set), the keys of the offensive-weight and blocking-target maps, injury replacements
- * and the libero-injury reserves.
+ * setters (flat and per-set), the keys of the offensive-weight map, the blocking commit + no-block ids, injury
+ * replacements and the libero-injury reserves.
  *
  * There is exactly ONE implementation of this on purpose. It backs three rules that must agree or a player
  * slips through: the dismiss/retire guard (a referenced player cannot be removed), the event rarity check
@@ -26,8 +26,8 @@ export function collectTacticsPlayerIds(config) {
         ...((config.offensivePreferences ?? []).flatMap(p => Object.keys(p.weights))),
         ...((config.systemSets ?? []).flatMap(s => s.designatedSetters)),
         ...((config.offensivePreferenceSets ?? []).flat().flatMap(p => Object.keys(p.weights))),
-        ...((config.blockingPreferences ?? []).flatMap(p => Object.values(p.targets).flatMap(m => Object.keys(m ?? {})))),
-        ...((config.blockingPreferenceSets ?? []).flat().flatMap(p => Object.values(p.targets).flatMap(m => Object.keys(m ?? {})))),
+        ...((config.blockingPreferences ?? []).flatMap(p => [...Object.keys(p.commit ?? {}), ...Object.values(p.noBlock ?? {}).flat()])),
+        ...((config.blockingPreferenceSets ?? []).flat().flatMap(p => [...Object.keys(p.commit ?? {}), ...Object.values(p.noBlock ?? {}).flat()])),
         // Injury replacements reference reserves (roster players outside the lineup); roster membership is the only
         // player check possible here (the schema enforces the bench/reserve role rules).
         ...((config.injuryReplacements ?? []).flatMap(ir => [ir.starterId, ir.replacementId, ir.benchBackfillId])),

package/dist/esm/src/data/models/tactics.d.ts CHANGED Viewed

@@ -1,7 +1,7 @@
 import * as Sequelize from 'sequelize';
 import { Model, Optional } from 'sequelize';
 import { PlayerId, TeamId, TeamModel } from '.';
-import { BaseConfig, BlockingAssignment, ConditionLogic, CourtPosition, DefenceFormation, EnergyBand, PinchCondition, RotationSystemEnum, SubBackMode, SubBand, SubMode } from '../../service';
+import { BaseConfig, ConditionLogic, CourtPosition, DefenceFormation, EnergyBand, LineupFunction, PinchCondition, RotationSystemEnum, SubBackMode, SubBand, SubMode } from '../../service';
 export interface TacticsLineupAttributes {
     [CourtPosition.LIBERO_ZONE]?: PlayerId;
     [CourtPosition.LEFT_BACK]: PlayerId;
@@ -36,7 +36,8 @@ export interface OffensivePreferenceAttributes {
 }
 export interface BlockingPreferenceAttributes {
     rotation: number;
-    targets: Record<DefenceFormation, Record<PlayerId, BlockingAssignment>>;
+    commit: Record<PlayerId, LineupFunction>;
+    noBlock: Record<DefenceFormation, PlayerId[]>;
 }
 export interface SystemSetAttributes {
     rotationSystem: RotationSystemEnum;

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

@@ -81,8 +81,8 @@ function transformToAttributes(tactics, teamId) {
         }))),
         serve_attack_shares: tactics.serveAttackShares ?? {},
         base_positions: tactics.basePositions,
-        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 }))),
+        blocking_preferences: tactics.blockingPreferences.map(p => ({ rotation: p.rotation, commit: p.commit, noBlock: p.noBlock })),
+        blocking_preference_sets: tactics.blockingPreferenceSets?.map(prefs => prefs.map(p => ({ rotation: p.rotation, commit: p.commit, noBlock: p.noBlock }))),
         replace_knocked_immediately: tactics.replaceKnockedImmediately,
         injury_replacements: tactics.injuryReplacements.map(ir => ({
             starterId: ir.starter.id,
@@ -203,8 +203,8 @@ function transformToObject(model, roster) {
             return healed;
         })(),
         basePositions: model.base_positions ?? undefined,
-        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 }))),
+        blockingPreferences: (model.blocking_preferences ?? []).map(p => ({ rotation: p.rotation, commit: p.commit, noBlock: p.noBlock })),
+        blockingPreferenceSets: model.blocking_preference_sets?.map(prefs => prefs.map(p => ({ rotation: p.rotation, commit: p.commit, noBlock: p.noBlock }))),
         // 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

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

@@ -1,6 +1,6 @@
 import { describe, it, expect } from '@jest/globals';
 import { tacticsColumnsToApiDto, transformFromTactics, transformToTactics } from './tactics';
-import { CourtPosition, EnergyBand, NO_BLOCK, RoleEnum, 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) {
@@ -262,37 +262,39 @@ describe('per-set tactics — service <-> row round-trip', () => {
         const back = transformToTactics(attrs, roster);
         expect(back.offensivePreferences[0].tempos).toEqual({ [p2.id]: 'FAST', [p3.id]: 'HIGH' });
     });
-    it('round-trips blocking preferences as per-defence-side id-keyed function maps', () => {
+    it('round-trips blocking preferences as a base commit map plus per-side no-block ids', () => {
         const withBlocking = Tactics.create({
             lineup: { 4: p4, 3: p3, 2: p2, 5: p5, 6: p6, 1: p1, bench: [] },
             liberoReplacements: [],
-            blockingPreferences: [{ rotation: 1, targets: { DEF_L: { [p4.id]: RoleEnum.OUTSIDE_HITTER }, DEF_R: { [p3.id]: RoleEnum.MIDDLE_BLOCKER } } }]
+            blockingPreferences: [{ rotation: 1, commit: { [p4.id]: RoleEnum.OUTSIDE_HITTER, [p3.id]: RoleEnum.MIDDLE_BLOCKER }, noBlock: { DEF_L: [p2.id] } }]
         });
         const attrs = transformFromTactics(withBlocking, 'team-1');
         expect(attrs.blocking_preferences).toEqual([
-            { rotation: 1, targets: { DEF_L: { [p4.id]: RoleEnum.OUTSIDE_HITTER }, DEF_M: {}, DEF_R: { [p3.id]: RoleEnum.MIDDLE_BLOCKER } } }
+            { rotation: 1, commit: { [p4.id]: RoleEnum.OUTSIDE_HITTER, [p3.id]: RoleEnum.MIDDLE_BLOCKER }, noBlock: { DEF_L: [p2.id], DEF_M: [], DEF_R: [] } }
         ]);
         const back = transformToTactics(attrs, roster);
-        expect(back.blockingPreferences[0].targets).toEqual({ DEF_L: { [p4.id]: RoleEnum.OUTSIDE_HITTER }, DEF_M: {}, DEF_R: { [p3.id]: RoleEnum.MIDDLE_BLOCKER } });
+        expect(back.blockingPreferences[0].commit).toEqual({ [p4.id]: RoleEnum.OUTSIDE_HITTER, [p3.id]: RoleEnum.MIDDLE_BLOCKER });
+        expect(back.blockingPreferences[0].noBlock).toEqual({ DEF_L: [p2.id], DEF_M: [], DEF_R: [] });
     });
-    // NO_BLOCK rides in the same targets map as a commit assignment, so the transformers copy it wholesale with no
-    // mapping code. This pins that: the sentinel must survive the row round-trip verbatim, mixed with a commit, and
-    // in the per-set overrides. If it ever gets translated or dropped, a player silently starts blocking again.
-    it('round-trips a NO_BLOCK assignment, mixed with a commit and in per-set overrides', () => {
+    // The base commit map (blind) and the per-side no-block ids are copied wholesale by the transformers with no
+    // mapping code. This pins that they survive the row round-trip verbatim, including in the per-set overrides. If a
+    // no-block id is ever translated or dropped, a player silently starts blocking again.
+    it('round-trips a base commit plus per-side no-block ids, including per-set overrides', () => {
         const withNoBlock = Tactics.create({
             lineup: { 4: p4, 3: p3, 2: p2, 5: p5, 6: p6, 1: p1, bench: [] },
             liberoReplacements: [],
-            blockingPreferences: [{ rotation: 1, targets: { DEF_M: { [p4.id]: NO_BLOCK, [p3.id]: RoleEnum.MIDDLE_BLOCKER } } }],
-            blockingPreferenceSets: [[{ rotation: 2, targets: { DEF_L: { [p2.id]: NO_BLOCK } } }]]
+            blockingPreferences: [{ rotation: 1, commit: { [p3.id]: RoleEnum.MIDDLE_BLOCKER }, noBlock: { DEF_M: [p4.id] } }],
+            blockingPreferenceSets: [[{ rotation: 2, noBlock: { DEF_L: [p2.id] } }]]
         });
         const attrs = transformFromTactics(withNoBlock, 'team-1');
         expect(attrs.blocking_preferences).toEqual([
-            { rotation: 1, targets: { DEF_L: {}, DEF_M: { [p4.id]: NO_BLOCK, [p3.id]: RoleEnum.MIDDLE_BLOCKER }, DEF_R: {} } }
+            { rotation: 1, commit: { [p3.id]: RoleEnum.MIDDLE_BLOCKER }, noBlock: { DEF_L: [], DEF_M: [p4.id], DEF_R: [] } }
         ]);
-        expect(attrs.blocking_preference_sets).toEqual([[{ rotation: 2, targets: { DEF_L: { [p2.id]: NO_BLOCK }, DEF_M: {}, DEF_R: {} } }]]);
+        expect(attrs.blocking_preference_sets).toEqual([[{ rotation: 2, commit: {}, noBlock: { DEF_L: [p2.id], DEF_M: [], DEF_R: [] } }]]);
         const back = transformToTactics(attrs, roster);
-        expect(back.blockingPreferences[0].targets).toEqual({ DEF_L: {}, DEF_M: { [p4.id]: NO_BLOCK, [p3.id]: RoleEnum.MIDDLE_BLOCKER }, DEF_R: {} });
-        expect(back.blockingPreferenceSets?.[0][0].targets).toEqual({ DEF_L: { [p2.id]: NO_BLOCK }, DEF_M: {}, DEF_R: {} });
+        expect(back.blockingPreferences[0].commit).toEqual({ [p3.id]: RoleEnum.MIDDLE_BLOCKER });
+        expect(back.blockingPreferences[0].noBlock).toEqual({ DEF_L: [], DEF_M: [p4.id], DEF_R: [] });
+        expect(back.blockingPreferenceSets?.[0][0].noBlock).toEqual({ DEF_L: [p2.id], DEF_M: [], DEF_R: [] });
     });
 });
 describe('libero injuries — service <-> row round-trip + lenient heal', () => {

package/dist/esm/src/service/event/schemas/set.z.js CHANGED Viewed

@@ -2,7 +2,7 @@ import { z } from 'zod';
 import { TraitEnum } from '../../player';
 import { EventIncidentSchema } from './incident.z';
 import { positionalEventFields } from './positional.z';
-const setTypeValues = [0, 1];
+const setTypeValues = [0, 1, 2]; // OVERHAND, DUMP, BUMP
 const setFailureValues = [0, 1, 2, 3, 4];
 const setTempoValues = [0, 1, 2];
 const courtTargetValues = Array.from({ length: 13 }, (_, i) => i);

package/dist/esm/src/service/event/set.d.ts CHANGED Viewed

@@ -1,9 +1,10 @@
 import { InPlayEvent } from './in-play-event';
 export declare enum SetTypeEnum {
     OVERHAND = 0,
-    DUMP = 1
+    DUMP = 1,
+    BUMP = 2
 }
-export type SetType = SetTypeEnum.OVERHAND | SetTypeEnum.DUMP;
+export type SetType = SetTypeEnum.OVERHAND | SetTypeEnum.BUMP | SetTypeEnum.DUMP;
 export declare enum SetTempoEnum {
     FIRST = 0,
     SECOND = 1,

package/dist/esm/src/service/event/set.js CHANGED Viewed

@@ -5,6 +5,10 @@ export var SetTypeEnum;
 (function (SetTypeEnum) {
     SetTypeEnum[SetTypeEnum["OVERHAND"] = 0] = "OVERHAND";
     SetTypeEnum[SetTypeEnum["DUMP"] = 1] = "DUMP";
+    // A forearm (bump) set, used when the pass is off the net (owner 2026-08-11). OVERHAND and BUMP are both normal
+    // sets and behave identically for metrics (assist, first-attack); they differ only by technique (which stat graded
+    // the set) and their play-by-play label. DUMP remains the setter's own second-ball attack.
+    SetTypeEnum[SetTypeEnum["BUMP"] = 2] = "BUMP";
 })(SetTypeEnum || (SetTypeEnum = {}));
 // The tempo of a set (set-tempo rework). Decided by the simulator (pass quality + target lane + setter skill)
 // or forced by a per-player offensive preference. FIRST = quick (swings the `quick` stat, hardest to nail,

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

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

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

@@ -1,7 +1 @@
-// A front-row player opted OUT of blocking for this rotation. They never join the wall under any circumstance:
-// not as the lead blocker (the lane's next-nearest front-row player leads instead), not as a side blocker, and
-// no trait can coerce them in -- MOVING_WALL's guaranteed lead hand, its beaten-read hand and its side-joiner
-// roll are all suppressed, as is a dedicated-blocking commit. Sits in the same `targets` map as a commit
-// assignment, so the two are mutually exclusive by construction: a player is reading, committed, or out.
-export const NO_BLOCK = 'NO_BLOCK';
 export const DEFENCE_FORMATIONS = ['DEF_L', 'DEF_M', 'DEF_R'];

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

@@ -282,19 +282,21 @@ export declare const TacticsInputSchema: z.ZodObject<{
     }, z.core.$strip>>>>;
     blockingPreferences: z.ZodDefault<z.ZodArray<z.ZodObject<{
         rotation: z.ZodNumber;
-        targets: z.ZodObject<{
-            DEF_L: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<typeof RoleEnum> & z.ZodType<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum, z.core.$ZodTypeInternals<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum>>, z.ZodLiteral<"NO_BLOCK">]>>>;
-            DEF_M: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<typeof RoleEnum> & z.ZodType<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum, z.core.$ZodTypeInternals<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum>>, z.ZodLiteral<"NO_BLOCK">]>>>;
-            DEF_R: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<typeof RoleEnum> & z.ZodType<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum, z.core.$ZodTypeInternals<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum>>, z.ZodLiteral<"NO_BLOCK">]>>>;
-        }, z.core.$strip>;
+        commit: z.ZodDefault<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>>>>;
+        noBlock: z.ZodDefault<z.ZodObject<{
+            DEF_L: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            DEF_M: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            DEF_R: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>>;
     blockingPreferenceSets: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodObject<{
         rotation: z.ZodNumber;
-        targets: z.ZodObject<{
-            DEF_L: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<typeof RoleEnum> & z.ZodType<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum, z.core.$ZodTypeInternals<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum>>, z.ZodLiteral<"NO_BLOCK">]>>>;
-            DEF_M: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<typeof RoleEnum> & z.ZodType<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum, z.core.$ZodTypeInternals<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum>>, z.ZodLiteral<"NO_BLOCK">]>>>;
-            DEF_R: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<typeof RoleEnum> & z.ZodType<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum, z.core.$ZodTypeInternals<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum>>, z.ZodLiteral<"NO_BLOCK">]>>>;
-        }, z.core.$strip>;
+        commit: z.ZodDefault<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>>>>;
+        noBlock: z.ZodDefault<z.ZodObject<{
+            DEF_L: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            DEF_M: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            DEF_R: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>>>;
     basePositions: z.ZodOptional<z.ZodObject<{
         coords: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{

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

@@ -1,6 +1,5 @@
 import { z } from 'zod';
 import { Player, RoleEnum } from '../../player';
-import { NO_BLOCK } from '../blocking-preference';
 import { EnergyBand } from '../energy-band';
 import { RotationSystemEnum, setterCountFor } from '../rotation-system';
 import { DesignatedSubSchema, SubBandSchema } from './designated-sub.z';
@@ -57,24 +56,23 @@ const offensivePreferenceSchema = z.object({
     weights: z.record(z.string(), z.number().int().min(0)),
     tempos: z.record(z.string(), tempoPreferenceSchema).optional()
 });
-// What a front-row starter can be assigned: an opposing attacking function to commit to (every RoleEnum except
-// the libero, which never attacks), or NO_BLOCK to sit the rotation out of the block entirely.
-const blockingFunctionSchema = z.union([
-    z.nativeEnum(RoleEnum).refine((v) => v !== RoleEnum.LIBERO, { message: 'BLOCKING_TARGET_CANNOT_BE_LIBERO' }),
-    z.literal(NO_BLOCK)
-]);
-// One rotation's dedicated-blocking assignments: `targets` maps my front-row starter ids to the opposing function
-// each commits to block. Cross-field checks (keys are starters) live in the superRefine below.
-const blockingTargetsSchema = z.record(z.string(), blockingFunctionSchema);
-// Per point-of-attack defence (owner 2026-08-06): a separate front-row commit map for an attack from my left /
-// middle / right. Each defaults to {} so a partial config stays valid.
+// An opposing attacking function a front-row starter can commit to (every RoleEnum except the libero, which never
+// attacks). The commit is the BLIND, pre-set Defence-base choice (owner 2026-08-10).
+const commitFunctionSchema = z.nativeEnum(RoleEnum).refine((v) => v !== RoleEnum.LIBERO, { message: 'BLOCKING_TARGET_CANNOT_BE_LIBERO' });
+// One rotation's blocking config (owner 2026-08-10). `commit` maps my front-row starter ids to the opposing function
+// each commits to (blind, rotation-wide; absent = reads); `noBlock` lists, per point-of-attack defence, the front-row
+// starters that sit out of the block for an attack from that side (overrides the commit for that side). Each side
+// defaults to [] so a partial config stays valid. Cross-field checks (keys/ids are starters) live in the superRefine.
+const commitSchema = z.record(z.string(), commitFunctionSchema);
+const noBlockSchema = z.object({
+    DEF_L: z.array(z.string()).default([]),
+    DEF_M: z.array(z.string()).default([]),
+    DEF_R: z.array(z.string()).default([])
+});
 const blockingPreferenceSchema = z.object({
     rotation: z.number().int().min(1).max(6),
-    targets: z.object({
-        DEF_L: blockingTargetsSchema.default({}),
-        DEF_M: blockingTargetsSchema.default({}),
-        DEF_R: blockingTargetsSchema.default({})
-    })
+    commit: commitSchema.default({}),
+    noBlock: noBlockSchema.default({ DEF_L: [], DEF_M: [], DEF_R: [] })
 });
 // One set's rotation-system override (per-set tactics): system + its designated setters travel together.
 const systemSetSchema = z.object({
@@ -211,8 +209,9 @@ export const TacticsInputSchema = 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.
+    // Blocking preferences: unique rotations; every committer id (base commit) and every no-block id (per side) keys
+    // an on-court starter (the UI only offers front-row players, the schema checks starters). The commit function is
+    // validated by commitFunctionSchema.
     const validateBlockingPreferences = (preferences, path) => {
         const seenRotations = new Set();
         for (const pref of preferences) {
@@ -220,8 +219,13 @@ export const TacticsInputSchema = z.object({
                 ctx.addIssue({ code: 'custom', message: 'BLOCKING_PREFERENCE_DUPLICATE_ROTATION', path });
             }
             seenRotations.add(pref.rotation);
+            for (const id of Object.keys(pref.commit)) {
+                if (!starterIds.has(id)) {
+                    ctx.addIssue({ code: 'custom', message: 'BLOCKING_PREFERENCE_BLOCKER_NOT_A_STARTER', path });
+                }
+            }
             for (const form of ['DEF_L', 'DEF_M', 'DEF_R']) {
-                for (const id of Object.keys(pref.targets[form] ?? {})) {
+                for (const id of pref.noBlock[form] ?? []) {
                     if (!starterIds.has(id)) {
                         ctx.addIssue({ code: 'custom', message: 'BLOCKING_PREFERENCE_BLOCKER_NOT_A_STARTER', path });
                     }

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

@@ -1,6 +1,5 @@
 import { describe, it, expect } from '@jest/globals';
 import { TacticsInputSchema } from './tactics.z';
-import { NO_BLOCK } from '../blocking-preference';
 import { RoleEnum } from '../../player';
 import { makeCountry, makePlayer } from '../../test-helpers';
 describe('TacticsInputSchema — second libero rules', () => {
@@ -234,40 +233,49 @@ describe('TacticsInputSchema — blocking preferences', () => {
             ...overrides
         };
     }
-    it('accepts a blocking preference that keys starters to attacking functions, per defence side', () => {
+    it('accepts a blocking preference that commits starters to attacking functions', () => {
         const res = TacticsInputSchema.safeParse(baseInput({
-            blockingPreferences: [{ rotation: 1, targets: { DEF_L: { [p4.id]: RoleEnum.OUTSIDE_HITTER }, DEF_M: {}, DEF_R: { [p3.id]: RoleEnum.MIDDLE_BLOCKER } } }]
+            blockingPreferences: [{ rotation: 1, commit: { [p4.id]: RoleEnum.OUTSIDE_HITTER, [p3.id]: RoleEnum.MIDDLE_BLOCKER }, noBlock: { DEF_L: [], DEF_M: [], DEF_R: [] } }]
         }));
         expect(res.success).toBe(true);
         if (res.success) {
-            expect(res.data.blockingPreferences[0].targets.DEF_L[p4.id]).toBe(RoleEnum.OUTSIDE_HITTER);
-            expect(res.data.blockingPreferences[0].targets.DEF_R[p3.id]).toBe(RoleEnum.MIDDLE_BLOCKER);
-            expect(res.data.blockingPreferences[0].targets.DEF_M).toEqual({}); // the middle side is independent (empty here)
+            expect(res.data.blockingPreferences[0].commit[p4.id]).toBe(RoleEnum.OUTSIDE_HITTER);
+            expect(res.data.blockingPreferences[0].commit[p3.id]).toBe(RoleEnum.MIDDLE_BLOCKER);
         }
     });
-    it('defaults the omitted defence sides to empty maps', () => {
+    it('defaults an omitted commit to empty and omitted no-block sides to empty arrays', () => {
         const res = TacticsInputSchema.safeParse(baseInput({
-            blockingPreferences: [{ rotation: 1, targets: { DEF_L: { [p4.id]: NO_BLOCK } } }]
+            blockingPreferences: [{ rotation: 1, noBlock: { DEF_L: [p4.id] } }]
         }));
         expect(res.success).toBe(true);
         if (res.success) {
-            expect(res.data.blockingPreferences[0].targets.DEF_L[p4.id]).toBe(NO_BLOCK);
-            expect(res.data.blockingPreferences[0].targets.DEF_M).toEqual({});
-            expect(res.data.blockingPreferences[0].targets.DEF_R).toEqual({});
+            expect(res.data.blockingPreferences[0].commit).toEqual({});
+            expect(res.data.blockingPreferences[0].noBlock.DEF_L).toEqual([p4.id]);
+            expect(res.data.blockingPreferences[0].noBlock.DEF_M).toEqual([]);
+            expect(res.data.blockingPreferences[0].noBlock.DEF_R).toEqual([]);
         }
     });
-    it('rejects a blocking target (on any side) that is not a starter', () => {
+    it('rejects a commit id that is not a starter', () => {
         const res = TacticsInputSchema.safeParse(baseInput({
-            blockingPreferences: [{ rotation: 1, targets: { DEF_M: { [reserve.id]: RoleEnum.OUTSIDE_HITTER } } }]
+            blockingPreferences: [{ rotation: 1, commit: { [reserve.id]: RoleEnum.OUTSIDE_HITTER } }]
         }));
         expect(res.success).toBe(false);
         if (!res.success) {
             expect(res.error.issues.some(i => i.message === 'BLOCKING_PREFERENCE_BLOCKER_NOT_A_STARTER')).toBe(true);
         }
     });
-    it('rejects a blocking target function of libero', () => {
+    it('rejects a no-block id (on any side) that is not a starter', () => {
         const res = TacticsInputSchema.safeParse(baseInput({
-            blockingPreferences: [{ rotation: 1, targets: { DEF_L: { [p4.id]: RoleEnum.LIBERO } } }]
+            blockingPreferences: [{ rotation: 1, noBlock: { DEF_M: [reserve.id] } }]
+        }));
+        expect(res.success).toBe(false);
+        if (!res.success) {
+            expect(res.error.issues.some(i => i.message === 'BLOCKING_PREFERENCE_BLOCKER_NOT_A_STARTER')).toBe(true);
+        }
+    });
+    it('rejects a commit function of libero', () => {
+        const res = TacticsInputSchema.safeParse(baseInput({
+            blockingPreferences: [{ rotation: 1, commit: { [p4.id]: RoleEnum.LIBERO } }]
         }));
         expect(res.success).toBe(false);
         if (!res.success) {
@@ -277,8 +285,8 @@ describe('TacticsInputSchema — blocking preferences', () => {
     it('rejects a duplicate rotation in blocking preferences', () => {
         const res = TacticsInputSchema.safeParse(baseInput({
             blockingPreferences: [
-                { rotation: 1, targets: { DEF_L: { [p4.id]: RoleEnum.OUTSIDE_HITTER } } },
-                { rotation: 1, targets: { DEF_M: { [p3.id]: RoleEnum.MIDDLE_BLOCKER } } }
+                { rotation: 1, commit: { [p4.id]: RoleEnum.OUTSIDE_HITTER } },
+                { rotation: 1, commit: { [p3.id]: RoleEnum.MIDDLE_BLOCKER } }
             ]
         }));
         expect(res.success).toBe(false);
@@ -288,38 +296,29 @@ describe('TacticsInputSchema — blocking preferences', () => {
     });
     it('accepts per-set blocking preference overrides', () => {
         const res = TacticsInputSchema.safeParse(baseInput({
-            blockingPreferenceSets: [[{ rotation: 1, targets: { DEF_R: { [p4.id]: RoleEnum.OPPOSITE_HITTER } } }], []]
+            blockingPreferenceSets: [[{ rotation: 1, commit: { [p4.id]: RoleEnum.OPPOSITE_HITTER } }], []]
         }));
         expect(res.success).toBe(true);
     });
-    it('accepts NO_BLOCK as an assignment, alongside a commit on another starter, on the same side', () => {
+    it('accepts a starter committed on the base AND no-blocked on a side (no-block overrides commit there)', () => {
         const res = TacticsInputSchema.safeParse(baseInput({
-            blockingPreferences: [{ rotation: 1, targets: { DEF_L: { [p4.id]: NO_BLOCK, [p3.id]: RoleEnum.MIDDLE_BLOCKER } } }]
+            blockingPreferences: [{ rotation: 1, commit: { [p3.id]: RoleEnum.MIDDLE_BLOCKER }, noBlock: { DEF_L: [p3.id] } }]
         }));
         expect(res.success).toBe(true);
         if (res.success) {
-            expect(res.data.blockingPreferences[0].targets.DEF_L[p4.id]).toBe(NO_BLOCK);
-            expect(res.data.blockingPreferences[0].targets.DEF_L[p3.id]).toBe(RoleEnum.MIDDLE_BLOCKER);
+            expect(res.data.blockingPreferences[0].commit[p3.id]).toBe(RoleEnum.MIDDLE_BLOCKER);
+            expect(res.data.blockingPreferences[0].noBlock.DEF_L).toEqual([p3.id]);
         }
     });
-    it('accepts NO_BLOCK in a per-set override', () => {
+    it('accepts a no-block in a per-set override', () => {
         const res = TacticsInputSchema.safeParse(baseInput({
-            blockingPreferenceSets: [[{ rotation: 1, targets: { DEF_M: { [p4.id]: NO_BLOCK } } }], []]
+            blockingPreferenceSets: [[{ rotation: 1, noBlock: { DEF_M: [p4.id] } }], []]
         }));
         expect(res.success).toBe(true);
     });
-    it('still rejects a NO_BLOCK assignment on a player who is not a starter', () => {
-        const res = TacticsInputSchema.safeParse(baseInput({
-            blockingPreferences: [{ rotation: 1, targets: { DEF_R: { [reserve.id]: NO_BLOCK } } }]
-        }));
-        expect(res.success).toBe(false);
-        if (!res.success) {
-            expect(res.error.issues.some(i => i.message === 'BLOCKING_PREFERENCE_BLOCKER_NOT_A_STARTER')).toBe(true);
-        }
-    });
-    it('rejects an unknown assignment string', () => {
+    it('rejects an unknown commit function string', () => {
         const res = TacticsInputSchema.safeParse(baseInput({
-            blockingPreferences: [{ rotation: 1, targets: { DEF_L: { [p4.id]: 'NO_BLOCKING' } } }]
+            blockingPreferences: [{ rotation: 1, commit: { [p4.id]: 'NOT_A_ROLE' } }]
         }));
         expect(res.success).toBe(false);
     });

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

@@ -290,19 +290,21 @@ export declare const TeamInputSchema: z.ZodObject<{
         }, z.core.$strip>>>>;
         blockingPreferences: z.ZodDefault<z.ZodArray<z.ZodObject<{
             rotation: z.ZodNumber;
-            targets: z.ZodObject<{
-                DEF_L: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<typeof import("../../player").RoleEnum> & z.ZodType<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum, z.core.$ZodTypeInternals<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum>>, z.ZodLiteral<"NO_BLOCK">]>>>;
-                DEF_M: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<typeof import("../../player").RoleEnum> & z.ZodType<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum, z.core.$ZodTypeInternals<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum>>, z.ZodLiteral<"NO_BLOCK">]>>>;
-                DEF_R: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<typeof import("../../player").RoleEnum> & z.ZodType<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum, z.core.$ZodTypeInternals<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum>>, z.ZodLiteral<"NO_BLOCK">]>>>;
-            }, z.core.$strip>;
+            commit: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodEnum<typeof import("../../player").RoleEnum> & z.ZodType<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum, z.core.$ZodTypeInternals<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum>>>>;
+            noBlock: z.ZodDefault<z.ZodObject<{
+                DEF_L: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                DEF_M: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                DEF_R: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
         }, z.core.$strip>>>;
         blockingPreferenceSets: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodObject<{
             rotation: z.ZodNumber;
-            targets: z.ZodObject<{
-                DEF_L: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<typeof import("../../player").RoleEnum> & z.ZodType<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum, z.core.$ZodTypeInternals<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum>>, z.ZodLiteral<"NO_BLOCK">]>>>;
-                DEF_M: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<typeof import("../../player").RoleEnum> & z.ZodType<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum, z.core.$ZodTypeInternals<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum>>, z.ZodLiteral<"NO_BLOCK">]>>>;
-                DEF_R: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<typeof import("../../player").RoleEnum> & z.ZodType<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum, z.core.$ZodTypeInternals<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum>>, z.ZodLiteral<"NO_BLOCK">]>>>;
-            }, z.core.$strip>;
+            commit: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodEnum<typeof import("../../player").RoleEnum> & z.ZodType<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum, z.core.$ZodTypeInternals<import("../../player").RoleEnum.SETTER | import("../../player").RoleEnum.OUTSIDE_HITTER | import("../../player").RoleEnum.OPPOSITE_HITTER | import("../../player").RoleEnum.MIDDLE_BLOCKER, import("../../player").RoleEnum>>>>;
+            noBlock: z.ZodDefault<z.ZodObject<{
+                DEF_L: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                DEF_M: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                DEF_R: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
         }, z.core.$strip>>>>;
         basePositions: z.ZodOptional<z.ZodObject<{
             coords: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{

package/package.json CHANGED Viewed

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