volleyballsimtypes 0.0.529 → 0.0.531

package/dist/cjs/src/data/models/auth-user.d.ts

@@ -12,12 +12,16 @@ export interface AuthUserAttributes {
     last_login_at?: Date | null;
     created_at?: Date;
     updated_at?: Date;
+    /** Comparison form of `email` (see canonicalEmail). Uniqueness is enforced on THIS, not on `email`. */
+    canonical_email?: string | null;
+    /** When the account was terminated. Also the clock the 4-month data purge runs off. */
+    terminated_at?: Date | null;
 }
 export type AuthUserPk = 'user_id';
 export type AuthUserId = AuthUserModel[AuthUserPk];
 export type AuthUserRole = 'ADMIN' | 'PLAYER';
-export type AuthUserStatus = 'ACTIVE' | 'DISABLED' | 'PENDING';
-export type AuthUserOptionalAttributes = 'role' | 'display_name' | 'avatar_url' | 'status' | 'email_verified_at' | 'last_login_at' | 'created_at' | 'updated_at';
+export type AuthUserStatus = 'ACTIVE' | 'DISABLED' | 'PENDING' | 'TERMINATED';
+export type AuthUserOptionalAttributes = 'role' | 'display_name' | 'avatar_url' | 'status' | 'email_verified_at' | 'last_login_at' | 'created_at' | 'updated_at' | 'canonical_email' | 'terminated_at';
 export type AuthUserCreationAttributes = Optional<AuthUserAttributes, AuthUserOptionalAttributes>;
 export declare class AuthUserModel extends Model<AuthUserAttributes, AuthUserCreationAttributes> implements AuthUserAttributes {
     user_id: string;
@@ -30,6 +34,8 @@ export declare class AuthUserModel extends Model<AuthUserAttributes, AuthUserCre
     last_login_at?: Date | null;
     created_at?: Date;
     updated_at?: Date;
+    canonical_email?: string | null;
+    terminated_at?: Date | null;
     AuthIdentities: AuthIdentityModel[];
     getAuthIdentities: Sequelize.HasManyGetAssociationsMixin<AuthIdentityModel>;
     setAuthIdentities: Sequelize.HasManySetAssociationsMixin<AuthIdentityModel, AuthIdentityId>;

package/dist/cjs/src/data/models/auth-user.js

@@ -1,6 +1,40 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AuthUserModel = void 0;
+const Sequelize = __importStar(require("sequelize"));
 const sequelize_1 = require("sequelize");
 class AuthUserModel extends sequelize_1.Model {
     static initModel(sequelize) {
@@ -12,8 +46,7 @@ class AuthUserModel extends sequelize_1.Model {
             },
             email: {
                 type: sequelize_1.DataTypes.STRING,
-                allowNull: false,
-                unique: 'AuthUser_email_uq'
+                allowNull: false
             },
             role: {
                 type: sequelize_1.DataTypes.ENUM('ADMIN', 'PLAYER'),
@@ -29,7 +62,7 @@ class AuthUserModel extends sequelize_1.Model {
                 allowNull: true
             },
             status: {
-                type: sequelize_1.DataTypes.ENUM('ACTIVE', 'DISABLED', 'PENDING'),
+                type: sequelize_1.DataTypes.ENUM('ACTIVE', 'DISABLED', 'PENDING', 'TERMINATED'),
                 allowNull: false,
                 defaultValue: 'PENDING'
             },
@@ -50,6 +83,14 @@ class AuthUserModel extends sequelize_1.Model {
                 type: sequelize_1.DataTypes.DATE,
                 allowNull: false,
                 defaultValue: sequelize_1.DataTypes.NOW
+            },
+            canonical_email: {
+                type: sequelize_1.DataTypes.STRING,
+                allowNull: true
+            },
+            terminated_at: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: true
             }
         }, {
             sequelize,
@@ -63,9 +104,16 @@ class AuthUserModel extends sequelize_1.Model {
                     fields: [{ name: 'user_id' }]
                 },
                 {
-                    name: 'AuthUser_email_uq',
+                    name: 'AuthUser_email_live_uq',
+                    unique: true,
+                    fields: [{ name: 'email' }],
+                    where: { status: { [Sequelize.Op.ne]: 'TERMINATED' } }
+                },
+                {
+                    name: 'AuthUser_canonical_email_live_uq',
                     unique: true,
-                    fields: [{ name: 'email' }]
+                    fields: [{ name: 'canonical_email' }],
+                    where: { status: { [Sequelize.Op.ne]: 'TERMINATED' } }
                 }
             ]
         });

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

@@ -103,6 +103,45 @@ const rally_event_1 = require("./rally-event");
         const decoded = (0, rally_event_1.transformToSpike)(compact, roster);
         (0, globals_1.expect)(decoded.incident).toEqual({ kind: 'INJURY', severity: 2 });
     });
+    // The off-ball cause (2026-09-01). An attacker making a fake spike and a blocker whose block attempt never
+    // touched the ball both jump, both can get hurt, and neither emits an event, so their incident rides another
+    // event and 'n' is the only thing saying what they were actually doing. Lose it and the feed says they spiked.
+    (0, globals_1.it)('packs the off-ball cause under n and round-trips it alongside the hurt player', () => {
+        const hitter = (0, uuid_1.v4)();
+        const faker = (0, uuid_1.v4)();
+        const pairRoster = [hitter, faker];
+        const pairIndex = new Map(pairRoster.map((id, i) => [id, i]));
+        const spike = service_1.Spike.create({
+            playerId: hitter,
+            score: 62.5,
+            target: 4,
+            failure: service_1.SpikeFailureEnum.NO_FAILURE,
+            type: service_1.SpikeTypeEnum.SPIKE,
+            incident: { kind: 'INJURY', severity: 4, playerId: faker, cause: service_1.EventTypeEnum.SPIKE }
+        });
+        const compact = (0, rally_event_1.transformToCompact)(spike, pairIndex);
+        (0, globals_1.expect)(compact.h).toBe(1);
+        (0, globals_1.expect)(compact.n).toBe(service_1.EventTypeEnum.SPIKE);
+        const decoded = (0, rally_event_1.transformToSpike)(compact, pairRoster);
+        (0, globals_1.expect)(decoded.incident).toEqual({ kind: 'INJURY', severity: 4, playerId: faker, cause: service_1.EventTypeEnum.SPIKE });
+    });
+    (0, globals_1.it)('round-trips a BLOCK cause, which is the other action that emits no event', () => {
+        const compact = (0, rally_event_1.transformToCompact)(makeSpike({ kind: 'KNOCK', severity: 1, playerId, cause: service_1.EventTypeEnum.BLOCK }), playerIndex);
+        (0, globals_1.expect)(compact.n).toBe(service_1.EventTypeEnum.BLOCK);
+        const decoded = (0, rally_event_1.transformToSpike)(compact, roster);
+        (0, globals_1.expect)(decoded.incident?.cause).toBe(service_1.EventTypeEnum.BLOCK);
+    });
+    (0, globals_1.it)('omits n for an ordinary incident, so nothing grows for the common case', () => {
+        const compact = (0, rally_event_1.transformToCompact)(makeSpike({ kind: 'INJURY', severity: 2 }), playerIndex);
+        (0, globals_1.expect)('n' in compact).toBe(false);
+        const decoded = (0, rally_event_1.transformToSpike)(compact, roster);
+        (0, globals_1.expect)(decoded.incident?.cause).toBeUndefined();
+    });
+    (0, globals_1.it)('decodes a legacy compact event (no n key) with no cause', () => {
+        const legacy = { p: 0, e: service_1.EventTypeEnum.SPIKE, f: 0, t: 0, a: 4, s: 50, i: 3 };
+        const decoded = (0, rally_event_1.transformToSpike)(legacy, roster);
+        (0, globals_1.expect)(decoded.incident).toEqual({ kind: 'INJURY', severity: 3 });
+    });
     (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/);

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

