volleyballsimtypes 0.0.469 → 0.0.471

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/rally-event-injury.test.js

@@ -31,3 +31,55 @@ const rally_event_1 = require("./rally-event");
         (0, globals_1.expect)(decoded.injury).toBeUndefined();
     });
 });
+(0, globals_1.describe)('rally-event compact round trip — incident marker on the causing event', () => {
+    const playerId = (0, uuid_1.v4)();
+    const roster = [playerId];
+    const playerIndex = new Map(roster.map((id, i) => [id, i]));
+    function makeSpike(incident) {
+        return service_1.Spike.create({
+            playerId,
+            score: 62.5,
+            target: 4,
+            failure: service_1.SpikeFailureEnum.NO_FAILURE,
+            type: service_1.SpikeTypeEnum.CROSS_SHOT,
+            ...(incident != null ? { incident } : {})
+        });
+    }
+    (0, globals_1.it)('packs an INJURY incident as i = severity (1-4) and round-trips kind + severity', () => {
+        const compact = (0, rally_event_1.transformToCompact)(makeSpike({ kind: 'INJURY', severity: 4 }), playerIndex);
+        (0, globals_1.expect)(compact.i).toBe(4);
+        const decoded = (0, rally_event_1.transformToSpike)(compact, roster);
+        (0, globals_1.expect)(decoded.incident).toEqual({ kind: 'INJURY', severity: 4 });
+    });
+    (0, globals_1.it)('packs a KNOCK incident as i = 10 + tier and round-trips kind + severity', () => {
+        const serve = service_1.Serve.create({
+            playerId,
+            score: 55,
+            target: 6,
+            failure: service_1.ServeFailureEnum.NO_FAILURE,
+            type: service_1.ServeTypeEnum.JUMP_TOPSPIN,
+            incident: { kind: 'KNOCK', severity: 2 }
+        });
+        const compact = (0, rally_event_1.transformToCompact)(serve, playerIndex);
+        (0, globals_1.expect)(compact.i).toBe(12);
+        const decoded = (0, rally_event_1.transformToServe)(compact, roster);
+        (0, globals_1.expect)(decoded.incident).toEqual({ kind: 'KNOCK', severity: 2 });
+    });
+    (0, globals_1.it)('omits i entirely for an event without an incident', () => {
+        const compact = (0, rally_event_1.transformToCompact)(makeSpike(), playerIndex);
+        (0, globals_1.expect)('i' in compact).toBe(false);
+        const decoded = (0, rally_event_1.transformToSpike)(compact, roster);
+        (0, globals_1.expect)(decoded.incident).toBeUndefined();
+    });
+    (0, globals_1.it)('decodes a legacy compact event (no i key) with no incident', () => {
+        const legacy = { p: 0, e: service_1.EventTypeEnum.SPIKE, f: 0, t: 0, a: 4, s: 50 };
+        const decoded = (0, rally_event_1.transformToSpike)(legacy, roster);
+        (0, globals_1.expect)(decoded.incident).toBeUndefined();
+    });
+    (0, globals_1.it)('rejects an out-of-range or malformed incident at the schema', () => {
+        (0, globals_1.expect)(() => makeSpike({ kind: 'INJURY', severity: 5 })).toThrow(/INVALID_SPIKE/);
+        (0, globals_1.expect)(() => makeSpike({ kind: 'INJURY', severity: 0 })).toThrow(/INVALID_SPIKE/);
+        (0, globals_1.expect)(() => makeSpike({ kind: 'KNOCK', severity: 4 })).toThrow(/INVALID_SPIKE/);
+        (0, globals_1.expect)(() => makeSpike({ kind: 'BRUISE', severity: 1 })).toThrow(/INVALID_SPIKE/);
+    });
+});

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

@@ -10,6 +10,7 @@ export interface CompactEvent {
     l?: number;
     o?: number;
     j?: number;
+    i?: number;
 }
 export declare function transformToCompact(evt: RallyEvent, playerIndex: Map<string, number>): CompactEvent;
 export declare function transformToBlock(event: CompactEvent, roster: string[]): Block;

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

@@ -9,6 +9,17 @@ exports.transformToSet = transformToSet;
 exports.transformToSpike = transformToSpike;
 exports.transformToSubstitution = transformToSubstitution;
 const service_1 = require("../../service");
