@dgpholdings/greatoak-shared 1.2.86 → 1.2.87

package/dist/utils/constellation/stars/lowerBody.js

@@ -0,0 +1,30 @@
+"use strict";
+// utils/constellation/stars/lowerBody.ts — Lower Body Star
+/**
+ * ============================================================================
+ * FITFRIX CONSTELLATION — Lower Body Star
+ * ============================================================================
+ *
+ * Lower-body strength across squat, lunge, and hinge patterns combined, any
+ * equipment. Squats, goblet squats, leg press, lunges, deadlifts, RDLs, hip
+ * thrusts, kettlebell swings — all count. Best load across all three lights it.
+ * (Knee-vs-hip balance nuance deferred to the future goal layer.)
+ *
+ * Threshold per level from STRENGTH_THRESHOLDS.lowerBody, resolved by sex.
+ * Leg press is NOT special-cased — it is simply a squat-pattern exercise.
+ * Bodyweight lower-body work loads via the exercise's weightMultiplier, so home
+ * users can reach the threshold honestly.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lowerBodyStar = void 0;
+const strengthStarHelpers_1 = require("../strengthStarHelpers");
+const LOWER_BODY_PATTERNS = ["squat", "lunge", "hinge"];
+exports.lowerBodyStar = {
+    id: "lowerBody",
+    displayName: { translationKey: "constellation.lowerBody.name" },
+    color: "#40b060", // earth green — the foundation everything sits on
+    figurePosition: "base",
+    objective: { translationKey: "constellation.lowerBody.objective" },
+    rationale: { translationKey: "constellation.lowerBody.rationale" },
+    evaluate: (ctx) => (0, strengthStarHelpers_1.evaluateStrengthStar)(ctx, "lowerBody", LOWER_BODY_PATTERNS, "constellation.lowerBody"),
+};

package/dist/utils/constellation/stars/pull.d.ts

@@ -0,0 +1,11 @@
+/**
+ * ============================================================================
+ * FITFRIX CONSTELLATION — Pull Star
+ * ============================================================================
+ *
+ * Pulling strength across all pull-pattern exercises (horizontal + vertical),
+ * any equipment. Rows, cable rows, lat pulldowns, pull-ups, chin-ups — all count.
+ * Threshold per level from STRENGTH_THRESHOLDS.pull, resolved by sex.
+ */
+import type { TStarDefinition } from "../types";
+export declare const pullStar: TStarDefinition;

package/dist/utils/constellation/stars/pull.js

@@ -0,0 +1,24 @@
+"use strict";
+// utils/constellation/stars/pull.ts — Pull Star
+/**
+ * ============================================================================
+ * FITFRIX CONSTELLATION — Pull Star
+ * ============================================================================
+ *
+ * Pulling strength across all pull-pattern exercises (horizontal + vertical),
+ * any equipment. Rows, cable rows, lat pulldowns, pull-ups, chin-ups — all count.
+ * Threshold per level from STRENGTH_THRESHOLDS.pull, resolved by sex.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pullStar = void 0;
+const strengthStarHelpers_1 = require("../strengthStarHelpers");
+const PULL_PATTERNS = ["pull_horizontal", "pull_vertical"];
+exports.pullStar = {
+    id: "pull",
+    displayName: { translationKey: "constellation.pull.name" },
+    color: "#2060ff", // cool blue — drawing resistance in
+    figurePosition: "rightArm",
+    objective: { translationKey: "constellation.pull.objective" },
+    rationale: { translationKey: "constellation.pull.rationale" },
+    evaluate: (ctx) => (0, strengthStarHelpers_1.evaluateStrengthStar)(ctx, "pull", PULL_PATTERNS, "constellation.pull"),
+};

package/dist/utils/constellation/stars/push.d.ts

@@ -0,0 +1,11 @@
+/**
+ * ============================================================================
+ * FITFRIX CONSTELLATION — Push Star
+ * ============================================================================
+ *
+ * Pushing strength across all push-pattern exercises (horizontal + vertical),
+ * any equipment. Bench, machine press, push-ups, overhead press — all count.
+ * Threshold per level from STRENGTH_THRESHOLDS.push, resolved by sex.
+ */
+import type { TStarDefinition } from "../types";
+export declare const pushStar: TStarDefinition;

