volleyballsimtypes 0.0.463 → 0.0.465

package/dist/esm/src/data/models/physiotherapist.js

@@ -0,0 +1,53 @@
+import { DataTypes, Model } from 'sequelize';
+export class PhysiotherapistModel extends Model {
+    static initModel(sequelize) {
+        return PhysiotherapistModel.init({
+            physiotherapist_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true
+            },
+            team_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                unique: true,
+                references: {
+                    model: 'Team',
+                    key: 'team_id'
+                }
+            },
+            name: {
+                type: DataTypes.STRING,
+                allowNull: false,
+                defaultValue: ''
+            },
+            rarity: {
+                type: DataTypes.STRING,
+                allowNull: false,
+                defaultValue: 'COMMON'
+            },
+            currency_invested: {
+                type: DataTypes.INTEGER,
+                allowNull: false,
+                defaultValue: 0
+            }
+        }, {
+            sequelize,
+            tableName: 'Physiotherapist',
+            schema: 'public',
+            timestamps: false,
+            indexes: [
+                {
+                    name: 'Physiotherapist_pk',
+                    unique: true,
+                    fields: [{ name: 'physiotherapist_id' }]
+                },
+                {
+                    name: 'Physiotherapist_team_id_unique',
+                    unique: true,
+                    fields: [{ name: 'team_id' }]
+                }
+            ]
+        });
+    }
+}

package/dist/esm/src/data/models/player.d.ts

@@ -15,6 +15,10 @@ export interface PlayerAttributes {
     birth_iteration: number;
     last_declined_iteration: number | null;
     decline_profile: DeclineProfile;
+    injury_prone_profile?: number | string;
+    injury_severity?: number | null;
+    injured_until?: Date | string | null;
+    injury_debuff?: number | string | null;
     PerformanceStat?: PerformanceStatsAttributes;
     BoxScores?: BoxScoreAttributes[];
 }
@@ -34,6 +38,10 @@ export declare class PlayerModel extends Model<PlayerAttributes, PlayerCreationA
     birth_iteration: number;
     last_declined_iteration: number | null;
     decline_profile: DeclineProfile;
+    injury_prone_profile: number | string;
+    injury_severity: number | null;
+    injured_until: Date | string | null;
+    injury_debuff: number | string | null;
     country: CountryModel;
     getCountry: Sequelize.BelongsToGetAssociationMixin<CountryModel>;
     setCountry: Sequelize.BelongsToSetAssociationMixin<CountryModel, CountryId>;

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