@@ -12,6 +12,7 @@ export interface CompactEvent {
     j?: number;
     i?: number;
     h?: number;
+    n?: number;
     m?: number;
     c?: number[];
     g?: number[];

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

@@ -30,13 +30,15 @@ function incidentToCompact(incident) {
         return undefined;
     return incident.kind === 'KNOCK' ? 10 + incident.severity : incident.severity;
 }
-function incidentFromCompact(i, h, roster) {
+function incidentFromCompact(e, roster) {
+    const i = e.i;
     if (i == null)
         return undefined;
-    const playerId = h != null && roster != null ? roster[h] : undefined;
+    const playerId = e.h != null && roster != null ? roster[e.h] : undefined;
     return {
         ...(i >= 10 ? { kind: 'KNOCK', severity: i - 10 } : { kind: 'INJURY', severity: i }),
-        ...(playerId != null ? { playerId } : {})
+        ...(playerId != null ? { playerId } : {}),
+        ...(e.n != null ? { cause: e.n } : {})
     };
 }
 function transformToCompact(evt, playerIndex) {
@@ -55,6 +57,8 @@ function transformToCompact(evt, playerIndex) {
             if (evt.incident?.playerId != null && evt.incident.playerId !== evt.playerId) {
                 out.h = playerIndex.get(evt.incident.playerId);
             }
+            if (evt.incident?.cause != null)
+                out.n = evt.incident.cause;
         }
         if (evt.contact != null)
             out.c = [evt.contact.x, evt.contact.y];
@@ -90,7 +94,7 @@ 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, roster),
         ...positionalFromCompact(event)
     });
 }
@@ -108,7 +112,7 @@ function transformToReception(event, roster) {
         playerId: roster[event.p],
         target: event.a,
         score: event.s,
-        incident: incidentFromCompact(event.i, event.h, roster),
+        incident: incidentFromCompact(event, roster),
         ...positionalFromCompact(event)
     });
 }
@@ -119,7 +123,7 @@ function transformToServe(event, roster) {
         playerId: roster[event.p],
         target: event.a,
         score: event.s,
-        incident: incidentFromCompact(event.i, event.h, roster),
+        incident: incidentFromCompact(event, roster),
         ...positionalFromCompact(event)
     });
 }
@@ -130,7 +134,7 @@ function transformToSet(event, roster) {
         playerId: roster[event.p],
         target: event.a,
         score: event.s,
-        incident: incidentFromCompact(event.i, event.h, roster),
+        incident: incidentFromCompact(event, roster),
         tempo: event.m,
         ...positionalFromCompact(event)
     });
@@ -144,7 +148,7 @@ function transformToSpike(event, roster) {
         playerId: roster[event.p],
         target: event.a,
         score: event.s,
-        incident: incidentFromCompact(event.i, event.h, roster),
+        incident: incidentFromCompact(event, roster),
         ...positionalFromCompact(event)
     });
 }

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

@@ -1,10 +1,11 @@
 import { CourtTarget } from '../match';
