volleyballsimtypes 0.0.469 → 0.0.471

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

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { TraitEnum } from '../../player';
+import { EventIncidentSchema } from './incident.z';
 const spikeTypeValues = [0, 1, 2, 3, 4, 5];
 const spikeFailureValues = [0, 1, 2, 3, 4];
 const courtTargetValues = Array.from({ length: 13 }, (_, i) => i);
@@ -9,5 +10,6 @@ export const SpikeInputSchema = z.object({
     target: z.number().int().refine((v) => courtTargetValues.includes(v), { message: 'INVALID_COURT_TARGET' }),
     activeTraits: z.array(z.enum(Object.values(TraitEnum))).default([]),
     failure: z.number().int().refine((v) => spikeFailureValues.includes(v), { message: 'INVALID_SPIKE_FAILURE' }),
-    type: z.number().int().refine((v) => spikeTypeValues.includes(v), { message: 'INVALID_SPIKE_TYPE' })
+    type: z.number().int().refine((v) => spikeTypeValues.includes(v), { message: 'INVALID_SPIKE_TYPE' }),
+    incident: EventIncidentSchema.optional()
 });

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

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

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

@@ -28,8 +28,8 @@ export class Set extends InPlayEvent {
         }
         return new Set(result.data);
     }
-    constructor({ score, playerId, target, failure, type, activeTraits }) {
-        super({ score, playerId, target, activeTraits, eventType });
+    constructor({ score, playerId, target, failure, type, activeTraits, incident }) {
+        super({ score, playerId, target, activeTraits, incident, eventType });
         this.type = type;
         this.failure = failure;
     }

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

@@ -32,8 +32,8 @@ export class Spike extends InPlayEvent {
         }
         return new Spike(result.data);
     }