@@ -59,6 +59,23 @@ export class PlayerModel extends Model {
                 type: DataTypes.ENUM(...Object.values(DeclineProfileEnum)),
                 allowNull: false,
                 defaultValue: DeclineProfileEnum.STANDARD
+            },
+            injury_prone_profile: {
+                type: DataTypes.DECIMAL(3, 2),
+                allowNull: false,
+                defaultValue: 0.5
+            },
+            injury_severity: {
+                type: DataTypes.INTEGER,
+                allowNull: true
+            },
+            injured_until: {
+                type: DataTypes.DATE,
+                allowNull: true
+            },
+            injury_debuff: {
+                type: DataTypes.DECIMAL(3, 2),
+                allowNull: true
             }
         }, {
             sequelize,

package/dist/esm/src/data/models/tactics.d.ts

@@ -39,6 +39,11 @@ export interface SystemSetAttributes {
     rotationSystem: RotationSystemEnum;
     designatedSetters: PlayerId[];
 }
+export interface InjuryReplacementAttributes {
+    starterId: PlayerId;
+    replacementId: PlayerId;
+    benchBackfillId?: PlayerId;
+}
 export interface LiberoSetSubConfigAttributes {
     mode: LiberoSubMode;
     fatigueBand?: EnergyBand;
@@ -61,10 +66,12 @@ export interface TacticsAttributes {
     offensive_preferences: OffensivePreferenceAttributes[];
     system_sets?: SystemSetAttributes[];
     offensive_preference_sets?: OffensivePreferenceAttributes[][];
+    replace_injured_immediately?: boolean;
+    injury_replacements?: InjuryReplacementAttributes[];
 }
 export type TacticsPk = 'team_id';
 export type TacticsId = TacticsModel[TacticsPk];
-export type TacticsOptionalAttributes = 'lineup' | 'libero_replacements' | 'receive_rotation_offset' | 'designated_subs' | 'substitution_band' | 'second_libero' | 'libero_sub' | 'libero_replacement_sets' | 'rotation_system' | 'designated_setters' | 'offensive_preferences' | 'system_sets' | 'offensive_preference_sets';
+export type TacticsOptionalAttributes = 'lineup' | 'libero_replacements' | 'receive_rotation_offset' | 'designated_subs' | 'substitution_band' | 'second_libero' | 'libero_sub' | 'libero_replacement_sets' | 'rotation_system' | 'designated_setters' | 'offensive_preferences' | 'system_sets' | 'offensive_preference_sets' | 'replace_injured_immediately' | 'injury_replacements';
 export type TacticsCreationAttributes = Optional<TacticsAttributes, TacticsOptionalAttributes>;
 export declare class TacticsModel extends Model<TacticsAttributes, TacticsCreationAttributes> implements TacticsAttributes {
     team_id: string;
@@ -81,6 +88,8 @@ export declare class TacticsModel extends Model<TacticsAttributes, TacticsCreati
     offensive_preferences: OffensivePreferenceAttributes[];
     system_sets?: SystemSetAttributes[];
     offensive_preference_sets?: OffensivePreferenceAttributes[][];
+    replace_injured_immediately?: boolean;
+    injury_replacements?: InjuryReplacementAttributes[];
     team: TeamModel;
     getTeam: Sequelize.BelongsToGetAssociationMixin<TeamModel>;
     setTeam: Sequelize.BelongsToSetAssociationMixin<TeamModel, TeamId>;

package/dist/esm/src/data/models/tactics.js

@@ -71,6 +71,15 @@ export class TacticsModel extends Model {
             offensive_preference_sets: {
                 type: DataTypes.JSONB,
                 allowNull: true
+            },
+            replace_injured_immediately: {
+                type: DataTypes.BOOLEAN,
+                allowNull: false,
+                defaultValue: true
+            },
+            injury_replacements: {
+                type: DataTypes.JSONB,
+                allowNull: true
             }
         }, {
             sequelize,

package/dist/esm/src/data/transformers/lineup-preset.js

@@ -1,11 +1,17 @@
 // `config` is already stored as the API Tactics DTO, so a preset row maps to its API shape with no hydration.
+// Presets saved before the injuries fields exist lack replaceInjuredImmediately: heal it to the effective
+// default (true, matching transformToTactics' hydration) so the DTO's required field is honest and a UI
+// toggle seeded from an old preset cannot silently flip the user's effective setting on re-save.
 function transformToObject(model) {
     return {
         presetId: model.preset_id,
         name: model.name,
         isActive: model.is_active,
         orderIndex: model.order_index,
-        config: model.config
+        config: {
+            ...model.config,
+            replaceInjuredImmediately: model.config.replaceInjuredImmediately ?? true
+        }
     };
 }
 export { transformToObject as transformToLineupPreset };

package/dist/esm/src/data/transformers/lineup-preset.test.js

@@ -1,7 +1,7 @@
 import { describe, it, expect } from '@jest/globals';
 import { transformToLineupPreset } from './lineup-preset';
 describe('transformToLineupPreset()', () => {
-    it('maps preset columns to the API shape and passes config through by reference', () => {
+    it('maps preset columns to the API shape and heals a pre-injuries config to the effective default', () => {
         const config = { lineup: { bench: [] }, substitutionBand: 'TIRED' };
         const preset = transformToLineupPreset({
             preset_id: 'p1',
@@ -16,8 +16,21 @@ describe('transformToLineupPreset()', () => {
             name: 'Starters',
             isActive: true,
             orderIndex: 2,
+            // A config stored before the injuries fields lacks replaceInjuredImmediately; the transform heals it
+            // to true (the effective hydration default) so the DTO's required field is honest.
+            config: { ...config, replaceInjuredImmediately: true }
+        });
+    });
+    it('keeps an explicit replaceInjuredImmediately: false', () => {
+        const config = { lineup: { bench: [] }, substitutionBand: 'TIRED', replaceInjuredImmediately: false };
+        const preset = transformToLineupPreset({
+            preset_id: 'p2',
+            team_id: 't1',
+            name: 'Risky',
+            is_active: false,
+            order_index: 3,
             config
         });
-        expect(preset.config).toBe(config);
+        expect(preset.config.replaceInjuredImmediately).toBe(false);
     });
 });

package/dist/esm/src/data/transformers/match-set.js

@@ -23,6 +23,7 @@ function transformToAttributes(set, matchId) {
         is_tie_break: set.isTieBreak,
         home_score: set.homeScore,
         away_score: set.awayScore,
+        forfeited: set.forfeited,
         player_positions: [...homeSetPositions, ...awaySetPositions],
         BoxScores: (set.boxScores ?? []).map(transformFromBoxScore),
         Rallies: (set.rallies ?? []).map((rally) => transformFromRally(rally, set.id))
@@ -39,6 +40,7 @@ function transformToObject(model) {
         homeScore: model.home_score,
         awayScore: model.away_score,
         isTieBreak: model.is_tie_break,
+        forfeited: model.forfeited ?? false,
         boxScores: (model.BoxScores ?? []).map(transformToBoxScore),
         homePlayerPosition,
         awayPlayerPosition,

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

@@ -8,7 +8,10 @@ function transformToAttributes(match) {
         away_team: match.awayTeam.id,
         home_team: match.homeTeam.id,
         scheduled_date: match.scheduledDate,
-        status: match.status
+        status: match.status,
+        // Both directions on purpose (the read is in transformToObject below). NOTE for the Sim: updateMatch's
+        // completion write uses an explicit column list and must include forfeit_type or the marker is lost.
+        forfeit_type: match.forfeitType ?? null
     };
 }
 function transformToObject(model, currentIteration, onPresetFallback) {
@@ -63,7 +66,8 @@ function transformToObject(model, currentIteration, onPresetFallback) {
         VPERs,
         homeScore,
         awayScore,
-        winner: model.MatchResult?.Winner != null ? transformToTeam(model.MatchResult.Winner, currentIteration) : undefined
+        winner: model.MatchResult?.Winner != null ? transformToTeam(model.MatchResult.Winner, currentIteration) : undefined,
+        forfeitType: model.forfeit_type ?? undefined
     });
 }
 export { transformToObject as transformToMatch, transformToAttributes as transformFromMatch };

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

@@ -21,7 +21,11 @@ function transformToAttributes(player) {
         birth_age: player.birthAge,
         birth_iteration: player.birthIteration,
         last_declined_iteration: null,
-        decline_profile: player.declineProfile
+        decline_profile: player.declineProfile,
+        injury_prone_profile: player.injuryProneProfile,
+        injury_severity: player.injury?.severity ?? null,
+        injured_until: player.injury?.injuredUntil ?? null,
+        injury_debuff: player.injury?.debuff ?? null
     };
 }
 function transformToBoxScoreTotals(model) {
@@ -87,6 +91,16 @@ function transformToObject(model, currentIteration) {
         birthAge: model.birth_age,
         birthIteration: model.birth_iteration,
         declineProfile: model.decline_profile,
+        // DECIMAL comes back as a string from pg; schema-defaulted when the column is absent (pre-migration rows).
+        injuryProneProfile: model.injury_prone_profile != null ? Number(model.injury_prone_profile) : undefined,
+        // Severity defends against a partial write: an injured_until without severity reads as MINOR.
+        injury: model.injured_until != null
+            ? {
+                severity: model.injury_severity != null ? Number(model.injury_severity) : 1,
+                injuredUntil: model.injured_until,
+                debuff: model.injury_debuff != null ? Number(model.injury_debuff) : undefined
+            }
+            : undefined,
         boxScores: (model.BoxScores ?? []).map(transformToBoxScore),
         boxScoreTotals
     });

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

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

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

@@ -0,0 +1,31 @@
+import { describe, it, expect } from '@jest/globals';
+import { v4 as uuidv4 } from 'uuid';
+import { EventTypeEnum, Substitution } from '../../service';
+import { transformToCompact, transformToSubstitution } from './rally-event';
+describe('rally-event compact round trip — injury substitution marker', () => {
+    const playerIn = uuidv4();
+    const playerOut = uuidv4();
+    const roster = [playerIn, playerOut];
+    const playerIndex = new Map(roster.map((id, i) => [id, i]));
+    it('packs the injury flag as j=1 and round-trips it', () => {
+        const sub = Substitution.create({ playerId: playerIn, playerOut, injury: true });
+        const compact = transformToCompact(sub, playerIndex);
+        expect(compact.j).toBe(1);
+        const decoded = transformToSubstitution(compact, roster);
+        expect(decoded.injury).toBe(true);
+        expect(decoded.playerId).toBe(playerIn);
+        expect(decoded.playerOut).toBe(playerOut);
+    });
+    it('omits j entirely for a normal substitution', () => {
+        const sub = Substitution.create({ playerId: playerIn, playerOut });
+        const compact = transformToCompact(sub, playerIndex);
+        expect('j' in compact).toBe(false);
+        const decoded = transformToSubstitution(compact, roster);
+        expect(decoded.injury).toBeUndefined();
+    });
+    it('decodes a legacy compact event (no j key) as a non-injury substitution', () => {
+        const legacy = { p: 0, e: EventTypeEnum.SUBSTITUTION, o: 1 };
+        const decoded = transformToSubstitution(legacy, roster);
+        expect(decoded.injury).toBeUndefined();
+    });
+});

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

@@ -9,6 +9,7 @@ export interface CompactEvent {
     b?: number[];
     l?: number;
     o?: number;
+    j?: 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

@@ -19,6 +19,8 @@ export function transformToCompact(evt, playerIndex) {
     }
     else if (evt instanceof Substitution) {
         out.o = playerIndex.get(evt.playerOut);
+        if (evt.injury === true)
+            out.j = 1;
     }
     return out;
 }
@@ -78,6 +80,7 @@ export function transformToSpike(event, roster) {
 export function transformToSubstitution(event, roster) {
     return Substitution.create({
         playerId: roster[event.p],
-        playerOut: roster[event.o]
+        playerOut: roster[event.o],
+        injury: event.j === 1 ? true : undefined
     });
 }

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

@@ -81,7 +81,13 @@ function transformToAttributes(tactics, teamId) {
         offensive_preference_sets: tactics.offensivePreferenceSets?.map(prefs => prefs.map(p => ({
             rotation: p.rotation,
             order: p.order.map((a) => a.id)
-        })))
+        }))),
+        replace_injured_immediately: tactics.replaceInjuredImmediately,
+        injury_replacements: tactics.injuryReplacements.map(ir => ({
+            starterId: ir.starter.id,
+            replacementId: ir.replacement.id,
+            benchBackfillId: ir.benchBackfill?.id
+        }))
     };
 }
 // Accepts TacticsAttributes (not just TacticsModel) so a per-match preset's config, shaped as column data by
@@ -158,7 +164,46 @@ function transformToObject(model, roster) {
         offensivePreferenceSets: model.offensive_preference_sets?.map(prefs => prefs.map(p => ({
             rotation: p.rotation,
             order: p.order.map((id) => findPlayer(id, roster))
-        })))
+        }))),
+        replaceInjuredImmediately: model.replace_injured_immediately ?? true,
+        // LENIENT (roster.find, not findPlayer): an entry whose starter or replacement is gone/invalid is DROPPED
+        // rather than crashing the sim batch (a dropped entry = unconfigured = the bench-only auto fallback, per
+        // the owner rules); an invalid benchBackfill drops only the backfill. First occurrence wins on duplicates;
+        // the next tactics save rewrites cleanly. Schema invariants mirrored: starter must be a court starter,
+        // replacement bench-or-reserve (never a starter/libero/L2), backfill only-with-bench-replacement + reserve.
+        injuryReplacements: (() => {
+            const starterIds = new Set([lineup[CourtPosition.LEFT_FRONT], lineup[CourtPosition.MIDDLE_FRONT], lineup[CourtPosition.RIGHT_FRONT],
+                lineup[CourtPosition.LEFT_BACK], lineup[CourtPosition.MIDDLE_BACK], lineup[CourtPosition.RIGHT_BACK]]
+                .map((p) => p.id));
+            const benchIds = new Set(lineup.bench.map((p) => p.id));
+            const seenStarters = new Set();
+            const seenIncoming = new Set();
+            const healed = [];
+            for (const ir of model.injury_replacements ?? []) {
+                const starter = roster.find((p) => p.id === ir.starterId);
+                const replacement = roster.find((p) => p.id === ir.replacementId);
+                if (starter == null || replacement == null)
+                    continue;
+                if (!starterIds.has(starter.id) || seenStarters.has(starter.id))
+                    continue;
+                if (starterIds.has(replacement.id) || replacement.id === lineup[CourtPosition.LIBERO_ZONE]?.id ||
+                    replacement.id === secondLibero?.id || seenIncoming.has(replacement.id))
+                    continue;
+                seenStarters.add(starter.id);
+                seenIncoming.add(replacement.id);
+                let benchBackfill;
+                if (ir.benchBackfillId != null && benchIds.has(replacement.id)) {
+                    const candidate = roster.find((p) => p.id === ir.benchBackfillId);
+                    if (candidate != null && !inLineupIds.has(candidate.id) && candidate.id !== secondLibero?.id &&
+                        !seenIncoming.has(candidate.id)) {
+                        benchBackfill = candidate;
+                        seenIncoming.add(candidate.id);
+                    }
+                }
+                healed.push({ starter, replacement, benchBackfill });
+            }
+            return healed;
+        })()
     });
 }
 // Serialize a Tactics ROW (db columns) straight to the API Tactics DTO (player references stay as ids; no
