volleyballsimtypes 0.0.477 → 0.0.479

package/dist/esm/src/service/notification/payloads.d.ts

@@ -0,0 +1,34 @@
+export interface MatchResultTeam {
+    id?: string;
+    name?: string;
+}
+export interface MatchResultPayload {
+    matchId?: string;
+    homeTeam?: MatchResultTeam;
+    awayTeam?: MatchResultTeam;
+    result?: 'WIN' | 'LOSS';
+    side?: 'HOME' | 'AWAY';
+}
+export interface InjuryPayload {
+    playerId?: string;
+    playerName?: string;
+    playerNickname?: string;
+    teamId?: string;
+    matchId?: string;
+}
+export interface InjuryRecoveredPayload {
+    playerId?: string;
+    playerName?: string;
+    playerNickname?: string;
+    teamId?: string;
+}
+export interface SeasonEndPayload {
+    competitionId?: string;
+    leagueId?: string;
+    position?: number;
+}
+export interface PromotionPayload {
+    teamId?: string;
+    amount?: number;
+}
+export type NotificationPayload = MatchResultPayload | InjuryPayload | InjuryRecoveredPayload | SeasonEndPayload | PromotionPayload | Record<string, unknown>;

package/dist/esm/src/service/notification/payloads.js

@@ -0,0 +1,4 @@
+// Typed payload shapes per notification type, for call-site safety in the Sim/API. The DB `Notification.payload`
+// column is jsonb (free-form), so the registry reads payloads defensively (Record<string, unknown>); these
+// interfaces document the intended shape and can be used by emitters when constructing the payload.
+export {};

package/dist/esm/src/service/notification/registry.d.ts

@@ -0,0 +1,13 @@
+import { type NotificationType } from './notification-type';
+export type CatalogKeyResolver = string | ((payload: Record<string, unknown>) => string);
+export interface NotificationDescriptor {
+    emitsPush: boolean;
+    deepLink?: (payload: Record<string, unknown>) => string;
+    pushTitleKey?: CatalogKeyResolver;
+    pushBodyKey?: CatalogKeyResolver;
+    inAppMessageKey?: CatalogKeyResolver;
+    richRender?: NotificationType;
+    params?: (payload: Record<string, unknown>) => Record<string, string>;
+    catalogKeys: string[];
+}
+export declare const NOTIFICATION_REGISTRY: Record<NotificationType, NotificationDescriptor>;

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

@@ -0,0 +1,109 @@
+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';
+}
+export const 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/esm/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/esm/src/service/notification/render.js

