volleyballsimtypes 0.0.489 → 0.0.491

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

@@ -1,4 +1,4 @@
-import { BoxScore, DataProps, DeclineStatus, Division as _Division, League as _League, Match as _Match, MatchSet as _MatchSet, Player as _Player, PlayerPosition, Qualifier as _Qualifier, QualifierMatch as _QualifierMatch, Rally as _Rally, RallyEvent as _RallyEvent, PointBreakdown, RallyMetrics, Season as _Season, Standing as _Standing, Team as _Team, Tournament as _Tournament, TournamentMatch as _TournamentMatch, National as _National, NationalMatch as _NationalMatch, Country as _Country, CourtPosition, ConditionLogic, EnergyBand, MatchForfeitType, PerformanceStats, PinchCondition, RoleEnum, RotationSystemEnum, SubBackMode, SubBand } from '../service';
+import { BoxScore, DataProps, DeclineStatus, Division as _Division, League as _League, Match as _Match, MatchSet as _MatchSet, Player as _Player, PlayerPosition, Qualifier as _Qualifier, QualifierMatch as _QualifierMatch, Rally as _Rally, RallyEvent as _RallyEvent, PointBreakdown, RallyMetrics, Season as _Season, Standing as _Standing, Team as _Team, Tournament as _Tournament, TournamentMatch as _TournamentMatch, National as _National, NationalMatch as _NationalMatch, Country as _Country, BlockingAssignment, CourtPosition, ConditionLogic, EnergyBand, MatchForfeitType, PerformanceStats, PinchCondition, RotationSystemEnum, SubBackMode, SubBand } from '../service';
 export type Rally = DataProps<_Rally> & {
     homePlayerPosition: PlayerPosition[];
     awayPlayerPosition: PlayerPosition[];
@@ -101,7 +101,7 @@ export interface ApiOffensivePreference {
 }
 export interface ApiBlockingPreference {
     rotation: number;
-    targets: Record<string, RoleEnum>;
+    targets: Record<string, BlockingAssignment>;
 }
 export interface ApiSystemSet {
     rotationSystem: RotationSystemEnum;

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

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

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

@@ -216,6 +216,25 @@ function makeTactics(designatedSubs) {
         const back = (0, tactics_1.transformToTactics)(attrs, roster);
         (0, globals_1.expect)(back.blockingPreferences[0].targets).toEqual({ [p4.id]: service_1.RoleEnum.OUTSIDE_HITTER, [p3.id]: service_1.RoleEnum.MIDDLE_BLOCKER });
     });
+    // 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', () => {
+        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: { [p4.id]: service_1.NO_BLOCK, [p3.id]: service_1.RoleEnum.MIDDLE_BLOCKER } }],
+            blockingPreferenceSets: [[{ rotation: 2, targets: { [p2.id]: service_1.NO_BLOCK } }]]
+        });
+        const attrs = (0, tactics_1.transformFromTactics)(withNoBlock, 'team-1');
+        (0, globals_1.expect)(attrs.blocking_preferences).toEqual([
+            { rotation: 1, targets: { [p4.id]: service_1.NO_BLOCK, [p3.id]: service_1.RoleEnum.MIDDLE_BLOCKER } }
+        ]);
+        (0, globals_1.expect)(attrs.blocking_preference_sets).toEqual([[{ rotation: 2, targets: { [p2.id]: service_1.NO_BLOCK } }]]);
+        const back = (0, tactics_1.transformToTactics)(attrs, roster);
+        (0, globals_1.expect)(back.blockingPreferences[0].targets).toEqual({ [p4.id]: service_1.NO_BLOCK, [p3.id]: service_1.RoleEnum.MIDDLE_BLOCKER });
+        (0, globals_1.expect)(back.blockingPreferenceSets?.[0][0].targets).toEqual({ [p2.id]: service_1.NO_BLOCK });
+    });
 });
 (0, globals_1.describe)('libero injuries — service <-> row round-trip + lenient heal', () => {
     const country = (0, test_helpers_1.makeCountry)();

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

@@ -1,5 +1,7 @@
 import { LineupFunction } from './lineup-function';
+export declare const NO_BLOCK: "NO_BLOCK";
+export type BlockingAssignment = LineupFunction | typeof NO_BLOCK;
 export interface BlockingPreference {
     readonly rotation: number;
-    readonly targets: Record<string, LineupFunction>;
+    readonly targets: Record<string, BlockingAssignment>;
 }

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

@@ -1,2 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+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';

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

@@ -281,11 +281,11 @@ export declare const TacticsInputSchema: z.ZodObject<{
     }, z.core.$strip>>>>;
     blockingPreferences: z.ZodDefault<z.ZodArray<z.ZodObject<{
         rotation: z.ZodNumber;
-        targets: z.ZodRecord<z.ZodString, z.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>>>;
+        targets: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<typeof RoleEnum> & z.ZodType<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum, z.core.$ZodTypeInternals<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum>>, z.ZodLiteral<"NO_BLOCK">]>>;
     }, z.core.$strip>>>;
     blockingPreferenceSets: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodObject<{
         rotation: z.ZodNumber;
-        targets: z.ZodRecord<z.ZodString, z.ZodEnum<typeof RoleEnum> & z.ZodType<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum, z.core.$ZodTypeInternals<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum>>>;
+        targets: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<typeof RoleEnum> & z.ZodType<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum, z.core.$ZodTypeInternals<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum>>, z.ZodLiteral<"NO_BLOCK">]>>;
     }, z.core.$strip>>>>;
     replaceKnockedImmediately: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
     injuryReplacements: z.ZodDefault<z.ZodArray<z.ZodObject<{

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

@@ -3,6 +3,7 @@ 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");
@@ -59,8 +60,12 @@ 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()
 });