package/dist/utils/constellation/stars/push.js

@@ -0,0 +1,24 @@
+"use strict";
+// utils/constellation/stars/push.ts — Push Star
+/**
+ * ============================================================================
+ * FITFRIX CONSTELLATION — Push Star
+ * ============================================================================
+ *
+ * Pushing strength across all push-pattern exercises (horizontal + vertical),
+ * any equipment. Bench, machine press, push-ups, overhead press — all count.
+ * Threshold per level from STRENGTH_THRESHOLDS.push, resolved by sex.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pushStar = void 0;
+const strengthStarHelpers_1 = require("../strengthStarHelpers");
+const PUSH_PATTERNS = ["push_horizontal", "push_vertical"];
+exports.pushStar = {
+    id: "push",
+    displayName: { translationKey: "constellation.push.name" },
+    color: "#ff4820", // warm red — forward force
+    figurePosition: "leftArm",
+    objective: { translationKey: "constellation.push.objective" },
+    rationale: { translationKey: "constellation.push.rationale" },
+    evaluate: (ctx) => (0, strengthStarHelpers_1.evaluateStrengthStar)(ctx, "push", PUSH_PATTERNS, "constellation.push"),
+};

package/dist/utils/constellation/stars/quality.d.ts

@@ -0,0 +1,19 @@
+/**
+ * ============================================================================
+ * FITFRIX CONSTELLATION — Quality Star (the core)
+ * ============================================================================
+ *
+ * Execution quality. Brightness reflects how many of the user's recent sessions
+ * were executed well. Reads PRE-SCORED sessions from context (the orchestrator
+ * scores once); this star never calls the scoring engine itself.
+ *
+ * Session quality  = simple average of its exercises' quality scores (0-100).
+ * Star brightness  = count-based: of the last N sessions, how many cleared the
+ *                    quality bar, scaled toward a target count. Count-based (not
+ *                    a consecutive streak) so a single off day never zeroes the
+ *                    star — inviting, not punishing.
+ *
+ * Thresholds come from QUALITY_THRESHOLDS[level].
+ */
+import type { TStarDefinition } from "../types";
+export declare const qualityStar: TStarDefinition;

package/dist/utils/constellation/stars/quality.js