@@ -0,0 +1,58 @@
+import { DEFAULT_NOTIFICATION_LOCALE } from './notification-type';
+import { NOTIFICATION_REGISTRY } from './registry';
+import { NOTIFICATION_CATALOG } from './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(NOTIFICATION_CATALOG[locale], dotKey) ??
+        readNested(NOTIFICATION_CATALOG[DEFAULT_NOTIFICATION_LOCALE], dotKey) ??
+        dotKey;
+}
+function resolveKey(resolver, payload) {
+    if (resolver == null)
+        return undefined;
+    return typeof resolver === 'function' ? resolver(payload) : resolver;
+}
+export 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.
+export 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).
+export function renderPush(type, payload, locale) {
+    const buildData = (path) => ({ type, payload: JSON.stringify(payload), path });
+    const descriptor = 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.
+export function notificationPath(type, payload) {
+    return NOTIFICATION_REGISTRY[type]?.deepLink?.(payload) ?? '/';
+}

package/dist/esm/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/esm/src/service/team/pinch-condition.js

@@ -31,3 +31,12 @@ export var ScoreDirection;
     ScoreDirection["TRAILING"] = "TRAILING";
     ScoreDirection["LEADING"] = "LEADING";
 })(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").
+export var Comparison;
+(function (Comparison) {
+    Comparison["AT_LEAST"] = "AT_LEAST";
+    Comparison["AT_MOST"] = "AT_MOST";
+})(Comparison || (Comparison = {}));

package/dist/esm/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/esm/src/service/team/schemas/designated-sub.z.js

@@ -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';
 const playerInstanceSchema = z.custom((v) => v instanceof Player, {
     message: 'INVALID_PLAYER_INSTANCE'
 });
@@ -10,11 +10,13 @@ export const PinchConditionSchema = z.discriminatedUnion('type', [
     z.object({ type: z.literal(PinchConditionType.ASAP) }),
     z.object({ type: z.literal(PinchConditionType.TEAM_SET_POINT), margin: z.number().int().min(1).max(25), opponent: z.nativeEnum(OpponentRelation) }),
     z.object({ type: z.literal(PinchConditionType.OPPONENT_SET_POINT), margin: z.number().int().min(1).max(25) }),
-    z.object({ type: z.literal(PinchConditionType.SCORE_DIFF), direction: z.nativeEnum(ScoreDirection), points: 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.
+    z.object({ type: z.literal(PinchConditionType.SCORE_DIFF), direction: z.nativeEnum(ScoreDirection), points: z.number().int().min(1).max(25), comparison: z.nativeEnum(Comparison).optional() }),
     z.object({ type: z.literal(PinchConditionType.AFTER_ROTATIONS), rotations: z.number().int().min(1).max(6) }),
     z.object({ type: z.literal(PinchConditionType.FROM_SET), set: z.number().int().min(1).max(5) }),
-    z.object({ type: z.literal(PinchConditionType.MIN_OWN_SCORE), score: z.number().int().min(0).max(40) }),
-    z.object({ type: z.literal(PinchConditionType.MIN_OPPONENT_SCORE), score: z.number().int().min(0).max(40) }),
+    z.object({ type: z.literal(PinchConditionType.MIN_OWN_SCORE), score: z.number().int().min(0).max(40), comparison: z.nativeEnum(Comparison).optional() }),
+    z.object({ type: z.literal(PinchConditionType.MIN_OPPONENT_SCORE), score: z.number().int().min(0).max(40), comparison: z.nativeEnum(Comparison).optional() }),
     // PHASE is used by the libero deployment rule (which reuses this schema); pinch servers never offer it.
     z.object({ type: z.literal(PinchConditionType.PHASE), phase: z.nativeEnum(MatchPhase) })
 ]);

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

@@ -1,7 +1,7 @@
 import { describe, it, expect } from '@jest/globals';
 import { ConditionLogicSchema, DesignatedSubSchema, PinchConditionSchema, SubBandSchema } from './designated-sub.z';
 import { EnergyBand } from '../energy-band';
-import { OpponentRelation, PinchConditionType, ScoreDirection } from '../pinch-condition';
+import { Comparison, OpponentRelation, PinchConditionType, ScoreDirection } from '../pinch-condition';
 import { makeCountry, makePlayer } from '../../test-helpers';
 describe('SubBandSchema', () => {
     it('accepts every energy band and NEVER', () => {
@@ -57,6 +57,16 @@ describe('PinchConditionSchema', () => {
     it('rejects a non-integer numeric field', () => {
         expect(PinchConditionSchema.safeParse({ type: PinchConditionType.FROM_SET, set: 2.5 }).success).toBe(false);
     });
+    it('accepts an optional comparison (Or more / Or less) on the numeric-threshold conditions', () => {
+        expect(PinchConditionSchema.safeParse({ type: PinchConditionType.SCORE_DIFF, direction: ScoreDirection.LEADING, points: 2, comparison: Comparison.AT_MOST }).success).toBe(true);
+        expect(PinchConditionSchema.safeParse({ type: PinchConditionType.MIN_OWN_SCORE, score: 20, comparison: Comparison.AT_MOST }).success).toBe(true);
+        expect(PinchConditionSchema.safeParse({ type: PinchConditionType.MIN_OPPONENT_SCORE, score: 20, comparison: Comparison.AT_LEAST }).success).toBe(true);
+        // absent comparison stays valid (defaults to AT_LEAST at eval time)
+        expect(PinchConditionSchema.safeParse({ type: PinchConditionType.SCORE_DIFF, direction: ScoreDirection.LEADING, points: 2 }).success).toBe(true);
+    });
+    it('rejects an invalid comparison value', () => {
+        expect(PinchConditionSchema.safeParse({ type: PinchConditionType.MIN_OWN_SCORE, score: 20, comparison: 'EXACTLY' }).success).toBe(false);
+    });
 });
 describe('DesignatedSubSchema', () => {
     const country = makeCountry();

package/dist/esm/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>;