volleyballsimtypes 0.0.507 → 0.0.508

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

@@ -4,6 +4,7 @@ export * from './formation';
 export * from './tactics';
 export * from './base-config';
 export * from './default-base-config';
+export * from './receive-overlap';
 export * from './team-name';
 export * from './energy-band';
 export * from './pinch-condition';

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

@@ -20,6 +20,7 @@ __exportStar(require("./formation"), exports);
 __exportStar(require("./tactics"), exports);
 __exportStar(require("./base-config"), exports);
 __exportStar(require("./default-base-config"), exports);
+__exportStar(require("./receive-overlap"), exports);
 __exportStar(require("./team-name"), exports);
 __exportStar(require("./energy-band"), exports);
 __exportStar(require("./pinch-condition"), exports);

package/dist/cjs/src/service/team/receive-overlap.d.ts

@@ -0,0 +1,33 @@
+import { BaseConfig } from './base-config';
+export interface ReceiveOverlapViolation {
+    /** Rotation (1..6) that has at least one violation. */
+    readonly rotation: number;
+    /** The rotational zones (1..6) involved in a violation, to flag in the editor. */
+    readonly zones: number[];
+    /** Human-readable violation messages for that rotation. */
+    readonly messages: string[];
+}
+/**
+ * Returns every RECEIVE rotation that breaks the overlap rule (empty if the whole receive formation is legal).
+ * A missing RECEIVE map or a missing zone is skipped rather than flagged, so partial/legacy configs never throw.
+ */
+export declare function receiveOverlapViolations(config: BaseConfig): ReceiveOverlapViolation[];
+/** True when the RECEIVE formation of `config` respects the overlap rule in every rotation. */
+export declare function isReceiveOverlapLegal(config: BaseConfig): boolean;
+/**
+ * Returns every SERVE rotation whose server (zone 1) is NOT behind the end line (owner 2026-08-10: on Serve, only
+ * the server is constrained; the rest of the serving formation is free). A missing SERVE map or zone-1 coord is
+ * skipped rather than flagged, so partial/legacy configs never throw.
+ */
+export declare function serveLineViolations(config: BaseConfig): ReceiveOverlapViolation[];
+/** A base-config rule violation, tagged with the formation it belongs to so the editor/API can point at it. */
+export interface FormationViolation extends ReceiveOverlapViolation {
+    readonly formation: 'RECEIVE' | 'SERVE';
+}
+/**
+ * Every base-config rule violation across the constrained formations: the RECEIVE overlap rule and the SERVE
+ * server-behind-the-line rule. This is the single check the tactics save (UI + API) and the editor flagging share.
+ */
+export declare function baseConfigViolations(config: BaseConfig): FormationViolation[];
+/** True when `config` breaks no RECEIVE overlap rule and no SERVE server-line rule. */
+export declare function isBaseConfigLegal(config: BaseConfig): boolean;

