volleyballsimtypes 0.0.477 → 0.0.479

package/dist/cjs/src/service/notification/registry.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NOTIFICATION_REGISTRY = void 0;
+function readString(value) {
+    return typeof value === 'string' && value !== '' ? value : null;
+}
+function teamPath(payload) {
+    const teamId = readString(payload.teamId);
+    return teamId != null ? `/team/${encodeURIComponent(teamId)}` : '/';
+}
+// MATCH_RESULT copy is recipient-relative: `result` is WIN/LOSS from the recipient's view and `side` marks
+// which team is theirs, so the OTHER team is the opponent. When side/names are missing, do not name a winner.
+function matchOpponent(payload) {
+    const homeTeam = typeof payload.homeTeam === 'object' && payload.homeTeam != null ? payload.homeTeam : {};
+    const awayTeam = typeof payload.awayTeam === 'object' && payload.awayTeam != null ? payload.awayTeam : {};
+    const homeName = readString(homeTeam.name);
+    const awayName = readString(awayTeam.name);
+    if (payload.side === 'HOME')
+        return awayName;
+    if (payload.side === 'AWAY')
+        return homeName;
+    return null;
+}
+function injuredName(payload) {
+    // Matches the old Sim injuredPlayerName fallback so a name-less payload never renders a subjectless sentence.
+    return readString(payload.playerNickname) ?? readString(payload.playerName) ?? 'A player';
+}
+exports.NOTIFICATION_REGISTRY = {
+    MATCH_RESULT: {
+        emitsPush: true,
+        deepLink: (p) => {
+            const matchId = readString(p.matchId);
+            return matchId != null ? `/match/${encodeURIComponent(matchId)}` : '/';
+        },
+        pushTitleKey: 'matchResult.title',
+        pushBodyKey: (p) => {
+            const outcome = p.result === 'WIN' ? 'won' : 'lost';
+            const named = matchOpponent(p) != null ? 'Named' : 'Unnamed';
+            return `matchResult.${outcome}${named}`;
+        },
+        params: (p) => ({ opponent: matchOpponent(p) ?? '' }),
+        richRender: 'MATCH_RESULT',
+        catalogKeys: ['matchResult.title', 'matchResult.wonNamed', 'matchResult.wonUnnamed', 'matchResult.lostNamed', 'matchResult.lostUnnamed']
+    },
+    INJURY: {
+        emitsPush: true,
+        deepLink: () => '/infirmary',
+        pushTitleKey: 'injury.title',
+        pushBodyKey: 'injury.body',
+        inAppMessageKey: 'injury.body',
+        params: (p) => ({ name: injuredName(p) }),
+        catalogKeys: ['injury.title', 'injury.body']
+    },
+    INJURY_RECOVERED: {
+        emitsPush: true,
+        deepLink: teamPath,
+        pushTitleKey: 'injuryRecovered.title',
+        pushBodyKey: 'injuryRecovered.body',
+        inAppMessageKey: 'injuryRecovered.body',
+        params: (p) => ({ name: injuredName(p) }),
+        catalogKeys: ['injuryRecovered.title', 'injuryRecovered.body']
+    },
+    SEASON_END: {
+        emitsPush: true,
+        deepLink: (p) => {
+            const leagueId = readString(p.leagueId);
+            return leagueId != null ? `/league/${encodeURIComponent(leagueId)}` : '/league';
+        },
+        pushTitleKey: 'seasonEnd.title',
+        pushBodyKey: 'seasonEnd.body',
+        inAppMessageKey: 'seasonEnd.body',
+        catalogKeys: ['seasonEnd.title', 'seasonEnd.body']
+    },
+    GRANT_RECEIVED: {
+        emitsPush: true,
+        deepLink: () => '/recruit',
+        pushTitleKey: 'grant.title',
+        pushBodyKey: 'grant.body',
+        inAppMessageKey: 'grant.body',
+        catalogKeys: ['grant.title', 'grant.body']
+    },
+    PROMOTION: {
+        emitsPush: true,
+        deepLink: teamPath,
+        pushTitleKey: 'promotion.title',
+        pushBodyKey: 'promotion.body',
+        inAppMessageKey: 'promotion.body',
+        catalogKeys: ['promotion.title', 'promotion.body']
+    },
+    DAILY_LOGIN: {
+        emitsPush: true,
+        deepLink: () => '/recruit',
+        pushTitleKey: 'dailyLogin.title',
+        pushBodyKey: 'dailyLogin.body',
+        inAppMessageKey: 'dailyLogin.body',
+        catalogKeys: ['dailyLogin.title', 'dailyLogin.body']
+    },
+    WELCOME: {
+        emitsPush: true,
+        deepLink: () => '/recruit',
+        pushTitleKey: 'welcome.title',
+        pushBodyKey: 'welcome.body',
+        richRender: 'WELCOME',
+        catalogKeys: ['welcome.title', 'welcome.body']
+    },
+    // In-app only (no push); the UI keeps a bespoke renderer (amount formatting) and its own `compensation` label.
+    COMPENSATION: {
+        emitsPush: false,
+        richRender: 'COMPENSATION',
+        catalogKeys: []
+    }
+};

