volleyballsimtypes 0.0.509 → 0.0.511

package/dist/cjs/src/service/match/point-breakdown.js

@@ -35,13 +35,13 @@ function computeMatchRallyAggregates(input) {
     });
     return { rallyMetrics, breakdown };
 }
-// A block scores a point in exactly ONE place in the sim (reception-simulator: a dig of a block fails
-// and the block landed in-court, i.e. target >= 7). Each such rally is ONE block point regardless of how
-// many blockers were on it; the box score records it as one `block_assists` per blocker (or one
-// `block_solo`), which is why summing solo+assists over-counts block points. We rebuild the true count
-// from the rallies. blockSolo / blockAssists must reconstruct box.block.solo and box.block.assists
-// exactly (the correctness gate). `teamOf(playerId)` returns a player's team id (or null); the scoring
-// team is the blockers' team.
+// A block scores a point when the block lands in-court (target >= 7): the positional engine ends the rally
+// on that BLOCK event; the zone engine ends it on the failed dig (RECEPTION) right after the BLOCK. Each
+// such rally is ONE block point regardless of how many blockers were on it; the box score records it as one
+// `block_assists` per blocker (or one `block_solo`), which is why summing solo+assists over-counts block
+// points. We rebuild the true count from the rallies. blockSolo / blockAssists must reconstruct box.block.solo
+// and box.block.assists exactly (the correctness gate). `teamOf(playerId)` returns a player's team id (or
+// null); the scoring team is the blockers' team.
 function tallyBlockPoints(rallies, teamOf) {
     const out = new Map();
     const tallyFor = (team) => {
@@ -56,17 +56,22 @@ function tallyBlockPoints(rallies, teamOf) {
         // Ignore substitutions / libero replacements (eventType < SERVE) when locating the terminal action.
         const inPlay = rally.events.filter(e => e.eventType >= event_1.EventTypeEnum.SERVE);
         const last = inPlay[inPlay.length - 1];
-        const prev = inPlay[inPlay.length - 2];
-        if (last == null || prev == null)
+        if (last == null)
             continue;
-        // Block point signature: the rally ends on a failed RECEPTION (dig) whose previous event is a BLOCK
-        // that landed in-court (target >= 7). target < 7 is a deflection -> the ATTACKER's kill, not a block.
-        if (last.eventType !== event_1.EventTypeEnum.RECEPTION || last.failure <= 0)
-            continue;
-        if (prev.eventType !== event_1.EventTypeEnum.BLOCK)
-            continue;
-        const block = prev;
-        if (block.target < 7)
+        // A block point lands in-court (target >= 7); a deflection / tool-out (target < 7) is the ATTACKER's kill.
+        // Two engines end a block point in different shapes, both counted here:
+        //  - positional: the rally ENDS on the BLOCK itself (the stuff kills the ball outright);
+        //  - zone: the rally ends on a failed RECEPTION (dig) whose previous event is the BLOCK.
+        let block;
+        if (last.eventType === event_1.EventTypeEnum.BLOCK) {
+            block = last;
+        }
+        else if (last.eventType === event_1.EventTypeEnum.RECEPTION && last.failure > 0) {
+            const prev = inPlay[inPlay.length - 2];
+            if (prev != null && prev.eventType === event_1.EventTypeEnum.BLOCK)
+                block = prev;
+        }
+        if (block == null || block.target < 7)
             continue;
         const team = teamOf(block.blockers[0] ?? block.playerId);
         if (team == null)

package/dist/cjs/src/service/match/point-breakdown.test.js

@@ -30,6 +30,14 @@ const teamOf = (id) => id.startsWith('h') ? 'HOME' : id.startsWith('a') ? 'AWAY'
         const t = (0, point_breakdown_1.tallyBlockPoints)([rally([blockEvent('h1', 8, ['h1', 'h2']), receptionEvent('a3', 0), spikeEvent('a3')])], teamOf);
         (0, globals_1.expect)(t.size).toBe(0);
     });
+    (0, globals_1.it)('counts a POSITIONAL stuff that ENDS on the BLOCK (no trailing dig)', () => {
+        const t = (0, point_breakdown_1.tallyBlockPoints)([rally([spikeEvent('a1'), blockEvent('h1', 9, ['h1', 'h2'])])], teamOf);
+        (0, globals_1.expect)(t.get('HOME')).toEqual({ blockPoints: 1, blockSolo: 0, blockAssists: 2 });
+    });
+    (0, globals_1.it)('does NOT count a terminal touch / tool-out block (target < 7)', () => {
+        const t = (0, point_breakdown_1.tallyBlockPoints)([rally([spikeEvent('a1'), blockEvent('h1', 0, ['h1'])])], teamOf);
+        (0, globals_1.expect)(t.size).toBe(0);
+    });
     (0, globals_1.it)('reconstructs box block.solo and block.assists across a mix (incl. a triple block)', () => {
         const t = (0, point_breakdown_1.tallyBlockPoints)([
             rally([blockEvent('h1', 8, ['h1', 'h2']), receptionEvent('a3', 1)]), // double: +2 assists

package/dist/cjs/src/service/match/rally-metrics.d.ts

@@ -1,6 +1,7 @@
 export interface RallyMetricsEvent {
     readonly eventType: number;
     readonly failure?: number;
+    readonly type?: number;
 }
 export interface RallyMetricsRally {
     readonly servingTeamId: string;

package/dist/cjs/src/service/match/rally-metrics.js

@@ -14,7 +14,9 @@ function isServiceError(rally) {
 // engine scores a second spike as a transition). This counts first-ball kills and the block errors forced
 // on that first attack, and excludes service-error sideouts (no spike) and dig-and-transition rallies (2+).
 function spikeCount(rally) {
-    return rally.events.reduce((n, e) => e.eventType === event_1.EventTypeEnum.SPIKE ? n + 1 : n, 0);
+    // An attack is a SPIKE, or a SET whose type is DUMP (the setter attacking on the second ball). Counting the
+    // dump matches the report builder's attack test, so a first-ball sideout won on a dump is not dropped.
+    return rally.events.reduce((n, e) => (e.eventType === event_1.EventTypeEnum.SPIKE || (e.eventType === event_1.EventTypeEnum.SET && e.type === event_1.SetTypeEnum.DUMP)) ? n + 1 : n, 0);
 }
 // The setter's zone after (rotationIndex - 1) rotations from their start zone, using the engine's own
 // rotatePosition (each rotation moves a player one zone: 2->1, 1->6, ...). null when no setter.

package/dist/cjs/src/service/match/rally-metrics.test.js

@@ -90,3 +90,25 @@ describe('computeRallyMetrics() first ball sideout', () => {
         expect(fm.total.home.modFbsoPct).toBe(0);
     });
 });
+// The positional engine emits a setter DUMP as a SET event (type DUMP), not a SPIKE. A first-ball sideout won
+// on a dump is still a first attack and must count as an FBSO. (Regression: spikeCount used to count only SPIKE.)
+const dumpEv = () => ({ eventType: event_1.EventTypeEnum.SET, type: event_1.SetTypeEnum.DUMP, failure: 0 });
+// serving H, A ; winners A, A (A 2 - H 0). A sides out on rally 0 via a single setter dump (no spike).
+const dumpSet = {
+    homePoints: 0,
+    awayPoints: 2,
+    homeSetterStartZone: null,
+    awaySetterStartZone: null,
+    rallies: [
+        { servingTeamId: HOME, events: [serveEv(), dumpEv()] }, // A sideout on a dump -> A FBSO
+        { servingTeamId: AWAY, events: [serveEv()] } // A breakpoint (A serving) -> not a reception win
+    ]
+};
+const dm = (0, rally_metrics_1.computeRallyMetrics)([dumpSet], HOME, AWAY);
+describe('computeRallyMetrics() first ball sideout - setter dump', () => {
+    it('counts a first-ball sideout won on a setter dump (SET type DUMP), not just a spike', () => {
+        expect(dm.total.away.receptions).toBe(1);
+        expect(dm.total.away.fbsoWins).toBe(1);
+        expect(dm.total.away.fbsoPct).toBeCloseTo(100, 5);
+    });
+});

package/dist/esm/src/service/match/point-breakdown.js

@@ -30,13 +30,13 @@ export function computeMatchRallyAggregates(input) {
     });
     return { rallyMetrics, breakdown };
 }
-// A block scores a point in exactly ONE place in the sim (reception-simulator: a dig of a block fails
-// and the block landed in-court, i.e. target >= 7). Each such rally is ONE block point regardless of how
-// many blockers were on it; the box score records it as one `block_assists` per blocker (or one
-// `block_solo`), which is why summing solo+assists over-counts block points. We rebuild the true count
-// from the rallies. blockSolo / blockAssists must reconstruct box.block.solo and box.block.assists
-// exactly (the correctness gate). `teamOf(playerId)` returns a player's team id (or null); the scoring
-// team is the blockers' team.
+// A block scores a point when the block lands in-court (target >= 7): the positional engine ends the rally
+// on that BLOCK event; the zone engine ends it on the failed dig (RECEPTION) right after the BLOCK. Each
+// such rally is ONE block point regardless of how many blockers were on it; the box score records it as one
+// `block_assists` per blocker (or one `block_solo`), which is why summing solo+assists over-counts block
+// points. We rebuild the true count from the rallies. blockSolo / blockAssists must reconstruct box.block.solo
+// and box.block.assists exactly (the correctness gate). `teamOf(playerId)` returns a player's team id (or
+// null); the scoring team is the blockers' team.
 export function tallyBlockPoints(rallies, teamOf) {
     const out = new Map();
     const tallyFor = (team) => {
@@ -51,17 +51,22 @@ export function tallyBlockPoints(rallies, teamOf) {
         // Ignore substitutions / libero replacements (eventType < SERVE) when locating the terminal action.
         const inPlay = rally.events.filter(e => e.eventType >= EventTypeEnum.SERVE);
         const last = inPlay[inPlay.length - 1];
-        const prev = inPlay[inPlay.length - 2];
-        if (last == null || prev == null)
+        if (last == null)
             continue;
-        // Block point signature: the rally ends on a failed RECEPTION (dig) whose previous event is a BLOCK
-        // that landed in-court (target >= 7). target < 7 is a deflection -> the ATTACKER's kill, not a block.
-        if (last.eventType !== EventTypeEnum.RECEPTION || last.failure <= 0)
-            continue;
-        if (prev.eventType !== EventTypeEnum.BLOCK)
-            continue;
-        const block = prev;
-        if (block.target < 7)
+        // A block point lands in-court (target >= 7); a deflection / tool-out (target < 7) is the ATTACKER's kill.
+        // Two engines end a block point in different shapes, both counted here:
+        //  - positional: the rally ENDS on the BLOCK itself (the stuff kills the ball outright);
+        //  - zone: the rally ends on a failed RECEPTION (dig) whose previous event is the BLOCK.
+        let block;
+        if (last.eventType === EventTypeEnum.BLOCK) {
+            block = last;
+        }
+        else if (last.eventType === EventTypeEnum.RECEPTION && last.failure > 0) {
+            const prev = inPlay[inPlay.length - 2];
+            if (prev != null && prev.eventType === EventTypeEnum.BLOCK)
+                block = prev;
+        }
+        if (block == null || block.target < 7)
             continue;
         const team = teamOf(block.blockers[0] ?? block.playerId);
         if (team == null)

package/dist/esm/src/service/match/point-breakdown.test.js

@@ -28,6 +28,14 @@ describe('tallyBlockPoints', () => {
         const t = tallyBlockPoints([rally([blockEvent('h1', 8, ['h1', 'h2']), receptionEvent('a3', 0), spikeEvent('a3')])], teamOf);
         expect(t.size).toBe(0);
     });
+    it('counts a POSITIONAL stuff that ENDS on the BLOCK (no trailing dig)', () => {
+        const t = tallyBlockPoints([rally([spikeEvent('a1'), blockEvent('h1', 9, ['h1', 'h2'])])], teamOf);
+        expect(t.get('HOME')).toEqual({ blockPoints: 1, blockSolo: 0, blockAssists: 2 });
+    });
+    it('does NOT count a terminal touch / tool-out block (target < 7)', () => {
+        const t = tallyBlockPoints([rally([spikeEvent('a1'), blockEvent('h1', 0, ['h1'])])], teamOf);
+        expect(t.size).toBe(0);
+    });
     it('reconstructs box block.solo and block.assists across a mix (incl. a triple block)', () => {
         const t = tallyBlockPoints([
             rally([blockEvent('h1', 8, ['h1', 'h2']), receptionEvent('a3', 1)]), // double: +2 assists

package/dist/esm/src/service/match/rally-metrics.d.ts

@@ -1,6 +1,7 @@
 export interface RallyMetricsEvent {
     readonly eventType: number;
     readonly failure?: number;
+    readonly type?: number;
 }
 export interface RallyMetricsRally {
     readonly servingTeamId: string;

package/dist/esm/src/service/match/rally-metrics.js

@@ -1,4 +1,4 @@
-import { EventTypeEnum } from '../event';
+import { EventTypeEnum, SetTypeEnum } from '../event';
 import { rotatePosition } from './court-position';
 function newAcc() {
     return { serves: 0, breakpointWins: 0, receptions: 0, sideoutWins: 0, serviceErrorsReceived: 0, fbsoWins: 0, rotations: new Map() };
@@ -11,7 +11,9 @@ function isServiceError(rally) {
 // engine scores a second spike as a transition). This counts first-ball kills and the block errors forced
 // on that first attack, and excludes service-error sideouts (no spike) and dig-and-transition rallies (2+).
 function spikeCount(rally) {
-    return rally.events.reduce((n, e) => e.eventType === EventTypeEnum.SPIKE ? n + 1 : n, 0);
+    // An attack is a SPIKE, or a SET whose type is DUMP (the setter attacking on the second ball). Counting the
+    // dump matches the report builder's attack test, so a first-ball sideout won on a dump is not dropped.
+    return rally.events.reduce((n, e) => (e.eventType === EventTypeEnum.SPIKE || (e.eventType === EventTypeEnum.SET && e.type === SetTypeEnum.DUMP)) ? n + 1 : n, 0);
 }
 // The setter's zone after (rotationIndex - 1) rotations from their start zone, using the engine's own
 // rotatePosition (each rotation moves a player one zone: 2->1, 1->6, ...). null when no setter.

package/dist/esm/src/service/match/rally-metrics.test.js

@@ -1,5 +1,5 @@
 import { computeRallyMetrics } from './rally-metrics';
-import { EventTypeEnum } from '../event';
+import { EventTypeEnum, SetTypeEnum } from '../event';
 const serve = (failure = 0) => ({
     events: [{ eventType: EventTypeEnum.SERVE, failure }]
 });
@@ -88,3 +88,25 @@ describe('computeRallyMetrics() first ball sideout', () => {
         expect(fm.total.home.modFbsoPct).toBe(0);
     });
 });
+// The positional engine emits a setter DUMP as a SET event (type DUMP), not a SPIKE. A first-ball sideout won
+// on a dump is still a first attack and must count as an FBSO. (Regression: spikeCount used to count only SPIKE.)
+const dumpEv = () => ({ eventType: EventTypeEnum.SET, type: SetTypeEnum.DUMP, failure: 0 });
+// serving H, A ; winners A, A (A 2 - H 0). A sides out on rally 0 via a single setter dump (no spike).
+const dumpSet = {
+    homePoints: 0,
+    awayPoints: 2,
+    homeSetterStartZone: null,
+    awaySetterStartZone: null,
+    rallies: [
+        { servingTeamId: HOME, events: [serveEv(), dumpEv()] }, // A sideout on a dump -> A FBSO
+        { servingTeamId: AWAY, events: [serveEv()] } // A breakpoint (A serving) -> not a reception win
+    ]
+};
+const dm = computeRallyMetrics([dumpSet], HOME, AWAY);
+describe('computeRallyMetrics() first ball sideout - setter dump', () => {
+    it('counts a first-ball sideout won on a setter dump (SET type DUMP), not just a spike', () => {
+        expect(dm.total.away.receptions).toBe(1);
+        expect(dm.total.away.fbsoWins).toBe(1);
+        expect(dm.total.away.fbsoPct).toBeCloseTo(100, 5);
+    });
+});

package/package.json

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