-// The opposing attacking functions a dedicated blocker can commit to: every RoleEnum except the libero.
-const blockingFunctionSchema = zod_1.z.nativeEnum(player_1.RoleEnum).refine((v) => v !== player_1.RoleEnum.LIBERO, { message: 'BLOCKING_TARGET_CANNOT_BE_LIBERO' });
+// 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 blockingPreferenceSchema = zod_1.z.object({

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const globals_1 = require("@jest/globals");
 const tactics_z_1 = require("./tactics.z");
+const 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', () => {
@@ -280,4 +281,35 @@ const test_helpers_1 = require("../../test-helpers");
         }));
         (0, globals_1.expect)(res.success).toBe(true);
     });
+    (0, globals_1.it)('accepts NO_BLOCK as an assignment, alongside a commit on another starter', () => {
+        const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
+            blockingPreferences: [{ rotation: 1, targets: { [p4.id]: blocking_preference_1.NO_BLOCK, [p3.id]: player_1.RoleEnum.MIDDLE_BLOCKER } }]
+        }));
+        (0, globals_1.expect)(res.success).toBe(true);
+        if (res.success) {
+            (0, globals_1.expect)(res.data.blockingPreferences[0].targets[p4.id]).toBe(blocking_preference_1.NO_BLOCK);
+            (0, globals_1.expect)(res.data.blockingPreferences[0].targets[p3.id]).toBe(player_1.RoleEnum.MIDDLE_BLOCKER);
+        }
+    });
+    (0, globals_1.it)('accepts NO_BLOCK in a per-set override', () => {
+        const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
+            blockingPreferenceSets: [[{ rotation: 1, targets: { [p4.id]: blocking_preference_1.NO_BLOCK } }], []]
+        }));
+        (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: { [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', () => {
+        const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
+            blockingPreferences: [{ rotation: 1, targets: { [p4.id]: 'NO_BLOCKING' } }]
+        }));
+        (0, globals_1.expect)(res.success).toBe(false);
+    });
 });

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

