volleyballsimtypes 0.0.467 → 0.0.470

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

@@ -132,7 +132,7 @@ export interface Tactics {
     offensivePreferences: ApiOffensivePreference[];
     systemSets?: ApiSystemSet[];
     offensivePreferenceSets?: ApiOffensivePreference[][];
-    replaceInjuredImmediately: boolean;
+    replaceKnockedImmediately?: Record<string, boolean>;
     injuryReplacements?: ApiInjuryReplacement[];
 }
 export interface ApiLineupPreset {

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

@@ -66,12 +66,12 @@ export interface TacticsAttributes {
     offensive_preferences: OffensivePreferenceAttributes[];
     system_sets?: SystemSetAttributes[];
     offensive_preference_sets?: OffensivePreferenceAttributes[][];
-    replace_injured_immediately?: boolean;
+    replace_knocked_immediately?: Record<PlayerId, boolean>;
     injury_replacements?: InjuryReplacementAttributes[];
 }
 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_injured_immediately' | 'injury_replacements';
+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';
 export type TacticsCreationAttributes = Optional<TacticsAttributes, TacticsOptionalAttributes>;
 export declare class TacticsModel extends Model<TacticsAttributes, TacticsCreationAttributes> implements TacticsAttributes {
     team_id: string;
@@ -88,7 +88,7 @@ export declare class TacticsModel extends Model<TacticsAttributes, TacticsCreati
     offensive_preferences: OffensivePreferenceAttributes[];
     system_sets?: SystemSetAttributes[];
     offensive_preference_sets?: OffensivePreferenceAttributes[][];
-    replace_injured_immediately?: boolean;
+    replace_knocked_immediately?: Record<PlayerId, boolean>;
     injury_replacements?: InjuryReplacementAttributes[];
     team: TeamModel;
     getTeam: Sequelize.BelongsToGetAssociationMixin<TeamModel>;

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

@@ -75,10 +75,9 @@ class TacticsModel extends sequelize_1.Model {
                 type: sequelize_1.DataTypes.JSONB,
                 allowNull: true
             },
-            replace_injured_immediately: {
-                type: sequelize_1.DataTypes.BOOLEAN,
-                allowNull: false,
-                defaultValue: true
+            replace_knocked_immediately: {
+                type: sequelize_1.DataTypes.JSONB,
+                allowNull: true
             },
             injury_replacements: {
                 type: sequelize_1.DataTypes.JSONB,

package/dist/cjs/src/data/transformers/lineup-preset.js

@@ -2,18 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.transformToLineupPreset = transformToObject;
 // `config` is already stored as the API Tactics DTO, so a preset row maps to its API shape with no hydration.
-// Presets saved before the injuries fields exist lack replaceInjuredImmediately: heal it to the effective
-// default (true, matching transformToTactics' hydration) so the DTO's required field is honest and a UI
-// toggle seeded from an old preset cannot silently flip the user's effective setting on re-save.
+// No injuries heal here anymore: replaceKnockedImmediately is optional (absent = every starter ON), and old
+// configs carrying the superseded replaceInjuredImmediately boolean pass through the spread as a dead key
+// that the save DTO strips (owner 2026-07-05: the old global value is dropped, default ON).
 function transformToObject(model) {
     return {
         presetId: model.preset_id,
         name: model.name,
         isActive: model.is_active,
         orderIndex: model.order_index,
-        config: {
-            ...model.config,
-            replaceInjuredImmediately: model.config.replaceInjuredImmediately ?? true
-        }
+        config: model.config
     };
 }

package/dist/cjs/src/data/transformers/lineup-preset.test.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const globals_1 = require("@jest/globals");
 const lineup_preset_1 = require("./lineup-preset");
 (0, globals_1.describe)('transformToLineupPreset()', () => {
-    (0, globals_1.it)('maps preset columns to the API shape and heals a pre-injuries config to the effective default', () => {
+    (0, globals_1.it)('maps preset columns to the API shape verbatim (no injuries heal: absent map = every starter ON)', () => {
         const config = { lineup: { bench: [] }, substitutionBand: 'TIRED' };
         const preset = (0, lineup_preset_1.transformToLineupPreset)({
             preset_id: 'p1',
@@ -18,13 +18,15 @@ const lineup_preset_1 = require("./lineup-preset");
             name: 'Starters',
             isActive: true,
             orderIndex: 2,
-            // A config stored before the injuries fields lacks replaceInjuredImmediately; the transform heals it
-            // to true (the effective hydration default) so the DTO's required field is honest.
-            config: { ...config, replaceInjuredImmediately: true }
+            config
         });
     });
-    (0, globals_1.it)('keeps an explicit replaceInjuredImmediately: false', () => {
-        const config = { lineup: { bench: [] }, substitutionBand: 'TIRED', replaceInjuredImmediately: false };
+    (0, globals_1.it)('keeps an explicit per-starter replaceKnockedImmediately map', () => {
+        const config = {
+            lineup: { bench: [] },
+            substitutionBand: 'TIRED',
+            replaceKnockedImmediately: { 'starter-1': false }
+        };
         const preset = (0, lineup_preset_1.transformToLineupPreset)({
             preset_id: 'p2',
             team_id: 't1',
@@ -33,6 +35,6 @@ const lineup_preset_1 = require("./lineup-preset");
             order_index: 3,
             config
         });
-        (0, globals_1.expect)(preset.config.replaceInjuredImmediately).toBe(false);
+        (0, globals_1.expect)(preset.config.replaceKnockedImmediately).toEqual({ 'starter-1': false });
     });
 });

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

@@ -88,7 +88,7 @@ function transformToAttributes(tactics, teamId) {
             rotation: p.rotation,
             order: p.order.map((a) => a.id)
         }))),
-        replace_injured_immediately: tactics.replaceInjuredImmediately,
+        replace_knocked_immediately: tactics.replaceKnockedImmediately,
         injury_replacements: tactics.injuryReplacements.map(ir => ({
             starterId: ir.starter.id,
             replacementId: ir.replacement.id,
@@ -171,7 +171,19 @@ function transformToObject(model, roster) {
             rotation: p.rotation,
             order: p.order.map((id) => findPlayer(id, roster))
         }))),
-        replaceInjuredImmediately: model.replace_injured_immediately ?? true,
+        // LENIENT: keep only starter-keyed boolean entries so stale jsonb (an ex-starter's key, a non-boolean
+        // value) can never fail schema validation and crash a team load; a dropped key = the ON default.
+        replaceKnockedImmediately: (() => {
+            const starterIds = new Set([lineup[service_1.CourtPosition.LEFT_FRONT], lineup[service_1.CourtPosition.MIDDLE_FRONT], lineup[service_1.CourtPosition.RIGHT_FRONT],
+                lineup[service_1.CourtPosition.LEFT_BACK], lineup[service_1.CourtPosition.MIDDLE_BACK], lineup[service_1.CourtPosition.RIGHT_BACK]]
+                .map((p) => p.id));
+            const healed = {};
+            for (const [id, value] of Object.entries(model.replace_knocked_immediately ?? {})) {
+                if (starterIds.has(id) && typeof value === 'boolean')
+                    healed[id] = value;
+            }
+            return healed;
+        })(),
         // LENIENT (roster.find, not findPlayer): an entry whose starter or replacement is gone/invalid is DROPPED
         // rather than crashing the sim batch (a dropped entry = unconfigured = the bench-only auto fallback, per
         // the owner rules); an invalid benchBackfill drops only the backfill. First occurrence wins on duplicates;
@@ -270,7 +282,19 @@ function tacticsColumnsToApiDto(model) {
         offensivePreferences: model.offensive_preferences,
         systemSets: model.system_sets,
         offensivePreferenceSets: model.offensive_preference_sets,
-        replaceInjuredImmediately: model.replace_injured_immediately ?? true,
+        // Same stale-data policy as the heals below: only starter-keyed boolean entries survive, and an empty
+        // map surfaces as absent (missing key = ON).
+        replaceKnockedImmediately: (() => {
+            const starterSlotIds = new Set([model.lineup[service_1.CourtPosition.LEFT_FRONT], model.lineup[service_1.CourtPosition.MIDDLE_FRONT],
+                model.lineup[service_1.CourtPosition.RIGHT_FRONT], model.lineup[service_1.CourtPosition.LEFT_BACK],
+                model.lineup[service_1.CourtPosition.MIDDLE_BACK], model.lineup[service_1.CourtPosition.RIGHT_BACK]]);
+            const healed = {};
+            for (const [id, value] of Object.entries(model.replace_knocked_immediately ?? {})) {
+                if (starterSlotIds.has(id) && typeof value === 'boolean')
+                    healed[id] = value;
+            }
+            return Object.keys(healed).length > 0 ? healed : undefined;
+        })(),
         // Same stale-data policy as validSecondLibero above: don't surface entries the service load would drop
         // (starter no longer a starter, replacement now a starter/libero/L2, duplicates), or the UI reloads and
         // re-emits them forever. Roster membership can't be checked here (ids only); the service heal covers that.
@@ -335,7 +359,7 @@ function apiTacticsConfigToAttributes(config, teamId) {
         offensive_preferences: config.offensivePreferences,
         system_sets: config.systemSets,
         offensive_preference_sets: config.offensivePreferenceSets,
-        replace_injured_immediately: config.replaceInjuredImmediately,
+        replace_knocked_immediately: config.replaceKnockedImmediately,
         injury_replacements: config.injuryReplacements
     };
 }

package/dist/cjs/src/service/player/injury.d.ts

@@ -2,7 +2,8 @@ import { Rarity } from './rarity';
 export declare enum InjurySeverityEnum {
     MINOR = 1,
     MODERATE = 2,
-    SEVERE = 3
+    SEVERE = 3,
+    CRITICAL = 4
 }
 export interface PlayerInjury {
     readonly severity: number;

package/dist/cjs/src/service/player/injury.js

@@ -10,6 +10,7 @@ var InjurySeverityEnum;
     InjurySeverityEnum[InjurySeverityEnum["MINOR"] = 1] = "MINOR";
     InjurySeverityEnum[InjurySeverityEnum["MODERATE"] = 2] = "MODERATE";
     InjurySeverityEnum[InjurySeverityEnum["SEVERE"] = 3] = "SEVERE";
+    InjurySeverityEnum[InjurySeverityEnum["CRITICAL"] = 4] = "CRITICAL";
 })(InjurySeverityEnum || (exports.InjurySeverityEnum = InjurySeverityEnum = {}));
 // A long-term injury is active while `at` is before injuredUntil.
 function hasActiveInjury(injury, at) {

package/dist/cjs/src/service/player/injury.test.js

@@ -26,7 +26,8 @@ const test_helpers_1 = require("../test-helpers");
         }
     });
     (0, globals_1.it)('rejects out-of-range severity and profile', () => {
-        (0, globals_1.expect)(player_z_1.PlayerInputSchema.safeParse({ ...validInput(), injury: { severity: 4, injuredUntil: new Date() } }).success).toBe(false);
+        (0, globals_1.expect)(player_z_1.PlayerInputSchema.safeParse({ ...validInput(), injury: { severity: 4, injuredUntil: new Date() } }).success).toBe(true);
+        (0, globals_1.expect)(player_z_1.PlayerInputSchema.safeParse({ ...validInput(), injury: { severity: 5, injuredUntil: new Date() } }).success).toBe(false);
         (0, globals_1.expect)(player_z_1.PlayerInputSchema.safeParse({ ...validInput(), injury: { severity: 0, injuredUntil: new Date() } }).success).toBe(false);
         (0, globals_1.expect)(player_z_1.PlayerInputSchema.safeParse({ ...validInput(), injuryProneProfile: 1.2 }).success).toBe(false);
         (0, globals_1.expect)(player_z_1.PlayerInputSchema.safeParse({ ...validInput(), injuryProneProfile: -0.1 }).success).toBe(false);

package/dist/cjs/src/service/player/schemas/player.z.js

@@ -41,7 +41,7 @@ exports.PlayerInputSchema = zod_1.z.object({
     // Defaulted so every existing Player.create caller (generator, transformers, test helpers) stays valid.
     injuryProneProfile: zod_1.z.number().min(0).max(1).default(0.5),
     injury: zod_1.z.object({
-        severity: zod_1.z.number().int().min(1).max(3),
+        severity: zod_1.z.number().int().min(1).max(4),
         injuredUntil: zod_1.z.coerce.date(),
         debuff: zod_1.z.number().min(0).max(1).optional()
     }).optional(),

package/dist/cjs/src/service/team/schemas/injury-replacement.z.test.js

@@ -32,14 +32,40 @@ const test_helpers_1 = require("../../test-helpers");
             ...overrides
         };
     }
-    (0, globals_1.it)('defaults to true / empty', () => {
+    (0, globals_1.it)('defaults to an empty knock map / empty replacements', () => {
         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.replaceInjuredImmediately).toBe(true);
+            (0, globals_1.expect)(res.data.replaceKnockedImmediately).toEqual({});
             (0, globals_1.expect)(res.data.injuryReplacements).toEqual([]);
         }
     });
+    (0, globals_1.it)('accepts a starter-keyed replaceKnockedImmediately map', () => {
+        const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
+            replaceKnockedImmediately: { [p1.id]: false, [p3.id]: true }
+        }));
+        (0, globals_1.expect)(res.success).toBe(true);
+        if (res.success) {
+            (0, globals_1.expect)(res.data.replaceKnockedImmediately).toEqual({ [p1.id]: false, [p3.id]: true });
+        }
+    });
+    (0, globals_1.it)('rejects a replaceKnockedImmediately key that is not a court starter', () => {
+        for (const outsider of [benchA, libero, reserveA]) {
+            const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
+                replaceKnockedImmediately: { [outsider.id]: false }
+            }));
+            (0, globals_1.expect)(res.success).toBe(false);
+            if (!res.success) {
+                (0, globals_1.expect)(res.error.issues.some(issue => issue.message === 'REPLACE_KNOCKED_KEY_NOT_A_STARTER')).toBe(true);
+            }
+        }
+    });
+    (0, globals_1.it)('rejects a non-boolean replaceKnockedImmediately value', () => {
+        const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
+            replaceKnockedImmediately: { [p1.id]: 'off' }
+        }));
+        (0, globals_1.expect)(res.success).toBe(false);
+    });
     (0, globals_1.it)('accepts a bench replacement with a reserve backfill', () => {
         const res = tactics_z_1.TacticsInputSchema.safeParse(baseInput({
             injuryReplacements: [{ starter: p1, replacement: benchA, benchBackfill: reserveA }]

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

@@ -123,7 +123,7 @@ export declare const TacticsInputSchema: z.ZodObject<{
         rotation: z.ZodNumber;
         order: z.ZodArray<z.ZodCustom<Player, Player>>;
     }, z.core.$strip>>>>;
-    replaceInjuredImmediately: z.ZodDefault<z.ZodBoolean>;
+    replaceKnockedImmediately: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
     injuryReplacements: z.ZodDefault<z.ZodArray<z.ZodObject<{
         starter: z.ZodCustom<Player, Player>;
         replacement: z.ZodCustom<Player, Player>;

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

@@ -81,10 +81,11 @@ exports.TacticsInputSchema = zod_1.z.object({
     // validated with the same cross-field rules as the flat fields (see superRefine below).
     systemSets: zod_1.z.array(systemSetSchema).max(5).optional(),
     offensivePreferenceSets: zod_1.z.array(zod_1.z.array(offensivePreferenceSchema)).max(5).optional(),
-    // Injuries. Defaults keep every existing Tactics.create({...}) call valid. injuryReplacements is the
-    // per-starter explicit replacement mapping (owner rules: followed verbatim, bench-only auto fallback,
-    // reserves never auto-promoted); cross-field rules in the superRefine below.
-    replaceInjuredImmediately: zod_1.z.boolean().default(true),
+    // Injuries. Defaults keep every existing Tactics.create({...}) call valid. replaceKnockedImmediately is
+    // PER STARTER (owner order 2026-07-05): keyed by starter id, missing key = ON; keys validated against the
+    // lineup in the superRefine below. injuryReplacements is the per-starter explicit replacement mapping
+    // (owner rules: followed verbatim, bench-only auto fallback, reserves never auto-promoted).
+    replaceKnockedImmediately: zod_1.z.record(zod_1.z.string(), zod_1.z.boolean()).default({}),
     injuryReplacements: zod_1.z.array(zod_1.z.object({
         starter: playerInstanceSchema,
         replacement: playerInstanceSchema,
@@ -187,6 +188,13 @@ exports.TacticsInputSchema = zod_1.z.object({
             }
         }
     }
+    // Per-starter knock toggle: every key must be a configured court starter (bench/reserve/libero players
+    // follow the slot they occupy, so they never carry their own key).
+    for (const starterId of Object.keys(data.replaceKnockedImmediately)) {
+        if (!starterIds.has(starterId)) {
+            ctx.addIssue({ code: 'custom', message: 'REPLACE_KNOCKED_KEY_NOT_A_STARTER', path: ['replaceKnockedImmediately'] });
+        }
+    }
     // Injury replacements (owner rules 2026-07-03). starter = a court starter, at most one entry each.
     // replacement = a bench player or a reserve (never another starter, the libero, or the L2). benchBackfill
     // only when the replacement came from the bench, and must be a RESERVE (outside the whole lineup, not the

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

@@ -131,7 +131,7 @@ export declare const TeamInputSchema: z.ZodObject<{
             rotation: z.ZodNumber;
             order: z.ZodArray<z.ZodCustom<Player, Player>>;
         }, z.core.$strip>>>>;
-        replaceInjuredImmediately: z.ZodDefault<z.ZodBoolean>;
+        replaceKnockedImmediately: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
         injuryReplacements: z.ZodDefault<z.ZodArray<z.ZodObject<{
             starter: z.ZodCustom<Player, Player>;
             replacement: z.ZodCustom<Player, Player>;

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

@@ -34,7 +34,7 @@ export interface TacticsOpts {
     readonly offensivePreferences: OffensivePreference[];
     readonly systemSets?: SystemSet[];
     readonly offensivePreferenceSets?: OffensivePreference[][];
-    readonly replaceInjuredImmediately: boolean;
+    readonly replaceKnockedImmediately: Record<string, boolean>;
     readonly injuryReplacements: InjuryReplacement[];
 }
 export declare class Tactics {
@@ -51,7 +51,7 @@ export declare class Tactics {
     readonly offensivePreferences: OffensivePreference[];
     readonly systemSets?: SystemSet[];
     readonly offensivePreferenceSets?: OffensivePreference[][];
-    readonly replaceInjuredImmediately: boolean;
+    readonly replaceKnockedImmediately: Record<string, boolean>;
     readonly injuryReplacements: InjuryReplacement[];
     static create(input: unknown): Tactics;
     private constructor();

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, replaceInjuredImmediately = true, injuryReplacements = [] }) {
+    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 = [] }) {
         this.lineup = lineup;
         this.liberoReplacements = liberoReplacements;
         this.receiveRotationOffset = receiveRotationOffset;
@@ -32,7 +32,7 @@ class Tactics {
         this.offensivePreferences = offensivePreferences;
         this.systemSets = systemSets;
         this.offensivePreferenceSets = offensivePreferenceSets;
-        this.replaceInjuredImmediately = replaceInjuredImmediately;
+        this.replaceKnockedImmediately = replaceKnockedImmediately;
         this.injuryReplacements = injuryReplacements;
     }
     findPlayerInLineup(id) {

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

@@ -132,7 +132,7 @@ export interface Tactics {
     offensivePreferences: ApiOffensivePreference[];
     systemSets?: ApiSystemSet[];
     offensivePreferenceSets?: ApiOffensivePreference[][];
-    replaceInjuredImmediately: boolean;
+    replaceKnockedImmediately?: Record<string, boolean>;
     injuryReplacements?: ApiInjuryReplacement[];
 }
 export interface ApiLineupPreset {

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

@@ -66,12 +66,12 @@ export interface TacticsAttributes {
     offensive_preferences: OffensivePreferenceAttributes[];
     system_sets?: SystemSetAttributes[];
     offensive_preference_sets?: OffensivePreferenceAttributes[][];
-    replace_injured_immediately?: boolean;
+    replace_knocked_immediately?: Record<PlayerId, boolean>;
     injury_replacements?: InjuryReplacementAttributes[];
 }
 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_injured_immediately' | 'injury_replacements';
+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';
 export type TacticsCreationAttributes = Optional<TacticsAttributes, TacticsOptionalAttributes>;
 export declare class TacticsModel extends Model<TacticsAttributes, TacticsCreationAttributes> implements TacticsAttributes {
     team_id: string;
@@ -88,7 +88,7 @@ export declare class TacticsModel extends Model<TacticsAttributes, TacticsCreati
     offensive_preferences: OffensivePreferenceAttributes[];
     system_sets?: SystemSetAttributes[];
     offensive_preference_sets?: OffensivePreferenceAttributes[][];
-    replace_injured_immediately?: boolean;
+    replace_knocked_immediately?: Record<PlayerId, boolean>;
     injury_replacements?: InjuryReplacementAttributes[];
     team: TeamModel;
     getTeam: Sequelize.BelongsToGetAssociationMixin<TeamModel>;

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

@@ -72,10 +72,9 @@ export class TacticsModel extends Model {
                 type: DataTypes.JSONB,
                 allowNull: true
             },
-            replace_injured_immediately: {
-                type: DataTypes.BOOLEAN,
-                allowNull: false,
-                defaultValue: true
+            replace_knocked_immediately: {
+                type: DataTypes.JSONB,
+                allowNull: true
             },
             injury_replacements: {
                 type: DataTypes.JSONB,

package/dist/esm/src/data/transformers/lineup-preset.js

@@ -1,17 +1,14 @@
 // `config` is already stored as the API Tactics DTO, so a preset row maps to its API shape with no hydration.
-// Presets saved before the injuries fields exist lack replaceInjuredImmediately: heal it to the effective
-// default (true, matching transformToTactics' hydration) so the DTO's required field is honest and a UI
-// toggle seeded from an old preset cannot silently flip the user's effective setting on re-save.
+// No injuries heal here anymore: replaceKnockedImmediately is optional (absent = every starter ON), and old
+// configs carrying the superseded replaceInjuredImmediately boolean pass through the spread as a dead key
+// that the save DTO strips (owner 2026-07-05: the old global value is dropped, default ON).
 function transformToObject(model) {
     return {
         presetId: model.preset_id,
         name: model.name,
         isActive: model.is_active,
         orderIndex: model.order_index,
-        config: {
-            ...model.config,
-            replaceInjuredImmediately: model.config.replaceInjuredImmediately ?? true
-        }
+        config: model.config
     };
 }
 export { transformToObject as transformToLineupPreset };

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

@@ -1,7 +1,7 @@
 import { describe, it, expect } from '@jest/globals';
 import { transformToLineupPreset } from './lineup-preset';
 describe('transformToLineupPreset()', () => {
-    it('maps preset columns to the API shape and heals a pre-injuries config to the effective default', () => {
+    it('maps preset columns to the API shape verbatim (no injuries heal: absent map = every starter ON)', () => {
         const config = { lineup: { bench: [] }, substitutionBand: 'TIRED' };
         const preset = transformToLineupPreset({
             preset_id: 'p1',
@@ -16,13 +16,15 @@ describe('transformToLineupPreset()', () => {
             name: 'Starters',
             isActive: true,
             orderIndex: 2,
-            // A config stored before the injuries fields lacks replaceInjuredImmediately; the transform heals it
-            // to true (the effective hydration default) so the DTO's required field is honest.
-            config: { ...config, replaceInjuredImmediately: true }
+            config
         });
     });
-    it('keeps an explicit replaceInjuredImmediately: false', () => {
-        const config = { lineup: { bench: [] }, substitutionBand: 'TIRED', replaceInjuredImmediately: false };
+    it('keeps an explicit per-starter replaceKnockedImmediately map', () => {
+        const config = {
+            lineup: { bench: [] },
+            substitutionBand: 'TIRED',
+            replaceKnockedImmediately: { 'starter-1': false }
+        };
         const preset = transformToLineupPreset({
             preset_id: 'p2',
             team_id: 't1',
@@ -31,6 +33,6 @@ describe('transformToLineupPreset()', () => {
             order_index: 3,
             config
         });
-        expect(preset.config.replaceInjuredImmediately).toBe(false);
+        expect(preset.config.replaceKnockedImmediately).toEqual({ 'starter-1': false });
     });
 });

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

@@ -82,7 +82,7 @@ function transformToAttributes(tactics, teamId) {
             rotation: p.rotation,
             order: p.order.map((a) => a.id)
         }))),
-        replace_injured_immediately: tactics.replaceInjuredImmediately,
+        replace_knocked_immediately: tactics.replaceKnockedImmediately,
         injury_replacements: tactics.injuryReplacements.map(ir => ({
             starterId: ir.starter.id,
             replacementId: ir.replacement.id,
@@ -165,7 +165,19 @@ function transformToObject(model, roster) {
             rotation: p.rotation,
             order: p.order.map((id) => findPlayer(id, roster))
         }))),
-        replaceInjuredImmediately: model.replace_injured_immediately ?? true,
+        // LENIENT: keep only starter-keyed boolean entries so stale jsonb (an ex-starter's key, a non-boolean
+        // value) can never fail schema validation and crash a team load; a dropped key = the ON default.
+        replaceKnockedImmediately: (() => {
+            const starterIds = new Set([lineup[CourtPosition.LEFT_FRONT], lineup[CourtPosition.MIDDLE_FRONT], lineup[CourtPosition.RIGHT_FRONT],
+                lineup[CourtPosition.LEFT_BACK], lineup[CourtPosition.MIDDLE_BACK], lineup[CourtPosition.RIGHT_BACK]]
+                .map((p) => p.id));
+            const healed = {};
+            for (const [id, value] of Object.entries(model.replace_knocked_immediately ?? {})) {
+                if (starterIds.has(id) && typeof value === 'boolean')
+                    healed[id] = value;
+            }
+            return healed;
+        })(),
         // LENIENT (roster.find, not findPlayer): an entry whose starter or replacement is gone/invalid is DROPPED
         // rather than crashing the sim batch (a dropped entry = unconfigured = the bench-only auto fallback, per
         // the owner rules); an invalid benchBackfill drops only the backfill. First occurrence wins on duplicates;
@@ -264,7 +276,19 @@ function tacticsColumnsToApiDto(model) {
         offensivePreferences: model.offensive_preferences,
         systemSets: model.system_sets,
         offensivePreferenceSets: model.offensive_preference_sets,
-        replaceInjuredImmediately: model.replace_injured_immediately ?? true,
+        // Same stale-data policy as the heals below: only starter-keyed boolean entries survive, and an empty
+        // map surfaces as absent (missing key = ON).
+        replaceKnockedImmediately: (() => {
+            const starterSlotIds = new Set([model.lineup[CourtPosition.LEFT_FRONT], model.lineup[CourtPosition.MIDDLE_FRONT],
+                model.lineup[CourtPosition.RIGHT_FRONT], model.lineup[CourtPosition.LEFT_BACK],
+                model.lineup[CourtPosition.MIDDLE_BACK], model.lineup[CourtPosition.RIGHT_BACK]]);
+            const healed = {};
+            for (const [id, value] of Object.entries(model.replace_knocked_immediately ?? {})) {
+                if (starterSlotIds.has(id) && typeof value === 'boolean')
+                    healed[id] = value;
+            }
+            return Object.keys(healed).length > 0 ? healed : undefined;
+        })(),
         // Same stale-data policy as validSecondLibero above: don't surface entries the service load would drop
         // (starter no longer a starter, replacement now a starter/libero/L2, duplicates), or the UI reloads and
         // re-emits them forever. Roster membership can't be checked here (ids only); the service heal covers that.
@@ -329,7 +353,7 @@ function apiTacticsConfigToAttributes(config, teamId) {
         offensive_preferences: config.offensivePreferences,
         system_sets: config.systemSets,
         offensive_preference_sets: config.offensivePreferenceSets,
-        replace_injured_immediately: config.replaceInjuredImmediately,
+        replace_knocked_immediately: config.replaceKnockedImmediately,
         injury_replacements: config.injuryReplacements
     };
 }

package/dist/esm/src/service/player/injury.d.ts

@@ -2,7 +2,8 @@ import { Rarity } from './rarity';
 export declare enum InjurySeverityEnum {
     MINOR = 1,
     MODERATE = 2,
-    SEVERE = 3
+    SEVERE = 3,
+    CRITICAL = 4
 }
 export interface PlayerInjury {
     readonly severity: number;

package/dist/esm/src/service/player/injury.js

@@ -4,6 +4,7 @@ export var InjurySeverityEnum;
     InjurySeverityEnum[InjurySeverityEnum["MINOR"] = 1] = "MINOR";
     InjurySeverityEnum[InjurySeverityEnum["MODERATE"] = 2] = "MODERATE";
     InjurySeverityEnum[InjurySeverityEnum["SEVERE"] = 3] = "SEVERE";
+    InjurySeverityEnum[InjurySeverityEnum["CRITICAL"] = 4] = "CRITICAL";
 })(InjurySeverityEnum || (InjurySeverityEnum = {}));
 // A long-term injury is active while `at` is before injuredUntil.
 export function hasActiveInjury(injury, at) {

package/dist/esm/src/service/player/injury.test.js

@@ -24,7 +24,8 @@ describe('Player injury fields', () => {
         }
     });
     it('rejects out-of-range severity and profile', () => {
-        expect(PlayerInputSchema.safeParse({ ...validInput(), injury: { severity: 4, injuredUntil: new Date() } }).success).toBe(false);
+        expect(PlayerInputSchema.safeParse({ ...validInput(), injury: { severity: 4, injuredUntil: new Date() } }).success).toBe(true);
+        expect(PlayerInputSchema.safeParse({ ...validInput(), injury: { severity: 5, injuredUntil: new Date() } }).success).toBe(false);
         expect(PlayerInputSchema.safeParse({ ...validInput(), injury: { severity: 0, injuredUntil: new Date() } }).success).toBe(false);
         expect(PlayerInputSchema.safeParse({ ...validInput(), injuryProneProfile: 1.2 }).success).toBe(false);
         expect(PlayerInputSchema.safeParse({ ...validInput(), injuryProneProfile: -0.1 }).success).toBe(false);

package/dist/esm/src/service/player/schemas/player.z.js

@@ -38,7 +38,7 @@ export const PlayerInputSchema = z.object({
     // Defaulted so every existing Player.create caller (generator, transformers, test helpers) stays valid.
     injuryProneProfile: z.number().min(0).max(1).default(0.5),
     injury: z.object({
-        severity: z.number().int().min(1).max(3),
+        severity: z.number().int().min(1).max(4),
         injuredUntil: z.coerce.date(),
         debuff: z.number().min(0).max(1).optional()
     }).optional(),

package/dist/esm/src/service/team/schemas/injury-replacement.z.test.js

@@ -30,14 +30,40 @@ describe('TacticsInputSchema — injuryReplacements (owner rules 2026-07-03)', (
             ...overrides
         };
     }
-    it('defaults to true / empty', () => {
+    it('defaults to an empty knock map / empty replacements', () => {
         const res = TacticsInputSchema.safeParse(baseInput());
         expect(res.success).toBe(true);
         if (res.success) {
-            expect(res.data.replaceInjuredImmediately).toBe(true);
+            expect(res.data.replaceKnockedImmediately).toEqual({});
             expect(res.data.injuryReplacements).toEqual([]);
         }
     });
+    it('accepts a starter-keyed replaceKnockedImmediately map', () => {
+        const res = TacticsInputSchema.safeParse(baseInput({
+            replaceKnockedImmediately: { [p1.id]: false, [p3.id]: true }
+        }));
+        expect(res.success).toBe(true);
+        if (res.success) {
+            expect(res.data.replaceKnockedImmediately).toEqual({ [p1.id]: false, [p3.id]: true });
+        }
+    });
+    it('rejects a replaceKnockedImmediately key that is not a court starter', () => {
+        for (const outsider of [benchA, libero, reserveA]) {
+            const res = TacticsInputSchema.safeParse(baseInput({
+                replaceKnockedImmediately: { [outsider.id]: false }
+            }));
+            expect(res.success).toBe(false);
+            if (!res.success) {
+                expect(res.error.issues.some(issue => issue.message === 'REPLACE_KNOCKED_KEY_NOT_A_STARTER')).toBe(true);
+            }
+        }
+    });
+    it('rejects a non-boolean replaceKnockedImmediately value', () => {
+        const res = TacticsInputSchema.safeParse(baseInput({
+            replaceKnockedImmediately: { [p1.id]: 'off' }
+        }));
+        expect(res.success).toBe(false);
+    });
     it('accepts a bench replacement with a reserve backfill', () => {
         const res = TacticsInputSchema.safeParse(baseInput({
             injuryReplacements: [{ starter: p1, replacement: benchA, benchBackfill: reserveA }]

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

@@ -123,7 +123,7 @@ export declare const TacticsInputSchema: z.ZodObject<{
         rotation: z.ZodNumber;
         order: z.ZodArray<z.ZodCustom<Player, Player>>;
     }, z.core.$strip>>>>;
-    replaceInjuredImmediately: z.ZodDefault<z.ZodBoolean>;
+    replaceKnockedImmediately: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
     injuryReplacements: z.ZodDefault<z.ZodArray<z.ZodObject<{
         starter: z.ZodCustom<Player, Player>;
         replacement: z.ZodCustom<Player, Player>;

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

@@ -78,10 +78,11 @@ export const TacticsInputSchema = z.object({
     // validated with the same cross-field rules as the flat fields (see superRefine below).
     systemSets: z.array(systemSetSchema).max(5).optional(),
     offensivePreferenceSets: z.array(z.array(offensivePreferenceSchema)).max(5).optional(),
-    // Injuries. Defaults keep every existing Tactics.create({...}) call valid. injuryReplacements is the
-    // per-starter explicit replacement mapping (owner rules: followed verbatim, bench-only auto fallback,
-    // reserves never auto-promoted); cross-field rules in the superRefine below.
-    replaceInjuredImmediately: z.boolean().default(true),
+    // Injuries. Defaults keep every existing Tactics.create({...}) call valid. replaceKnockedImmediately is
+    // PER STARTER (owner order 2026-07-05): keyed by starter id, missing key = ON; keys validated against the
+    // lineup in the superRefine below. injuryReplacements is the per-starter explicit replacement mapping
+    // (owner rules: followed verbatim, bench-only auto fallback, reserves never auto-promoted).
+    replaceKnockedImmediately: z.record(z.string(), z.boolean()).default({}),
     injuryReplacements: z.array(z.object({
         starter: playerInstanceSchema,
         replacement: playerInstanceSchema,
@@ -184,6 +185,13 @@ export const TacticsInputSchema = z.object({
             }
         }
     }
+    // Per-starter knock toggle: every key must be a configured court starter (bench/reserve/libero players
+    // follow the slot they occupy, so they never carry their own key).
+    for (const starterId of Object.keys(data.replaceKnockedImmediately)) {
+        if (!starterIds.has(starterId)) {
+            ctx.addIssue({ code: 'custom', message: 'REPLACE_KNOCKED_KEY_NOT_A_STARTER', path: ['replaceKnockedImmediately'] });
+        }
+    }
     // Injury replacements (owner rules 2026-07-03). starter = a court starter, at most one entry each.
     // replacement = a bench player or a reserve (never another starter, the libero, or the L2). benchBackfill
     // only when the replacement came from the bench, and must be a RESERVE (outside the whole lineup, not the

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

@@ -131,7 +131,7 @@ export declare const TeamInputSchema: z.ZodObject<{
             rotation: z.ZodNumber;
             order: z.ZodArray<z.ZodCustom<Player, Player>>;
         }, z.core.$strip>>>>;
-        replaceInjuredImmediately: z.ZodDefault<z.ZodBoolean>;
+        replaceKnockedImmediately: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
         injuryReplacements: z.ZodDefault<z.ZodArray<z.ZodObject<{
             starter: z.ZodCustom<Player, Player>;
             replacement: z.ZodCustom<Player, Player>;

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

@@ -34,7 +34,7 @@ export interface TacticsOpts {
     readonly offensivePreferences: OffensivePreference[];
     readonly systemSets?: SystemSet[];
     readonly offensivePreferenceSets?: OffensivePreference[][];
-    readonly replaceInjuredImmediately: boolean;
+    readonly replaceKnockedImmediately: Record<string, boolean>;
     readonly injuryReplacements: InjuryReplacement[];
 }
 export declare class Tactics {
@@ -51,7 +51,7 @@ export declare class Tactics {
     readonly offensivePreferences: OffensivePreference[];
     readonly systemSets?: SystemSet[];
     readonly offensivePreferenceSets?: OffensivePreference[][];
-    readonly replaceInjuredImmediately: boolean;
+    readonly replaceKnockedImmediately: Record<string, boolean>;
     readonly injuryReplacements: InjuryReplacement[];
     static create(input: unknown): Tactics;
     private constructor();

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, replaceInjuredImmediately = true, injuryReplacements = [] }) {
+    constructor({ lineup, liberoReplacements, receiveRotationOffset = false, designatedSubs = [], substitutionBand = EnergyBand.TIRED, secondLibero, liberoSub, liberoReplacementSets, rotationSystem = RotationSystemEnum.SIX_ZERO, designatedSetters = [], offensivePreferences = [], systemSets, offensivePreferenceSets, replaceKnockedImmediately = {}, injuryReplacements = [] }) {
         this.lineup = lineup;
         this.liberoReplacements = liberoReplacements;
         this.receiveRotationOffset = receiveRotationOffset;
@@ -29,7 +29,7 @@ export class Tactics {
         this.offensivePreferences = offensivePreferences;
         this.systemSets = systemSets;
         this.offensivePreferenceSets = offensivePreferenceSets;
-        this.replaceInjuredImmediately = replaceInjuredImmediately;
+        this.replaceKnockedImmediately = replaceKnockedImmediately;
         this.injuryReplacements = injuryReplacements;
     }
     findPlayerInLineup(id) {

package/package.json

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