-    constructor({ score, playerId, target, failure, type, activeTraits }) {
-        super({ score, playerId, target, activeTraits, eventType });
+    constructor({ score, playerId, target, failure, type, activeTraits, incident }) {
+        super({ score, playerId, target, activeTraits, incident, eventType });
         this.type = type;
         this.failure = failure;
     }

package/dist/esm/src/service/team/schemas/injury-replacement.z.test.js

@@ -30,14 +30,40 @@ describe('TacticsInputSchema — injuryReplacements (owner rules 2026-07-03)', (
             ...overrides
         };
     }
-    it('defaults to true / empty', () => {
+    it('defaults to an empty knock map / empty replacements', () => {
         const res = TacticsInputSchema.safeParse(baseInput());
         expect(res.success).toBe(true);
         if (res.success) {
-            expect(res.data.replaceInjuredImmediately).toBe(true);
+            expect(res.data.replaceKnockedImmediately).toEqual({});
             expect(res.data.injuryReplacements).toEqual([]);
         }
     });
+    it('accepts a starter-keyed replaceKnockedImmediately map', () => {
+        const res = TacticsInputSchema.safeParse(baseInput({
+            replaceKnockedImmediately: { [p1.id]: false, [p3.id]: true }
+        }));
+        expect(res.success).toBe(true);
+        if (res.success) {
+            expect(res.data.replaceKnockedImmediately).toEqual({ [p1.id]: false, [p3.id]: true });
+        }
+    });
+    it('rejects a replaceKnockedImmediately key that is not a court starter', () => {
+        for (const outsider of [benchA, libero, reserveA]) {
+            const res = TacticsInputSchema.safeParse(baseInput({
+                replaceKnockedImmediately: { [outsider.id]: false }
+            }));
+            expect(res.success).toBe(false);
+            if (!res.success) {
+                expect(res.error.issues.some(issue => issue.message === 'REPLACE_KNOCKED_KEY_NOT_A_STARTER')).toBe(true);
+            }
+        }
+    });
+    it('rejects a non-boolean replaceKnockedImmediately value', () => {
+        const res = TacticsInputSchema.safeParse(baseInput({
+            replaceKnockedImmediately: { [p1.id]: 'off' }
+        }));
+        expect(res.success).toBe(false);
+    });
     it('accepts a bench replacement with a reserve backfill', () => {
         const res = TacticsInputSchema.safeParse(baseInput({
             injuryReplacements: [{ starter: p1, replacement: benchA, benchBackfill: reserveA }]

package/dist/esm/src/service/team/schemas/tactics.z.d.ts

@@ -123,7 +123,7 @@ export declare const TacticsInputSchema: z.ZodObject<{
         rotation: z.ZodNumber;
         order: z.ZodArray<z.ZodCustom<Player, Player>>;
     }, z.core.$strip>>>>;
-    replaceInjuredImmediately: z.ZodDefault<z.ZodBoolean>;
+    replaceKnockedImmediately: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
     injuryReplacements: z.ZodDefault<z.ZodArray<z.ZodObject<{
         starter: z.ZodCustom<Player, Player>;
         replacement: z.ZodCustom<Player, Player>;

package/dist/esm/src/service/team/schemas/tactics.z.js

@@ -78,10 +78,11 @@ export const TacticsInputSchema = z.object({
     // validated with the same cross-field rules as the flat fields (see superRefine below).
     systemSets: z.array(systemSetSchema).max(5).optional(),
     offensivePreferenceSets: z.array(z.array(offensivePreferenceSchema)).max(5).optional(),
-    // Injuries. Defaults keep every existing Tactics.create({...}) call valid. injuryReplacements is the
-    // per-starter explicit replacement mapping (owner rules: followed verbatim, bench-only auto fallback,
-    // reserves never auto-promoted); cross-field rules in the superRefine below.
-    replaceInjuredImmediately: z.boolean().default(true),
+    // Injuries. Defaults keep every existing Tactics.create({...}) call valid. replaceKnockedImmediately is
+    // PER STARTER (owner order 2026-07-05): keyed by starter id, missing key = ON; keys validated against the
+    // lineup in the superRefine below. injuryReplacements is the per-starter explicit replacement mapping
+    // (owner rules: followed verbatim, bench-only auto fallback, reserves never auto-promoted).
+    replaceKnockedImmediately: z.record(z.string(), z.boolean()).default({}),
     injuryReplacements: z.array(z.object({
         starter: playerInstanceSchema,
         replacement: playerInstanceSchema,
@@ -184,6 +185,13 @@ export const TacticsInputSchema = z.object({
             }
         }
     }
+    // Per-starter knock toggle: every key must be a configured court starter (bench/reserve/libero players
+    // follow the slot they occupy, so they never carry their own key).
+    for (const starterId of Object.keys(data.replaceKnockedImmediately)) {
+        if (!starterIds.has(starterId)) {
+            ctx.addIssue({ code: 'custom', message: 'REPLACE_KNOCKED_KEY_NOT_A_STARTER', path: ['replaceKnockedImmediately'] });
+        }
+    }
     // Injury replacements (owner rules 2026-07-03). starter = a court starter, at most one entry each.
     // replacement = a bench player or a reserve (never another starter, the libero, or the L2). benchBackfill
     // only when the replacement came from the bench, and must be a RESERVE (outside the whole lineup, not the

package/dist/esm/src/service/team/schemas/team.z.d.ts

@@ -131,7 +131,7 @@ export declare const TeamInputSchema: z.ZodObject<{
             rotation: z.ZodNumber;
             order: z.ZodArray<z.ZodCustom<Player, Player>>;
         }, z.core.$strip>>>>;
-        replaceInjuredImmediately: z.ZodDefault<z.ZodBoolean>;
+        replaceKnockedImmediately: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
         injuryReplacements: z.ZodDefault<z.ZodArray<z.ZodObject<{
             starter: z.ZodCustom<Player, Player>;
             replacement: z.ZodCustom<Player, Player>;

package/dist/esm/src/service/team/tactics.d.ts

@@ -34,7 +34,7 @@ export interface TacticsOpts {
     readonly offensivePreferences: OffensivePreference[];
     readonly systemSets?: SystemSet[];
     readonly offensivePreferenceSets?: OffensivePreference[][];
-    readonly replaceInjuredImmediately: boolean;
+    readonly replaceKnockedImmediately: Record<string, boolean>;
     readonly injuryReplacements: InjuryReplacement[];
 }
 export declare class Tactics {
@@ -51,7 +51,7 @@ export declare class Tactics {
     readonly offensivePreferences: OffensivePreference[];
     readonly systemSets?: SystemSet[];
     readonly offensivePreferenceSets?: OffensivePreference[][];
-    readonly replaceInjuredImmediately: boolean;
+    readonly replaceKnockedImmediately: Record<string, boolean>;
     readonly injuryReplacements: InjuryReplacement[];
     static create(input: unknown): Tactics;
     private constructor();

package/dist/esm/src/service/team/tactics.js

@@ -15,7 +15,7 @@ export class Tactics {
         }
         return new Tactics(result.data);
     }
-    constructor({ lineup, liberoReplacements, receiveRotationOffset = false, designatedSubs = [], substitutionBand = EnergyBand.TIRED, secondLibero, liberoSub, liberoReplacementSets, rotationSystem = RotationSystemEnum.SIX_ZERO, designatedSetters = [], offensivePreferences = [], systemSets, offensivePreferenceSets, replaceInjuredImmediately = true, injuryReplacements = [] }) {
+    constructor({ lineup, liberoReplacements, receiveRotationOffset = false, designatedSubs = [], substitutionBand = EnergyBand.TIRED, secondLibero, liberoSub, liberoReplacementSets, rotationSystem = RotationSystemEnum.SIX_ZERO, designatedSetters = [], offensivePreferences = [], systemSets, offensivePreferenceSets, replaceKnockedImmediately = {}, injuryReplacements = [] }) {
         this.lineup = lineup;
         this.liberoReplacements = liberoReplacements;
         this.receiveRotationOffset = receiveRotationOffset;
@@ -29,7 +29,7 @@ export class Tactics {
         this.offensivePreferences = offensivePreferences;
         this.systemSets = systemSets;
         this.offensivePreferenceSets = offensivePreferenceSets;
-        this.replaceInjuredImmediately = replaceInjuredImmediately;
+        this.replaceKnockedImmediately = replaceKnockedImmediately;
         this.injuryReplacements = injuryReplacements;
     }
     findPlayerInLineup(id) {

package/package.json

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