volleyballsimtypes 0.0.516 → 0.0.518

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

@@ -137,6 +137,7 @@ export interface Tactics {
     liberoReplacementSets?: string[][];
     rotationSystem: RotationSystemEnum;
     designatedSetters: string[];
+    emergencySetterOrder: string[];
     offensivePreferences: ApiOffensivePreference[];
     systemSets?: ApiSystemSet[];
     offensivePreferenceSets?: ApiOffensivePreference[][];

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

@@ -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 map, the blocking commit + no-block ids, injury
- * replacements and the libero-injury reserves.
+ * setters (flat and per-set), the emergency setter order, 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

@@ -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 map, the blocking commit + no-block ids, injury
- * replacements and the libero-injury reserves.
+ * setters (flat and per-set), the emergency setter order, 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,6 +26,7 @@ function collectTacticsPlayerIds(config) {
         config.secondLibero,
         ...((config.liberoReplacementSets ?? []).flat()),
         ...(config.designatedSetters ?? []),
+        ...(config.emergencySetterOrder ?? []),
         ...((config.offensivePreferences ?? []).flatMap(p => Object.keys(p.priorities))),
         ...((config.systemSets ?? []).flatMap(s => s.designatedSetters)),
         ...((config.offensivePreferenceSets ?? []).flat().flatMap(p => Object.keys(p.priorities))),

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

@@ -74,6 +74,7 @@ export interface TacticsAttributes {
     libero_replacement_sets?: PlayerId[][];
     rotation_system: RotationSystemEnum;
     designated_setters: PlayerId[];
+    emergency_setter_order: PlayerId[];
     offensive_preferences: OffensivePreferenceAttributes[];
     system_sets?: SystemSetAttributes[];
     offensive_preference_sets?: OffensivePreferenceAttributes[][];
@@ -86,7 +87,7 @@ export interface TacticsAttributes {
 }
 export type TacticsPk = 'team_id';
 export type TacticsId = TacticsModel[TacticsPk];
-export type TacticsOptionalAttributes = 'lineup' | 'libero_replacements' | 'receive_rotation_offset' | 'designated_subs' | 'substitution_band' | 'second_libero' | 'libero_sub' | 'libero_replacement_sets' | 'rotation_system' | 'designated_setters' | 'offensive_preferences' | 'system_sets' | 'offensive_preference_sets' | 'replace_knocked_immediately' | 'injury_replacements' | 'libero_injury' | 'blocking_preferences' | 'blocking_preference_sets' | 'base_positions';
+export type TacticsOptionalAttributes = 'lineup' | 'libero_replacements' | 'receive_rotation_offset' | 'designated_subs' | 'substitution_band' | 'second_libero' | 'libero_sub' | 'libero_replacement_sets' | 'rotation_system' | 'designated_setters' | 'emergency_setter_order' | 'offensive_preferences' | 'system_sets' | 'offensive_preference_sets' | 'replace_knocked_immediately' | 'injury_replacements' | 'libero_injury' | 'blocking_preferences' | 'blocking_preference_sets' | 'base_positions';
 export type TacticsCreationAttributes = Optional<TacticsAttributes, TacticsOptionalAttributes>;
 export declare class TacticsModel extends Model<TacticsAttributes, TacticsCreationAttributes> implements TacticsAttributes {
     team_id: string;
@@ -100,6 +101,7 @@ export declare class TacticsModel extends Model<TacticsAttributes, TacticsCreati
     libero_replacement_sets?: PlayerId[][];
     rotation_system: RotationSystemEnum;
     designated_setters: PlayerId[];
+    emergency_setter_order: PlayerId[];
     offensive_preferences: OffensivePreferenceAttributes[];
     system_sets?: SystemSetAttributes[];
     offensive_preference_sets?: OffensivePreferenceAttributes[][];

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

@@ -62,6 +62,11 @@ class TacticsModel extends sequelize_1.Model {
                 allowNull: false,
                 defaultValue: []
             },
+            emergency_setter_order: {
+                type: sequelize_1.DataTypes.ARRAY(sequelize_1.DataTypes.UUID),
+                allowNull: false,
+                defaultValue: []
+            },
             offensive_preferences: {
                 type: sequelize_1.DataTypes.JSONB,
                 allowNull: false,

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

@@ -71,6 +71,7 @@ function transformToAttributes(tactics, teamId) {
         })),
         rotation_system: tactics.rotationSystem,
         designated_setters: tactics.designatedSetters.map((s) => s.id),
+        emergency_setter_order: tactics.emergencySetterOrder.map((p) => p.id),
         offensive_preferences: tactics.offensivePreferences.map(p => ({
             rotation: p.rotation,
             priorities: p.priorities,
@@ -178,6 +179,27 @@ function transformToObject(model, roster) {
         })),
         rotationSystem: model.rotation_system,
         designatedSetters: (model.designated_setters ?? []).map((id) => findPlayer(id, roster)),
+        // LENIENT (roster.find): the coach-ranked emergency-setter chain. Keep only ids still on the roster, inside the
+        // squad pool (starters + starting libero + L2 + bench), and NOT a current designated setter (setters are pinned
+        // ahead of this list, never stored inside it), first-occurrence-wins on duplicates. So stale jsonb (a departed
+        // player, a promoted setter, a non-pool id) can never fail schema validation and crash a team load; the next
+        // tactics save rewrites it cleanly.
+        emergencySetterOrder: (() => {
+            const poolIds = new Set([...inLineupIds, ...(secondLibero != null ? [secondLibero.id] : [])]);
+            const setterIds = new Set(model.designated_setters ?? []);
+            const seen = new Set();
+            const healed = [];
+            for (const id of model.emergency_setter_order ?? []) {
+                if (setterIds.has(id) || seen.has(id) || !poolIds.has(id))
+                    continue;
+                const p = roster.find((x) => x.id === id);
+                if (p == null)
+                    continue;
+                seen.add(id);
+                healed.push(p);
+            }
+            return healed;
+        })(),
         offensivePreferences: (model.offensive_preferences ?? []).map(p => ({
             rotation: p.rotation,
             priorities: p.priorities,
@@ -335,6 +357,22 @@ function tacticsColumnsToApiDto(model) {
         }),
         rotationSystem: model.rotation_system,
         designatedSetters: model.designated_setters,
+        // Same stale-data policy: drop any emergency-setter id the service load would drop (a current designated
+        // setter, or one outside the squad pool) so the UI never reloads and re-emits a rejected entry. Roster
+        // membership can't be checked here (ids only); the service heal covers that.
+        emergencySetterOrder: (() => {
+            const poolIds = new Set([...lineupIds, ...(validSecondLibero != null ? [validSecondLibero] : [])]);
+            const setterIds = new Set(model.designated_setters ?? []);
+            const seen = new Set();
+            const healed = [];
+            for (const id of model.emergency_setter_order ?? []) {
+                if (setterIds.has(id) || seen.has(id) || !poolIds.has(id))
+                    continue;
+                seen.add(id);
+                healed.push(id);
+            }
+            return healed;
+        })(),
         offensivePreferences: model.offensive_preferences,
         systemSets: model.system_sets,
         offensivePreferenceSets: model.offensive_preference_sets,
@@ -443,6 +481,7 @@ function apiTacticsConfigToAttributes(config, teamId) {
         libero_replacement_sets: config.liberoReplacementSets,
         rotation_system: config.rotationSystem,
         designated_setters: config.designatedSetters,
+        emergency_setter_order: config.emergencySetterOrder ?? [],
         offensive_preferences: config.offensivePreferences,
         system_sets: config.systemSets,
         offensive_preference_sets: config.offensivePreferenceSets,

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

@@ -261,6 +261,31 @@ function makeTactics(designatedSubs) {
         (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.it)('round-trips the emergency setter order (non-setter pool members)', () => {
+        const withOrder = service_1.Tactics.create({
+            lineup: { 4: p4, 3: p3, 2: p2, 5: p5, 6: p6, 1: p1, bench: [] },
+            liberoReplacements: [],
+            emergencySetterOrder: [p2, p3]
+        });
+        const attrs = (0, tactics_1.transformFromTactics)(withOrder, 'team-1');
+        (0, globals_1.expect)(attrs.emergency_setter_order).toEqual([p2.id, p3.id]);
+        const back = (0, tactics_1.transformToTactics)(attrs, roster);
+        (0, globals_1.expect)(back.emergencySetterOrder.map(p => p.id)).toEqual([p2.id, p3.id]);
+    });
+    // The read path must never crash a team load on a stale order. Ids that are gone from the roster, outside the
+    // squad pool, or now a designated setter (setters are pinned, never stored) are silently dropped, order preserved.
+    (0, globals_1.it)('drops emergency-order ids that are gone or a designated setter on read (lenient)', () => {
+        const attrs = (0, tactics_1.transformFromTactics)(service_1.Tactics.create({
+            lineup: { 4: p4, 3: p3, 2: p2, 5: p5, 6: p6, 1: p1, bench: [] },
+            liberoReplacements: [],
+            rotationSystem: service_1.RotationSystemEnum.FIVE_ONE,
+            designatedSetters: [p1],
+            emergencySetterOrder: [p2]
+        }), 'team-1');
+        attrs.emergency_setter_order = [p1.id, 'gone', p2.id];
+        const back = (0, tactics_1.transformToTactics)(attrs, roster);
+        (0, globals_1.expect)(back.emergencySetterOrder.map(p => p.id)).toEqual([p2.id]);
+    });
 });
 (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/base-config.d.ts

@@ -10,4 +10,5 @@ export interface BaseConfig {
     readonly receiveByPlayer?: Record<string, Record<string, boolean>>;
     readonly blocking?: Record<string, Record<string, Record<string, boolean>>>;
     readonly attackContact?: Record<string, Record<string, BaseCoord>>;
+    readonly liberoCoords?: Record<string, Record<string, Record<string, BaseCoord>>>;
 }

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

@@ -259,6 +259,7 @@ export declare const TacticsInputSchema: z.ZodObject<{
     liberoReplacementSets: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodCustom<Player, Player>>>>;
     rotationSystem: z.ZodDefault<z.ZodEnum<typeof RotationSystemEnum>>;
     designatedSetters: z.ZodDefault<z.ZodArray<z.ZodCustom<Player, Player>>>;
+    emergencySetterOrder: z.ZodDefault<z.ZodArray<z.ZodCustom<Player, Player>>>;
     offensivePreferences: z.ZodDefault<z.ZodArray<z.ZodObject<{
         rotation: z.ZodNumber;
         priorities: z.ZodRecord<z.ZodString, z.ZodEnum<{
@@ -319,6 +320,10 @@ export declare const TacticsInputSchema: z.ZodObject<{
             d: z.ZodNumber;
             r: z.ZodNumber;
         }, z.core.$strip>>>>;
+        liberoCoords: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{
+            d: z.ZodNumber;
+            r: z.ZodNumber;
+        }, z.core.$strip>>>>>;
     }, z.core.$strip>>;
     replaceKnockedImmediately: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
     injuryReplacements: z.ZodDefault<z.ZodArray<z.ZodObject<{

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

@@ -99,7 +99,10 @@ const baseConfigSchema = zod_1.z.object({
     blocking: zod_1.z.record(zod_1.z.string(), zod_1.z.record(zod_1.z.string(), zod_1.z.record(zod_1.z.string(), zod_1.z.boolean()))).optional(),
     // Desired attack contact per attacker (trajectory-set, owner 2026-08-12): [rotation][zone] -> {d,r}. Optional so
     // configs saved before this field validate unchanged.
-    attackContact: zod_1.z.record(zod_1.z.string(), zod_1.z.record(zod_1.z.string(), baseCoordSchema)).optional()
+    attackContact: zod_1.z.record(zod_1.z.string(), zod_1.z.record(zod_1.z.string(), baseCoordSchema)).optional(),
+    // Independent libero coords (owner 2026-08-14): [formation][rotation][zone] -> {d,r}, same shape as coords. Optional
+    // so configs saved before this field validate unchanged; absent => the libero shares the zone coord.
+    liberoCoords: zod_1.z.record(zod_1.z.string(), zod_1.z.record(zod_1.z.string(), zod_1.z.record(zod_1.z.string(), baseCoordSchema))).optional()
 });
 exports.TacticsInputSchema = zod_1.z.object({
     lineup: lineupSchema,
@@ -118,6 +121,10 @@ exports.TacticsInputSchema = zod_1.z.object({
     // Tactics.create({...}) call valid and make an unconfigured team play exactly as before.
     rotationSystem: zod_1.z.nativeEnum(rotation_system_1.RotationSystemEnum).default(rotation_system_1.RotationSystemEnum.SIX_ZERO),
     designatedSetters: zod_1.z.array(playerInstanceSchema).default([]),
+    // Emergency setter order (owner 2026-08-14): the coach-ranked NON-setter chain the engine follows when the
+    // designated setter is out of system. GLOBAL. Holds only non-setter pool members (setters are pinned ahead of
+    // it, derived). Default [] keeps every existing Tactics.create({...}) call valid; cross-field pool rules below.
+    emergencySetterOrder: zod_1.z.array(playerInstanceSchema).default([]),
     offensivePreferences: zod_1.z.array(offensivePreferenceSchema).default([]),
     // Attack shares on serve (libero-serve feature): per-player attack share the sim applies when a
     // libero-replaced player is on court unreplaced (serving, or through a libero injury). Keyed by starter id.
@@ -293,6 +300,29 @@ exports.TacticsInputSchema = zod_1.z.object({
             }
         }
     }
+    // Emergency setter order (owner 2026-08-14): the coach-ranked NON-setter chain. Every entry must be a squad-pool
+    // member (a court starter, the starting libero, the second libero, or a bench player), appear at most once, and
+    // NOT be one of the flat designated setters (they are pinned ahead of this list and never stored inside it).
+    const emergencyPoolIds = new Set([
+        ...starterIds,
+        ...(libero != null ? [libero.id] : []),
+        ...(data.secondLibero != null ? [data.secondLibero.id] : []),
+        ...data.lineup.bench.map(p => p.id)
+    ]);
+    const flatSetterIds = new Set(data.designatedSetters.map(s => s.id));
+    const seenEmergency = new Set();
+    for (const player of data.emergencySetterOrder) {
+        if (!emergencyPoolIds.has(player.id)) {
+            ctx.addIssue({ code: 'custom', message: 'EMERGENCY_SETTER_NOT_IN_POOL', path: ['emergencySetterOrder'] });
+        }
+        if (flatSetterIds.has(player.id)) {
+            ctx.addIssue({ code: 'custom', message: 'EMERGENCY_SETTER_IS_DESIGNATED_SETTER', path: ['emergencySetterOrder'] });
+        }
+        if (seenEmergency.has(player.id)) {
+            ctx.addIssue({ code: 'custom', message: 'EMERGENCY_SETTER_DUPLICATE', path: ['emergencySetterOrder'] });
+        }
+        seenEmergency.add(player.id);
+    }
     // Per-player knock toggle: every key must be a court starter OR the starting libero. The libero may carry its
     // own key so the user can choose to keep a lightly knocked libero on court (owner 2026-07-06). Bench/reserve
     // players still follow the slot they occupy, so they never carry their own key.

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

@@ -338,3 +338,66 @@ const test_helpers_1 = require("../../test-helpers");
         (0, globals_1.expect)(res.success).toBe(false);
     });
 });
+(0, globals_1.describe)('TacticsInputSchema — emergency setter order', () => {
+    const country = (0, test_helpers_1.makeCountry)();
+    const p1 = (0, test_helpers_1.makePlayer)(country);
+    const p2 = (0, test_helpers_1.makePlayer)(country);
+    const p3 = (0, test_helpers_1.makePlayer)(country);
+    const p4 = (0, test_helpers_1.makePlayer)(country);
+    const p5 = (0, test_helpers_1.makePlayer)(country);
+    const p6 = (0, test_helpers_1.makePlayer)(country);
+    const libero = (0, test_helpers_1.makePlayer)(country);
+    const benchA = (0, test_helpers_1.makePlayer)(country);
+    const secondLibero = (0, test_helpers_1.makePlayer)(country);
+    const reserve = (0, test_helpers_1.makePlayer)(country);
+    // Pool = the 6 starters (p1..p6), the starting libero, the second libero, and the bench (benchA). `reserve` is
+    // outside the pool. 6-0 default => no designated setters, so the whole pool is orderable.
+    function baseInput(overrides = {}) {
+        return {
+            lineup: { 4: p4, 3: p3, 2: p2, 5: p5, 6: p6, 1: p1, 0: libero, bench: [benchA] },
+            liberoReplacements: [],
+            secondLibero,
+            ...overrides
+        };
+    }
+    (0, globals_1.it)('accepts an order of pool members (starters, libero, L2, bench), no duplicates', () => {
+        const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
+            emergencySetterOrder: [p2, benchA, libero, secondLibero]
+        }));
+        (0, globals_1.expect)(res.success).toBe(true);
+        if (res.success) {
+            (0, globals_1.expect)(res.data.emergencySetterOrder.map(p => p.id)).toEqual([p2.id, benchA.id, libero.id, secondLibero.id]);
+        }
+    });
+    (0, globals_1.it)('defaults to [] when omitted', () => {
+        const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput());
+        (0, globals_1.expect)(res.success).toBe(true);
+        if (res.success)
+            (0, globals_1.expect)(res.data.emergencySetterOrder).toEqual([]);
+    });
+    (0, globals_1.it)('rejects an entry outside the squad pool', () => {
+        const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({ emergencySetterOrder: [reserve] }));
+        (0, globals_1.expect)(res.success).toBe(false);
+        if (!res.success) {
+            (0, globals_1.expect)(res.error.issues.some(i => i.message === 'EMERGENCY_SETTER_NOT_IN_POOL')).toBe(true);
+        }
+    });
+    (0, globals_1.it)('rejects a duplicate entry', () => {
+        const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({ emergencySetterOrder: [p2, p2] }));
+        (0, globals_1.expect)(res.success).toBe(false);
+        if (!res.success) {
+            (0, globals_1.expect)(res.error.issues.some(i => i.message === 'EMERGENCY_SETTER_DUPLICATE')).toBe(true);
+        }
+    });
+    (0, globals_1.it)('rejects an entry that is a flat designated setter (setters are pinned, never stored in the list)', () => {
+        const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
+            rotationSystem: '5-1',
+            designatedSetters: [p1],
+            emergencySetterOrder: [p1]
+        }));
+        (0, globals_1.expect)(res.success).toBe(false);
+        if (!res.success) {
+            (0, globals_1.expect)(res.error.issues.some(i => i.message === 'EMERGENCY_SETTER_IS_DESIGNATED_SETTER')).toBe(true);
+        }
+    });
+});

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