+// Incident packing for the compact key 'i': values below 10 are injury severities, 10+ are knock tiers.
+function incidentToCompact(incident) {
+    if (incident == null)
+        return undefined;
+    return incident.kind === 'KNOCK' ? 10 + incident.severity : incident.severity;
+}
+function incidentFromCompact(i) {
+    if (i == null)
+        return undefined;
+    return i >= 10 ? { kind: 'KNOCK', severity: i - 10 } : { kind: 'INJURY', severity: i };
+}
 function transformToCompact(evt, playerIndex) {
     const out = {
         p: playerIndex.get(evt.playerId),
@@ -19,6 +30,9 @@ function transformToCompact(evt, playerIndex) {
         out.t = evt.type;
         out.a = evt.target;
         out.s = evt.score;
+        const i = incidentToCompact(evt.incident);
+        if (i != null)
+            out.i = i;
         if (evt instanceof service_1.Block) {
             out.b = evt.blockers.map(id => playerIndex.get(id));
         }
@@ -41,7 +55,8 @@ function transformToBlock(event, roster) {
         playerId: roster[event.p],
         target: event.a,
         blockers: (event.b ?? []).map(i => roster[i]),
-        score: event.s
+        score: event.s,
+        incident: incidentFromCompact(event.i)
     });
 }
 function transformToLiberoReplacement(event, roster) {
@@ -57,7 +72,8 @@ function transformToReception(event, roster) {
         type: event.t,
         playerId: roster[event.p],
         target: event.a,
-        score: event.s
+        score: event.s,
+        incident: incidentFromCompact(event.i)
     });
 }
 function transformToServe(event, roster) {
@@ -66,7 +82,8 @@ function transformToServe(event, roster) {
         type: event.t,
         playerId: roster[event.p],
         target: event.a,
-        score: event.s
+        score: event.s,
+        incident: incidentFromCompact(event.i)
     });
 }
 function transformToSet(event, roster) {
@@ -75,7 +92,8 @@ function transformToSet(event, roster) {
         type: event.t,
         playerId: roster[event.p],
         target: event.a,
-        score: event.s
+        score: event.s,
+        incident: incidentFromCompact(event.i)
     });
 }
 function transformToSpike(event, roster) {
@@ -84,7 +102,8 @@ function transformToSpike(event, roster) {
         type: event.t,
         playerId: roster[event.p],
         target: event.a,
-        score: event.s
+        score: event.s,
+        incident: incidentFromCompact(event.i)
     });
 }
 function transformToSubstitution(event, roster) {

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/event/block.js

@@ -34,8 +34,8 @@ class Block extends in_play_event_1.InPlayEvent {
         }
         return new Block(result.data);
     }