-import { RallyEvent, RallyEventOpts } from './rally-event';
+import { EventType, RallyEvent, RallyEventOpts } from './rally-event';
 import { Trait } from '../player';
 export interface EventIncident {
     readonly kind: 'KNOCK' | 'INJURY';
     readonly severity: number;
     readonly playerId?: string;
+    readonly cause?: EventType;
 }
 export declare enum DigQualityEnum {
     PERFECT = 0,

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

@@ -44,6 +44,7 @@ export declare const BlockInputSchema: z.ZodObject<{
         }>;
         severity: z.ZodNumber;
         playerId: z.ZodOptional<z.ZodUUID>;
+        cause: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type BlockInput = z.infer<typeof BlockInputSchema>;

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

@@ -6,5 +6,6 @@ export declare const EventIncidentSchema: z.ZodObject<{
     }>;
     severity: z.ZodNumber;
     playerId: z.ZodOptional<z.ZodUUID>;
+    cause: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 export type EventIncidentInput = z.infer<typeof EventIncidentSchema>;

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

@@ -10,5 +10,8 @@ exports.EventIncidentSchema = zod_1.z.object({
     severity: zod_1.z.number().int().min(1).max(4),
     // Who got hurt, ONLY when it is not the event's actor (a secondary blocker on a multi-player block);
     // absent = the event's own playerId.
-    playerId: zod_1.z.uuid().optional()
+    playerId: zod_1.z.uuid().optional(),
+    // The action the hurt player was performing (an EventType), set only when this event is not their own action
+    // and does not list them: SPIKE = a fake spike, BLOCK = a block attempt that never touched the ball.
+    cause: zod_1.z.number().int().min(0).max(7).optional()
 }).refine(v => v.kind !== 'KNOCK' || v.severity <= 3, { message: 'INVALID_KNOCK_TIER' });

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

@@ -43,6 +43,7 @@ export declare const ReceptionInputSchema: z.ZodObject<{
         }>;
         severity: z.ZodNumber;
         playerId: z.ZodOptional<z.ZodUUID>;
+        cause: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type ReceptionInput = z.infer<typeof ReceptionInputSchema>;

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

@@ -43,6 +43,7 @@ export declare const ServeInputSchema: z.ZodObject<{
         }>;
         severity: z.ZodNumber;
         playerId: z.ZodOptional<z.ZodUUID>;
+        cause: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type ServeInput = z.infer<typeof ServeInputSchema>;

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

@@ -43,6 +43,7 @@ export declare const SetInputSchema: z.ZodObject<{
         }>;
         severity: z.ZodNumber;
         playerId: z.ZodOptional<z.ZodUUID>;
+        cause: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
     tempo: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;

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

@@ -43,6 +43,7 @@ export declare const SpikeInputSchema: z.ZodObject<{
         }>;
         severity: z.ZodNumber;
         playerId: z.ZodOptional<z.ZodUUID>;
+        cause: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type SpikeInput = z.infer<typeof SpikeInputSchema>;

package/dist/cjs/src/service/match/match-rating.d.ts

@@ -1,4 +1,4 @@
-import { Match, MatchTeam } from '.';
+import { Match, MatchScore, MatchTeam } from '.';
 import { MatchContext } from './schemas/match-rating.z';
 export type { MatchContext };
 interface SetScoreVariant {
@@ -28,6 +28,18 @@ export declare class MatchRating {
     private static applyBotPenalty;
     private static computeWeight;
     static calculateProbability(z: number): number;
+    /**
+     * The FIVB model's probability of each of the six possible set scores, from the rating gap alone.
+     *
+     * getExpectedResult() has always computed these six numbers and immediately collapsed them into one weighted
+     * average. They are exposed here because the SAME distribution is what the Sim draws from to resolve a
+     * bot-vs-bot match without simulating it: the model that GRADES a result is then also the model that produces
+     * it, so a shortcut result can never disagree with the rating it earns. Extracted rather than duplicated,
+     * because a second copy of the cut-points would drift silently.
+     *
+     * Sums to 1 (P6 is the remainder), and is ordered best-to-worst FOR THE HOME TEAM.
+     */
+    static outcomeProbabilities(homeRating: number, awayRating: number): Record<MatchScore, number>;
     getExpectedResult(): number;
     getPoints(team: MatchTeam): number;
 }

package/dist/cjs/src/service/match/match-rating.js

@@ -42,20 +42,36 @@ class MatchRating {
     static calculateProbability(z) {
         return 0.5 * (1 + (0, utils_1.erf)(z / Math.SQRT2));
     }
+    /**
+     * The FIVB model's probability of each of the six possible set scores, from the rating gap alone.
+     *
+     * getExpectedResult() has always computed these six numbers and immediately collapsed them into one weighted
+     * average. They are exposed here because the SAME distribution is what the Sim draws from to resolve a
+     * bot-vs-bot match without simulating it: the model that GRADES a result is then also the model that produces
+     * it, so a shortcut result can never disagree with the rating it earns. Extracted rather than duplicated,
+     * because a second copy of the cut-points would drift silently.
+     *
+     * Sums to 1 (P6 is the remainder), and is ordered best-to-worst FOR THE HOME TEAM.
+     */
+    static outcomeProbabilities(homeRating, awayRating) {
+        const D = MatchRating.K * (homeRating - awayRating) / 1000;
+        return {
+            '3-0': MatchRating.calculateProbability(MatchRating.C1 + D),
+            '3-1': MatchRating.calculateProbability(MatchRating.C2 + D) - MatchRating.calculateProbability(MatchRating.C1 + D),
+            '3-2': MatchRating.calculateProbability(MatchRating.C3 + D) - MatchRating.calculateProbability(MatchRating.C2 + D),
+            '2-3': MatchRating.calculateProbability(MatchRating.C4 + D) - MatchRating.calculateProbability(MatchRating.C3 + D),
+            '1-3': MatchRating.calculateProbability(MatchRating.C5 + D) - MatchRating.calculateProbability(MatchRating.C4 + D),
+            '0-3': 1 - MatchRating.calculateProbability(MatchRating.C5 + D)
+        };
+    }
     getExpectedResult() {
-        const D = MatchRating.K * (this.match.homeTeam.rating - this.match.awayTeam.rating) / 1000;
-        const P1 = MatchRating.calculateProbability(MatchRating.C1 + D);
-        const P2 = MatchRating.calculateProbability(MatchRating.C2 + D) - MatchRating.calculateProbability(MatchRating.C1 + D);
-        const P3 = MatchRating.calculateProbability(MatchRating.C3 + D) - MatchRating.calculateProbability(MatchRating.C2 + D);
-        const P4 = MatchRating.calculateProbability(MatchRating.C4 + D) - MatchRating.calculateProbability(MatchRating.C3 + D);
-        const P5 = MatchRating.calculateProbability(MatchRating.C5 + D) - MatchRating.calculateProbability(MatchRating.C4 + D);
-        const P6 = 1 - MatchRating.calculateProbability(MatchRating.C5 + D);
-        return P1 * MatchRating.SSV['3-0'] +
-            P2 * MatchRating.SSV['3-1'] +
-            P3 * MatchRating.SSV['3-2'] +
-            P4 * MatchRating.SSV['2-3'] +
-            P5 * MatchRating.SSV['1-3'] +
-            P6 * MatchRating.SSV['0-3'];
+        const P = MatchRating.outcomeProbabilities(this.match.homeTeam.rating, this.match.awayTeam.rating);
+        return P['3-0'] * MatchRating.SSV['3-0'] +
+            P['3-1'] * MatchRating.SSV['3-1'] +
+            P['3-2'] * MatchRating.SSV['3-2'] +
+            P['2-3'] * MatchRating.SSV['2-3'] +
+            P['1-3'] * MatchRating.SSV['1-3'] +
+            P['0-3'] * MatchRating.SSV['0-3'];
     }
     getPoints(team) {
         const homeScoreKey = this.match.getScore();

package/dist/cjs/src/service/match/match-rating.test.js

@@ -91,6 +91,59 @@ const number_utils_1 = require("../utils/number-utils");
         (0, globals_1.expect)(mr1.getExpectedResult()).toBeCloseTo(-mr2.getExpectedResult(), 8);
     });
 });
