volleyballsimtypes 0.0.501 → 0.0.503

package/dist/esm/src/data/models/views/box-score-totals.d.ts

@@ -6,12 +6,15 @@ export interface BoxScoreTotalsAttributes {
     attack_attempts: number;
     attack_kills: number;
     attack_errors: number;
+    attack_blocked: number;
     serve_attempts: number;
     serve_aces: number;
     serve_errors: number;
     reception_attempts: number;
     reception_perfect: number;
     reception_positive: number;
+    reception_ok: number;
+    reception_negative: number;
     reception_overpasses: number;
     reception_errors: number;
     block_solo: number;
@@ -22,6 +25,9 @@ export interface BoxScoreTotalsAttributes {
     setting_errors: number;
     setting_pass: number;
     defense_digs: number;
+    defense_digs_perfect: number;
+    defense_digs_mediocre: number;
+    defense_digs_bad: number;
     defense_errors: number;
     misc_points_played: number;
     misc_points_won_on_court: number;
@@ -39,12 +45,15 @@ export declare class BoxScoreTotalsModel extends Model<BoxScoreTotalsAttributes,
     attack_attempts: number;
     attack_kills: number;
     attack_errors: number;
+    attack_blocked: number;
     serve_attempts: number;
     serve_aces: number;
     serve_errors: number;
     reception_attempts: number;
     reception_perfect: number;
     reception_positive: number;
+    reception_ok: number;
+    reception_negative: number;
     reception_overpasses: number;
     reception_errors: number;
     block_solo: number;
@@ -55,6 +64,9 @@ export declare class BoxScoreTotalsModel extends Model<BoxScoreTotalsAttributes,
     setting_errors: number;
     setting_pass: number;
     defense_digs: number;
+    defense_digs_perfect: number;
+    defense_digs_mediocre: number;
+    defense_digs_bad: number;
     defense_errors: number;
     misc_points_played: number;
     misc_points_won_on_court: number;

package/dist/esm/src/data/models/views/box-score-totals.js

@@ -23,6 +23,10 @@ export class BoxScoreTotalsModel extends Model {
                 type: DataTypes.INTEGER,
                 allowNull: false
             },
+            attack_blocked: {
+                type: DataTypes.INTEGER,
+                allowNull: false
+            },
             serve_attempts: {
                 type: DataTypes.INTEGER,
                 allowNull: false
@@ -47,6 +51,14 @@ export class BoxScoreTotalsModel extends Model {
                 type: DataTypes.INTEGER,
                 allowNull: false
             },
+            reception_ok: {
+                type: DataTypes.INTEGER,
+                allowNull: false
+            },
+            reception_negative: {
+                type: DataTypes.INTEGER,
+                allowNull: false
+            },
             reception_overpasses: {
                 type: DataTypes.INTEGER,
                 allowNull: false
@@ -87,6 +99,18 @@ export class BoxScoreTotalsModel extends Model {
                 type: DataTypes.INTEGER,
                 allowNull: false
             },
+            defense_digs_perfect: {
+                type: DataTypes.INTEGER,
+                allowNull: false
+            },
+            defense_digs_mediocre: {
+                type: DataTypes.INTEGER,
+                allowNull: false
+            },
+            defense_digs_bad: {
+                type: DataTypes.INTEGER,
+                allowNull: false
+            },
             defense_errors: {
                 type: DataTypes.INTEGER,
                 allowNull: false

package/dist/esm/src/data/transformers/box-score.js

@@ -6,12 +6,15 @@ function transformToAttributes(boxScore) {
         attack_attempts: boxScore.attack.attempts,
         attack_kills: boxScore.attack.kills,
         attack_errors: boxScore.attack.errors,
+        attack_blocked: boxScore.attack.blocked,
         serve_attempts: boxScore.serve.attempts,
         serve_aces: boxScore.serve.aces,
         serve_errors: boxScore.serve.errors,
         reception_attempts: boxScore.reception.attempts,
         reception_perfect: boxScore.reception.perfect,
         reception_positive: boxScore.reception.positive,
+        reception_ok: boxScore.reception.ok,
+        reception_negative: boxScore.reception.negative,
         reception_overpasses: boxScore.reception.overpasses,
         reception_errors: boxScore.reception.errors,
         block_solo: boxScore.block.solo,
@@ -22,6 +25,9 @@ function transformToAttributes(boxScore) {
         setting_errors: boxScore.setting.errors,
         setting_pass: boxScore.setting.pass,
         defense_digs: boxScore.defense.digs,
+        defense_digs_perfect: boxScore.defense.digsPerfect,
+        defense_digs_mediocre: boxScore.defense.digsMediocre,
+        defense_digs_bad: boxScore.defense.digsBad,
         defense_errors: boxScore.defense.errors,
         misc_points_played: boxScore.misc.pointsPlayed,
         misc_points_won_on_court: boxScore.misc.pointsWonOnCourt,
@@ -37,7 +43,8 @@ function transformToObject(model) {
         attack: {
             attempts: model.attack_attempts,
             kills: model.attack_kills,
-            errors: model.attack_errors
+            errors: model.attack_errors,
+            blocked: model.attack_blocked
         },
         serve: {
             attempts: model.serve_attempts,
@@ -48,6 +55,8 @@ function transformToObject(model) {
             attempts: model.reception_attempts,
             perfect: model.reception_perfect,
             positive: model.reception_positive,
+            ok: model.reception_ok,
+            negative: model.reception_negative,
             overpasses: model.reception_overpasses,
             errors: model.reception_errors
         },
@@ -64,6 +73,9 @@ function transformToObject(model) {
         },
         defense: {
             digs: model.defense_digs,
+            digsPerfect: model.defense_digs_perfect,
+            digsMediocre: model.defense_digs_mediocre,
+            digsBad: model.defense_digs_bad,
             errors: model.defense_errors
         },
         misc: {

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

@@ -33,7 +33,8 @@ function transformToBoxScoreTotals(model) {
         attack: {
             attempts: toNumberStrict(model.attack_attempts, 'attack_attempts'),
             kills: toNumberStrict(model.attack_kills, 'attack_kills'),
-            errors: toNumberStrict(model.attack_errors, 'attack_errors')
+            errors: toNumberStrict(model.attack_errors, 'attack_errors'),
+            blocked: toNumberStrict(model.attack_blocked, 'attack_blocked')
         },
         serve: {
             attempts: toNumberStrict(model.serve_attempts, 'serve_attempts'),
@@ -44,6 +45,8 @@ function transformToBoxScoreTotals(model) {
             attempts: toNumberStrict(model.reception_attempts, 'reception_attempts'),
             perfect: toNumberStrict(model.reception_perfect, 'reception_perfect'),
             positive: toNumberStrict(model.reception_positive, 'reception_positive'),
+            ok: toNumberStrict(model.reception_ok, 'reception_ok'),
+            negative: toNumberStrict(model.reception_negative, 'reception_negative'),
             overpasses: toNumberStrict(model.reception_overpasses, 'reception_overpasses'),
             errors: toNumberStrict(model.reception_errors, 'reception_errors')
         },
@@ -60,6 +63,9 @@ function transformToBoxScoreTotals(model) {
         },
         defense: {
             digs: toNumberStrict(model.defense_digs, 'defense_digs'),
+            digsPerfect: toNumberStrict(model.defense_digs_perfect, 'defense_digs_perfect'),
+            digsMediocre: toNumberStrict(model.defense_digs_mediocre, 'defense_digs_mediocre'),
+            digsBad: toNumberStrict(model.defense_digs_bad, 'defense_digs_bad'),
             errors: toNumberStrict(model.defense_errors, 'defense_errors')
         },
         misc: {

package/dist/esm/src/data/transformers/rally-event-positional.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/src/data/transformers/rally-event-positional.test.js

@@ -0,0 +1,54 @@
+import { describe, it, expect } from '@jest/globals';
+import { v4 as uuidv4 } from 'uuid';
+import { DigQualityEnum, Reception, ReceptionFailureEnum, ReceptionTypeEnum, Spike, SpikeFailureEnum, SpikeTypeEnum } from '../../service';
+import { transformToCompact, transformToReception, transformToSpike } from './rally-event';
+describe('rally-event compact round trip -- positional fields (coords / speed / dig quality)', () => {
+    const playerId = uuidv4();
+    const roster = [playerId];
+    const playerIndex = new Map(roster.map((id, i) => [id, i]));
+    it('packs contact/landing/speed and round-trips them, 2-dp rounded', () => {
+        const spike = Spike.create({
+            playerId,
+            score: 60,
+            target: 4,
+            failure: SpikeFailureEnum.NO_FAILURE,
+            type: SpikeTypeEnum.CROSS_SHOT,
+            contact: { x: 1.234, y: -0.5 },
+            landing: { x: -2.5, y: 6.789 },
+            speed: 92.456
+        });
+        const compact = transformToCompact(spike, playerIndex);
+        expect(compact.c).toEqual([1.23, -0.5]);
+        expect(compact.g).toEqual([-2.5, 6.79]);
+        expect(compact.v).toBe(92.46);
+        const decoded = transformToSpike(compact, roster);
+        expect(decoded.contact).toEqual({ x: 1.23, y: -0.5 });
+        expect(decoded.landing).toEqual({ x: -2.5, y: 6.79 });
+        expect(decoded.speed).toBe(92.46);
+    });
+    it('packs dig quality on a reception and round-trips it', () => {
+        const dig = Reception.create({
+            playerId,
+            score: 40,
+            target: 3,
+            failure: ReceptionFailureEnum.NO_FAILURE,
+            type: ReceptionTypeEnum.DIG,
+            digQuality: DigQualityEnum.MEDIOCRE
+        });
+        const compact = transformToCompact(dig, playerIndex);
+        expect(compact.q).toBe(DigQualityEnum.MEDIOCRE);
+        const decoded = transformToReception(compact, roster);
+        expect(decoded.digQuality).toBe(DigQualityEnum.MEDIOCRE);
+    });
+    it('omits the positional keys when absent, and a legacy event decodes them as undefined', () => {
+        const spike = Spike.create({ playerId, score: 60, target: 4, failure: SpikeFailureEnum.NO_FAILURE, type: SpikeTypeEnum.CROSS_SHOT });
+        const compact = transformToCompact(spike, playerIndex);
+        expect('c' in compact).toBe(false);
+        expect('v' in compact).toBe(false);
+        expect('q' in compact).toBe(false);
+        const decoded = transformToSpike(compact, roster);
+        expect(decoded.contact).toBeUndefined();
+        expect(decoded.speed).toBeUndefined();
+        expect(decoded.digQuality).toBeUndefined();
+    });
+});

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

@@ -13,6 +13,10 @@ export interface CompactEvent {
     i?: number;
     h?: number;
     m?: number;
+    c?: number[];
+    g?: number[];
+    v?: number;
+    q?: 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,18 @@
 import { Block, FreeBall, InPlayEvent, LiberoReplacement, Reception, Serve, Set, Spike, Substitution } from '../../service';
+// Rebuild the optional positional fields (contact / landing / speed / digQuality) from a compact event, for the
+// event .create() inputs. Loosely typed since create() validates via its Zod schema.
+function positionalFromCompact(e) {
+    const out = {};
+    if (e.c != null)
+        out.contact = { x: e.c[0], y: e.c[1] };
+    if (e.g != null)
+        out.landing = { x: e.g[0], y: e.g[1] };
+    if (e.v != null)
+        out.speed = e.v;
+    if (e.q != null)
+        out.digQuality = e.q;
+    return out;
+}
 // Incident packing for the compact key 'i': values below 10 are injury severities, 10+ are knock tiers.
 function incidentToCompact(incident) {
     if (incident == null)
@@ -31,6 +45,14 @@ export function transformToCompact(evt, playerIndex) {
                 out.h = playerIndex.get(evt.incident.playerId);
             }
         }
+        if (evt.contact != null)
+            out.c = [evt.contact.x, evt.contact.y];
+        if (evt.landing != null)
+            out.g = [evt.landing.x, evt.landing.y];
+        if (evt.speed != null)
+            out.v = evt.speed;
+        if (evt.digQuality != null)
+            out.q = evt.digQuality;
         if (evt instanceof Block) {
             out.b = evt.blockers.map(id => playerIndex.get(id));
         }
@@ -57,7 +79,8 @@ export function transformToBlock(event, roster) {
         target: event.a,
         blockers: (event.b ?? []).map(i => roster[i]),
         score: event.s,
-        incident: incidentFromCompact(event.i, event.h, roster)
+        incident: incidentFromCompact(event.i, event.h, roster),
+        ...positionalFromCompact(event)
     });
 }
 export function transformToLiberoReplacement(event, roster) {
@@ -74,7 +97,8 @@ export function transformToReception(event, roster) {
         playerId: roster[event.p],
         target: event.a,
         score: event.s,
-        incident: incidentFromCompact(event.i, event.h, roster)
+        incident: incidentFromCompact(event.i, event.h, roster),
+        ...positionalFromCompact(event)
     });
 }
 export function transformToServe(event, roster) {
@@ -84,7 +108,8 @@ export function transformToServe(event, roster) {
         playerId: roster[event.p],
         target: event.a,
         score: event.s,
-        incident: incidentFromCompact(event.i, event.h, roster)
+        incident: incidentFromCompact(event.i, event.h, roster),
+        ...positionalFromCompact(event)
     });
 }
 export function transformToSet(event, roster) {
@@ -95,7 +120,8 @@ export function transformToSet(event, roster) {
         target: event.a,
         score: event.s,
         incident: incidentFromCompact(event.i, event.h, roster),
-        tempo: event.m
+        tempo: event.m,
+        ...positionalFromCompact(event)
     });
 }
 export function transformToSpike(event, roster) {
@@ -105,7 +131,8 @@ export function transformToSpike(event, roster) {
         playerId: roster[event.p],
         target: event.a,
         score: event.s,
-        incident: incidentFromCompact(event.i, event.h, roster)
+        incident: incidentFromCompact(event.i, event.h, roster),
+        ...positionalFromCompact(event)
     });
 }
 // FreeBall (Last Resort save) is a plain InPlayEvent with no incident of its own, so it decodes from f/t/a/s
@@ -116,7 +143,8 @@ export function transformToFreeBall(event, roster) {
         type: event.t,
         playerId: roster[event.p],
         target: event.a,
-        score: event.s
+        score: event.s,
+        ...positionalFromCompact(event)
     });
 }
 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, incident }) {
-        super({ score, playerId, target, activeTraits, incident, eventType });
+    constructor({ score, playerId, target, failure, type, blockers, activeTraits, incident, contact, landing, speed, digQuality }) {
+        super({ score, playerId, target, activeTraits, incident, eventType, contact, landing, speed, digQuality });
         this.type = type;
         this.failure = failure;
         this.blockers = blockers;

package/dist/esm/src/service/event/free-ball.js

@@ -30,8 +30,8 @@ export class FreeBall extends InPlayEvent {
         }
         return new FreeBall(result.data);
     }
-    constructor({ score, playerId, target, failure, type, activeTraits }) {
-        super({ score, playerId, target, activeTraits, eventType });
+    constructor({ score, playerId, target, failure, type, activeTraits, contact, landing, speed, digQuality }) {
+        super({ score, playerId, target, activeTraits, eventType, contact, landing, speed, digQuality });
         this.type = type;
         this.failure = failure;
     }

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

@@ -6,11 +6,25 @@ export interface EventIncident {
     readonly severity: number;
     readonly playerId?: string;
 }
+export declare enum DigQualityEnum {
+    PERFECT = 0,
+    MEDIOCRE = 1,
+    BAD = 2
+}
+export type DigQuality = DigQualityEnum.PERFECT | DigQualityEnum.MEDIOCRE | DigQualityEnum.BAD;
+export interface EventCoord {
+    readonly x: number;
+    readonly y: number;
+}
 export interface InPlayEventOpts extends RallyEventOpts {
     readonly target: CourtTarget;
     readonly score: number;
     readonly activeTraits: Trait[];
     readonly incident?: EventIncident;
+    readonly contact?: EventCoord;
+    readonly landing?: EventCoord;
+    readonly speed?: number;
+    readonly digQuality?: DigQuality;
 }
 export declare abstract class InPlayEvent<F, T> extends RallyEvent {
     abstract failure: F;
@@ -19,5 +33,9 @@ export declare abstract class InPlayEvent<F, T> extends RallyEvent {
     readonly score: number;
     readonly activeTraits: Trait[];
     readonly incident?: EventIncident;
-    protected constructor({ eventType, playerId, target, score, activeTraits, incident }: InPlayEventOpts);
+    readonly contact?: EventCoord;
+    readonly landing?: EventCoord;
+    readonly speed?: number;
+    readonly digQuality?: DigQuality;
+    protected constructor({ eventType, playerId, target, score, activeTraits, incident, contact, landing, speed, digQuality }: InPlayEventOpts);
 }

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

@@ -1,10 +1,25 @@
 import { RallyEvent } from './rally-event';
+// The quality of a DEFENSIVE dig (positional engine, effort gating): a PERFECT dig sets up a clean in-system
+// counter, MEDIOCRE is out of position, BAD is a scramble. Persisted on the Reception (dig) event's 'q' key.
+export var DigQualityEnum;
+(function (DigQualityEnum) {
+    DigQualityEnum[DigQualityEnum["PERFECT"] = 0] = "PERFECT";
+    DigQualityEnum[DigQualityEnum["MEDIOCRE"] = 1] = "MEDIOCRE";
+    DigQualityEnum[DigQualityEnum["BAD"] = 2] = "BAD";
+})(DigQualityEnum || (DigQualityEnum = {}));
+function roundCoord(c) {
+    return c != null ? { x: Number(c.x.toFixed(2)), y: Number(c.y.toFixed(2)) } : undefined;
+}
 export class InPlayEvent extends RallyEvent {
-    constructor({ eventType, playerId, target, score, activeTraits, incident }) {
+    constructor({ eventType, playerId, target, score, activeTraits, incident, contact, landing, speed, digQuality }) {
         super({ playerId, eventType });
         this.target = target;
         this.score = Number(score.toFixed(2));
         this.activeTraits = activeTraits;
         this.incident = incident;
+        this.contact = roundCoord(contact);
+        this.landing = roundCoord(landing);
+        this.speed = speed != null ? Number(speed.toFixed(2)) : undefined;
+        this.digQuality = digQuality;
     }
 }

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, incident }) {
-        super({ score, playerId, target, activeTraits, incident, eventType });
+    constructor({ score, playerId, target, failure, type, activeTraits, incident, contact, landing, speed, digQuality }) {
+        super({ score, playerId, target, activeTraits, incident, eventType, contact, landing, speed, digQuality });
         this.type = type;
         this.failure = failure;
     }

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

@@ -1,6 +1,16 @@
 import { z } from 'zod';
 import { TraitEnum } from '../../player';
 export declare const BlockInputSchema: z.ZodObject<{
+    contact: z.ZodOptional<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>>;
+    landing: z.ZodOptional<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>>;
+    speed: z.ZodOptional<z.ZodNumber>;
+    digQuality: z.ZodOptional<z.ZodNumber>;
     playerId: z.ZodUUID;
     score: z.ZodNumber;
     target: z.ZodNumber;

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

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { TraitEnum } from '../../player';
 import { EventIncidentSchema } from './incident.z';
+import { positionalEventFields } from './positional.z';
 const blockTypeValues = [0, 1, 2, 3];
 const blockFailureValues = [0, 1, 2, 3, 4, 5];
 const courtTargetValues = Array.from({ length: 13 }, (_, i) => i);
@@ -12,7 +13,8 @@ export const BlockInputSchema = z.object({
     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()),
-    incident: EventIncidentSchema.optional()
+    incident: EventIncidentSchema.optional(),
+    ...positionalEventFields
 }).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/free-ball.z.d.ts

@@ -1,6 +1,16 @@
 import { z } from 'zod';
 import { TraitEnum } from '../../player';
 export declare const FreeBallInputSchema: z.ZodObject<{
+    contact: z.ZodOptional<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>>;
+    landing: z.ZodOptional<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>>;
+    speed: z.ZodOptional<z.ZodNumber>;
+    digQuality: z.ZodOptional<z.ZodNumber>;
     playerId: z.ZodUUID;
     score: z.ZodNumber;
     target: z.ZodNumber;

package/dist/esm/src/service/event/schemas/free-ball.z.js

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { TraitEnum } from '../../player';
+import { positionalEventFields } from './positional.z';
 const freeBallTypeValues = [0, 1];
 const freeBallFailureValues = [0];
 const courtTargetValues = Array.from({ length: 13 }, (_, i) => i);
@@ -9,5 +10,6 @@ export const FreeBallInputSchema = 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) => freeBallFailureValues.includes(v), { message: 'INVALID_FREE_BALL_FAILURE' }),
-    type: z.number().int().refine((v) => freeBallTypeValues.includes(v), { message: 'INVALID_FREE_BALL_TYPE' })
+    type: z.number().int().refine((v) => freeBallTypeValues.includes(v), { message: 'INVALID_FREE_BALL_TYPE' }),
+    ...positionalEventFields
 });

package/dist/esm/src/service/event/schemas/positional.z.d.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+export declare const EventCoordSchema: z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+}, z.core.$strip>;
+export declare const positionalEventFields: {
+    contact: z.ZodOptional<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>>;
+    landing: z.ZodOptional<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>>;
+    speed: z.ZodOptional<z.ZodNumber>;
+    digQuality: z.ZodOptional<z.ZodNumber>;
+};

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

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+// A precise court position (metres) on an in-play event.
+export const EventCoordSchema = z.object({
+    x: z.number().finite(),
+    y: z.number().finite()
+});
+// The optional positional-engine fields shared by every in-play event schema: where the actor contacted the ball,
+// where it went, the ball speed (km/h), and the dig quality (0 PERFECT / 1 MEDIOCRE / 2 BAD). Spread into each
+// event schema; absent for zone-engine events (decoded as undefined).
+export const positionalEventFields = {
+    contact: EventCoordSchema.optional(),
+    landing: EventCoordSchema.optional(),
+    speed: z.number().finite().optional(),
+    digQuality: z.number().int().min(0).max(2).optional()
+};

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

@@ -1,6 +1,16 @@
 import { z } from 'zod';
 import { TraitEnum } from '../../player';
 export declare const ReceptionInputSchema: z.ZodObject<{
+    contact: z.ZodOptional<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>>;
+    landing: z.ZodOptional<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>>;
+    speed: z.ZodOptional<z.ZodNumber>;
+    digQuality: z.ZodOptional<z.ZodNumber>;
     playerId: z.ZodUUID;
     score: z.ZodNumber;
     target: z.ZodNumber;

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

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { TraitEnum } from '../../player';
 import { EventIncidentSchema } from './incident.z';
+import { positionalEventFields } from './positional.z';
 const receptionTypeValues = [0, 1, 2, 3, 4];
 const receptionFailureValues = [0, 1, 2, 3, 4];
 const courtTargetValues = Array.from({ length: 13 }, (_, i) => i);
@@ -11,5 +12,6 @@ export const ReceptionInputSchema = z.object({
     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' }),
-    incident: EventIncidentSchema.optional()
+    incident: EventIncidentSchema.optional(),
+    ...positionalEventFields
 });

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

@@ -1,6 +1,16 @@
 import { z } from 'zod';
 import { TraitEnum } from '../../player';
 export declare const ServeInputSchema: z.ZodObject<{
+    contact: z.ZodOptional<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>>;
+    landing: z.ZodOptional<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>>;
+    speed: z.ZodOptional<z.ZodNumber>;
+    digQuality: z.ZodOptional<z.ZodNumber>;
     playerId: z.ZodUUID;
     score: z.ZodNumber;
     target: z.ZodNumber;

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

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { TraitEnum } from '../../player';
 import { EventIncidentSchema } from './incident.z';
+import { positionalEventFields } from './positional.z';
 const serveTypeValues = [0, 1, 2, 3];
 const serveFailureValues = [0, 1, 2, 3, 4];
 const courtTargetValues = Array.from({ length: 13 }, (_, i) => i);
@@ -11,5 +12,6 @@ export const ServeInputSchema = z.object({
     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' }),
-    incident: EventIncidentSchema.optional()
+    incident: EventIncidentSchema.optional(),
+    ...positionalEventFields
 });

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

@@ -1,6 +1,16 @@
 import { z } from 'zod';
 import { TraitEnum } from '../../player';
 export declare const SetInputSchema: z.ZodObject<{
+    contact: z.ZodOptional<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>>;
+    landing: z.ZodOptional<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>>;
+    speed: z.ZodOptional<z.ZodNumber>;
+    digQuality: z.ZodOptional<z.ZodNumber>;
     playerId: z.ZodUUID;
     score: z.ZodNumber;
     target: z.ZodNumber;

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

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { TraitEnum } from '../../player';
 import { EventIncidentSchema } from './incident.z';
+import { positionalEventFields } from './positional.z';
 const setTypeValues = [0, 1];
 const setFailureValues = [0, 1, 2, 3, 4];
 const setTempoValues = [0, 1, 2];
@@ -14,5 +15,6 @@ export const SetInputSchema = z.object({
     type: z.number().int().refine((v) => setTypeValues.includes(v), { message: 'INVALID_SET_TYPE' }),
     incident: EventIncidentSchema.optional(),
     // Set tempo (FIRST=0, SECOND=1, HIGH=2). Optional: absent on dumps, failed sets, and every pre-tempo event.
-    tempo: z.number().int().refine((v) => setTempoValues.includes(v), { message: 'INVALID_SET_TEMPO' }).optional()
+    tempo: z.number().int().refine((v) => setTempoValues.includes(v), { message: 'INVALID_SET_TEMPO' }).optional(),
+    ...positionalEventFields
 });