package/dist/cjs/src/service/team/receive-overlap.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.receiveOverlapViolations = receiveOverlapViolations;
+exports.isReceiveOverlapLegal = isReceiveOverlapLegal;
+exports.serveLineViolations = serveLineViolations;
+exports.baseConfigViolations = baseConfigViolations;
+exports.isBaseConfigLegal = isBaseConfigLegal;
+/**
+ * Returns every RECEIVE rotation that breaks the overlap rule (empty if the whole receive formation is legal).
+ * A missing RECEIVE map or a missing zone is skipped rather than flagged, so partial/legacy configs never throw.
+ */
+function receiveOverlapViolations(config) {
+    const rc = config.coords?.RECEIVE;
+    if (rc == null)
+        return [];
+    const out = [];
+    for (let rot = 1; rot <= 6; rot++) {
+        const row = rc[String(rot)];
+        if (row == null)
+            continue;
+        const at = (zone) => row[String(zone)];
+        const bad = new Set();
+        const messages = [];
+        const lateral = (left, right, ln, rn) => {
+            const a = at(left);
+            const b = at(right);
+            if (a == null || b == null)
+                return;
+            if (a.r >= b.r) {
+                bad.add(left);
+                bad.add(right);
+                messages.push(`${ln} must be left of ${rn}`);
+            }
+        };
+        const depth = (front, back, fn, bn) => {
+            const a = at(front);
+            const b = at(back);
+            if (a == null || b == null)
+                return;
+            if (a.d >= b.d) {
+                bad.add(front);
+                bad.add(back);
+                messages.push(`${fn} must be in front of ${bn}`);
+            }
+        };
+        lateral(4, 3, 'left-front', 'middle-front');
+        lateral(3, 2, 'middle-front', 'right-front');
+        lateral(5, 6, 'left-back', 'middle-back');
+        lateral(6, 1, 'middle-back', 'right-back');
+        depth(2, 1, 'right-front', 'right-back');
+        depth(3, 6, 'middle-front', 'middle-back');
+        depth(4, 5, 'left-front', 'left-back');
+        if (bad.size > 0)
+            out.push({ rotation: rot, zones: [...bad].sort((a, b) => a - b), messages });
+    }
+    return out;
+}
+/** True when the RECEIVE formation of `config` respects the overlap rule in every rotation. */
+function isReceiveOverlapLegal(config) {
+    return receiveOverlapViolations(config).length === 0;
+}
+// The end line sits 9 m off the net (the FIVB court depth; matches the court editor's END_LINE). A server must
+// contact the ball from BEHIND it, so on the SERVE formation the server (rotational zone 1) must have d >= this.
+const END_LINE_DEPTH = 9;
+/**
+ * Returns every SERVE rotation whose server (zone 1) is NOT behind the end line (owner 2026-08-10: on Serve, only
+ * the server is constrained; the rest of the serving formation is free). A missing SERVE map or zone-1 coord is
+ * skipped rather than flagged, so partial/legacy configs never throw.
+ */
+function serveLineViolations(config) {
+    const sc = config.coords?.SERVE;
+    if (sc == null)
+        return [];
+    const out = [];
+    for (let rot = 1; rot <= 6; rot++) {
+        const server = sc[String(rot)]?.['1'];
+        if (server == null)
+            continue;
+        if (server.d < END_LINE_DEPTH)
+            out.push({ rotation: rot, zones: [1], messages: ['server must be behind the end line'] });
+    }
+    return out;
+}
+/**
+ * Every base-config rule violation across the constrained formations: the RECEIVE overlap rule and the SERVE
+ * server-behind-the-line rule. This is the single check the tactics save (UI + API) and the editor flagging share.
+ */
+function baseConfigViolations(config) {
+    return [
+        ...receiveOverlapViolations(config).map(v => ({ ...v, formation: 'RECEIVE' })),
+        ...serveLineViolations(config).map(v => ({ ...v, formation: 'SERVE' }))
+    ];
+}
+/** True when `config` breaks no RECEIVE overlap rule and no SERVE server-line rule. */
+function isBaseConfigLegal(config) {
+    return baseConfigViolations(config).length === 0;
+}

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

@@ -4,6 +4,7 @@ export * from './formation';
 export * from './tactics';
 export * from './base-config';
 export * from './default-base-config';
+export * from './receive-overlap';
 export * from './team-name';
 export * from './energy-band';
 export * from './pinch-condition';

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

@@ -4,6 +4,7 @@ export * from './formation';
 export * from './tactics';
 export * from './base-config';
 export * from './default-base-config';
+export * from './receive-overlap';
 export * from './team-name';
 export * from './energy-band';
 export * from './pinch-condition';

package/dist/esm/src/service/team/receive-overlap.d.ts

@@ -0,0 +1,33 @@
+import { BaseConfig } from './base-config';
+export interface ReceiveOverlapViolation {
+    /** Rotation (1..6) that has at least one violation. */
+    readonly rotation: number;
+    /** The rotational zones (1..6) involved in a violation, to flag in the editor. */
+    readonly zones: number[];
+    /** Human-readable violation messages for that rotation. */
+    readonly messages: string[];
+}
+/**
+ * Returns every RECEIVE rotation that breaks the overlap rule (empty if the whole receive formation is legal).
+ * A missing RECEIVE map or a missing zone is skipped rather than flagged, so partial/legacy configs never throw.
+ */
+export declare function receiveOverlapViolations(config: BaseConfig): ReceiveOverlapViolation[];
+/** True when the RECEIVE formation of `config` respects the overlap rule in every rotation. */
+export declare function isReceiveOverlapLegal(config: BaseConfig): boolean;
+/**
+ * Returns every SERVE rotation whose server (zone 1) is NOT behind the end line (owner 2026-08-10: on Serve, only
+ * the server is constrained; the rest of the serving formation is free). A missing SERVE map or zone-1 coord is
+ * skipped rather than flagged, so partial/legacy configs never throw.
+ */
+export declare function serveLineViolations(config: BaseConfig): ReceiveOverlapViolation[];
+/** A base-config rule violation, tagged with the formation it belongs to so the editor/API can point at it. */
+export interface FormationViolation extends ReceiveOverlapViolation {
+    readonly formation: 'RECEIVE' | 'SERVE';
+}
+/**
+ * Every base-config rule violation across the constrained formations: the RECEIVE overlap rule and the SERVE
+ * server-behind-the-line rule. This is the single check the tactics save (UI + API) and the editor flagging share.
+ */
+export declare function baseConfigViolations(config: BaseConfig): FormationViolation[];
+/** True when `config` breaks no RECEIVE overlap rule and no SERVE server-line rule. */
+export declare function isBaseConfigLegal(config: BaseConfig): boolean;