@@ -289,11 +289,11 @@ export declare const TeamInputSchema: z.ZodObject<{
         }, z.core.$strip>>>>;
         blockingPreferences: z.ZodDefault<z.ZodArray<z.ZodObject<{
             rotation: z.ZodNumber;
-            targets: 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>>>;
+            targets: 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>>>;
         blockingPreferenceSets: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodObject<{
             rotation: z.ZodNumber;
-            targets: 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>>>;
+            targets: 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>>>>;
         replaceKnockedImmediately: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
         injuryReplacements: z.ZodDefault<z.ZodArray<z.ZodObject<{

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

@@ -1,4 +1,4 @@
-import { BoxScore, DataProps, DeclineStatus, Division as _Division, League as _League, Match as _Match, MatchSet as _MatchSet, Player as _Player, PlayerPosition, Qualifier as _Qualifier, QualifierMatch as _QualifierMatch, Rally as _Rally, RallyEvent as _RallyEvent, PointBreakdown, RallyMetrics, Season as _Season, Standing as _Standing, Team as _Team, Tournament as _Tournament, TournamentMatch as _TournamentMatch, National as _National, NationalMatch as _NationalMatch, Country as _Country, CourtPosition, ConditionLogic, EnergyBand, MatchForfeitType, PerformanceStats, PinchCondition, RoleEnum, RotationSystemEnum, SubBackMode, SubBand } from '../service';
+import { BoxScore, DataProps, DeclineStatus, Division as _Division, League as _League, Match as _Match, MatchSet as _MatchSet, Player as _Player, PlayerPosition, Qualifier as _Qualifier, QualifierMatch as _QualifierMatch, Rally as _Rally, RallyEvent as _RallyEvent, PointBreakdown, RallyMetrics, Season as _Season, Standing as _Standing, Team as _Team, Tournament as _Tournament, TournamentMatch as _TournamentMatch, National as _National, NationalMatch as _NationalMatch, Country as _Country, BlockingAssignment, CourtPosition, ConditionLogic, EnergyBand, MatchForfeitType, PerformanceStats, PinchCondition, RotationSystemEnum, SubBackMode, SubBand } from '../service';
 export type Rally = DataProps<_Rally> & {
     homePlayerPosition: PlayerPosition[];
     awayPlayerPosition: PlayerPosition[];
@@ -101,7 +101,7 @@ export interface ApiOffensivePreference {
 }
 export interface ApiBlockingPreference {
     rotation: number;
-    targets: Record<string, RoleEnum>;
+    targets: Record<string, BlockingAssignment>;
 }
 export interface ApiSystemSet {
     rotationSystem: RotationSystemEnum;

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, PinchCondition, RoleEnum, RotationSystemEnum, SubBackMode, SubBand, SubMode } from '../../service';
+import { BlockingAssignment, ConditionLogic, CourtPosition, EnergyBand, PinchCondition, RotationSystemEnum, SubBackMode, SubBand, SubMode } from '../../service';
 export interface TacticsLineupAttributes {
     [CourtPosition.LIBERO_ZONE]?: PlayerId;
     [CourtPosition.LEFT_BACK]: PlayerId;
@@ -36,7 +36,7 @@ export interface OffensivePreferenceAttributes {
 }
 export interface BlockingPreferenceAttributes {
     rotation: number;
-    targets: Record<PlayerId, RoleEnum>;
+    targets: Record<PlayerId, BlockingAssignment>;
 }
 export interface SystemSetAttributes {
     rotationSystem: RotationSystemEnum;

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, RoleEnum, RotationSystemEnum, Tactics } from '../../service';
+import { CourtPosition, EnergyBand, NO_BLOCK, 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) {
@@ -214,6 +214,25 @@ describe('per-set tactics — service <-> row round-trip', () => {
         const back = transformToTactics(attrs, roster);
         expect(back.blockingPreferences[0].targets).toEqual({ [p4.id]: RoleEnum.OUTSIDE_HITTER, [p3.id]: RoleEnum.MIDDLE_BLOCKER });
     });
+    // NO_BLOCK rides in the same targets map as a commit assignment, so the transformers copy it wholesale with no
+    // mapping code. This pins that: the sentinel must survive the row round-trip verbatim, mixed with a commit, and
+    // 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', () => {
+        const withNoBlock = Tactics.create({
+            lineup: { 4: p4, 3: p3, 2: p2, 5: p5, 6: p6, 1: p1, bench: [] },
+            liberoReplacements: [],
+            blockingPreferences: [{ rotation: 1, targets: { [p4.id]: NO_BLOCK, [p3.id]: RoleEnum.MIDDLE_BLOCKER } }],
+            blockingPreferenceSets: [[{ rotation: 2, targets: { [p2.id]: NO_BLOCK } }]]
+        });
+        const attrs = transformFromTactics(withNoBlock, 'team-1');
+        expect(attrs.blocking_preferences).toEqual([
+            { rotation: 1, targets: { [p4.id]: NO_BLOCK, [p3.id]: RoleEnum.MIDDLE_BLOCKER } }
+        ]);
+        expect(attrs.blocking_preference_sets).toEqual([[{ rotation: 2, targets: { [p2.id]: NO_BLOCK } }]]);
+        const back = transformToTactics(attrs, roster);
+        expect(back.blockingPreferences[0].targets).toEqual({ [p4.id]: NO_BLOCK, [p3.id]: RoleEnum.MIDDLE_BLOCKER });
+        expect(back.blockingPreferenceSets?.[0][0].targets).toEqual({ [p2.id]: NO_BLOCK });
+    });
 });
 describe('libero injuries — service <-> row round-trip + lenient heal', () => {
     const country = makeCountry();

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

@@ -1,5 +1,7 @@
 import { LineupFunction } from './lineup-function';
+export declare const NO_BLOCK: "NO_BLOCK";
+export type BlockingAssignment = LineupFunction | typeof NO_BLOCK;
 export interface BlockingPreference {
     readonly rotation: number;
-    readonly targets: Record<string, LineupFunction>;
+    readonly targets: Record<string, BlockingAssignment>;
 }

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

@@ -1 +1,6 @@
-export {};
+// 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';

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

@@ -281,11 +281,11 @@ export declare const TacticsInputSchema: z.ZodObject<{
     }, z.core.$strip>>>>;
     blockingPreferences: z.ZodDefault<z.ZodArray<z.ZodObject<{
         rotation: z.ZodNumber;
-        targets: z.ZodRecord<z.ZodString, z.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>>>;
+        targets: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<typeof RoleEnum> & z.ZodType<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum, z.core.$ZodTypeInternals<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum>>, z.ZodLiteral<"NO_BLOCK">]>>;
     }, z.core.$strip>>>;
     blockingPreferenceSets: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodObject<{
         rotation: z.ZodNumber;
-        targets: z.ZodRecord<z.ZodString, z.ZodEnum<typeof RoleEnum> & z.ZodType<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum, z.core.$ZodTypeInternals<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum>>>;
+        targets: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<typeof RoleEnum> & z.ZodType<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum, z.core.$ZodTypeInternals<RoleEnum.SETTER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER | RoleEnum.MIDDLE_BLOCKER, RoleEnum>>, z.ZodLiteral<"NO_BLOCK">]>>;
     }, z.core.$strip>>>>;
     replaceKnockedImmediately: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
     injuryReplacements: z.ZodDefault<z.ZodArray<z.ZodObject<{

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

@@ -1,5 +1,6 @@
 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';
@@ -56,8 +57,12 @@ const offensivePreferenceSchema = z.object({
     weights: z.record(z.string(), z.number().int().min(0)),
     tempos: z.record(z.string(), tempoPreferenceSchema).optional()
 });
-// The opposing attacking functions a dedicated blocker can commit to: every RoleEnum except the libero.
-const blockingFunctionSchema = z.nativeEnum(RoleEnum).refine((v) => v !== RoleEnum.LIBERO, { message: 'BLOCKING_TARGET_CANNOT_BE_LIBERO' });
+// 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 blockingPreferenceSchema = z.object({

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

@@ -1,5 +1,6 @@
 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', () => {
@@ -278,4 +279,35 @@ describe('TacticsInputSchema — blocking preferences', () => {
         }));
         expect(res.success).toBe(true);
     });