@@ -218,7 +263,39 @@ function tacticsColumnsToApiDto(model) {
         designatedSetters: model.designated_setters,
         offensivePreferences: model.offensive_preferences,
         systemSets: model.system_sets,
-        offensivePreferenceSets: model.offensive_preference_sets
+        offensivePreferenceSets: model.offensive_preference_sets,
+        replaceInjuredImmediately: model.replace_injured_immediately ?? true,
+        // Same stale-data policy as validSecondLibero above: don't surface entries the service load would drop
+        // (starter no longer a starter, replacement now a starter/libero/L2, duplicates), or the UI reloads and
+        // re-emits them forever. Roster membership can't be checked here (ids only); the service heal covers that.
+        injuryReplacements: (() => {
+            const starterSlotIds = new Set([model.lineup[CourtPosition.LEFT_FRONT], model.lineup[CourtPosition.MIDDLE_FRONT],
+                model.lineup[CourtPosition.RIGHT_FRONT], model.lineup[CourtPosition.LEFT_BACK],
+                model.lineup[CourtPosition.MIDDLE_BACK], model.lineup[CourtPosition.RIGHT_BACK]]);
+            const benchIdSet = new Set(model.lineup.bench);
+            const liberoId = model.lineup[CourtPosition.LIBERO_ZONE];
+            const seenStarters = new Set();
+            const seenIncoming = new Set();
+            const healed = [];
+            for (const ir of model.injury_replacements ?? []) {
+                if (!starterSlotIds.has(ir.starterId) || seenStarters.has(ir.starterId))
+                    continue;
+                if (starterSlotIds.has(ir.replacementId) || ir.replacementId === liberoId ||
+                    ir.replacementId === validSecondLibero || seenIncoming.has(ir.replacementId))
+                    continue;
+                seenStarters.add(ir.starterId);
+                seenIncoming.add(ir.replacementId);
+                let benchBackfillId;
+                if (ir.benchBackfillId != null && benchIdSet.has(ir.replacementId) &&
+                    !lineupIds.has(ir.benchBackfillId) && ir.benchBackfillId !== validSecondLibero &&
+                    !seenIncoming.has(ir.benchBackfillId)) {
+                    benchBackfillId = ir.benchBackfillId;
+                    seenIncoming.add(benchBackfillId);
+                }
+                healed.push({ starterId: ir.starterId, replacementId: ir.replacementId, benchBackfillId });
+            }
+            return healed.length > 0 ? healed : undefined;
+        })()
     };
 }
 // Inverse of tacticsColumnsToApiDto: shape a preset's stored API config (camelCase, player ids) as