package/dist/esm/src/service/team/receive-overlap.js

@@ -0,0 +1,90 @@
+/**
+ * Returns every RECEIVE rotation that breaks the overlap rule (empty if the whole receive formation is legal).
+ * A missing RECEIVE map or a missing zone is skipped rather than flagged, so partial/legacy configs never throw.
+ */
+export function receiveOverlapViolations(config) {
+    const rc = config.coords?.RECEIVE;
+    if (rc == null)
+        return [];
+    const out = [];
+    for (let rot = 1; rot <= 6; rot++) {
+        const row = rc[String(rot)];
+        if (row == null)
+            continue;
+        const at = (zone) => row[String(zone)];
+        const bad = new Set();
+        const messages = [];
+        const lateral = (left, right, ln, rn) => {
+            const a = at(left);
+            const b = at(right);
+            if (a == null || b == null)
+                return;
+            if (a.r >= b.r) {
+                bad.add(left);
+                bad.add(right);
+                messages.push(`${ln} must be left of ${rn}`);
+            }
+        };
+        const depth = (front, back, fn, bn) => {
+            const a = at(front);
+            const b = at(back);
+            if (a == null || b == null)
+                return;
+            if (a.d >= b.d) {
+                bad.add(front);
+                bad.add(back);
+                messages.push(`${fn} must be in front of ${bn}`);
+            }
+        };
+        lateral(4, 3, 'left-front', 'middle-front');
+        lateral(3, 2, 'middle-front', 'right-front');
+        lateral(5, 6, 'left-back', 'middle-back');
+        lateral(6, 1, 'middle-back', 'right-back');
+        depth(2, 1, 'right-front', 'right-back');
+        depth(3, 6, 'middle-front', 'middle-back');
+        depth(4, 5, 'left-front', 'left-back');
+        if (bad.size > 0)
+            out.push({ rotation: rot, zones: [...bad].sort((a, b) => a - b), messages });
+    }
+    return out;
+}
+/** True when the RECEIVE formation of `config` respects the overlap rule in every rotation. */
+export function isReceiveOverlapLegal(config) {
+    return receiveOverlapViolations(config).length === 0;
+}
+// The end line sits 9 m off the net (the FIVB court depth; matches the court editor's END_LINE). A server must
+// contact the ball from BEHIND it, so on the SERVE formation the server (rotational zone 1) must have d >= this.
+const END_LINE_DEPTH = 9;
+/**
+ * Returns every SERVE rotation whose server (zone 1) is NOT behind the end line (owner 2026-08-10: on Serve, only
+ * the server is constrained; the rest of the serving formation is free). A missing SERVE map or zone-1 coord is
+ * skipped rather than flagged, so partial/legacy configs never throw.
+ */
+export function serveLineViolations(config) {
+    const sc = config.coords?.SERVE;
+    if (sc == null)
+        return [];
+    const out = [];
+    for (let rot = 1; rot <= 6; rot++) {
+        const server = sc[String(rot)]?.['1'];
+        if (server == null)
+            continue;
+        if (server.d < END_LINE_DEPTH)
+            out.push({ rotation: rot, zones: [1], messages: ['server must be behind the end line'] });
+    }
+    return out;
+}
+/**
+ * Every base-config rule violation across the constrained formations: the RECEIVE overlap rule and the SERVE
+ * server-behind-the-line rule. This is the single check the tactics save (UI + API) and the editor flagging share.
+ */
+export function baseConfigViolations(config) {
+    return [
+        ...receiveOverlapViolations(config).map(v => ({ ...v, formation: 'RECEIVE' })),
+        ...serveLineViolations(config).map(v => ({ ...v, formation: 'SERVE' }))
+    ];
+}
+/** True when `config` breaks no RECEIVE overlap rule and no SERVE server-line rule. */
+export function isBaseConfigLegal(config) {
+    return baseConfigViolations(config).length === 0;
+}

package/package.json

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