volleyballsimtypes 0.0.470 → 0.0.471

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/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/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/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>;

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

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { TraitEnum } from '../../player';
+import { EventIncidentSchema } from './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);
@@ -9,5 +10,6 @@ export const SpikeInputSchema = 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) => spikeFailureValues.includes(v), { message: 'INVALID_SPIKE_FAILURE' }),
-    type: z.number().int().refine((v) => spikeTypeValues.includes(v), { message: 'INVALID_SPIKE_TYPE' })
+    type: z.number().int().refine((v) => spikeTypeValues.includes(v), { message: 'INVALID_SPIKE_TYPE' }),
+    incident: EventIncidentSchema.optional()
 });

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

@@ -30,8 +30,8 @@ export class Serve extends 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/esm/src/service/event/set.js

@@ -28,8 +28,8 @@ export class Set extends 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/esm/src/service/event/spike.js

@@ -32,8 +32,8 @@ export class Spike extends 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/package.json

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