@@ -0,0 +1,98 @@
+"use strict";
+// utils/constellation/stars/quality.ts — Quality Star (the core)
+/**
+ * ============================================================================
+ * FITFRIX CONSTELLATION — Quality Star (the core)
+ * ============================================================================
+ *
+ * Execution quality. Brightness reflects how many of the user's recent sessions
+ * were executed well. Reads PRE-SCORED sessions from context (the orchestrator
+ * scores once); this star never calls the scoring engine itself.
+ *
+ * Session quality  = simple average of its exercises' quality scores (0-100).
+ * Star brightness  = count-based: of the last N sessions, how many cleared the
+ *                    quality bar, scaled toward a target count. Count-based (not
+ *                    a consecutive streak) so a single off day never zeroes the
+ *                    star — inviting, not punishing.
+ *
+ * Thresholds come from QUALITY_THRESHOLDS[level].
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.qualityStar = void 0;
+const levelThresholds_1 = require("../levelThresholds");
+// --- Session quality --------------------------------------------------------
+/**
+ * Average score across a scored session's scorable exercises. Returns null if
+ * the session has no scorable exercises (all missing/unscorable).
+ */
+function sessionQuality(session) {
+    const scores = [];
+    for (const ex of session.exercises) {
+        if (typeof ex.score === "number")
+            scores.push(ex.score);
+    }
+    if (scores.length === 0)
+        return null;
+    return scores.reduce((s, v) => s + v, 0) / scores.length;
+}
+// --- Detail builders --------------------------------------------------------
+function clearingMeasure(clearing, target) {
+    return {
+        value: clearing,
+        unit: "sessions",
+        display: {
+            translationKey: "constellation.quality.measure.clearing",
+            params: [Math.min(clearing, target), target],
+        },
+    };
+}
+function buildGap(clearing, considered, target, bar) {
+    if (considered === 0) {
+        return { translationKey: "constellation.quality.gap.noData" };
+    }
+    if (clearing >= target) {
+        return { translationKey: "constellation.quality.gap.full" };
+    }
+    return {
+        translationKey: "constellation.quality.gap.moreQuality",
+        params: [target - clearing, bar],
+    };
+}
+// --- Evaluator --------------------------------------------------------------
+function evaluateQuality(ctx) {
+    const { bar, windowSessions, targetClearing } = levelThresholds_1.QUALITY_THRESHOLDS[ctx.level];
+    // Most recent N scored sessions (descending by date). Future sessions were
+    // already excluded by the orchestrator when scoring.
+    const recent = [...ctx.scoredSessions]
+        .sort((a, b) => b.date - a.date)
+        .slice(0, windowSessions);
+    let clearing = 0;
+    let considered = 0;
+    for (const session of recent) {
+        const q = sessionQuality(session);
+        if (q === null)
+            continue; // unscorable session counts neither way
+        considered++;
+        if (q >= bar)
+            clearing++;
+    }
+    const brightness = Math.min(100, (clearing / targetClearing) * 100);
+    return {
+        brightness,
+        detail: {
+            currentState: clearingMeasure(clearing, targetClearing),
+            target: clearingMeasure(targetClearing, targetClearing),
+            gap: buildGap(clearing, considered, targetClearing, bar),
+        },
+    };
+}
+// --- Definition -------------------------------------------------------------
+exports.qualityStar = {
+    id: "quality",
+    displayName: { translationKey: "constellation.quality.name" },
+    color: "#00c4b4", // teal — precision, cool focus
+    figurePosition: "core",
+    objective: { translationKey: "constellation.quality.objective" },
+    rationale: { translationKey: "constellation.quality.rationale" },
+    evaluate: evaluateQuality,
+};

package/dist/utils/constellation/stars/recovery.d.ts

@@ -0,0 +1,29 @@
+/**
+ * ============================================================================
+ * FITFRIX CONSTELLATION — Recovery Star (the crown)
+ * ============================================================================
+ *
+ * Recovery intelligence: does the user let trained muscles fully recover, not
+ * just grind through fatigue? Brightness reflects how many RECOVERY CYCLES the
+ * user achieved in the trailing window.
+ *
+ * ZONE-BASED (not all-or-nothing). The body is split into three independent
+ * recovery zones — upper, lower, core. A split-routine lifter (e.g. Push/Pull/
+ * Legs) almost never has the WHOLE body fresh at once, yet is recovering
+ * intelligently zone by zone; an all-muscles-at-once rule would wrongly score
+ * them near zero. So we count cycles PER ZONE.
+ *
+ * A zone "cycle" = a transition where that zone goes fatigued -> recovered
+ * (a multi-day rest counts once). Crucially, a zone only earns cycles if the
+ * user actually TRAINS it in the window — an untrained zone is "always fresh"
+ * and must not hand out free recovery credit. Total cycles = sum across the
+ * zones the user trains, capped at the level target.
+ *
+ * Reads PRE-SCORED sessions from context (orchestrator scores once); builds the
+ * enriched history the fatigue model consumes, then replays the model across
+ * each day of the window. This star never calls the scoring engine itself.
+ *
+ * Thresholds come from RECOVERY_THRESHOLDS[level].
+ */
+import type { TStarDefinition } from "../types";
+export declare const recoveryStar: TStarDefinition;