+    it('accepts NO_BLOCK as an assignment, alongside a commit on another starter', () => {
+        const res = TacticsInputSchema.safeParse(baseInput({
+            blockingPreferences: [{ rotation: 1, targets: { [p4.id]: NO_BLOCK, [p3.id]: RoleEnum.MIDDLE_BLOCKER } }]
+        }));
+        expect(res.success).toBe(true);
+        if (res.success) {
+            expect(res.data.blockingPreferences[0].targets[p4.id]).toBe(NO_BLOCK);
+            expect(res.data.blockingPreferences[0].targets[p3.id]).toBe(RoleEnum.MIDDLE_BLOCKER);
+        }
+    });
+    it('accepts NO_BLOCK in a per-set override', () => {
+        const res = TacticsInputSchema.safeParse(baseInput({
+            blockingPreferenceSets: [[{ rotation: 1, targets: { [p4.id]: NO_BLOCK } }], []]
+        }));
+        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: { [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', () => {
+        const res = TacticsInputSchema.safeParse(baseInput({
+            blockingPreferences: [{ rotation: 1, targets: { [p4.id]: 'NO_BLOCKING' } }]
+        }));
+        expect(res.success).toBe(false);
+    });
 });

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

@@ -289,11 +289,11 @@ export declare const TeamInputSchema: z.ZodObject<{
         }, z.core.$strip>>>>;
         blockingPreferences: z.ZodDefault<z.ZodArray<z.ZodObject<{
             rotation: z.ZodNumber;
-            targets: 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>>>;
+            targets: 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>>>;
         blockingPreferenceSets: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodObject<{
             rotation: z.ZodNumber;
-            targets: 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>>>;
+            targets: 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>>>>;
         replaceKnockedImmediately: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
         injuryReplacements: z.ZodDefault<z.ZodArray<z.ZodObject<{

package/package.json

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