@@ -267,6 +267,7 @@ export declare const TeamInputSchema: z.ZodObject<{
         liberoReplacementSets: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodCustom<Player, Player>>>>;
         rotationSystem: z.ZodDefault<z.ZodEnum<typeof import("..").RotationSystemEnum>>;
         designatedSetters: z.ZodDefault<z.ZodArray<z.ZodCustom<Player, Player>>>;
+        emergencySetterOrder: z.ZodDefault<z.ZodArray<z.ZodCustom<Player, Player>>>;
         offensivePreferences: z.ZodDefault<z.ZodArray<z.ZodObject<{
             rotation: z.ZodNumber;
             priorities: z.ZodRecord<z.ZodString, z.ZodEnum<{
@@ -327,6 +328,10 @@ export declare const TeamInputSchema: z.ZodObject<{
                 d: z.ZodNumber;
                 r: z.ZodNumber;
             }, z.core.$strip>>>>;
+            liberoCoords: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{
+                d: z.ZodNumber;
+                r: z.ZodNumber;
+            }, z.core.$strip>>>>>;
         }, z.core.$strip>>;
         replaceKnockedImmediately: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
         injuryReplacements: z.ZodDefault<z.ZodArray<z.ZodObject<{

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

@@ -34,6 +34,7 @@ export interface TacticsOpts {
     readonly liberoReplacementSets?: Player[][];
     readonly rotationSystem: RotationSystemEnum;
     readonly designatedSetters: Player[];
+    readonly emergencySetterOrder: Player[];
     readonly offensivePreferences: OffensivePreference[];
     readonly systemSets?: SystemSet[];
     readonly offensivePreferenceSets?: OffensivePreference[][];
@@ -55,6 +56,7 @@ export declare class Tactics {
     readonly liberoReplacementSets?: Player[][];
     readonly rotationSystem: RotationSystemEnum;
     readonly designatedSetters: Player[];
+    readonly emergencySetterOrder: Player[];
     readonly offensivePreferences: OffensivePreference[];
     readonly systemSets?: SystemSet[];
     readonly offensivePreferenceSets?: OffensivePreference[][];

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

@@ -18,7 +18,7 @@ class Tactics {
         }
         return new Tactics(result.data);
     }
-    constructor({ lineup, liberoReplacements, receiveRotationOffset = false, designatedSubs = [], substitutionBand = energy_band_1.EnergyBand.TIRED, secondLibero, liberoSub, liberoReplacementSets, rotationSystem = rotation_system_1.RotationSystemEnum.SIX_ZERO, designatedSetters = [], offensivePreferences = [], systemSets, offensivePreferenceSets, replaceKnockedImmediately = {}, injuryReplacements = [], liberoInjury, blockingPreferences = [], blockingPreferenceSets, basePositions }) {
+    constructor({ lineup, liberoReplacements, receiveRotationOffset = false, designatedSubs = [], substitutionBand = energy_band_1.EnergyBand.TIRED, secondLibero, liberoSub, liberoReplacementSets, rotationSystem = rotation_system_1.RotationSystemEnum.SIX_ZERO, designatedSetters = [], emergencySetterOrder = [], offensivePreferences = [], systemSets, offensivePreferenceSets, replaceKnockedImmediately = {}, injuryReplacements = [], liberoInjury, blockingPreferences = [], blockingPreferenceSets, basePositions }) {
         this.lineup = lineup;
         this.liberoReplacements = liberoReplacements;
         this.receiveRotationOffset = receiveRotationOffset;
@@ -29,6 +29,7 @@ class Tactics {
         this.liberoReplacementSets = liberoReplacementSets;
         this.rotationSystem = rotationSystem;
         this.designatedSetters = designatedSetters;
+        this.emergencySetterOrder = emergencySetterOrder;
         this.offensivePreferences = offensivePreferences;
         this.systemSets = systemSets;
         this.offensivePreferenceSets = offensivePreferenceSets;

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

@@ -137,6 +137,7 @@ export interface Tactics {
     liberoReplacementSets?: string[][];
     rotationSystem: RotationSystemEnum;
     designatedSetters: string[];
+    emergencySetterOrder: string[];
     offensivePreferences: ApiOffensivePreference[];
     systemSets?: ApiSystemSet[];
     offensivePreferenceSets?: ApiOffensivePreference[][];

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

@@ -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 map, the blocking commit + no-block ids, injury
- * replacements and the libero-injury reserves.
+ * setters (flat and per-set), the emergency setter order, 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

@@ -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 map, the blocking commit + no-block ids, injury
- * replacements and the libero-injury reserves.
+ * setters (flat and per-set), the emergency setter order, 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
@@ -23,6 +23,7 @@ export function collectTacticsPlayerIds(config) {
         config.secondLibero,
         ...((config.liberoReplacementSets ?? []).flat()),
         ...(config.designatedSetters ?? []),
+        ...(config.emergencySetterOrder ?? []),
         ...((config.offensivePreferences ?? []).flatMap(p => Object.keys(p.priorities))),
         ...((config.systemSets ?? []).flatMap(s => s.designatedSetters)),
         ...((config.offensivePreferenceSets ?? []).flat().flatMap(p => Object.keys(p.priorities))),

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

@@ -74,6 +74,7 @@ export interface TacticsAttributes {
     libero_replacement_sets?: PlayerId[][];
     rotation_system: RotationSystemEnum;
     designated_setters: PlayerId[];
+    emergency_setter_order: PlayerId[];
     offensive_preferences: OffensivePreferenceAttributes[];
     system_sets?: SystemSetAttributes[];
     offensive_preference_sets?: OffensivePreferenceAttributes[][];
@@ -86,7 +87,7 @@ export interface TacticsAttributes {
 }
 export type TacticsPk = 'team_id';
 export type TacticsId = TacticsModel[TacticsPk];
-export type TacticsOptionalAttributes = 'lineup' | 'libero_replacements' | 'receive_rotation_offset' | 'designated_subs' | 'substitution_band' | 'second_libero' | 'libero_sub' | 'libero_replacement_sets' | 'rotation_system' | 'designated_setters' | 'offensive_preferences' | 'system_sets' | 'offensive_preference_sets' | 'replace_knocked_immediately' | 'injury_replacements' | 'libero_injury' | 'blocking_preferences' | 'blocking_preference_sets' | 'base_positions';
+export type TacticsOptionalAttributes = 'lineup' | 'libero_replacements' | 'receive_rotation_offset' | 'designated_subs' | 'substitution_band' | 'second_libero' | 'libero_sub' | 'libero_replacement_sets' | 'rotation_system' | 'designated_setters' | 'emergency_setter_order' | 'offensive_preferences' | 'system_sets' | 'offensive_preference_sets' | 'replace_knocked_immediately' | 'injury_replacements' | 'libero_injury' | 'blocking_preferences' | 'blocking_preference_sets' | 'base_positions';
 export type TacticsCreationAttributes = Optional<TacticsAttributes, TacticsOptionalAttributes>;
 export declare class TacticsModel extends Model<TacticsAttributes, TacticsCreationAttributes> implements TacticsAttributes {
     team_id: string;
@@ -100,6 +101,7 @@ export declare class TacticsModel extends Model<TacticsAttributes, TacticsCreati
     libero_replacement_sets?: PlayerId[][];
     rotation_system: RotationSystemEnum;
     designated_setters: PlayerId[];
+    emergency_setter_order: PlayerId[];
     offensive_preferences: OffensivePreferenceAttributes[];
     system_sets?: SystemSetAttributes[];
     offensive_preference_sets?: OffensivePreferenceAttributes[][];

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

@@ -59,6 +59,11 @@ export class TacticsModel extends Model {
                 allowNull: false,
                 defaultValue: []
             },
+            emergency_setter_order: {
+                type: DataTypes.ARRAY(DataTypes.UUID),
+                allowNull: false,
+                defaultValue: []
+            },
             offensive_preferences: {
                 type: DataTypes.JSONB,
                 allowNull: false,

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

@@ -65,6 +65,7 @@ function transformToAttributes(tactics, teamId) {
         })),
         rotation_system: tactics.rotationSystem,
         designated_setters: tactics.designatedSetters.map((s) => s.id),
+        emergency_setter_order: tactics.emergencySetterOrder.map((p) => p.id),
         offensive_preferences: tactics.offensivePreferences.map(p => ({
             rotation: p.rotation,
             priorities: p.priorities,
@@ -172,6 +173,27 @@ function transformToObject(model, roster) {
         })),
         rotationSystem: model.rotation_system,
         designatedSetters: (model.designated_setters ?? []).map((id) => findPlayer(id, roster)),
+        // LENIENT (roster.find): the coach-ranked emergency-setter chain. Keep only ids still on the roster, inside the
+        // squad pool (starters + starting libero + L2 + bench), and NOT a current designated setter (setters are pinned
+        // ahead of this list, never stored inside it), first-occurrence-wins on duplicates. So stale jsonb (a departed
+        // player, a promoted setter, a non-pool id) can never fail schema validation and crash a team load; the next
+        // tactics save rewrites it cleanly.
+        emergencySetterOrder: (() => {
+            const poolIds = new Set([...inLineupIds, ...(secondLibero != null ? [secondLibero.id] : [])]);
+            const setterIds = new Set(model.designated_setters ?? []);
+            const seen = new Set();
+            const healed = [];
+            for (const id of model.emergency_setter_order ?? []) {
+                if (setterIds.has(id) || seen.has(id) || !poolIds.has(id))
+                    continue;
+                const p = roster.find((x) => x.id === id);
+                if (p == null)
+                    continue;
+                seen.add(id);
+                healed.push(p);
+            }
+            return healed;
+        })(),
         offensivePreferences: (model.offensive_preferences ?? []).map(p => ({
             rotation: p.rotation,
             priorities: p.priorities,
@@ -329,6 +351,22 @@ function tacticsColumnsToApiDto(model) {
         }),
         rotationSystem: model.rotation_system,
         designatedSetters: model.designated_setters,
+        // Same stale-data policy: drop any emergency-setter id the service load would drop (a current designated
+        // setter, or one outside the squad pool) so the UI never reloads and re-emits a rejected entry. Roster
+        // membership can't be checked here (ids only); the service heal covers that.
+        emergencySetterOrder: (() => {
+            const poolIds = new Set([...lineupIds, ...(validSecondLibero != null ? [validSecondLibero] : [])]);
+            const setterIds = new Set(model.designated_setters ?? []);
+            const seen = new Set();
+            const healed = [];
+            for (const id of model.emergency_setter_order ?? []) {
+                if (setterIds.has(id) || seen.has(id) || !poolIds.has(id))
+                    continue;
+                seen.add(id);
+                healed.push(id);
+            }
+            return healed;
+        })(),
         offensivePreferences: model.offensive_preferences,
         systemSets: model.system_sets,
         offensivePreferenceSets: model.offensive_preference_sets,
@@ -437,6 +475,7 @@ function apiTacticsConfigToAttributes(config, teamId) {
         libero_replacement_sets: config.liberoReplacementSets,
         rotation_system: config.rotationSystem,
         designated_setters: config.designatedSetters,
+        emergency_setter_order: config.emergencySetterOrder ?? [],
         offensive_preferences: config.offensivePreferences,
         system_sets: config.systemSets,
         offensive_preference_sets: config.offensivePreferenceSets,

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

@@ -259,6 +259,31 @@ describe('per-set tactics — service <-> row round-trip', () => {
         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: [] });
     });
+    it('round-trips the emergency setter order (non-setter pool members)', () => {
+        const withOrder = Tactics.create({
+            lineup: { 4: p4, 3: p3, 2: p2, 5: p5, 6: p6, 1: p1, bench: [] },
+            liberoReplacements: [],
+            emergencySetterOrder: [p2, p3]
+        });
+        const attrs = transformFromTactics(withOrder, 'team-1');
+        expect(attrs.emergency_setter_order).toEqual([p2.id, p3.id]);
+        const back = transformToTactics(attrs, roster);
+        expect(back.emergencySetterOrder.map(p => p.id)).toEqual([p2.id, p3.id]);
+    });
+    // The read path must never crash a team load on a stale order. Ids that are gone from the roster, outside the
+    // squad pool, or now a designated setter (setters are pinned, never stored) are silently dropped, order preserved.
+    it('drops emergency-order ids that are gone or a designated setter on read (lenient)', () => {
+        const attrs = transformFromTactics(Tactics.create({
+            lineup: { 4: p4, 3: p3, 2: p2, 5: p5, 6: p6, 1: p1, bench: [] },
+            liberoReplacements: [],
+            rotationSystem: RotationSystemEnum.FIVE_ONE,
+            designatedSetters: [p1],
+            emergencySetterOrder: [p2]
+        }), 'team-1');
+        attrs.emergency_setter_order = [p1.id, 'gone', p2.id];
+        const back = transformToTactics(attrs, roster);
+        expect(back.emergencySetterOrder.map(p => p.id)).toEqual([p2.id]);
+    });
 });
 describe('libero injuries — service <-> row round-trip + lenient heal', () => {
     const country = makeCountry();

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

@@ -10,4 +10,5 @@ export interface BaseConfig {
     readonly receiveByPlayer?: Record<string, Record<string, boolean>>;
     readonly blocking?: Record<string, Record<string, Record<string, boolean>>>;
     readonly attackContact?: Record<string, Record<string, BaseCoord>>;
+    readonly liberoCoords?: Record<string, Record<string, Record<string, BaseCoord>>>;
 }

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

@@ -259,6 +259,7 @@ export declare const TacticsInputSchema: z.ZodObject<{
     liberoReplacementSets: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodCustom<Player, Player>>>>;
     rotationSystem: z.ZodDefault<z.ZodEnum<typeof RotationSystemEnum>>;
     designatedSetters: z.ZodDefault<z.ZodArray<z.ZodCustom<Player, Player>>>;
+    emergencySetterOrder: z.ZodDefault<z.ZodArray<z.ZodCustom<Player, Player>>>;
     offensivePreferences: z.ZodDefault<z.ZodArray<z.ZodObject<{
         rotation: z.ZodNumber;
         priorities: z.ZodRecord<z.ZodString, z.ZodEnum<{
@@ -319,6 +320,10 @@ export declare const TacticsInputSchema: z.ZodObject<{
             d: z.ZodNumber;
             r: z.ZodNumber;
         }, z.core.$strip>>>>;
+        liberoCoords: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{
+            d: z.ZodNumber;
+            r: z.ZodNumber;
+        }, z.core.$strip>>>>>;
     }, z.core.$strip>>;
     replaceKnockedImmediately: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
     injuryReplacements: z.ZodDefault<z.ZodArray<z.ZodObject<{

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

@@ -96,7 +96,10 @@ const baseConfigSchema = z.object({
     blocking: z.record(z.string(), z.record(z.string(), z.record(z.string(), z.boolean()))).optional(),
     // Desired attack contact per attacker (trajectory-set, owner 2026-08-12): [rotation][zone] -> {d,r}. Optional so
     // configs saved before this field validate unchanged.
-    attackContact: z.record(z.string(), z.record(z.string(), baseCoordSchema)).optional()
+    attackContact: z.record(z.string(), z.record(z.string(), baseCoordSchema)).optional(),
+    // Independent libero coords (owner 2026-08-14): [formation][rotation][zone] -> {d,r}, same shape as coords. Optional
+    // so configs saved before this field validate unchanged; absent => the libero shares the zone coord.
+    liberoCoords: z.record(z.string(), z.record(z.string(), z.record(z.string(), baseCoordSchema))).optional()
 });
 export const TacticsInputSchema = z.object({
     lineup: lineupSchema,
@@ -115,6 +118,10 @@ export const TacticsInputSchema = z.object({
     // Tactics.create({...}) call valid and make an unconfigured team play exactly as before.
     rotationSystem: z.nativeEnum(RotationSystemEnum).default(RotationSystemEnum.SIX_ZERO),
     designatedSetters: z.array(playerInstanceSchema).default([]),
+    // Emergency setter order (owner 2026-08-14): the coach-ranked NON-setter chain the engine follows when the
+    // designated setter is out of system. GLOBAL. Holds only non-setter pool members (setters are pinned ahead of
+    // it, derived). Default [] keeps every existing Tactics.create({...}) call valid; cross-field pool rules below.
+    emergencySetterOrder: z.array(playerInstanceSchema).default([]),
     offensivePreferences: z.array(offensivePreferenceSchema).default([]),
     // Attack shares on serve (libero-serve feature): per-player attack share the sim applies when a
     // libero-replaced player is on court unreplaced (serving, or through a libero injury). Keyed by starter id.
@@ -290,6 +297,29 @@ export const TacticsInputSchema = z.object({
             }
         }
     }
+    // Emergency setter order (owner 2026-08-14): the coach-ranked NON-setter chain. Every entry must be a squad-pool
+    // member (a court starter, the starting libero, the second libero, or a bench player), appear at most once, and
+    // NOT be one of the flat designated setters (they are pinned ahead of this list and never stored inside it).
+    const emergencyPoolIds = new Set([
+        ...starterIds,
+        ...(libero != null ? [libero.id] : []),
+        ...(data.secondLibero != null ? [data.secondLibero.id] : []),
+        ...data.lineup.bench.map(p => p.id)
+    ]);
+    const flatSetterIds = new Set(data.designatedSetters.map(s => s.id));
+    const seenEmergency = new Set();
+    for (const player of data.emergencySetterOrder) {
+        if (!emergencyPoolIds.has(player.id)) {
+            ctx.addIssue({ code: 'custom', message: 'EMERGENCY_SETTER_NOT_IN_POOL', path: ['emergencySetterOrder'] });
+        }
+        if (flatSetterIds.has(player.id)) {
+            ctx.addIssue({ code: 'custom', message: 'EMERGENCY_SETTER_IS_DESIGNATED_SETTER', path: ['emergencySetterOrder'] });
+        }
+        if (seenEmergency.has(player.id)) {
+            ctx.addIssue({ code: 'custom', message: 'EMERGENCY_SETTER_DUPLICATE', path: ['emergencySetterOrder'] });
+        }
+        seenEmergency.add(player.id);
+    }
     // Per-player knock toggle: every key must be a court starter OR the starting libero. The libero may carry its
     // own key so the user can choose to keep a lightly knocked libero on court (owner 2026-07-06). Bench/reserve
     // players still follow the slot they occupy, so they never carry their own key.

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

@@ -336,3 +336,66 @@ describe('TacticsInputSchema — blocking preferences', () => {
         expect(res.success).toBe(false);
     });
 });
+describe('TacticsInputSchema — emergency setter order', () => {
+    const country = makeCountry();
+    const p1 = makePlayer(country);
+    const p2 = makePlayer(country);
+    const p3 = makePlayer(country);
+    const p4 = makePlayer(country);
+    const p5 = makePlayer(country);
+    const p6 = makePlayer(country);
+    const libero = makePlayer(country);
+    const benchA = makePlayer(country);
+    const secondLibero = makePlayer(country);
+    const reserve = makePlayer(country);
+    // Pool = the 6 starters (p1..p6), the starting libero, the second libero, and the bench (benchA). `reserve` is
+    // outside the pool. 6-0 default => no designated setters, so the whole pool is orderable.
+    function baseInput(overrides = {}) {
+        return {
+            lineup: { 4: p4, 3: p3, 2: p2, 5: p5, 6: p6, 1: p1, 0: libero, bench: [benchA] },
+            liberoReplacements: [],
+            secondLibero,
+            ...overrides
+        };
+    }
+    it('accepts an order of pool members (starters, libero, L2, bench), no duplicates', () => {
+        const res = TacticsInputSchema.safeParse(baseInput({
+            emergencySetterOrder: [p2, benchA, libero, secondLibero]
+        }));
+        expect(res.success).toBe(true);
+        if (res.success) {
+            expect(res.data.emergencySetterOrder.map(p => p.id)).toEqual([p2.id, benchA.id, libero.id, secondLibero.id]);
+        }
+    });
+    it('defaults to [] when omitted', () => {
+        const res = TacticsInputSchema.safeParse(baseInput());
+        expect(res.success).toBe(true);
+        if (res.success)
+            expect(res.data.emergencySetterOrder).toEqual([]);
+    });
+    it('rejects an entry outside the squad pool', () => {
+        const res = TacticsInputSchema.safeParse(baseInput({ emergencySetterOrder: [reserve] }));
+        expect(res.success).toBe(false);
+        if (!res.success) {
+            expect(res.error.issues.some(i => i.message === 'EMERGENCY_SETTER_NOT_IN_POOL')).toBe(true);
+        }
+    });
+    it('rejects a duplicate entry', () => {
+        const res = TacticsInputSchema.safeParse(baseInput({ emergencySetterOrder: [p2, p2] }));
+        expect(res.success).toBe(false);
+        if (!res.success) {
+            expect(res.error.issues.some(i => i.message === 'EMERGENCY_SETTER_DUPLICATE')).toBe(true);
+        }
+    });
+    it('rejects an entry that is a flat designated setter (setters are pinned, never stored in the list)', () => {
+        const res = TacticsInputSchema.safeParse(baseInput({
+            rotationSystem: '5-1',
+            designatedSetters: [p1],
+            emergencySetterOrder: [p1]
+        }));
+        expect(res.success).toBe(false);
+        if (!res.success) {
+            expect(res.error.issues.some(i => i.message === 'EMERGENCY_SETTER_IS_DESIGNATED_SETTER')).toBe(true);
+        }
+    });
+});

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

@@ -267,6 +267,7 @@ export declare const TeamInputSchema: z.ZodObject<{
         liberoReplacementSets: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodCustom<Player, Player>>>>;
         rotationSystem: z.ZodDefault<z.ZodEnum<typeof import("..").RotationSystemEnum>>;
         designatedSetters: z.ZodDefault<z.ZodArray<z.ZodCustom<Player, Player>>>;
+        emergencySetterOrder: z.ZodDefault<z.ZodArray<z.ZodCustom<Player, Player>>>;
         offensivePreferences: z.ZodDefault<z.ZodArray<z.ZodObject<{
             rotation: z.ZodNumber;
             priorities: z.ZodRecord<z.ZodString, z.ZodEnum<{
@@ -327,6 +328,10 @@ export declare const TeamInputSchema: z.ZodObject<{
                 d: z.ZodNumber;
                 r: z.ZodNumber;
             }, z.core.$strip>>>>;
+            liberoCoords: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{
+                d: z.ZodNumber;
+                r: z.ZodNumber;
+            }, z.core.$strip>>>>>;
         }, z.core.$strip>>;
         replaceKnockedImmediately: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
         injuryReplacements: z.ZodDefault<z.ZodArray<z.ZodObject<{

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

@@ -34,6 +34,7 @@ export interface TacticsOpts {
     readonly liberoReplacementSets?: Player[][];
     readonly rotationSystem: RotationSystemEnum;
     readonly designatedSetters: Player[];
+    readonly emergencySetterOrder: Player[];
     readonly offensivePreferences: OffensivePreference[];
     readonly systemSets?: SystemSet[];
     readonly offensivePreferenceSets?: OffensivePreference[][];
@@ -55,6 +56,7 @@ export declare class Tactics {
     readonly liberoReplacementSets?: Player[][];
     readonly rotationSystem: RotationSystemEnum;
     readonly designatedSetters: Player[];
+    readonly emergencySetterOrder: Player[];
     readonly offensivePreferences: OffensivePreference[];
     readonly systemSets?: SystemSet[];
     readonly offensivePreferenceSets?: OffensivePreference[][];

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

@@ -15,7 +15,7 @@ export class Tactics {
         }
         return new Tactics(result.data);
     }
-    constructor({ lineup, liberoReplacements, receiveRotationOffset = false, designatedSubs = [], substitutionBand = EnergyBand.TIRED, secondLibero, liberoSub, liberoReplacementSets, rotationSystem = RotationSystemEnum.SIX_ZERO, designatedSetters = [], offensivePreferences = [], systemSets, offensivePreferenceSets, replaceKnockedImmediately = {}, injuryReplacements = [], liberoInjury, blockingPreferences = [], blockingPreferenceSets, basePositions }) {
+    constructor({ lineup, liberoReplacements, receiveRotationOffset = false, designatedSubs = [], substitutionBand = EnergyBand.TIRED, secondLibero, liberoSub, liberoReplacementSets, rotationSystem = RotationSystemEnum.SIX_ZERO, designatedSetters = [], emergencySetterOrder = [], offensivePreferences = [], systemSets, offensivePreferenceSets, replaceKnockedImmediately = {}, injuryReplacements = [], liberoInjury, blockingPreferences = [], blockingPreferenceSets, basePositions }) {
         this.lineup = lineup;
         this.liberoReplacements = liberoReplacements;
         this.receiveRotationOffset = receiveRotationOffset;
@@ -26,6 +26,7 @@ export class Tactics {
         this.liberoReplacementSets = liberoReplacementSets;
         this.rotationSystem = rotationSystem;
         this.designatedSetters = designatedSetters;
+        this.emergencySetterOrder = emergencySetterOrder;
         this.offensivePreferences = offensivePreferences;
         this.systemSets = systemSets;
         this.offensivePreferenceSets = offensivePreferenceSets;

package/package.json

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