-    constructor({ score, playerId, target, failure, type, blockers, activeTraits }) {
-        super({ score, playerId, target, activeTraits, eventType });
+    constructor({ score, playerId, target, failure, type, blockers, activeTraits, incident }) {
+        super({ score, playerId, target, activeTraits, incident, eventType });
         this.type = type;
         this.failure = failure;
         this.blockers = blockers;

package/dist/cjs/src/service/event/in-play-event.d.ts

@@ -1,10 +1,15 @@
 import { CourtTarget } from '../match';
 import { RallyEvent, RallyEventOpts } from './rally-event';
 import { Trait } from '../player';
+export interface EventIncident {
+    readonly kind: 'KNOCK' | 'INJURY';
+    readonly severity: number;
+}
 export interface InPlayEventOpts extends RallyEventOpts {
     readonly target: CourtTarget;
     readonly score: number;
     readonly activeTraits: Trait[];
+    readonly incident?: EventIncident;
 }
 export declare abstract class InPlayEvent<F, T> extends RallyEvent {
     abstract failure: F;
@@ -12,6 +17,7 @@ export declare abstract class InPlayEvent<F, T> extends RallyEvent {
     readonly target: CourtTarget;
     readonly score: number;
     readonly activeTraits: Trait[];
-    protected constructor({ eventType, playerId, target, score, activeTraits }: InPlayEventOpts);
+    readonly incident?: EventIncident;
+    protected constructor({ eventType, playerId, target, score, activeTraits, incident }: InPlayEventOpts);
     protected _toString(): string;
 }

package/dist/cjs/src/service/event/in-play-event.js

@@ -3,11 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.InPlayEvent = void 0;
 const rally_event_1 = require("./rally-event");
 class InPlayEvent extends rally_event_1.RallyEvent {
-    constructor({ eventType, playerId, target, score, activeTraits }) {
+    constructor({ eventType, playerId, target, score, activeTraits, incident }) {
         super({ playerId, eventType });
         this.target = target;
         this.score = Number(score.toFixed(2));
         this.activeTraits = activeTraits;
+        this.incident = incident;
     }
     _toString() {
         const score = `"score":${this.score}`;

package/dist/cjs/src/service/event/reception.js

@@ -36,8 +36,8 @@ class Reception extends in_play_event_1.InPlayEvent {
         }
         return new Reception(result.data);
     }
-    constructor({ score, playerId, target, failure, type, activeTraits }) {
-        super({ score, playerId, target, activeTraits, eventType });
+    constructor({ score, playerId, target, failure, type, activeTraits, incident }) {
+        super({ score, playerId, target, activeTraits, incident, eventType });
         this.type = type;
         this.failure = failure;
     }

package/dist/cjs/src/service/event/schemas/block.z.d.ts

@@ -27,5 +27,12 @@ export declare const BlockInputSchema: z.ZodObject<{
     failure: z.ZodNumber;
     type: z.ZodNumber;
     blockers: z.ZodArray<z.ZodUUID>;
+    incident: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodEnum<{
+            KNOCK: "KNOCK";
+            INJURY: "INJURY";
+        }>;
+        severity: z.ZodNumber;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type BlockInput = z.infer<typeof BlockInputSchema>;

package/dist/cjs/src/service/event/schemas/block.z.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BlockInputSchema = void 0;
 const zod_1 = require("zod");
 const player_1 = require("../../player");
+const incident_z_1 = require("./incident.z");
 const blockTypeValues = [0, 1, 2, 3];
 const blockFailureValues = [0, 1, 2, 3, 4, 5];
 const courtTargetValues = Array.from({ length: 13 }, (_, i) => i);
@@ -13,7 +14,8 @@ exports.BlockInputSchema = zod_1.z.object({
     activeTraits: zod_1.z.array(zod_1.z.enum(Object.values(player_1.TraitEnum))).default([]),
     failure: zod_1.z.number().int().refine((v) => blockFailureValues.includes(v), { message: 'INVALID_BLOCK_FAILURE' }),
     type: zod_1.z.number().int().refine((v) => blockTypeValues.includes(v), { message: 'INVALID_BLOCK_TYPE' }),
-    blockers: zod_1.z.array(zod_1.z.uuid())
+    blockers: zod_1.z.array(zod_1.z.uuid()),
+    incident: incident_z_1.EventIncidentSchema.optional()
 }).superRefine((data, ctx) => {
     // The block type IS the blocker count (NO_BLOCKER=0, SINGLE=1, DOUBLE=2, TRIPLE=3), so the two must agree.
     if (data.blockers.length !== data.type) {

package/dist/cjs/src/service/event/schemas/incident.z.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+export declare const EventIncidentSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        KNOCK: "KNOCK";
+        INJURY: "INJURY";
+    }>;
+    severity: z.ZodNumber;
+}, z.core.$strip>;
+export type EventIncidentInput = z.infer<typeof EventIncidentSchema>;

package/dist/cjs/src/service/event/schemas/incident.z.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventIncidentSchema = void 0;
+const zod_1 = require("zod");
+// The moment a player got hurt, attached to the causing in-play event (owner 2026-07-05: EVERY knock and
+// injury marks the action that produced it). KNOCK severity is the knock tier (1-3); INJURY severity is the
+// InjurySeverityEnum value (1-4).
+exports.EventIncidentSchema = zod_1.z.object({
+    kind: zod_1.z.enum(['KNOCK', 'INJURY']),
+    severity: zod_1.z.number().int().min(1).max(4)
+}).refine(v => v.kind !== 'KNOCK' || v.severity <= 3, { message: 'INVALID_KNOCK_TIER' });

package/dist/cjs/src/service/event/schemas/reception.z.d.ts

@@ -26,5 +26,12 @@ export declare const ReceptionInputSchema: z.ZodObject<{
     }>>>;
     failure: z.ZodNumber;
     type: z.ZodNumber;
+    incident: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodEnum<{
+            KNOCK: "KNOCK";
+            INJURY: "INJURY";
+        }>;
+        severity: z.ZodNumber;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type ReceptionInput = z.infer<typeof ReceptionInputSchema>;

package/dist/cjs/src/service/event/schemas/reception.z.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ReceptionInputSchema = void 0;
 const zod_1 = require("zod");
 const player_1 = require("../../player");
+const incident_z_1 = require("./incident.z");
 const receptionTypeValues = [0, 1, 2, 3, 4];
 const receptionFailureValues = [0, 1, 2, 3, 4];
 const courtTargetValues = Array.from({ length: 13 }, (_, i) => i);
@@ -12,5 +13,6 @@ exports.ReceptionInputSchema = zod_1.z.object({
     target: zod_1.z.number().int().refine((v) => courtTargetValues.includes(v), { message: 'INVALID_COURT_TARGET' }),
     activeTraits: zod_1.z.array(zod_1.z.enum(Object.values(player_1.TraitEnum))).default([]),
     failure: zod_1.z.number().int().refine((v) => receptionFailureValues.includes(v), { message: 'INVALID_RECEPTION_FAILURE' }),
-    type: zod_1.z.number().int().refine((v) => receptionTypeValues.includes(v), { message: 'INVALID_RECEPTION_TYPE' })
+    type: zod_1.z.number().int().refine((v) => receptionTypeValues.includes(v), { message: 'INVALID_RECEPTION_TYPE' }),
+    incident: incident_z_1.EventIncidentSchema.optional()
 });

package/dist/cjs/src/service/event/schemas/serve.z.d.ts

@@ -26,5 +26,12 @@ export declare const ServeInputSchema: z.ZodObject<{
     }>>>;
     failure: z.ZodNumber;
     type: z.ZodNumber;
+    incident: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodEnum<{
+            KNOCK: "KNOCK";
+            INJURY: "INJURY";
+        }>;
+        severity: z.ZodNumber;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type ServeInput = z.infer<typeof ServeInputSchema>;

package/dist/cjs/src/service/event/schemas/serve.z.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ServeInputSchema = void 0;
 const zod_1 = require("zod");
 const player_1 = require("../../player");
+const incident_z_1 = require("./incident.z");
 const serveTypeValues = [0, 1, 2, 3];
 const serveFailureValues = [0, 1, 2, 3, 4];
 const courtTargetValues = Array.from({ length: 13 }, (_, i) => i);
@@ -12,5 +13,6 @@ exports.ServeInputSchema = zod_1.z.object({
     target: zod_1.z.number().int().refine((v) => courtTargetValues.includes(v), { message: 'INVALID_COURT_TARGET' }),
     activeTraits: zod_1.z.array(zod_1.z.enum(Object.values(player_1.TraitEnum))).default([]),
     failure: zod_1.z.number().int().refine((v) => serveFailureValues.includes(v), { message: 'INVALID_SERVE_FAILURE' }),
-    type: zod_1.z.number().int().refine((v) => serveTypeValues.includes(v), { message: 'INVALID_SERVE_TYPE' })
+    type: zod_1.z.number().int().refine((v) => serveTypeValues.includes(v), { message: 'INVALID_SERVE_TYPE' }),
+    incident: incident_z_1.EventIncidentSchema.optional()
 });

package/dist/cjs/src/service/event/schemas/set.z.d.ts

@@ -26,5 +26,12 @@ export declare const SetInputSchema: z.ZodObject<{
     }>>>;
     failure: z.ZodNumber;
     type: z.ZodNumber;
+    incident: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodEnum<{
+            KNOCK: "KNOCK";
+            INJURY: "INJURY";
+        }>;
+        severity: z.ZodNumber;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type SetInput = z.infer<typeof SetInputSchema>;

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SetInputSchema = void 0;
 const zod_1 = require("zod");
 const player_1 = require("../../player");
+const incident_z_1 = require("./incident.z");
 const setTypeValues = [0, 1];
 const setFailureValues = [0, 1, 2, 3, 4];
 const courtTargetValues = Array.from({ length: 13 }, (_, i) => i);
@@ -12,5 +13,6 @@ exports.SetInputSchema = zod_1.z.object({
     target: zod_1.z.number().int().refine((v) => courtTargetValues.includes(v), { message: 'INVALID_COURT_TARGET' }),
     activeTraits: zod_1.z.array(zod_1.z.enum(Object.values(player_1.TraitEnum))).default([]),
     failure: zod_1.z.number().int().refine((v) => setFailureValues.includes(v), { message: 'INVALID_SET_FAILURE' }),
-    type: zod_1.z.number().int().refine((v) => setTypeValues.includes(v), { message: 'INVALID_SET_TYPE' })
+    type: zod_1.z.number().int().refine((v) => setTypeValues.includes(v), { message: 'INVALID_SET_TYPE' }),
+    incident: incident_z_1.EventIncidentSchema.optional()
 });

package/dist/cjs/src/service/event/schemas/spike.z.d.ts

@@ -26,5 +26,12 @@ export declare const SpikeInputSchema: z.ZodObject<{
     }>>>;
     failure: z.ZodNumber;
     type: z.ZodNumber;
+    incident: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodEnum<{
+            KNOCK: "KNOCK";
+            INJURY: "INJURY";
+        }>;
+        severity: z.ZodNumber;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type SpikeInput = z.infer<typeof SpikeInputSchema>;

package/dist/cjs/src/service/event/schemas/spike.z.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SpikeInputSchema = void 0;
 const zod_1 = require("zod");
 const player_1 = require("../../player");
+const incident_z_1 = require("./incident.z");
 const spikeTypeValues = [0, 1, 2, 3, 4, 5];
 const spikeFailureValues = [0, 1, 2, 3, 4];
 const courtTargetValues = Array.from({ length: 13 }, (_, i) => i);
@@ -12,5 +13,6 @@ exports.SpikeInputSchema = zod_1.z.object({
     target: zod_1.z.number().int().refine((v) => courtTargetValues.includes(v), { message: 'INVALID_COURT_TARGET' }),
     activeTraits: zod_1.z.array(zod_1.z.enum(Object.values(player_1.TraitEnum))).default([]),
     failure: zod_1.z.number().int().refine((v) => spikeFailureValues.includes(v), { message: 'INVALID_SPIKE_FAILURE' }),
-    type: zod_1.z.number().int().refine((v) => spikeTypeValues.includes(v), { message: 'INVALID_SPIKE_TYPE' })
+    type: zod_1.z.number().int().refine((v) => spikeTypeValues.includes(v), { message: 'INVALID_SPIKE_TYPE' }),
+    incident: incident_z_1.EventIncidentSchema.optional()
 });

package/dist/cjs/src/service/event/serve.js

@@ -33,8 +33,8 @@ class Serve extends in_play_event_1.InPlayEvent {
         }
         return new Serve(result.data);
     }
-    constructor({ score, playerId, target, failure, type, activeTraits }) {
-        super({ score, playerId, target, activeTraits, eventType });
+    constructor({ score, playerId, target, failure, type, activeTraits, incident }) {
+        super({ score, playerId, target, activeTraits, incident, eventType });
         this.type = type;
         this.failure = failure;
     }

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

@@ -31,8 +31,8 @@ class Set extends in_play_event_1.InPlayEvent {
         }
         return new Set(result.data);
     }
-    constructor({ score, playerId, target, failure, type, activeTraits }) {
-        super({ score, playerId, target, activeTraits, eventType });
+    constructor({ score, playerId, target, failure, type, activeTraits, incident }) {
+        super({ score, playerId, target, activeTraits, incident, eventType });
         this.type = type;
         this.failure = failure;
     }

package/dist/cjs/src/service/event/spike.js

@@ -35,8 +35,8 @@ class Spike extends in_play_event_1.InPlayEvent {
         }
         return new Spike(result.data);
     }
-    constructor({ score, playerId, target, failure, type, activeTraits }) {
-        super({ score, playerId, target, activeTraits, eventType });
+    constructor({ score, playerId, target, failure, type, activeTraits, incident }) {
+        super({ score, playerId, target, activeTraits, incident, eventType });
         this.type = type;
         this.failure = failure;
     }

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 }]