+// ─── outcomeProbabilities ─────────────────────────────────────────────────────
+(0, globals_1.describe)('MatchRating.outcomeProbabilities()', () => {
+    const SCORES = ['3-0', '3-1', '3-2', '2-3', '1-3', '0-3'];
+    (0, globals_1.it)('sums to 1 for any rating gap', () => {
+        for (const [h, a] of [[1000, 1000], [1500, 1000], [1000, 1500], [100, 100], [130, 70]]) {
+            const P = match_rating_1.MatchRating.outcomeProbabilities(h, a);
+            const total = SCORES.reduce((sum, key) => sum + P[key], 0);
+            (0, globals_1.expect)(total).toBeCloseTo(1, 10);
+        }
+    });
+    (0, globals_1.it)('is never negative', () => {
+        for (const [h, a] of [[1000, 1000], [5000, 100], [100, 5000]]) {
+            const P = match_rating_1.MatchRating.outcomeProbabilities(h, a);
+            for (const key of SCORES)
+                (0, globals_1.expect)(P[key]).toBeGreaterThanOrEqual(0);
+        }
+    });
+    (0, globals_1.it)('is symmetric between the two sides at equal rating', () => {
+        // 8 rather than 10 decimals: erf() is a series approximation, so the mirrored buckets agree to ~1e-9.
+        const P = match_rating_1.MatchRating.outcomeProbabilities(100, 100);
+        (0, globals_1.expect)(P['3-0']).toBeCloseTo(P['0-3'], 8);
+        (0, globals_1.expect)(P['3-1']).toBeCloseTo(P['1-3'], 8);
+        (0, globals_1.expect)(P['3-2']).toBeCloseTo(P['2-3'], 8);
+    });
+    (0, globals_1.it)('mirrors when the gap is reversed', () => {
+        const P = match_rating_1.MatchRating.outcomeProbabilities(130, 70);
+        const Q = match_rating_1.MatchRating.outcomeProbabilities(70, 130);
+        (0, globals_1.expect)(P['3-0']).toBeCloseTo(Q['0-3'], 8);
+        (0, globals_1.expect)(P['3-1']).toBeCloseTo(Q['1-3'], 8);
+        (0, globals_1.expect)(P['3-2']).toBeCloseTo(Q['2-3'], 8);
+    });
+    (0, globals_1.it)('shifts weight toward the stronger side as the gap widens', () => {
+        const even = match_rating_1.MatchRating.outcomeProbabilities(100, 100);
+        const wide = match_rating_1.MatchRating.outcomeProbabilities(160, 40);
+        (0, globals_1.expect)(wide['3-0']).toBeGreaterThan(even['3-0']);
+        (0, globals_1.expect)(wide['0-3']).toBeLessThan(even['0-3']);
+    });
+    // The extraction guarantee: getExpectedResult() must still be the SSV-weighted sum of exactly these six
+    // numbers. If someone changes one and not the other, this fails.
+    (0, globals_1.it)('reproduces getExpectedResult() as the SSV-weighted sum', () => {
+        for (const [h, a] of [[1000, 1000], [1500, 1000], [1000, 1500], [130, 70]]) {
+            const home = (0, test_helpers_1.makeTeam)({ rating: h });
+            const away = (0, test_helpers_1.makeTeam)({ rating: a });
+            const mr = match_rating_1.MatchRating.create({
+                match: (0, test_helpers_1.makeMatch30)(home, away),
+                context: { kind: 'LEAGUE', tier: 1, homeIsBot: false, awayIsBot: false }
+            });
+            const P = match_rating_1.MatchRating.outcomeProbabilities(h, a);
+            const expected = SCORES.reduce((sum, key) => sum + P[key] * match_rating_1.MatchRating.SSV[key], 0);
+            (0, globals_1.expect)(mr.getExpectedResult()).toBeCloseTo(expected, 10);
+        }
+    });
+});
 // ─── getPoints ────────────────────────────────────────────────────────────────
 (0, globals_1.describe)('MatchRating.getPoints()', () => {
     (0, globals_1.it)('home and away deltas are opposite signs', () => {

package/dist/cjs/src/service/utils/email-utils.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The comparison form of an email address. Lowercased and trimmed; the local part loses any `+tag`; on Gmail it
+ * also loses its dots and the domain folds onto gmail.com.
+ *
+ * Split local from domain FIRST. Splitting the whole address on '+' looks equivalent and is not: an address
+ * with no tag comes back whole, and a later dot-strip then eats the dot in "gmail.com" too.
+ *
+ * Returns the trimmed lowercase input unchanged when it is not a single-@ address, so a malformed value is
+ * never silently reshaped into something that could collide with a real account. Format validation is the
+ * caller's job.
+ */
+export declare function canonicalEmail(raw: string): string;

package/dist/cjs/src/service/utils/email-utils.js

@@ -0,0 +1,43 @@
+"use strict";
+// Email identity helpers.
+//
+// A person must not be able to hold two accounts on one mailbox by spelling the same address differently. The
+// canonical form is what uniqueness is enforced on; the raw address the user typed is still what we display and
+// send mail to.
+//
+// Owner decision 2026-09-01: GMAIL RULES FOR GMAIL ONLY. Dots are insignificant and +tags are aliases on
+// Gmail, so both are stripped there. Applying either rule to every provider would WRONGLY merge two real
+// people on providers where the local part is taken literally, so everyone else gets lowercasing and +tag
+// removal alone (+tag aliasing is near-universal; dot-insignificance is not).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canonicalEmail = canonicalEmail;
+/** Domains that alias onto gmail.com and follow its dot/plus rules. */
+const GMAIL_DOMAINS = new Set(['gmail.com', 'googlemail.com']);
+/**
+ * The comparison form of an email address. Lowercased and trimmed; the local part loses any `+tag`; on Gmail it
+ * also loses its dots and the domain folds onto gmail.com.
+ *
+ * Split local from domain FIRST. Splitting the whole address on '+' looks equivalent and is not: an address
+ * with no tag comes back whole, and a later dot-strip then eats the dot in "gmail.com" too.
+ *
+ * Returns the trimmed lowercase input unchanged when it is not a single-@ address, so a malformed value is
+ * never silently reshaped into something that could collide with a real account. Format validation is the
+ * caller's job.
+ */
+function canonicalEmail(raw) {
+    const trimmed = raw.trim().toLowerCase();
+    const at = trimmed.lastIndexOf('@');
+    if (at <= 0 || at === trimmed.length - 1 || trimmed.indexOf('@') !== at)
+        return trimmed;
+    const local = trimmed.slice(0, at);
+    const domain = trimmed.slice(at + 1);
+    const untagged = local.split('+')[0];
+    // An address that is nothing BUT a tag and/or dots has no local part left once they are stripped. Fall back to
+    // the ORIGINAL local part, never to the stripped one: an empty local would canonicalize every degenerate
+    // address to the same value and collide them with each other.
+    if (GMAIL_DOMAINS.has(domain)) {
+        const noDots = untagged.split('.').join('');
+        return `${noDots.length > 0 ? noDots : local}@gmail.com`;
+    }
+    return `${untagged.length > 0 ? untagged : local}@${domain}`;
+}

package/dist/cjs/src/service/utils/email-utils.test.d.ts

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

package/dist/cjs/src/service/utils/email-utils.test.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+const email_utils_1 = require("./email-utils");
+// ─── canonicalEmail ──────────────────────────────────────────────────────────
+(0, globals_1.describe)('canonicalEmail()', () => {
+    (0, globals_1.it)('lowercases and trims', () => {
+        (0, globals_1.expect)((0, email_utils_1.canonicalEmail)('  Foo.Bar@Example.COM  ')).toBe('foo.bar@example.com');
+    });
+    (0, globals_1.it)('strips a +tag on any provider', () => {
+        (0, globals_1.expect)((0, email_utils_1.canonicalEmail)('user+anything@example.com')).toBe('user@example.com');
+    });
+    (0, globals_1.it)('keeps dots on non-Gmail providers, where they are significant', () => {
+        (0, globals_1.expect)((0, email_utils_1.canonicalEmail)('a.b@example.com')).toBe('a.b@example.com');
+        (0, globals_1.expect)((0, email_utils_1.canonicalEmail)('ab@example.com')).toBe('ab@example.com');
+        (0, globals_1.expect)((0, email_utils_1.canonicalEmail)('a.b@example.com')).not.toBe((0, email_utils_1.canonicalEmail)('ab@example.com'));
+    });
+    (0, globals_1.it)('strips dots AND +tags on gmail', () => {
+        (0, globals_1.expect)((0, email_utils_1.canonicalEmail)('a.b.c+tag@gmail.com')).toBe('abc@gmail.com');
+        (0, globals_1.expect)((0, email_utils_1.canonicalEmail)('abc@gmail.com')).toBe('abc@gmail.com');
+        (0, globals_1.expect)((0, email_utils_1.canonicalEmail)('a.b.c@gmail.com')).toBe((0, email_utils_1.canonicalEmail)('abc+anything@gmail.com'));
+    });
+    (0, globals_1.it)('folds googlemail.com onto gmail.com', () => {
+        (0, globals_1.expect)((0, email_utils_1.canonicalEmail)('a.b@googlemail.com')).toBe('ab@gmail.com');
+        (0, globals_1.expect)((0, email_utils_1.canonicalEmail)('ab@googlemail.com')).toBe((0, email_utils_1.canonicalEmail)('ab@gmail.com'));
+    });
+    // The exact bug the first prod duplicate report hit: splitting the WHOLE address on '+' returns the address
+    // intact when there is no tag, and the Gmail dot-strip then eats the dot in "gmail.com" as well.
+    (0, globals_1.it)('does not mangle a Gmail address that has no +tag', () => {
+        (0, globals_1.expect)((0, email_utils_1.canonicalEmail)('fariasfranciscoe@gmail.com')).toBe('fariasfranciscoe@gmail.com');
+        (0, globals_1.expect)((0, email_utils_1.canonicalEmail)('fariasfranciscoe@gmail.com')).not.toContain('gmailcom');
+    });
+    (0, globals_1.it)('matches the real prod collision it was written for', () => {
+        (0, globals_1.expect)((0, email_utils_1.canonicalEmail)('fariasfranciscoe+playreview@gmail.com'))
+            .toBe((0, email_utils_1.canonicalEmail)('fariasfranciscoe@gmail.com'));
+    });
+    (0, globals_1.it)('leaves a malformed address alone rather than reshaping it', () => {
+        (0, globals_1.expect)((0, email_utils_1.canonicalEmail)('not-an-email')).toBe('not-an-email');
+        (0, globals_1.expect)((0, email_utils_1.canonicalEmail)('@example.com')).toBe('@example.com');
+        (0, globals_1.expect)((0, email_utils_1.canonicalEmail)('user@')).toBe('user@');
+        (0, globals_1.expect)((0, email_utils_1.canonicalEmail)('two@ats@example.com')).toBe('two@ats@example.com');
+    });
+    (0, globals_1.it)('never returns an empty local part for a degenerate address', () => {
+        (0, globals_1.expect)((0, email_utils_1.canonicalEmail)('+tag@gmail.com')).toBe('+tag@gmail.com');
+        (0, globals_1.expect)((0, email_utils_1.canonicalEmail)('...@gmail.com')).toBe('...@gmail.com');
+    });
+    (0, globals_1.it)('is idempotent', () => {
+        for (const raw of ['A.B+x@Gmail.com', 'user+t@example.com', 'plain@example.com', 'weird']) {
+            (0, globals_1.expect)((0, email_utils_1.canonicalEmail)((0, email_utils_1.canonicalEmail)(raw))).toBe((0, email_utils_1.canonicalEmail)(raw));
+        }
+    });
+});

package/dist/cjs/src/service/utils/index.d.ts

@@ -1,4 +1,5 @@
 export * from './object-utils';
+export * from './email-utils';
 export * from './number-utils';
 export * from './rng-utils';
 export * from './faker-generators';

package/dist/cjs/src/service/utils/index.js

@@ -15,6 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./object-utils"), exports);
+__exportStar(require("./email-utils"), exports);
 __exportStar(require("./number-utils"), exports);
 __exportStar(require("./rng-utils"), exports);
 __exportStar(require("./faker-generators"), exports);

package/dist/esm/src/data/models/auth-user.d.ts

@@ -12,12 +12,16 @@ export interface AuthUserAttributes {
     last_login_at?: Date | null;
     created_at?: Date;
     updated_at?: Date;
+    /** Comparison form of `email` (see canonicalEmail). Uniqueness is enforced on THIS, not on `email`. */
+    canonical_email?: string | null;
+    /** When the account was terminated. Also the clock the 4-month data purge runs off. */
+    terminated_at?: Date | null;
 }
 export type AuthUserPk = 'user_id';
 export type AuthUserId = AuthUserModel[AuthUserPk];
 export type AuthUserRole = 'ADMIN' | 'PLAYER';
-export type AuthUserStatus = 'ACTIVE' | 'DISABLED' | 'PENDING';
-export type AuthUserOptionalAttributes = 'role' | 'display_name' | 'avatar_url' | 'status' | 'email_verified_at' | 'last_login_at' | 'created_at' | 'updated_at';
+export type AuthUserStatus = 'ACTIVE' | 'DISABLED' | 'PENDING' | 'TERMINATED';
+export type AuthUserOptionalAttributes = 'role' | 'display_name' | 'avatar_url' | 'status' | 'email_verified_at' | 'last_login_at' | 'created_at' | 'updated_at' | 'canonical_email' | 'terminated_at';
 export type AuthUserCreationAttributes = Optional<AuthUserAttributes, AuthUserOptionalAttributes>;
 export declare class AuthUserModel extends Model<AuthUserAttributes, AuthUserCreationAttributes> implements AuthUserAttributes {
     user_id: string;
@@ -30,6 +34,8 @@ export declare class AuthUserModel extends Model<AuthUserAttributes, AuthUserCre
     last_login_at?: Date | null;
     created_at?: Date;
     updated_at?: Date;
+    canonical_email?: string | null;
+    terminated_at?: Date | null;
     AuthIdentities: AuthIdentityModel[];
     getAuthIdentities: Sequelize.HasManyGetAssociationsMixin<AuthIdentityModel>;
     setAuthIdentities: Sequelize.HasManySetAssociationsMixin<AuthIdentityModel, AuthIdentityId>;

package/dist/esm/src/data/models/auth-user.js

@@ -1,3 +1,4 @@
+import * as Sequelize from 'sequelize';
 import { DataTypes, Model } from 'sequelize';
 export class AuthUserModel extends Model {
     static initModel(sequelize) {
@@ -9,8 +10,7 @@ export class AuthUserModel extends Model {
             },
             email: {
                 type: DataTypes.STRING,
-                allowNull: false,
-                unique: 'AuthUser_email_uq'
+                allowNull: false
             },
             role: {
                 type: DataTypes.ENUM('ADMIN', 'PLAYER'),
@@ -26,7 +26,7 @@ export class AuthUserModel extends Model {
                 allowNull: true
             },
             status: {
-                type: DataTypes.ENUM('ACTIVE', 'DISABLED', 'PENDING'),
+                type: DataTypes.ENUM('ACTIVE', 'DISABLED', 'PENDING', 'TERMINATED'),
                 allowNull: false,
                 defaultValue: 'PENDING'
             },
@@ -47,6 +47,14 @@ export class AuthUserModel extends Model {
                 type: DataTypes.DATE,
                 allowNull: false,
                 defaultValue: DataTypes.NOW
+            },
+            canonical_email: {
+                type: DataTypes.STRING,
+                allowNull: true
+            },
+            terminated_at: {
+                type: DataTypes.DATE,
+                allowNull: true
             }
         }, {
             sequelize,
@@ -60,9 +68,16 @@ export class AuthUserModel extends Model {
                     fields: [{ name: 'user_id' }]
                 },
                 {
-                    name: 'AuthUser_email_uq',
+                    name: 'AuthUser_email_live_uq',
+                    unique: true,
+                    fields: [{ name: 'email' }],
+                    where: { status: { [Sequelize.Op.ne]: 'TERMINATED' } }
+                },
+                {
+                    name: 'AuthUser_canonical_email_live_uq',
                     unique: true,
-                    fields: [{ name: 'email' }]
+                    fields: [{ name: 'canonical_email' }],
+                    where: { status: { [Sequelize.Op.ne]: 'TERMINATED' } }
                 }
             ]
         });

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

@@ -101,6 +101,45 @@ describe('rally-event compact round trip — incident marker on the causing even
         const decoded = transformToSpike(compact, roster);
         expect(decoded.incident).toEqual({ kind: 'INJURY', severity: 2 });
     });
+    // The off-ball cause (2026-09-01). An attacker making a fake spike and a blocker whose block attempt never
+    // touched the ball both jump, both can get hurt, and neither emits an event, so their incident rides another
+    // event and 'n' is the only thing saying what they were actually doing. Lose it and the feed says they spiked.
+    it('packs the off-ball cause under n and round-trips it alongside the hurt player', () => {
+        const hitter = uuidv4();
+        const faker = uuidv4();
+        const pairRoster = [hitter, faker];
+        const pairIndex = new Map(pairRoster.map((id, i) => [id, i]));
+        const spike = Spike.create({
+            playerId: hitter,
+            score: 62.5,
+            target: 4,
+            failure: SpikeFailureEnum.NO_FAILURE,
+            type: SpikeTypeEnum.SPIKE,
+            incident: { kind: 'INJURY', severity: 4, playerId: faker, cause: EventTypeEnum.SPIKE }
+        });
+        const compact = transformToCompact(spike, pairIndex);
+        expect(compact.h).toBe(1);
+        expect(compact.n).toBe(EventTypeEnum.SPIKE);
+        const decoded = transformToSpike(compact, pairRoster);
+        expect(decoded.incident).toEqual({ kind: 'INJURY', severity: 4, playerId: faker, cause: EventTypeEnum.SPIKE });
+    });
+    it('round-trips a BLOCK cause, which is the other action that emits no event', () => {
+        const compact = transformToCompact(makeSpike({ kind: 'KNOCK', severity: 1, playerId, cause: EventTypeEnum.BLOCK }), playerIndex);
+        expect(compact.n).toBe(EventTypeEnum.BLOCK);
+        const decoded = transformToSpike(compact, roster);
+        expect(decoded.incident?.cause).toBe(EventTypeEnum.BLOCK);
+    });
+    it('omits n for an ordinary incident, so nothing grows for the common case', () => {
+        const compact = transformToCompact(makeSpike({ kind: 'INJURY', severity: 2 }), playerIndex);
+        expect('n' in compact).toBe(false);
+        const decoded = transformToSpike(compact, roster);
+        expect(decoded.incident?.cause).toBeUndefined();
+    });
+    it('decodes a legacy compact event (no n key) with no cause', () => {
+        const legacy = { p: 0, e: EventTypeEnum.SPIKE, f: 0, t: 0, a: 4, s: 50, i: 3 };
+        const decoded = transformToSpike(legacy, roster);
+        expect(decoded.incident).toEqual({ kind: 'INJURY', severity: 3 });
+    });
     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/);

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

@@ -12,6 +12,7 @@ export interface CompactEvent {
     j?: number;
     i?: number;
     h?: number;
+    n?: number;
     m?: number;
     c?: number[];
     g?: number[];

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

@@ -19,13 +19,15 @@ function incidentToCompact(incident) {
         return undefined;
     return incident.kind === 'KNOCK' ? 10 + incident.severity : incident.severity;
 }
-function incidentFromCompact(i, h, roster) {
+function incidentFromCompact(e, roster) {
+    const i = e.i;
     if (i == null)
         return undefined;
-    const playerId = h != null && roster != null ? roster[h] : undefined;
+    const playerId = e.h != null && roster != null ? roster[e.h] : undefined;
     return {
         ...(i >= 10 ? { kind: 'KNOCK', severity: i - 10 } : { kind: 'INJURY', severity: i }),
-        ...(playerId != null ? { playerId } : {})
+        ...(playerId != null ? { playerId } : {}),
+        ...(e.n != null ? { cause: e.n } : {})
     };
 }
 export function transformToCompact(evt, playerIndex) {
@@ -44,6 +46,8 @@ export function transformToCompact(evt, playerIndex) {
             if (evt.incident?.playerId != null && evt.incident.playerId !== evt.playerId) {
                 out.h = playerIndex.get(evt.incident.playerId);
             }
+            if (evt.incident?.cause != null)
+                out.n = evt.incident.cause;
         }
         if (evt.contact != null)
             out.c = [evt.contact.x, evt.contact.y];
@@ -79,7 +83,7 @@ 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, roster),
         ...positionalFromCompact(event)
     });
 }
@@ -97,7 +101,7 @@ 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, roster),
         ...positionalFromCompact(event)
     });
 }