package/dist/cjs/src/service/notification/render.d.ts

@@ -0,0 +1,10 @@
+import { type NotificationLocale } from './notification-type';
+export interface RenderedPush {
+    title: string;
+    body: string;
+    data: Record<string, string>;
+}
+export declare function interpolate(template: string, params: Record<string, string>): string;
+export declare function translateNotification(locale: NotificationLocale, key: string, params?: Record<string, string>): string;
+export declare function renderPush(type: string, payload: Record<string, unknown>, locale: NotificationLocale): RenderedPush | undefined;
+export declare function notificationPath(type: string, payload: Record<string, unknown>): string;

package/dist/cjs/src/service/notification/render.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.interpolate = interpolate;
+exports.translateNotification = translateNotification;
+exports.renderPush = renderPush;
+exports.notificationPath = notificationPath;
+const notification_type_1 = require("./notification-type");
+const registry_1 = require("./registry");
+const catalog_1 = require("./catalog");
+function readNested(node, dotKey) {
+    let current = node;
+    for (const part of dotKey.split('.')) {
+        if (typeof current !== 'object' || current == null)
+            return undefined;
+        current = current[part];
+    }
+    return typeof current === 'string' ? current : undefined;
+}
+function lookupCatalog(locale, dotKey) {
+    return readNested(catalog_1.NOTIFICATION_CATALOG[locale], dotKey) ??
+        readNested(catalog_1.NOTIFICATION_CATALOG[notification_type_1.DEFAULT_NOTIFICATION_LOCALE], dotKey) ??
+        dotKey;
+}
+function resolveKey(resolver, payload) {
+    if (resolver == null)
+        return undefined;
+    return typeof resolver === 'function' ? resolver(payload) : resolver;
+}
+function interpolate(template, params) {
+    return template.replace(/\{\{(\w+)\}\}/g, (_match, key) => params[key] ?? '');
+}
+// Resolve one catalog key to a localized, interpolated string. Missing key/locale falls back to English,
+// then to the raw key. Exposed so consumers can render notification copy off the shared catalog too.
+function translateNotification(locale, key, params = {}) {
+    return interpolate(lookupCatalog(locale, key), params);
+}
+// Build the localized push payload for a notification. Returns undefined for in-app-only types (emitsPush
+// false, e.g. COMPENSATION). Unknown/future types fall back to the generic copy and the root path, matching
+// the previous hardcoded fallback. Callers pass the recipient's locale (normalizeNotificationLocale first).
+function renderPush(type, payload, locale) {
+    const buildData = (path) => ({ type, payload: JSON.stringify(payload), path });
+    const descriptor = registry_1.NOTIFICATION_REGISTRY[type];
+    if (descriptor == null) {
+        return {
+            title: translateNotification(locale, 'generic.title'),
+            body: translateNotification(locale, 'generic.body'),
+            data: buildData('/')
+        };
+    }
+    if (!descriptor.emitsPush)
+        return undefined;
+    const params = descriptor.params?.(payload) ?? {};
+    const titleKey = resolveKey(descriptor.pushTitleKey, payload) ?? 'generic.title';
+    const bodyKey = resolveKey(descriptor.pushBodyKey, payload) ?? 'generic.body';
+    return {
+        title: translateNotification(locale, titleKey, params),
+        body: translateNotification(locale, bodyKey, params),
+        data: buildData(descriptor.deepLink?.(payload) ?? '/')
+    };
+}
+// Deep-link path for a type/payload, used for both the push data.path and the in-app click target.
+function notificationPath(type, payload) {
+    return registry_1.NOTIFICATION_REGISTRY[type]?.deepLink?.(payload) ?? '/';
+}

package/dist/cjs/src/service/team/pinch-condition.d.ts

@@ -22,6 +22,10 @@ export declare enum ScoreDirection {
     TRAILING = "TRAILING",
     LEADING = "LEADING"
 }
+export declare enum Comparison {
+    AT_LEAST = "AT_LEAST",
+    AT_MOST = "AT_MOST"
+}
 export interface AsapCondition {
     readonly type: PinchConditionType.ASAP;
 }