@@ -251,7 +328,9 @@ function apiTacticsConfigToAttributes(config, teamId) {
         designated_setters: config.designatedSetters,
         offensive_preferences: config.offensivePreferences,
         system_sets: config.systemSets,
-        offensive_preference_sets: config.offensivePreferenceSets
+        offensive_preference_sets: config.offensivePreferenceSets,
+        replace_injured_immediately: config.replaceInjuredImmediately,
+        injury_replacements: config.injuryReplacements
     };
 }
 export { transformToObject as transformToTactics, transformToAttributes as transformFromTactics, tacticsColumnsToApiDto, apiTacticsConfigToAttributes as apiTacticsConfigToTacticsAttributes };

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

@@ -2,5 +2,6 @@ import { z } from 'zod';
 export declare const SubstitutionInputSchema: z.ZodObject<{
     playerId: z.ZodUUID;
     playerOut: z.ZodUUID;
+    injury: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export type SubstitutionInput = z.infer<typeof SubstitutionInputSchema>;

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

@@ -1,7 +1,8 @@
 import { z } from 'zod';
 export const SubstitutionInputSchema = z.object({
     playerId: z.uuid(),
-    playerOut: z.uuid()
+    playerOut: z.uuid(),
+    injury: z.boolean().optional()
 }).superRefine((data, ctx) => {
     if (data.playerId === data.playerOut) {
         ctx.addIssue({

package/dist/esm/src/service/event/substitution.d.ts

@@ -1,6 +1,7 @@
 import { RallyEvent } from './rally-event';
 export declare class Substitution extends RallyEvent {
     readonly playerOut: string;
+    readonly injury?: boolean;
     static create(input: unknown): Substitution;
     private constructor();
     toString(): string;

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

@@ -14,14 +14,16 @@ export class Substitution extends RallyEvent {
         }
         return new Substitution(result.data);
     }
-    constructor({ playerOut, playerId }) {
+    constructor({ playerOut, playerId, injury }) {
         super({ eventType, playerId });
         this.playerOut = playerOut;
+        this.injury = injury;
     }
     toString() {
         const playerId = `"playerId":"${this.playerId}"`;
         const playerOut = `"playerOut":"${this.playerOut}"`;
         const eventType = `"eventType":${this.eventType}`;
-        return `{${playerId},${playerOut},${eventType}}`;
+        const injury = this.injury === true ? ',"injury":true' : '';
+        return `{${playerId},${playerOut},${eventType}${injury}}`;
     }
 }

package/dist/esm/src/service/match/match-set-forfeit.test.d.ts

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

package/dist/esm/src/service/match/match-set-forfeit.test.js

@@ -0,0 +1,74 @@
+import { describe, it, expect } from '@jest/globals';
+import { v4 as uuidv4 } from 'uuid';
+import { MatchSet } from './match-set';
+import { MatchTeam } from './match-team';
+function makeSet(homeScore, awayScore, isTieBreak = false, forfeited) {
+    return MatchSet.create({
+        id: uuidv4(),
+        order: isTieBreak ? 4 : 0,
+        isTieBreak,
+        homePlayerPosition: [],
+        awayPlayerPosition: [],
+        homeScore,
+        awayScore,
+        boxScores: [],
+        rallies: [],
+        ...(forfeited != null ? { forfeited } : {})
+    });
+}
+// Mid-set states are not valid CREATION states (the schema wants 0-0 or a finished score), so build them the
+// way the sim does: create at 0-0 and play to the score.
+function playedTo(homeScore, awayScore, isTieBreak = false) {
+    const set = makeSet(0, 0, isTieBreak);
+    for (let i = 0; i < homeScore; i++)
+        set.increaseScore(MatchTeam.HOME);
+    for (let i = 0; i < awayScore; i++)
+        set.increaseScore(MatchTeam.AWAY);
+    return set;
+}
+describe('MatchSet — forfeit (FIVB 6.4.3)', () => {
+    it('defaults forfeited to false', () => {
+        expect(makeSet(25, 20).forfeited).toBe(false);
+    });
+    it('accepts a persisted forfeited set with an awarded score', () => {
+        const set = makeSet(25, 13, false, true);
+        expect(set.forfeited).toBe(true);
+        expect(set.isOver()).toBe(true);
+        expect(set.getWinner()).toBe(MatchTeam.HOME);
+    });
+    it('awards the threshold when the loser is below deuce (18-23, home granted)', () => {
+        const set = playedTo(18, 23);
+        // Score order in makeSet is home, away; away leads 23-18 but HOME is granted the forfeit win.
+        set.forfeit(MatchTeam.HOME);
+        expect(set.homeScore).toBe(25);
+        expect(set.awayScore).toBe(23);
+        expect(set.forfeited).toBe(true);
+        expect(set.isOver()).toBe(true);
+        expect(set.getWinner()).toBe(MatchTeam.HOME);
+    });
+    it('awards loser + 2 beyond deuce (24-24, away granted -> 24-26)', () => {
+        const set = playedTo(24, 24);
+        set.forfeit(MatchTeam.AWAY);
+        expect(set.homeScore).toBe(24);
+        expect(set.awayScore).toBe(26);
+        expect(set.isOver()).toBe(true);
+        expect(set.getWinner()).toBe(MatchTeam.AWAY);
+    });
+    it('keeps the forfeiting side points (0-0 fully-awarded set -> 25-0)', () => {
+        const set = makeSet(0, 0);
+        set.forfeit(MatchTeam.HOME);
+        expect(set.homeScore).toBe(25);
+        expect(set.awayScore).toBe(0);
+        expect(set.isOver()).toBe(true);
+    });
+    it('awards 15 on a tie break', () => {
+        const set = playedTo(10, 13, true);
+        set.forfeit(MatchTeam.HOME);
+        expect(set.homeScore).toBe(15);
+        expect(set.awayScore).toBe(13);
+        expect(set.isOver()).toBe(true);
+    });
+    it('rejects a forfeited set whose score never reached the awarding rule (below threshold)', () => {
+        expect(() => makeSet(18, 12, false, true)).toThrow(/INVALID_MATCH_SET/);
+    });
+});

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

@@ -13,10 +13,18 @@ export declare class MatchSet {
     readonly scoreThreshold: ScoreThreshold;
     private _homeScore;
     private _awayScore;
+    private _forfeited;
     static create(input: unknown): MatchSet;
     private constructor();
     get homeScore(): number;
     get awayScore(): number;
+    get forfeited(): boolean;
+    /**
+     * End the set by forfeit (FIVB 6.4.3, incomplete team). The forfeiting side keeps its points; the winner
+     * is granted exactly the points needed to win the set (the threshold, or loser + 2 beyond deuce), so the
+     * final score always satisfies the normal reached-threshold and win-by-2 rules. Marks the set forfeited.
+     */
+    forfeit(winner: MatchTeam): void;
     increaseScore(team: MatchTeam): void;
     addRally(rally: Rally): void;
     /**

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

@@ -13,11 +13,12 @@ export class MatchSet {
         }
         return new MatchSet(result.data);
     }
-    constructor({ id, order, isTieBreak, homePlayerPosition, awayPlayerPosition, boxScores, rallies, homeScore, awayScore }) {
+    constructor({ id, order, isTieBreak, homePlayerPosition, awayPlayerPosition, boxScores, rallies, homeScore, awayScore, forfeited = false }) {
         this.id = id;
         this.order = order;
         this._homeScore = homeScore;
         this._awayScore = awayScore;
+        this._forfeited = forfeited;
         this.homePlayerPosition = homePlayerPosition;
         this.awayPlayerPosition = awayPlayerPosition;
         this.boxScores = boxScores;
@@ -31,6 +32,27 @@ export class MatchSet {
     get awayScore() {
         return this._awayScore;
     }
+    get forfeited() {
+        return this._forfeited;
+    }
+    /**
+     * End the set by forfeit (FIVB 6.4.3, incomplete team). The forfeiting side keeps its points; the winner
+     * is granted exactly the points needed to win the set (the threshold, or loser + 2 beyond deuce), so the
+     * final score always satisfies the normal reached-threshold and win-by-2 rules. Marks the set forfeited.
+     */
+    forfeit(winner) {
+        // Forfeiting an already-decided (or already-forfeited) set would silently rewrite the winner with a
+        // schema-legal score: surface the caller bug instead (e.g. both teams forfeited in the same rally).
+        if (this._forfeited || this.isOver())
+            throw new Error('SET_ALREADY_DECIDED');
+        if (winner === MatchTeam.HOME)
+            this._homeScore = Math.max(this.scoreThreshold, this._awayScore + 2);
+        else if (winner === MatchTeam.AWAY)
+            this._awayScore = Math.max(this.scoreThreshold, this._homeScore + 2);
+        else
+            throw new Error('UNKNOWN_TEAM');
+        this._forfeited = true;
+    }
     increaseScore(team) {
         if (team === MatchTeam.HOME)
             this._homeScore++;

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

@@ -3,6 +3,7 @@ import { Team } from '../team';
 import { MatchTeam } from './match-team';
 import { StatusEnum } from '../../data';
 import { VPER } from './vper';
+export type MatchForfeitType = 'INCOMPLETE' | 'DEFAULT';
 export type MatchScore = '3-0' | '3-1' | '3-2' | '2-3' | '1-3' | '0-3';
 export type SetScore = 0 | 1 | 2 | 3;
 export declare class Match {
@@ -16,6 +17,7 @@ export declare class Match {
     homeScore?: number;
     awayScore?: number;
     winner?: Team;
+    forfeitType?: MatchForfeitType;
     static create(input: unknown): Match;
     private constructor();
     addSet(set: MatchSet): void;