package/dist/utils/constellation/stars/recovery.js

@@ -0,0 +1,169 @@
+"use strict";
+// utils/constellation/stars/recovery.ts — Recovery Star (the crown)
+/**
+ * ============================================================================
+ * FITFRIX CONSTELLATION — Recovery Star (the crown)
+ * ============================================================================
+ *
+ * Recovery intelligence: does the user let trained muscles fully recover, not
+ * just grind through fatigue? Brightness reflects how many RECOVERY CYCLES the
+ * user achieved in the trailing window.
+ *
+ * ZONE-BASED (not all-or-nothing). The body is split into three independent
+ * recovery zones — upper, lower, core. A split-routine lifter (e.g. Push/Pull/
+ * Legs) almost never has the WHOLE body fresh at once, yet is recovering
+ * intelligently zone by zone; an all-muscles-at-once rule would wrongly score
+ * them near zero. So we count cycles PER ZONE.
+ *
+ * A zone "cycle" = a transition where that zone goes fatigued -> recovered
+ * (a multi-day rest counts once). Crucially, a zone only earns cycles if the
+ * user actually TRAINS it in the window — an untrained zone is "always fresh"
+ * and must not hand out free recovery credit. Total cycles = sum across the
+ * zones the user trains, capped at the level target.
+ *
+ * Reads PRE-SCORED sessions from context (orchestrator scores once); builds the
+ * enriched history the fatigue model consumes, then replays the model across
+ * each day of the window. This star never calls the scoring engine itself.
+ *
+ * Thresholds come from RECOVERY_THRESHOLDS[level].
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recoveryStar = void 0;
+const computeMuscleFatigueMap_1 = require("../../scoringWorkout/computeMuscleFatigueMap");
+const levelThresholds_1 = require("../levelThresholds");
+const MS_PER_DAY = 24 * 60 * 60 * 1000;
+/**
+ * Recovery zones — independent regions that recover on their own clocks. Each
+ * lists the major muscle keys that define it. A zone is "recovered" on a given
+ * day when ALL of its listed muscles are below the fatigue threshold (or carry
+ * no tracked fatigue).
+ */
+const RECOVERY_ZONES = {
+    upper: [
+        "pectoralis-major",
+        "latissimus-dorsi",
+        "deltoids-anterior",
+        "tricep-brachii-long",
+    ],
+    lower: ["quadriceps", "hamstrings", "glutes-maximus"],
+    core: ["abs-upper", "abs-lower", "obliques"],
+};
+const ZONE_NAMES = Object.keys(RECOVERY_ZONES);
+// --- Enriched history (feed for the fatigue map) ----------------------------
+/**
+ * Turn the orchestrator's pre-scored sessions into the fatigue model's inputs.
+ * Also records which zones the user actually trained (any tracked fatigue in a
+ * zone's muscles at any point), so untrained zones earn no recovery credit.
+ */
+function buildEnrichedHistory(ctx) {
+    var _a;
+    var _b;
+    const exercises = {};
+    const byExercise = {};
+    const trainedMuscles = new Set();
+    for (const session of ctx.scoredSessions) {
+        for (const ex of session.exercises) {
+            if (ex.score === null)
+                continue;
+            const exercise = ctx.exerciseCatalog[ex.exerciseId];
+            if (!exercise)
+                continue;
+            if (!exercises[ex.exerciseId]) {
+                exercises[ex.exerciseId] = {
+                    primaryMuscles: exercise.primaryMuscles,
+                    secondaryMuscles: exercise.secondaryMuscles,
+                };
+            }
+            for (const m of exercise.primaryMuscles)
+                trainedMuscles.add(m);
+            for (const m of exercise.secondaryMuscles)
+                trainedMuscles.add(m);
+            ((_a = byExercise[_b = ex.exerciseId]) !== null && _a !== void 0 ? _a : (byExercise[_b] = [])).push({
+                score: ex.score,
+                recordDate: session.date,
+                muscleScores: ex.muscleScores,
+            });
+        }
+    }
+    const scoreHistory = Object.entries(byExercise).map(([exerciseId, recordScore]) => ({ exerciseId, recordScore }));
+    // A zone is "trained" if the user touched any of its muscles in the window.
+    const trainedZones = new Set();
+    for (const zone of ZONE_NAMES) {
+        if (RECOVERY_ZONES[zone].some((m) => trainedMuscles.has(m))) {
+            trainedZones.add(zone);
+        }
+    }
+    return { exercises, scoreHistory, trainedZones };
+}
+/** Is a single zone recovered (all its muscles below threshold) on a day's map? */
+function isZoneRecovered(zone, fatigueMap, recoveredBelow) {
+    for (const muscle of RECOVERY_ZONES[zone]) {
+        const entry = fatigueMap[muscle];
+        if (entry && entry.fatigue >= recoveredBelow)
+            return false;
+    }
+    return true;
+}
+// --- Detail builders --------------------------------------------------------
+function cyclesMeasure(cycles, target) {
+    return {
+        value: cycles,
+        unit: "cycles",
+        display: {
+            translationKey: "constellation.recovery.measure.cycles",
+            params: [Math.min(cycles, target), target],
+        },
+    };
+}
+function buildGap(cycles, target, hasHistory) {
+    if (!hasHistory)
+        return { translationKey: "constellation.recovery.gap.noData" };
+    if (cycles >= target)
+        return { translationKey: "constellation.recovery.gap.full" };
+    return {
+        translationKey: "constellation.recovery.gap.moreCycles",
+        params: [target - cycles],
+    };
+}
+// --- Evaluator --------------------------------------------------------------
+function evaluateRecovery(ctx) {
+    const { targetCycles, windowDays, recoveredBelow } = levelThresholds_1.RECOVERY_THRESHOLDS[ctx.level];
+    const { exercises, scoreHistory, trainedZones } = buildEnrichedHistory(ctx);
+    const hasHistory = scoreHistory.length > 0;
+    const startDay = Math.floor((ctx.now - windowDays * MS_PER_DAY) / MS_PER_DAY);
+    const endDay = Math.floor(ctx.now / MS_PER_DAY);
+    // Per-zone cycle counting. Only zones the user trains can earn cycles.
+    // Seed each trained zone as "recovered" (pre-window baseline = fresh), so the
+    // first cycle is only credited after the zone has actually been fatigued.
+    let totalCycles = 0;
+    for (const zone of trainedZones) {
+        let wasRecovered = true;
+        for (let d = startDay; d <= endDay; d++) {
+            const dayDate = new Date(d * MS_PER_DAY + MS_PER_DAY / 2); // midday
+            const map = (0, computeMuscleFatigueMap_1.computeMuscleFatigueMap)(exercises, scoreHistory, ctx.user, dayDate);
+            const recovered = isZoneRecovered(zone, map, recoveredBelow);
+            if (recovered && !wasRecovered)
+                totalCycles++;
+            wasRecovered = recovered;
+        }
+    }
+    const brightness = Math.min(100, (totalCycles / targetCycles) * 100);
+    return {
+        brightness,
+        detail: {
+            currentState: cyclesMeasure(totalCycles, targetCycles),
+            target: cyclesMeasure(targetCycles, targetCycles),
+            gap: buildGap(totalCycles, targetCycles, hasHistory),
+        },
+    };
+}
+// --- Definition -------------------------------------------------------------
+exports.recoveryStar = {
+    id: "recovery",
+    displayName: { translationKey: "constellation.recovery.name" },
+    color: "#c8d8ff", // silver-white — moonlight, the quiet phase
+    figurePosition: "crown",
+    objective: { translationKey: "constellation.recovery.objective" },
+    rationale: { translationKey: "constellation.recovery.rationale" },
+    evaluate: evaluateRecovery,
+};