@@ -38,6 +42,7 @@ export interface ScoreDiffCondition {
     readonly type: PinchConditionType.SCORE_DIFF;
     readonly direction: ScoreDirection;
     readonly points: number;
+    readonly comparison?: Comparison;
 }
 export interface AfterRotationsCondition {
     readonly type: PinchConditionType.AFTER_ROTATIONS;
@@ -50,10 +55,12 @@ export interface FromSetCondition {
 export interface MinOwnScoreCondition {
     readonly type: PinchConditionType.MIN_OWN_SCORE;
     readonly score: number;
+    readonly comparison?: Comparison;
 }
 export interface MinOpponentScoreCondition {
     readonly type: PinchConditionType.MIN_OPPONENT_SCORE;
     readonly score: number;
+    readonly comparison?: Comparison;
 }
 export interface PhaseCondition {
     readonly type: PinchConditionType.PHASE;

package/dist/cjs/src/service/team/pinch-condition.js

@@ -3,7 +3,7 @@
 // wins back the serve, out the moment the serve is lost). Each condition is evaluated against the live set
 // state; a pinch entry combines them with ALL (every condition must hold) or ANY (one is enough).
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ScoreDirection = exports.OpponentRelation = exports.MatchPhase = exports.PinchConditionType = void 0;
+exports.Comparison = exports.ScoreDirection = exports.OpponentRelation = exports.MatchPhase = exports.PinchConditionType = void 0;
 var PinchConditionType;
 (function (PinchConditionType) {
     PinchConditionType["ASAP"] = "ASAP";
@@ -34,3 +34,12 @@ var ScoreDirection;
     ScoreDirection["TRAILING"] = "TRAILING";
     ScoreDirection["LEADING"] = "LEADING";
 })(ScoreDirection || (exports.ScoreDirection = ScoreDirection = {}));
+// Comparison direction for a numeric-threshold condition (SCORE_DIFF / MIN_OWN_SCORE / MIN_OPPONENT_SCORE).
+// AT_LEAST ("Or more", value >= threshold) is the default when absent, so every existing stored condition keeps
+// its `>=` behavior. AT_MOST ("Or less", value <= threshold) lets a rule fire as a value SHRINKS (e.g. a sub-back
+// once "Leading by 2 or less" holds, instead of the always-implied "Leading by 2 or more").
+var Comparison;
+(function (Comparison) {
+    Comparison["AT_LEAST"] = "AT_LEAST";
+    Comparison["AT_MOST"] = "AT_MOST";
+})(Comparison || (exports.Comparison = Comparison = {}));

package/dist/cjs/src/service/team/schemas/designated-sub.z.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { Player } from '../../player';
 import { EnergyBand } from '../energy-band';
-import { MatchPhase, OpponentRelation, PinchConditionType, ScoreDirection } from '../pinch-condition';
+import { Comparison, MatchPhase, OpponentRelation, PinchConditionType, ScoreDirection } from '../pinch-condition';
 export declare const SubBandSchema: z.ZodUnion<readonly [z.ZodEnum<typeof EnergyBand>, z.ZodLiteral<"NEVER">]>;
 export declare const PinchConditionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<PinchConditionType.ASAP>;
@@ -16,6 +16,7 @@ export declare const PinchConditionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
     type: z.ZodLiteral<PinchConditionType.SCORE_DIFF>;
     direction: z.ZodEnum<typeof ScoreDirection>;
     points: z.ZodNumber;
+    comparison: z.ZodOptional<z.ZodEnum<typeof Comparison>>;
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<PinchConditionType.AFTER_ROTATIONS>;
     rotations: z.ZodNumber;
@@ -25,9 +26,11 @@ export declare const PinchConditionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<PinchConditionType.MIN_OWN_SCORE>;
     score: z.ZodNumber;
+    comparison: z.ZodOptional<z.ZodEnum<typeof Comparison>>;
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<PinchConditionType.MIN_OPPONENT_SCORE>;
     score: z.ZodNumber;
+    comparison: z.ZodOptional<z.ZodEnum<typeof Comparison>>;
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<PinchConditionType.PHASE>;
     phase: z.ZodEnum<typeof MatchPhase>;
@@ -64,6 +67,7 @@ export declare const SetSubConfigSchema: z.ZodObject<{
         type: z.ZodLiteral<PinchConditionType.SCORE_DIFF>;
         direction: z.ZodEnum<typeof ScoreDirection>;
         points: z.ZodNumber;
+        comparison: z.ZodOptional<z.ZodEnum<typeof Comparison>>;
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<PinchConditionType.AFTER_ROTATIONS>;
         rotations: z.ZodNumber;
@@ -73,9 +77,11 @@ export declare const SetSubConfigSchema: z.ZodObject<{
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<PinchConditionType.MIN_OWN_SCORE>;
         score: z.ZodNumber;
+        comparison: z.ZodOptional<z.ZodEnum<typeof Comparison>>;
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<PinchConditionType.MIN_OPPONENT_SCORE>;
         score: z.ZodNumber;
+        comparison: z.ZodOptional<z.ZodEnum<typeof Comparison>>;
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<PinchConditionType.PHASE>;
         phase: z.ZodEnum<typeof MatchPhase>;
@@ -99,6 +105,7 @@ export declare const SetSubConfigSchema: z.ZodObject<{
         type: z.ZodLiteral<PinchConditionType.SCORE_DIFF>;
         direction: z.ZodEnum<typeof ScoreDirection>;
         points: z.ZodNumber;
+        comparison: z.ZodOptional<z.ZodEnum<typeof Comparison>>;
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<PinchConditionType.AFTER_ROTATIONS>;
         rotations: z.ZodNumber;
@@ -108,9 +115,11 @@ export declare const SetSubConfigSchema: z.ZodObject<{
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<PinchConditionType.MIN_OWN_SCORE>;
         score: z.ZodNumber;
+        comparison: z.ZodOptional<z.ZodEnum<typeof Comparison>>;
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<PinchConditionType.MIN_OPPONENT_SCORE>;
         score: z.ZodNumber;
+        comparison: z.ZodOptional<z.ZodEnum<typeof Comparison>>;
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<PinchConditionType.PHASE>;
         phase: z.ZodEnum<typeof MatchPhase>;
@@ -140,6 +149,7 @@ export declare const DesignatedSubSchema: z.ZodObject<{
             type: z.ZodLiteral<PinchConditionType.SCORE_DIFF>;
             direction: z.ZodEnum<typeof ScoreDirection>;
             points: z.ZodNumber;
+            comparison: z.ZodOptional<z.ZodEnum<typeof Comparison>>;
         }, z.core.$strip>, z.ZodObject<{
             type: z.ZodLiteral<PinchConditionType.AFTER_ROTATIONS>;
             rotations: z.ZodNumber;
@@ -149,9 +159,11 @@ export declare const DesignatedSubSchema: z.ZodObject<{
         }, z.core.$strip>, z.ZodObject<{
             type: z.ZodLiteral<PinchConditionType.MIN_OWN_SCORE>;
             score: z.ZodNumber;
+            comparison: z.ZodOptional<z.ZodEnum<typeof Comparison>>;
         }, z.core.$strip>, z.ZodObject<{
             type: z.ZodLiteral<PinchConditionType.MIN_OPPONENT_SCORE>;
             score: z.ZodNumber;
+            comparison: z.ZodOptional<z.ZodEnum<typeof Comparison>>;
         }, z.core.$strip>, z.ZodObject<{
             type: z.ZodLiteral<PinchConditionType.PHASE>;
             phase: z.ZodEnum<typeof MatchPhase>;
@@ -175,6 +187,7 @@ export declare const DesignatedSubSchema: z.ZodObject<{
             type: z.ZodLiteral<PinchConditionType.SCORE_DIFF>;
             direction: z.ZodEnum<typeof ScoreDirection>;
             points: z.ZodNumber;
+            comparison: z.ZodOptional<z.ZodEnum<typeof Comparison>>;
         }, z.core.$strip>, z.ZodObject<{
             type: z.ZodLiteral<PinchConditionType.AFTER_ROTATIONS>;
             rotations: z.ZodNumber;
@@ -184,9 +197,11 @@ export declare const DesignatedSubSchema: z.ZodObject<{
         }, z.core.$strip>, z.ZodObject<{
             type: z.ZodLiteral<PinchConditionType.MIN_OWN_SCORE>;
             score: z.ZodNumber;
+            comparison: z.ZodOptional<z.ZodEnum<typeof Comparison>>;
         }, z.core.$strip>, z.ZodObject<{
             type: z.ZodLiteral<PinchConditionType.MIN_OPPONENT_SCORE>;
             score: z.ZodNumber;
+            comparison: z.ZodOptional<z.ZodEnum<typeof Comparison>>;
         }, z.core.$strip>, z.ZodObject<{
             type: z.ZodLiteral<PinchConditionType.PHASE>;
             phase: z.ZodEnum<typeof MatchPhase>;
@@ -214,6 +229,7 @@ export declare const DesignatedSubSchema: z.ZodObject<{
         type: z.ZodLiteral<PinchConditionType.SCORE_DIFF>;
         direction: z.ZodEnum<typeof ScoreDirection>;
         points: z.ZodNumber;
+        comparison: z.ZodOptional<z.ZodEnum<typeof Comparison>>;
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<PinchConditionType.AFTER_ROTATIONS>;
         rotations: z.ZodNumber;
@@ -223,9 +239,11 @@ export declare const DesignatedSubSchema: z.ZodObject<{
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<PinchConditionType.MIN_OWN_SCORE>;
         score: z.ZodNumber;
+        comparison: z.ZodOptional<z.ZodEnum<typeof Comparison>>;
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<PinchConditionType.MIN_OPPONENT_SCORE>;
         score: z.ZodNumber;
+        comparison: z.ZodOptional<z.ZodEnum<typeof Comparison>>;
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<PinchConditionType.PHASE>;
         phase: z.ZodEnum<typeof MatchPhase>;
@@ -249,6 +267,7 @@ export declare const DesignatedSubSchema: z.ZodObject<{
         type: z.ZodLiteral<PinchConditionType.SCORE_DIFF>;
         direction: z.ZodEnum<typeof ScoreDirection>;
         points: z.ZodNumber;
+        comparison: z.ZodOptional<z.ZodEnum<typeof Comparison>>;
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<PinchConditionType.AFTER_ROTATIONS>;
         rotations: z.ZodNumber;
@@ -258,9 +277,11 @@ export declare const DesignatedSubSchema: z.ZodObject<{
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<PinchConditionType.MIN_OWN_SCORE>;
         score: z.ZodNumber;
+        comparison: z.ZodOptional<z.ZodEnum<typeof Comparison>>;
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<PinchConditionType.MIN_OPPONENT_SCORE>;
         score: z.ZodNumber;
+        comparison: z.ZodOptional<z.ZodEnum<typeof Comparison>>;
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<PinchConditionType.PHASE>;
         phase: z.ZodEnum<typeof MatchPhase>;

package/dist/cjs/src/service/team/schemas/designated-sub.z.js

@@ -13,11 +13,13 @@ exports.PinchConditionSchema = zod_1.z.discriminatedUnion('type', [
     zod_1.z.object({ type: zod_1.z.literal(pinch_condition_1.PinchConditionType.ASAP) }),
     zod_1.z.object({ type: zod_1.z.literal(pinch_condition_1.PinchConditionType.TEAM_SET_POINT), margin: zod_1.z.number().int().min(1).max(25), opponent: zod_1.z.nativeEnum(pinch_condition_1.OpponentRelation) }),
     zod_1.z.object({ type: zod_1.z.literal(pinch_condition_1.PinchConditionType.OPPONENT_SET_POINT), margin: zod_1.z.number().int().min(1).max(25) }),
-    zod_1.z.object({ type: zod_1.z.literal(pinch_condition_1.PinchConditionType.SCORE_DIFF), direction: zod_1.z.nativeEnum(pinch_condition_1.ScoreDirection), points: zod_1.z.number().int().min(1).max(25) }),
+    // SCORE_DIFF / MIN_OWN_SCORE / MIN_OPPONENT_SCORE carry an optional comparison direction ("Or more" AT_LEAST,
+    // the default; "Or less" AT_MOST). Absent = AT_LEAST so existing conditions keep their `>=` behavior.
+    zod_1.z.object({ type: zod_1.z.literal(pinch_condition_1.PinchConditionType.SCORE_DIFF), direction: zod_1.z.nativeEnum(pinch_condition_1.ScoreDirection), points: zod_1.z.number().int().min(1).max(25), comparison: zod_1.z.nativeEnum(pinch_condition_1.Comparison).optional() }),
     zod_1.z.object({ type: zod_1.z.literal(pinch_condition_1.PinchConditionType.AFTER_ROTATIONS), rotations: zod_1.z.number().int().min(1).max(6) }),
     zod_1.z.object({ type: zod_1.z.literal(pinch_condition_1.PinchConditionType.FROM_SET), set: zod_1.z.number().int().min(1).max(5) }),
-    zod_1.z.object({ type: zod_1.z.literal(pinch_condition_1.PinchConditionType.MIN_OWN_SCORE), score: zod_1.z.number().int().min(0).max(40) }),
-    zod_1.z.object({ type: zod_1.z.literal(pinch_condition_1.PinchConditionType.MIN_OPPONENT_SCORE), score: zod_1.z.number().int().min(0).max(40) }),
+    zod_1.z.object({ type: zod_1.z.literal(pinch_condition_1.PinchConditionType.MIN_OWN_SCORE), score: zod_1.z.number().int().min(0).max(40), comparison: zod_1.z.nativeEnum(pinch_condition_1.Comparison).optional() }),
+    zod_1.z.object({ type: zod_1.z.literal(pinch_condition_1.PinchConditionType.MIN_OPPONENT_SCORE), score: zod_1.z.number().int().min(0).max(40), comparison: zod_1.z.nativeEnum(pinch_condition_1.Comparison).optional() }),
     // PHASE is used by the libero deployment rule (which reuses this schema); pinch servers never offer it.
     zod_1.z.object({ type: zod_1.z.literal(pinch_condition_1.PinchConditionType.PHASE), phase: zod_1.z.nativeEnum(pinch_condition_1.MatchPhase) })
 ]);

package/dist/cjs/src/service/team/schemas/designated-sub.z.test.js

@@ -59,6 +59,16 @@ const test_helpers_1 = require("../../test-helpers");
     (0, globals_1.it)('rejects a non-integer numeric field', () => {
         (0, globals_1.expect)(designated_sub_z_1.PinchConditionSchema.safeParse({ type: pinch_condition_1.PinchConditionType.FROM_SET, set: 2.5 }).success).toBe(false);
     });
+    (0, globals_1.it)('accepts an optional comparison (Or more / Or less) on the numeric-threshold conditions', () => {
+        (0, globals_1.expect)(designated_sub_z_1.PinchConditionSchema.safeParse({ type: pinch_condition_1.PinchConditionType.SCORE_DIFF, direction: pinch_condition_1.ScoreDirection.LEADING, points: 2, comparison: pinch_condition_1.Comparison.AT_MOST }).success).toBe(true);
+        (0, globals_1.expect)(designated_sub_z_1.PinchConditionSchema.safeParse({ type: pinch_condition_1.PinchConditionType.MIN_OWN_SCORE, score: 20, comparison: pinch_condition_1.Comparison.AT_MOST }).success).toBe(true);
+        (0, globals_1.expect)(designated_sub_z_1.PinchConditionSchema.safeParse({ type: pinch_condition_1.PinchConditionType.MIN_OPPONENT_SCORE, score: 20, comparison: pinch_condition_1.Comparison.AT_LEAST }).success).toBe(true);
+        // absent comparison stays valid (defaults to AT_LEAST at eval time)
+        (0, globals_1.expect)(designated_sub_z_1.PinchConditionSchema.safeParse({ type: pinch_condition_1.PinchConditionType.SCORE_DIFF, direction: pinch_condition_1.ScoreDirection.LEADING, points: 2 }).success).toBe(true);
+    });
+    (0, globals_1.it)('rejects an invalid comparison value', () => {
+        (0, globals_1.expect)(designated_sub_z_1.PinchConditionSchema.safeParse({ type: pinch_condition_1.PinchConditionType.MIN_OWN_SCORE, score: 20, comparison: 'EXACTLY' }).success).toBe(false);
+    });
 });
 (0, globals_1.describe)('DesignatedSubSchema', () => {
     const country = (0, test_helpers_1.makeCountry)();

package/dist/cjs/src/service/team/schemas/libero-sub.z.d.ts

@@ -27,6 +27,7 @@ export declare const LiberoSetSubConfigSchema: z.ZodObject<{
         type: z.ZodLiteral<import("..").PinchConditionType.SCORE_DIFF>;
         direction: z.ZodEnum<typeof import("..").ScoreDirection>;
         points: z.ZodNumber;
+        comparison: z.ZodOptional<z.ZodEnum<typeof import("..").Comparison>>;
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<import("..").PinchConditionType.AFTER_ROTATIONS>;
         rotations: z.ZodNumber;
@@ -36,9 +37,11 @@ export declare const LiberoSetSubConfigSchema: z.ZodObject<{
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<import("..").PinchConditionType.MIN_OWN_SCORE>;
         score: z.ZodNumber;
+        comparison: z.ZodOptional<z.ZodEnum<typeof import("..").Comparison>>;
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<import("..").PinchConditionType.MIN_OPPONENT_SCORE>;
         score: z.ZodNumber;
+        comparison: z.ZodOptional<z.ZodEnum<typeof import("..").Comparison>>;
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<import("..").PinchConditionType.PHASE>;
         phase: z.ZodEnum<typeof import("..").MatchPhase>;
@@ -67,6 +70,7 @@ export declare const LiberoSubConfigSchema: z.ZodObject<{
             type: z.ZodLiteral<import("..").PinchConditionType.SCORE_DIFF>;
             direction: z.ZodEnum<typeof import("..").ScoreDirection>;
             points: z.ZodNumber;
+            comparison: z.ZodOptional<z.ZodEnum<typeof import("..").Comparison>>;
         }, z.core.$strip>, z.ZodObject<{
             type: z.ZodLiteral<import("..").PinchConditionType.AFTER_ROTATIONS>;
             rotations: z.ZodNumber;
@@ -76,9 +80,11 @@ export declare const LiberoSubConfigSchema: z.ZodObject<{
         }, z.core.$strip>, z.ZodObject<{
             type: z.ZodLiteral<import("..").PinchConditionType.MIN_OWN_SCORE>;
             score: z.ZodNumber;
+            comparison: z.ZodOptional<z.ZodEnum<typeof import("..").Comparison>>;
         }, z.core.$strip>, z.ZodObject<{
             type: z.ZodLiteral<import("..").PinchConditionType.MIN_OPPONENT_SCORE>;
             score: z.ZodNumber;
+            comparison: z.ZodOptional<z.ZodEnum<typeof import("..").Comparison>>;
         }, z.core.$strip>, z.ZodObject<{
             type: z.ZodLiteral<import("..").PinchConditionType.PHASE>;
             phase: z.ZodEnum<typeof import("..").MatchPhase>;
@@ -105,6 +111,7 @@ export declare const LiberoSubConfigSchema: z.ZodObject<{
         type: z.ZodLiteral<import("..").PinchConditionType.SCORE_DIFF>;
         direction: z.ZodEnum<typeof import("..").ScoreDirection>;
         points: z.ZodNumber;
+        comparison: z.ZodOptional<z.ZodEnum<typeof import("..").Comparison>>;
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<import("..").PinchConditionType.AFTER_ROTATIONS>;
         rotations: z.ZodNumber;
@@ -114,9 +121,11 @@ export declare const LiberoSubConfigSchema: z.ZodObject<{
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<import("..").PinchConditionType.MIN_OWN_SCORE>;
         score: z.ZodNumber;
+        comparison: z.ZodOptional<z.ZodEnum<typeof import("..").Comparison>>;
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<import("..").PinchConditionType.MIN_OPPONENT_SCORE>;
         score: z.ZodNumber;
+        comparison: z.ZodOptional<z.ZodEnum<typeof import("..").Comparison>>;
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<import("..").PinchConditionType.PHASE>;
         phase: z.ZodEnum<typeof import("..").MatchPhase>;

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

@@ -38,6 +38,7 @@ export declare const TacticsInputSchema: z.ZodObject<{
                 type: z.ZodLiteral<import("..").PinchConditionType.SCORE_DIFF>;
                 direction: z.ZodEnum<typeof import("..").ScoreDirection>;
                 points: z.ZodNumber;
+                comparison: z.ZodOptional<z.ZodEnum<typeof import("..").Comparison>>;
             }, z.core.$strip>, z.ZodObject<{
                 type: z.ZodLiteral<import("..").PinchConditionType.AFTER_ROTATIONS>;
                 rotations: z.ZodNumber;
@@ -47,9 +48,11 @@ export declare const TacticsInputSchema: z.ZodObject<{
             }, z.core.$strip>, z.ZodObject<{
                 type: z.ZodLiteral<import("..").PinchConditionType.MIN_OWN_SCORE>;
                 score: z.ZodNumber;
+                comparison: z.ZodOptional<z.ZodEnum<typeof import("..").Comparison>>;
             }, z.core.$strip>, z.ZodObject<{
                 type: z.ZodLiteral<import("..").PinchConditionType.MIN_OPPONENT_SCORE>;
                 score: z.ZodNumber;
+                comparison: z.ZodOptional<z.ZodEnum<typeof import("..").Comparison>>;
             }, z.core.$strip>, z.ZodObject<{
                 type: z.ZodLiteral<import("..").PinchConditionType.PHASE>;
                 phase: z.ZodEnum<typeof import("..").MatchPhase>;
@@ -73,6 +76,7 @@ export declare const TacticsInputSchema: z.ZodObject<{
                 type: z.ZodLiteral<import("..").PinchConditionType.SCORE_DIFF>;
                 direction: z.ZodEnum<typeof import("..").ScoreDirection>;
                 points: z.ZodNumber;
+                comparison: z.ZodOptional<z.ZodEnum<typeof import("..").Comparison>>;
             }, z.core.$strip>, z.ZodObject<{
                 type: z.ZodLiteral<import("..").PinchConditionType.AFTER_ROTATIONS>;
                 rotations: z.ZodNumber;
@@ -82,9 +86,11 @@ export declare const TacticsInputSchema: z.ZodObject<{
             }, z.core.$strip>, z.ZodObject<{
                 type: z.ZodLiteral<import("..").PinchConditionType.MIN_OWN_SCORE>;
                 score: z.ZodNumber;
+                comparison: z.ZodOptional<z.ZodEnum<typeof import("..").Comparison>>;
             }, z.core.$strip>, z.ZodObject<{
                 type: z.ZodLiteral<import("..").PinchConditionType.MIN_OPPONENT_SCORE>;
                 score: z.ZodNumber;
+                comparison: z.ZodOptional<z.ZodEnum<typeof import("..").Comparison>>;
             }, z.core.$strip>, z.ZodObject<{
                 type: z.ZodLiteral<import("..").PinchConditionType.PHASE>;
                 phase: z.ZodEnum<typeof import("..").MatchPhase>;
@@ -112,6 +118,7 @@ export declare const TacticsInputSchema: z.ZodObject<{
             type: z.ZodLiteral<import("..").PinchConditionType.SCORE_DIFF>;
             direction: z.ZodEnum<typeof import("..").ScoreDirection>;
             points: z.ZodNumber;
+            comparison: z.ZodOptional<z.ZodEnum<typeof import("..").Comparison>>;
         }, z.core.$strip>, z.ZodObject<{
             type: z.ZodLiteral<import("..").PinchConditionType.AFTER_ROTATIONS>;
             rotations: z.ZodNumber;
@@ -121,9 +128,11 @@ export declare const TacticsInputSchema: z.ZodObject<{
         }, z.core.$strip>, z.ZodObject<{
             type: z.ZodLiteral<import("..").PinchConditionType.MIN_OWN_SCORE>;
             score: z.ZodNumber;
+            comparison: z.ZodOptional<z.ZodEnum<typeof import("..").Comparison>>;
         }, z.core.$strip>, z.ZodObject<{
             type: z.ZodLiteral<import("..").PinchConditionType.MIN_OPPONENT_SCORE>;
             score: z.ZodNumber;
+            comparison: z.ZodOptional<z.ZodEnum<typeof import("..").Comparison>>;
         }, z.core.$strip>, z.ZodObject<{
             type: z.ZodLiteral<import("..").PinchConditionType.PHASE>;
             phase: z.ZodEnum<typeof import("..").MatchPhase>;
@@ -147,6 +156,7 @@ export declare const TacticsInputSchema: z.ZodObject<{
             type: z.ZodLiteral<import("..").PinchConditionType.SCORE_DIFF>;
             direction: z.ZodEnum<typeof import("..").ScoreDirection>;
             points: z.ZodNumber;
+            comparison: z.ZodOptional<z.ZodEnum<typeof import("..").Comparison>>;
         }, z.core.$strip>, z.ZodObject<{
             type: z.ZodLiteral<import("..").PinchConditionType.AFTER_ROTATIONS>;
             rotations: z.ZodNumber;
@@ -156,9 +166,11 @@ export declare const TacticsInputSchema: z.ZodObject<{
         }, z.core.$strip>, z.ZodObject<{
             type: z.ZodLiteral<import("..").PinchConditionType.MIN_OWN_SCORE>;
             score: z.ZodNumber;
+            comparison: z.ZodOptional<z.ZodEnum<typeof import("..").Comparison>>;
         }, z.core.$strip>, z.ZodObject<{
             type: z.ZodLiteral<import("..").PinchConditionType.MIN_OPPONENT_SCORE>;
             score: z.ZodNumber;
+            comparison: z.ZodOptional<z.ZodEnum<typeof import("..").Comparison>>;
         }, z.core.$strip>, z.ZodObject<{
             type: z.ZodLiteral<import("..").PinchConditionType.PHASE>;
             phase: z.ZodEnum<typeof import("..").MatchPhase>;
@@ -190,6 +202,7 @@ export declare const TacticsInputSchema: z.ZodObject<{
                 type: z.ZodLiteral<import("..").PinchConditionType.SCORE_DIFF>;
                 direction: z.ZodEnum<typeof import("..").ScoreDirection>;
                 points: z.ZodNumber;
+                comparison: z.ZodOptional<z.ZodEnum<typeof import("..").Comparison>>;
             }, z.core.$strip>, z.ZodObject<{
                 type: z.ZodLiteral<import("..").PinchConditionType.AFTER_ROTATIONS>;
                 rotations: z.ZodNumber;
@@ -199,9 +212,11 @@ export declare const TacticsInputSchema: z.ZodObject<{
             }, z.core.$strip>, z.ZodObject<{
                 type: z.ZodLiteral<import("..").PinchConditionType.MIN_OWN_SCORE>;
                 score: z.ZodNumber;
+                comparison: z.ZodOptional<z.ZodEnum<typeof import("..").Comparison>>;
             }, z.core.$strip>, z.ZodObject<{
                 type: z.ZodLiteral<import("..").PinchConditionType.MIN_OPPONENT_SCORE>;
                 score: z.ZodNumber;
+                comparison: z.ZodOptional<z.ZodEnum<typeof import("..").Comparison>>;
             }, z.core.$strip>, z.ZodObject<{
                 type: z.ZodLiteral<import("..").PinchConditionType.PHASE>;
                 phase: z.ZodEnum<typeof import("..").MatchPhase>;
@@ -228,6 +243,7 @@ export declare const TacticsInputSchema: z.ZodObject<{
             type: z.ZodLiteral<import("..").PinchConditionType.SCORE_DIFF>;
             direction: z.ZodEnum<typeof import("..").ScoreDirection>;
             points: z.ZodNumber;
+            comparison: z.ZodOptional<z.ZodEnum<typeof import("..").Comparison>>;
         }, z.core.$strip>, z.ZodObject<{
             type: z.ZodLiteral<import("..").PinchConditionType.AFTER_ROTATIONS>;
             rotations: z.ZodNumber;
@@ -237,9 +253,11 @@ export declare const TacticsInputSchema: z.ZodObject<{
         }, z.core.$strip>, z.ZodObject<{
             type: z.ZodLiteral<import("..").PinchConditionType.MIN_OWN_SCORE>;
             score: z.ZodNumber;
+            comparison: z.ZodOptional<z.ZodEnum<typeof import("..").Comparison>>;
         }, z.core.$strip>, z.ZodObject<{
             type: z.ZodLiteral<import("..").PinchConditionType.MIN_OPPONENT_SCORE>;
             score: z.ZodNumber;
+            comparison: z.ZodOptional<z.ZodEnum<typeof import("..").Comparison>>;
         }, z.core.$strip>, z.ZodObject<{
             type: z.ZodLiteral<import("..").PinchConditionType.PHASE>;
             phase: z.ZodEnum<typeof import("..").MatchPhase>;