@@ -108,7 +112,7 @@ 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, roster),
         ...positionalFromCompact(event)
     });
 }
@@ -119,7 +123,7 @@ export function transformToSet(event, roster) {
         playerId: roster[event.p],
         target: event.a,
         score: event.s,
-        incident: incidentFromCompact(event.i, event.h, roster),
+        incident: incidentFromCompact(event, roster),
         tempo: event.m,
         ...positionalFromCompact(event)
     });
@@ -133,7 +137,7 @@ 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, roster),
         ...positionalFromCompact(event)
     });
 }

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

@@ -1,10 +1,11 @@
 import { CourtTarget } from '../match';
-import { RallyEvent, RallyEventOpts } from './rally-event';
+import { EventType, RallyEvent, RallyEventOpts } from './rally-event';
 import { Trait } from '../player';
 export interface EventIncident {
     readonly kind: 'KNOCK' | 'INJURY';
     readonly severity: number;
     readonly playerId?: string;
+    readonly cause?: EventType;
 }
 export declare enum DigQualityEnum {
     PERFECT = 0,

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

@@ -44,6 +44,7 @@ export declare const BlockInputSchema: z.ZodObject<{
         }>;
         severity: z.ZodNumber;
         playerId: z.ZodOptional<z.ZodUUID>;
+        cause: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type BlockInput = z.infer<typeof BlockInputSchema>;

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

@@ -6,5 +6,6 @@ export declare const EventIncidentSchema: z.ZodObject<{
     }>;
     severity: z.ZodNumber;
     playerId: z.ZodOptional<z.ZodUUID>;
+    cause: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 export type EventIncidentInput = z.infer<typeof EventIncidentSchema>;

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

@@ -7,5 +7,8 @@ export const EventIncidentSchema = z.object({
     severity: z.number().int().min(1).max(4),
     // Who got hurt, ONLY when it is not the event's actor (a secondary blocker on a multi-player block);
     // absent = the event's own playerId.
-    playerId: z.uuid().optional()
+    playerId: z.uuid().optional(),
+    // The action the hurt player was performing (an EventType), set only when this event is not their own action
+    // and does not list them: SPIKE = a fake spike, BLOCK = a block attempt that never touched the ball.
+    cause: z.number().int().min(0).max(7).optional()
 }).refine(v => v.kind !== 'KNOCK' || v.severity <= 3, { message: 'INVALID_KNOCK_TIER' });

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

@@ -43,6 +43,7 @@ export declare const ReceptionInputSchema: z.ZodObject<{
         }>;
         severity: z.ZodNumber;
         playerId: z.ZodOptional<z.ZodUUID>;
+        cause: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type ReceptionInput = z.infer<typeof ReceptionInputSchema>;

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

@@ -43,6 +43,7 @@ export declare const ServeInputSchema: z.ZodObject<{
         }>;
         severity: z.ZodNumber;
         playerId: z.ZodOptional<z.ZodUUID>;
+        cause: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type ServeInput = z.infer<typeof ServeInputSchema>;

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

@@ -43,6 +43,7 @@ export declare const SetInputSchema: z.ZodObject<{
         }>;
         severity: z.ZodNumber;
         playerId: z.ZodOptional<z.ZodUUID>;
+        cause: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
     tempo: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;

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

@@ -43,6 +43,7 @@ export declare const SpikeInputSchema: z.ZodObject<{
         }>;
         severity: z.ZodNumber;
         playerId: z.ZodOptional<z.ZodUUID>;
+        cause: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type SpikeInput = z.infer<typeof SpikeInputSchema>;

package/dist/esm/src/service/match/match-rating.d.ts

@@ -1,4 +1,4 @@
-import { Match, MatchTeam } from '.';
+import { Match, MatchScore, MatchTeam } from '.';
 import { MatchContext } from './schemas/match-rating.z';
 export type { MatchContext };
 interface SetScoreVariant {
@@ -28,6 +28,18 @@ export declare class MatchRating {
     private static applyBotPenalty;
     private static computeWeight;
     static calculateProbability(z: number): number;
+    /**
+     * The FIVB model's probability of each of the six possible set scores, from the rating gap alone.
+     *
+     * getExpectedResult() has always computed these six numbers and immediately collapsed them into one weighted
+     * average. They are exposed here because the SAME distribution is what the Sim draws from to resolve a
+     * bot-vs-bot match without simulating it: the model that GRADES a result is then also the model that produces
+     * it, so a shortcut result can never disagree with the rating it earns. Extracted rather than duplicated,
+     * because a second copy of the cut-points would drift silently.
+     *
+     * Sums to 1 (P6 is the remainder), and is ordered best-to-worst FOR THE HOME TEAM.
+     */
+    static outcomeProbabilities(homeRating: number, awayRating: number): Record<MatchScore, number>;
     getExpectedResult(): number;
     getPoints(team: MatchTeam): number;
 }

package/dist/esm/src/service/match/match-rating.js

@@ -39,20 +39,36 @@ export class MatchRating {
     static calculateProbability(z) {
         return 0.5 * (1 + erf(z / Math.SQRT2));
     }
+    /**
+     * The FIVB model's probability of each of the six possible set scores, from the rating gap alone.
+     *
+     * getExpectedResult() has always computed these six numbers and immediately collapsed them into one weighted
+     * average. They are exposed here because the SAME distribution is what the Sim draws from to resolve a
+     * bot-vs-bot match without simulating it: the model that GRADES a result is then also the model that produces
+     * it, so a shortcut result can never disagree with the rating it earns. Extracted rather than duplicated,
+     * because a second copy of the cut-points would drift silently.
+     *
+     * Sums to 1 (P6 is the remainder), and is ordered best-to-worst FOR THE HOME TEAM.
+     */
+    static outcomeProbabilities(homeRating, awayRating) {
+        const D = MatchRating.K * (homeRating - awayRating) / 1000;
+        return {
+            '3-0': MatchRating.calculateProbability(MatchRating.C1 + D),
+            '3-1': MatchRating.calculateProbability(MatchRating.C2 + D) - MatchRating.calculateProbability(MatchRating.C1 + D),
+            '3-2': MatchRating.calculateProbability(MatchRating.C3 + D) - MatchRating.calculateProbability(MatchRating.C2 + D),
+            '2-3': MatchRating.calculateProbability(MatchRating.C4 + D) - MatchRating.calculateProbability(MatchRating.C3 + D),
+            '1-3': MatchRating.calculateProbability(MatchRating.C5 + D) - MatchRating.calculateProbability(MatchRating.C4 + D),
+            '0-3': 1 - MatchRating.calculateProbability(MatchRating.C5 + D)
+        };
+    }
     getExpectedResult() {
-        const D = MatchRating.K * (this.match.homeTeam.rating - this.match.awayTeam.rating) / 1000;
-        const P1 = MatchRating.calculateProbability(MatchRating.C1 + D);
-        const P2 = MatchRating.calculateProbability(MatchRating.C2 + D) - MatchRating.calculateProbability(MatchRating.C1 + D);
-        const P3 = MatchRating.calculateProbability(MatchRating.C3 + D) - MatchRating.calculateProbability(MatchRating.C2 + D);
-        const P4 = MatchRating.calculateProbability(MatchRating.C4 + D) - MatchRating.calculateProbability(MatchRating.C3 + D);
-        const P5 = MatchRating.calculateProbability(MatchRating.C5 + D) - MatchRating.calculateProbability(MatchRating.C4 + D);
-        const P6 = 1 - MatchRating.calculateProbability(MatchRating.C5 + D);
-        return P1 * MatchRating.SSV['3-0'] +
-            P2 * MatchRating.SSV['3-1'] +
-            P3 * MatchRating.SSV['3-2'] +
-            P4 * MatchRating.SSV['2-3'] +
-            P5 * MatchRating.SSV['1-3'] +
-            P6 * MatchRating.SSV['0-3'];
+        const P = MatchRating.outcomeProbabilities(this.match.homeTeam.rating, this.match.awayTeam.rating);
+        return P['3-0'] * MatchRating.SSV['3-0'] +
+            P['3-1'] * MatchRating.SSV['3-1'] +
+            P['3-2'] * MatchRating.SSV['3-2'] +
+            P['2-3'] * MatchRating.SSV['2-3'] +
+            P['1-3'] * MatchRating.SSV['1-3'] +
+            P['0-3'] * MatchRating.SSV['0-3'];
     }
     getPoints(team) {
         const homeScoreKey = this.match.getScore();

package/dist/esm/src/service/match/match-rating.test.js

@@ -89,6 +89,59 @@ describe('MatchRating.getExpectedResult()', () => {
         expect(mr1.getExpectedResult()).toBeCloseTo(-mr2.getExpectedResult(), 8);
     });
 });
+// ─── outcomeProbabilities ─────────────────────────────────────────────────────
+describe('MatchRating.outcomeProbabilities()', () => {
+    const SCORES = ['3-0', '3-1', '3-2', '2-3', '1-3', '0-3'];
+    it('sums to 1 for any rating gap', () => {
+        for (const [h, a] of [[1000, 1000], [1500, 1000], [1000, 1500], [100, 100], [130, 70]]) {
+            const P = MatchRating.outcomeProbabilities(h, a);
+            const total = SCORES.reduce((sum, key) => sum + P[key], 0);
+            expect(total).toBeCloseTo(1, 10);
+        }
+    });
+    it('is never negative', () => {
+        for (const [h, a] of [[1000, 1000], [5000, 100], [100, 5000]]) {
+            const P = MatchRating.outcomeProbabilities(h, a);
+            for (const key of SCORES)
+                expect(P[key]).toBeGreaterThanOrEqual(0);
+        }
+    });
+    it('is symmetric between the two sides at equal rating', () => {
+        // 8 rather than 10 decimals: erf() is a series approximation, so the mirrored buckets agree to ~1e-9.
+        const P = MatchRating.outcomeProbabilities(100, 100);
+        expect(P['3-0']).toBeCloseTo(P['0-3'], 8);
+        expect(P['3-1']).toBeCloseTo(P['1-3'], 8);
+        expect(P['3-2']).toBeCloseTo(P['2-3'], 8);
+    });
+    it('mirrors when the gap is reversed', () => {
+        const P = MatchRating.outcomeProbabilities(130, 70);
+        const Q = MatchRating.outcomeProbabilities(70, 130);
+        expect(P['3-0']).toBeCloseTo(Q['0-3'], 8);
+        expect(P['3-1']).toBeCloseTo(Q['1-3'], 8);
+        expect(P['3-2']).toBeCloseTo(Q['2-3'], 8);
+    });
+    it('shifts weight toward the stronger side as the gap widens', () => {
+        const even = MatchRating.outcomeProbabilities(100, 100);
+        const wide = MatchRating.outcomeProbabilities(160, 40);
+        expect(wide['3-0']).toBeGreaterThan(even['3-0']);
+        expect(wide['0-3']).toBeLessThan(even['0-3']);
+    });
+    // The extraction guarantee: getExpectedResult() must still be the SSV-weighted sum of exactly these six
+    // numbers. If someone changes one and not the other, this fails.
+    it('reproduces getExpectedResult() as the SSV-weighted sum', () => {
+        for (const [h, a] of [[1000, 1000], [1500, 1000], [1000, 1500], [130, 70]]) {
+            const home = makeTeam({ rating: h });
+            const away = makeTeam({ rating: a });
+            const mr = MatchRating.create({
+                match: makeMatch30(home, away),
+                context: { kind: 'LEAGUE', tier: 1, homeIsBot: false, awayIsBot: false }
+            });
+            const P = MatchRating.outcomeProbabilities(h, a);
+            const expected = SCORES.reduce((sum, key) => sum + P[key] * MatchRating.SSV[key], 0);
+            expect(mr.getExpectedResult()).toBeCloseTo(expected, 10);
+        }
+    });
+});
 // ─── getPoints ────────────────────────────────────────────────────────────────
 describe('MatchRating.getPoints()', () => {
     it('home and away deltas are opposite signs', () => {

package/dist/esm/src/service/utils/email-utils.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The comparison form of an email address. Lowercased and trimmed; the local part loses any `+tag`; on Gmail it
+ * also loses its dots and the domain folds onto gmail.com.
+ *
+ * Split local from domain FIRST. Splitting the whole address on '+' looks equivalent and is not: an address
+ * with no tag comes back whole, and a later dot-strip then eats the dot in "gmail.com" too.
+ *
+ * Returns the trimmed lowercase input unchanged when it is not a single-@ address, so a malformed value is
+ * never silently reshaped into something that could collide with a real account. Format validation is the
+ * caller's job.
+ */
+export declare function canonicalEmail(raw: string): string;

package/dist/esm/src/service/utils/email-utils.js

@@ -0,0 +1,40 @@
+// Email identity helpers.
+//
+// A person must not be able to hold two accounts on one mailbox by spelling the same address differently. The
+// canonical form is what uniqueness is enforced on; the raw address the user typed is still what we display and
+// send mail to.
+//
+// Owner decision 2026-09-01: GMAIL RULES FOR GMAIL ONLY. Dots are insignificant and +tags are aliases on
+// Gmail, so both are stripped there. Applying either rule to every provider would WRONGLY merge two real
+// people on providers where the local part is taken literally, so everyone else gets lowercasing and +tag
+// removal alone (+tag aliasing is near-universal; dot-insignificance is not).
+/** Domains that alias onto gmail.com and follow its dot/plus rules. */
+const GMAIL_DOMAINS = new Set(['gmail.com', 'googlemail.com']);
+/**
+ * The comparison form of an email address. Lowercased and trimmed; the local part loses any `+tag`; on Gmail it
+ * also loses its dots and the domain folds onto gmail.com.
+ *
+ * Split local from domain FIRST. Splitting the whole address on '+' looks equivalent and is not: an address
+ * with no tag comes back whole, and a later dot-strip then eats the dot in "gmail.com" too.
+ *
+ * Returns the trimmed lowercase input unchanged when it is not a single-@ address, so a malformed value is
+ * never silently reshaped into something that could collide with a real account. Format validation is the
+ * caller's job.
+ */
+export function canonicalEmail(raw) {
+    const trimmed = raw.trim().toLowerCase();
+    const at = trimmed.lastIndexOf('@');
+    if (at <= 0 || at === trimmed.length - 1 || trimmed.indexOf('@') !== at)
+        return trimmed;
+    const local = trimmed.slice(0, at);
+    const domain = trimmed.slice(at + 1);
+    const untagged = local.split('+')[0];
+    // An address that is nothing BUT a tag and/or dots has no local part left once they are stripped. Fall back to
+    // the ORIGINAL local part, never to the stripped one: an empty local would canonicalize every degenerate
+    // address to the same value and collide them with each other.
+    if (GMAIL_DOMAINS.has(domain)) {
+        const noDots = untagged.split('.').join('');
+        return `${noDots.length > 0 ? noDots : local}@gmail.com`;
+    }
+    return `${untagged.length > 0 ? untagged : local}@${domain}`;
+}

package/dist/esm/src/service/utils/email-utils.test.d.ts

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

package/dist/esm/src/service/utils/email-utils.test.js

@@ -0,0 +1,50 @@
+import { describe, it, expect } from '@jest/globals';
+import { canonicalEmail } from './email-utils';
+// ─── canonicalEmail ──────────────────────────────────────────────────────────
+describe('canonicalEmail()', () => {
+    it('lowercases and trims', () => {
+        expect(canonicalEmail('  Foo.Bar@Example.COM  ')).toBe('foo.bar@example.com');
+    });
+    it('strips a +tag on any provider', () => {
+        expect(canonicalEmail('user+anything@example.com')).toBe('user@example.com');
+    });
+    it('keeps dots on non-Gmail providers, where they are significant', () => {
+        expect(canonicalEmail('a.b@example.com')).toBe('a.b@example.com');
+        expect(canonicalEmail('ab@example.com')).toBe('ab@example.com');
+        expect(canonicalEmail('a.b@example.com')).not.toBe(canonicalEmail('ab@example.com'));
+    });
+    it('strips dots AND +tags on gmail', () => {
+        expect(canonicalEmail('a.b.c+tag@gmail.com')).toBe('abc@gmail.com');
+        expect(canonicalEmail('abc@gmail.com')).toBe('abc@gmail.com');
+        expect(canonicalEmail('a.b.c@gmail.com')).toBe(canonicalEmail('abc+anything@gmail.com'));
+    });
+    it('folds googlemail.com onto gmail.com', () => {
+        expect(canonicalEmail('a.b@googlemail.com')).toBe('ab@gmail.com');
+        expect(canonicalEmail('ab@googlemail.com')).toBe(canonicalEmail('ab@gmail.com'));
+    });
+    // The exact bug the first prod duplicate report hit: splitting the WHOLE address on '+' returns the address
+    // intact when there is no tag, and the Gmail dot-strip then eats the dot in "gmail.com" as well.
+    it('does not mangle a Gmail address that has no +tag', () => {
+        expect(canonicalEmail('fariasfranciscoe@gmail.com')).toBe('fariasfranciscoe@gmail.com');
+        expect(canonicalEmail('fariasfranciscoe@gmail.com')).not.toContain('gmailcom');
+    });
+    it('matches the real prod collision it was written for', () => {
+        expect(canonicalEmail('fariasfranciscoe+playreview@gmail.com'))
+            .toBe(canonicalEmail('fariasfranciscoe@gmail.com'));
+    });
+    it('leaves a malformed address alone rather than reshaping it', () => {
+        expect(canonicalEmail('not-an-email')).toBe('not-an-email');
+        expect(canonicalEmail('@example.com')).toBe('@example.com');
+        expect(canonicalEmail('user@')).toBe('user@');
+        expect(canonicalEmail('two@ats@example.com')).toBe('two@ats@example.com');
+    });
+    it('never returns an empty local part for a degenerate address', () => {
+        expect(canonicalEmail('+tag@gmail.com')).toBe('+tag@gmail.com');
+        expect(canonicalEmail('...@gmail.com')).toBe('...@gmail.com');
+    });
+    it('is idempotent', () => {
+        for (const raw of ['A.B+x@Gmail.com', 'user+t@example.com', 'plain@example.com', 'weird']) {
+            expect(canonicalEmail(canonicalEmail(raw))).toBe(canonicalEmail(raw));
+        }
+    });
+});

package/dist/esm/src/service/utils/index.d.ts

@@ -1,4 +1,5 @@
 export * from './object-utils';
+export * from './email-utils';
 export * from './number-utils';
 export * from './rng-utils';
 export * from './faker-generators';

package/dist/esm/src/service/utils/index.js

@@ -1,4 +1,5 @@
 export * from './object-utils';
+export * from './email-utils';
 export * from './number-utils';
 export * from './rng-utils';
 export * from './faker-generators';

package/package.json

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