package/dist/utils/constellation/strengthStarHelpers.d.ts

@@ -0,0 +1,41 @@
+/**
+ * ============================================================================
+ * FITFRIX CONSTELLATION — Strength Star Helpers
+ * ============================================================================
+ *
+ * Shared by the three strength stars (push, pull, lowerBody). Each star is a
+ * thin definition that names its movement patterns and its threshold key; this
+ * helper does the rest: filter the catalog to those patterns, compute the
+ * normalised load, and turn the ratio into brightness + i18n detail.
+ *
+ * Thresholds come from STRENGTH_THRESHOLDS[key][level], resolved by sex.
+ */
+import type { TUserMetric } from "../../types";
+import { type ISexThreshold } from "./levelThresholds";
+import type { TStarContext, TStarEvaluation, TLocalizedText } from "./types";
+/** Rolling window for strength PRs: 8 weeks. */
+export declare const STRENGTH_WINDOW_DAYS = 56;
+/** Resolve the threshold ratio for this user. unmentioned -> male (higher bar). */
+export declare function resolveThreshold(threshold: ISexThreshold, gender: string | undefined): number;
+/** User bodyweight with fallback. */
+export declare function userBodyweight(user: Partial<TUserMetric>): number;
+/**
+ * Brightness from current ratio vs threshold, graded & continuous.
+ *   brightness = (currentRatio / thresholdRatio) * 100, capped at 100.
+ * Faint from the first rep; full at threshold. No wall.
+ */
+export declare function ratioToBrightness(currentRatio: number, thresholdRatio: number): number;
+/**
+ * Build the "what's missing" gap text. At/above threshold -> a "full" message;
+ * otherwise the remaining kg on the user's best lift to reach the threshold.
+ */
+export declare function buildGap(gapKeyPrefix: string, currentRatio: number, thresholdRatio: number, bodyweightKg: number): TLocalizedText;
+/**
+ * The full strength-star evaluation, shared by push/pull/lowerBody.
+ *
+ * @param ctx               star context (sessions, catalog, user, now, level)
+ * @param strengthKey       which STRENGTH_THRESHOLDS row to use ("push" | "pull" | "lowerBody")
+ * @param matchingPatterns  movement patterns this star counts
+ * @param gapKeyPrefix      translation-key prefix (e.g. "constellation.push")
+ */
+export declare function evaluateStrengthStar(ctx: TStarContext, strengthKey: "push" | "pull" | "lowerBody", matchingPatterns: string[], gapKeyPrefix: string): TStarEvaluation;

