volleyballsimtypes 0.0.469 → 0.0.471

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

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

package/dist/esm/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/esm/src/data/transformers/rally-event.js

@@ -1,4 +1,15 @@
 import { Block, InPlayEvent, LiberoReplacement, Reception, Serve, Set, Spike, Substitution } from '../../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 };
+}
 export function transformToCompact(evt, playerIndex) {
     const out = {
         p: playerIndex.get(evt.playerId),
@@ -9,6 +20,9 @@ export 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 Block) {
             out.b = evt.blockers.map(id => playerIndex.get(id));
         }
@@ -31,7 +45,8 @@ export 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)
     });
 }
 export function transformToLiberoReplacement(event, roster) {
@@ -47,7 +62,8 @@ export function transformToReception(event, roster) {
         type: event.t,
         playerId: roster[event.p],
         target: event.a,
-        score: event.s
+        score: event.s,
+        incident: incidentFromCompact(event.i)
     });
 }
 export function transformToServe(event, roster) {
@@ -56,7 +72,8 @@ export function transformToServe(event, roster) {
         type: event.t,
         playerId: roster[event.p],
         target: event.a,
-        score: event.s
+        score: event.s,
+        incident: incidentFromCompact(event.i)
     });
 }
 export function transformToSet(event, roster) {
@@ -65,7 +82,8 @@ export function transformToSet(event, roster) {
         type: event.t,
         playerId: roster[event.p],
         target: event.a,
-        score: event.s
+        score: event.s,
+        incident: incidentFromCompact(event.i)
     });
 }
 export function transformToSpike(event, roster) {
@@ -74,7 +92,8 @@ export function transformToSpike(event, roster) {
         type: event.t,
         playerId: roster[event.p],
         target: event.a,
-        score: event.s
+        score: event.s,
+        incident: incidentFromCompact(event.i)
     });
 }
 export function transformToSubstitution(event, roster) {

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

@@ -31,8 +31,8 @@ export class Block extends 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/esm/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/esm/src/service/event/in-play-event.js

@@ -1,10 +1,11 @@
 import { RallyEvent } from './rally-event';
 export class InPlayEvent extends 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/esm/src/service/event/reception.js

@@ -33,8 +33,8 @@ export class Reception extends 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/esm/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/esm/src/service/event/schemas/block.z.js

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { TraitEnum } from '../../player';
+import { EventIncidentSchema } from './incident.z';
 const blockTypeValues = [0, 1, 2, 3];
 const blockFailureValues = [0, 1, 2, 3, 4, 5];
 const courtTargetValues = Array.from({ length: 13 }, (_, i) => i);
@@ -10,7 +11,8 @@ export const BlockInputSchema = z.object({
     activeTraits: z.array(z.enum(Object.values(TraitEnum))).default([]),
     failure: z.number().int().refine((v) => blockFailureValues.includes(v), { message: 'INVALID_BLOCK_FAILURE' }),
     type: z.number().int().refine((v) => blockTypeValues.includes(v), { message: 'INVALID_BLOCK_TYPE' }),
-    blockers: z.array(z.uuid())
+    blockers: z.array(z.uuid()),
+    incident: 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/esm/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/esm/src/service/event/schemas/incident.z.js

@@ -0,0 +1,8 @@
+import { z } from '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).
+export const EventIncidentSchema = z.object({
+    kind: z.enum(['KNOCK', 'INJURY']),
+    severity: z.number().int().min(1).max(4)
+}).refine(v => v.kind !== 'KNOCK' || v.severity <= 3, { message: 'INVALID_KNOCK_TIER' });

package/dist/esm/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/esm/src/service/event/schemas/reception.z.js

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { TraitEnum } from '../../player';
+import { EventIncidentSchema } from './incident.z';
 const receptionTypeValues = [0, 1, 2, 3, 4];
 const receptionFailureValues = [0, 1, 2, 3, 4];
 const courtTargetValues = Array.from({ length: 13 }, (_, i) => i);
@@ -9,5 +10,6 @@ export const ReceptionInputSchema = z.object({
     target: z.number().int().refine((v) => courtTargetValues.includes(v), { message: 'INVALID_COURT_TARGET' }),
     activeTraits: z.array(z.enum(Object.values(TraitEnum))).default([]),
     failure: z.number().int().refine((v) => receptionFailureValues.includes(v), { message: 'INVALID_RECEPTION_FAILURE' }),
-    type: z.number().int().refine((v) => receptionTypeValues.includes(v), { message: 'INVALID_RECEPTION_TYPE' })
+    type: z.number().int().refine((v) => receptionTypeValues.includes(v), { message: 'INVALID_RECEPTION_TYPE' }),
+    incident: EventIncidentSchema.optional()
 });

package/dist/esm/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/esm/src/service/event/schemas/serve.z.js

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { TraitEnum } from '../../player';
+import { EventIncidentSchema } from './incident.z';
 const serveTypeValues = [0, 1, 2, 3];
 const serveFailureValues = [0, 1, 2, 3, 4];
 const courtTargetValues = Array.from({ length: 13 }, (_, i) => i);
@@ -9,5 +10,6 @@ export const ServeInputSchema = z.object({
     target: z.number().int().refine((v) => courtTargetValues.includes(v), { message: 'INVALID_COURT_TARGET' }),
     activeTraits: z.array(z.enum(Object.values(TraitEnum))).default([]),
     failure: z.number().int().refine((v) => serveFailureValues.includes(v), { message: 'INVALID_SERVE_FAILURE' }),
-    type: z.number().int().refine((v) => serveTypeValues.includes(v), { message: 'INVALID_SERVE_TYPE' })
+    type: z.number().int().refine((v) => serveTypeValues.includes(v), { message: 'INVALID_SERVE_TYPE' }),
+    incident: EventIncidentSchema.optional()
 });

package/dist/esm/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/esm/src/service/event/schemas/set.z.js

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { TraitEnum } from '../../player';
+import { EventIncidentSchema } from './incident.z';
 const setTypeValues = [0, 1];
 const setFailureValues = [0, 1, 2, 3, 4];
 const courtTargetValues = Array.from({ length: 13 }, (_, i) => i);
@@ -9,5 +10,6 @@ export const SetInputSchema = z.object({
     target: z.number().int().refine((v) => courtTargetValues.includes(v), { message: 'INVALID_COURT_TARGET' }),
     activeTraits: z.array(z.enum(Object.values(TraitEnum))).default([]),
     failure: z.number().int().refine((v) => setFailureValues.includes(v), { message: 'INVALID_SET_FAILURE' }),
-    type: z.number().int().refine((v) => setTypeValues.includes(v), { message: 'INVALID_SET_TYPE' })
+    type: z.number().int().refine((v) => setTypeValues.includes(v), { message: 'INVALID_SET_TYPE' }),
+    incident: EventIncidentSchema.optional()
 });

package/dist/esm/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>;