package/dist/utils/constellation/strengthStarHelpers.js

@@ -0,0 +1,104 @@
+"use strict";
+// utils/constellation/strengthStarHelpers.ts — Strength Star Helpers
+/**
+ * ============================================================================
+ * FITFRIX CONSTELLATION — Strength Star Helpers
+ * ============================================================================
+ *
+ * Shared by the three strength stars (push, pull, lowerBody). Each star is a
+ * thin definition that names its movement patterns and its threshold key; this
+ * helper does the rest: filter the catalog to those patterns, compute the
+ * normalised load, and turn the ratio into brightness + i18n detail.
+ *
+ * Thresholds come from STRENGTH_THRESHOLDS[key][level], resolved by sex.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STRENGTH_WINDOW_DAYS = void 0;
+exports.resolveThreshold = resolveThreshold;
+exports.userBodyweight = userBodyweight;
+exports.ratioToBrightness = ratioToBrightness;
+exports.buildGap = buildGap;
+exports.evaluateStrengthStar = evaluateStrengthStar;
+const computeNormalisedLoad_1 = require("./computeNormalisedLoad");
+const levelThresholds_1 = require("./levelThresholds");
+/** Rolling window for strength PRs: 8 weeks. */
+exports.STRENGTH_WINDOW_DAYS = 56;
+const MS_PER_DAY = 24 * 60 * 60 * 1000;
+const DEFAULT_BODYWEIGHT_KG = 70;
+/** Resolve the threshold ratio for this user. unmentioned -> male (higher bar). */
+function resolveThreshold(threshold, gender) {
+    return gender === "female" ? threshold.female : threshold.male;
+}
+/** User bodyweight with fallback. */
+function userBodyweight(user) {
+    const bw = user.weightKg;
+    return bw && bw > 0 ? bw : DEFAULT_BODYWEIGHT_KG;
+}
+/**
+ * Brightness from current ratio vs threshold, graded & continuous.
+ *   brightness = (currentRatio / thresholdRatio) * 100, capped at 100.
+ * Faint from the first rep; full at threshold. No wall.
+ */
+function ratioToBrightness(currentRatio, thresholdRatio) {
+    if (thresholdRatio <= 0)
+        return 0;
+    return Math.min(100, (currentRatio / thresholdRatio) * 100);
+}
+/** Build a bodyweight-ratio measure for the detail panel. */
+function bwRatioMeasure(ratio) {
+    const rounded = Math.round(ratio * 100) / 100;
+    return {
+        value: rounded,
+        unit: "bw_ratio",
+        display: {
+            translationKey: "constellation.measure.bwRatio",
+            params: [rounded],
+        },
+    };
+}
+/**
+ * Build the "what's missing" gap text. At/above threshold -> a "full" message;
+ * otherwise the remaining kg on the user's best lift to reach the threshold.
+ */
+function buildGap(gapKeyPrefix, currentRatio, thresholdRatio, bodyweightKg) {
+    if (currentRatio >= thresholdRatio) {
+        return { translationKey: `${gapKeyPrefix}.gap.full` };
+    }
+    const remainingKg = Math.max(0, Math.round((thresholdRatio - currentRatio) * bodyweightKg));
+    return {
+        translationKey: `${gapKeyPrefix}.gap.toGo`,
+        params: [remainingKg],
+    };
+}
+/**
+ * The full strength-star evaluation, shared by push/pull/lowerBody.
+ *
+ * @param ctx               star context (sessions, catalog, user, now, level)
+ * @param strengthKey       which STRENGTH_THRESHOLDS row to use ("push" | "pull" | "lowerBody")
+ * @param matchingPatterns  movement patterns this star counts
+ * @param gapKeyPrefix      translation-key prefix (e.g. "constellation.push")
+ */
+function evaluateStrengthStar(ctx, strengthKey, matchingPatterns, gapKeyPrefix) {
+    const bw = userBodyweight(ctx.user);
+    const gender = ctx.user.gender;
+    const thresholdRatio = resolveThreshold(levelThresholds_1.STRENGTH_THRESHOLDS[strengthKey][ctx.level], gender);
+    // Build the matching-exercise id set from the catalog by movement pattern.
+    const patternSet = new Set(matchingPatterns);
+    const matchingIds = new Set();
+    for (const id of Object.keys(ctx.exerciseCatalog)) {
+        const ex = ctx.exerciseCatalog[id];
+        if (patternSet.has(ex.movementPattern))
+            matchingIds.add(id);
+    }
+    const windowStart = ctx.now - exports.STRENGTH_WINDOW_DAYS * MS_PER_DAY;
+    const load = (0, computeNormalisedLoad_1.computeNormalisedLoad)(matchingIds, ctx.sessions, ctx.exerciseCatalog, bw, gender, windowStart, ctx.now);
+    const brightness = ratioToBrightness(load.ratio, thresholdRatio);
+    return {
+        brightness,
+        detail: {
+            currentState: bwRatioMeasure(load.ratio),
+            target: bwRatioMeasure(thresholdRatio),
+            gap: buildGap(gapKeyPrefix, load.ratio, thresholdRatio, bw),
+        },
+    };
+}