@dgpholdings/greatoak-shared 1.2.87 → 1.2.89

package/dist/utils/constellation/computeNormalisedLoad.test.js

@@ -0,0 +1,218 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// shared/src/utils/constellation/computeNormalisedLoad.test.ts
+const computeNormalisedLoad_1 = require("./computeNormalisedLoad");
+const vitest_1 = require("vitest");
+const NOW = Date.UTC(2026, 5, 1);
+const day = (d) => NOW - d * 86400000;
+const wr = (kg, reps, isDone = true) => ({ type: "weight-reps", kg, reps, isDone, isStrictMode: false });
+const ro = (reps, auxWeightKg = "0", isDone = true) => ({
+    type: "reps-only",
+    reps,
+    auxWeightKg,
+    isDone,
+    isStrictMode: false,
+});
+const ex = (over) => ({
+    exerciseId: "e",
+    name: "E",
+    primaryMuscles: [],
+    secondaryMuscles: [],
+    difficultyLevel: 3,
+    movementPattern: "push_horizontal",
+    status: "active",
+    ...over,
+});
+(0, vitest_1.describe)("estimateOneRepMax — Epley with rep cap", () => {
+    (0, vitest_1.it)("60kg x5 ≈ 70kg", () => (0, vitest_1.expect)((0, computeNormalisedLoad_1.estimateOneRepMax)(60, 5)).toBeCloseTo(70, 1));
+    (0, vitest_1.it)("70kg x1 ≈ 72.33kg", () => (0, vitest_1.expect)((0, computeNormalisedLoad_1.estimateOneRepMax)(70, 1)).toBeCloseTo(72.33, 1));
+    (0, vitest_1.it)("reps capped at 12: 50x30 == 50x12", () => (0, vitest_1.expect)((0, computeNormalisedLoad_1.estimateOneRepMax)(50, 30)).toBe((0, computeNormalisedLoad_1.estimateOneRepMax)(50, computeNormalisedLoad_1.EPLEY_REP_CAP)));
+    (0, vitest_1.it)("zero or negative weight → 0", () => {
+        (0, vitest_1.expect)((0, computeNormalisedLoad_1.estimateOneRepMax)(0, 5)).toBe(0);
+        (0, vitest_1.expect)((0, computeNormalisedLoad_1.estimateOneRepMax)(-10, 5)).toBe(0);
+    });
+    (0, vitest_1.it)("zero reps → 0", () => (0, vitest_1.expect)((0, computeNormalisedLoad_1.estimateOneRepMax)(60, 0)).toBe(0));
+});
+(0, vitest_1.describe)("computeNormalisedLoad — weighted sets", () => {
+    const catalog = { bench: ex({ exerciseId: "bench" }) };
+    const ids = new Set(["bench"]);
+    const sessions = [
+        {
+            date: day(2),
+            exercises: [{ exerciseId: "bench", records: [wr("60", "5")] }],
+        },
+    ];
+    (0, vitest_1.it)("best 1RM as bodyweight ratio (60x5 @80kg → ~0.875)", () => {
+        const r = (0, computeNormalisedLoad_1.computeNormalisedLoad)(ids, sessions, catalog, 80, "male", day(56), NOW);
+        (0, vitest_1.expect)(r.ratio).toBeCloseTo(0.875, 2);
+        (0, vitest_1.expect)(r.bestExerciseId).toBe("bench");
+    });
+    (0, vitest_1.it)("picks the best set across sessions", () => {
+        const multi = [
+            {
+                date: day(10),
+                exercises: [{ exerciseId: "bench", records: [wr("60", "5")] }],
+            },
+            {
+                date: day(2),
+                exercises: [{ exerciseId: "bench", records: [wr("80", "5")] }],
+            },
+        ];
+        const r = (0, computeNormalisedLoad_1.computeNormalisedLoad)(ids, multi, catalog, 80, "male", day(56), NOW);
+        (0, vitest_1.expect)(r.bestOneRepMaxKg).toBeCloseTo(93.33, 1);
+    });
+    (0, vitest_1.it)("ignores sessions outside the window", () => {
+        const old = [
+            {
+                date: day(70),
+                exercises: [{ exerciseId: "bench", records: [wr("100", "5")] }],
+            },
+        ];
+        (0, vitest_1.expect)((0, computeNormalisedLoad_1.computeNormalisedLoad)(ids, old, catalog, 80, "male", day(56), NOW).ratio).toBe(0);
+    });
+    (0, vitest_1.it)("ignores non-matching exercise ids", () => {
+        const r = (0, computeNormalisedLoad_1.computeNormalisedLoad)(new Set(["other"]), sessions, catalog, 80, "male", day(56), NOW);
+        (0, vitest_1.expect)(r.ratio).toBe(0);
+    });
+    (0, vitest_1.it)("ignores incomplete sets (isDone false)", () => {
+        const undone = [
+            {
+                date: day(2),
+                exercises: [{ exerciseId: "bench", records: [wr("100", "5", false)] }],
+            },
+        ];
+        (0, vitest_1.expect)((0, computeNormalisedLoad_1.computeNormalisedLoad)(ids, undone, catalog, 80, "male", day(56), NOW)
+            .ratio).toBe(0);
+    });
+});
+(0, vitest_1.describe)("computeNormalisedLoad — unilateral doubling", () => {
+    (0, vitest_1.it)("unilateral weight is doubled for total load", () => {
+        const catalog = { uni: ex({ exerciseId: "uni", isUnilateral: true }) };
+        const sessions = [
+            {
+                date: day(2),
+                exercises: [{ exerciseId: "uni", records: [wr("30", "5")] }],
+            },
+        ];
+        // 30*2=60 → 1RM 70 → /80 = 0.875
+        const r = (0, computeNormalisedLoad_1.computeNormalisedLoad)(new Set(["uni"]), sessions, catalog, 80, "male", day(56), NOW);
+        (0, vitest_1.expect)(r.ratio).toBeCloseTo(0.875, 2);
+    });
+});
+(0, vitest_1.describe)("computeNormalisedLoad — bodyweight loading", () => {
+    (0, vitest_1.it)("uses weightMultiplier (male) for reps-only", () => {
+        const catalog = {
+            pull: ex({
+                exerciseId: "pull",
+                weightMultiplier: { male: 1.0, female: 0.95, default: 0.97 },
+            }),
+        };
+        const sessions = [
+            { date: day(2), exercises: [{ exerciseId: "pull", records: [ro("8")] }] },
+        ];
+        // load = 1.0*80 = 80; 1RM = 80*(1+8/30)=101.3; /80 = 1.27
+        const r = (0, computeNormalisedLoad_1.computeNormalisedLoad)(new Set(["pull"]), sessions, catalog, 80, "male", day(56), NOW);
+        (0, vitest_1.expect)(r.ratio).toBeCloseTo(1.27, 1);
+    });
+    (0, vitest_1.it)("falls back to bodyweightDependency when no weightMultiplier", () => {
+        const catalog = {
+            dip: ex({ exerciseId: "dip", bodyweightDependency: "high" }),
+        };
+        const sessions = [
+            { date: day(2), exercises: [{ exerciseId: "dip", records: [ro("8")] }] },
+        ];
+        // high → 0.9*80=72; 1RM=72*(1+8/30)=91.2; /80=1.14
+        const r = (0, computeNormalisedLoad_1.computeNormalisedLoad)(new Set(["dip"]), sessions, catalog, 80, "male", day(56), NOW);
+        (0, vitest_1.expect)(r.ratio).toBeCloseTo(1.14, 1);
+    });
+    (0, vitest_1.it)("added aux weight stacks on bodyweight load", () => {
+        const catalog = {
+            pull: ex({
+                exerciseId: "pull",
+                weightMultiplier: { male: 1.0, female: 0.95, default: 0.97 },
+            }),
+        };
+        const sessions = [
+            {
+                date: day(2),
+                exercises: [{ exerciseId: "pull", records: [ro("5", "20")] }],
+            },
+        ];
+        // load = 80 + 20 = 100; 1RM=100*(1+5/30)=116.7; /80=1.46
+        const r = (0, computeNormalisedLoad_1.computeNormalisedLoad)(new Set(["pull"]), sessions, catalog, 80, "male", day(56), NOW);
+        (0, vitest_1.expect)(r.ratio).toBeCloseTo(1.46, 1);
+    });
+    (0, vitest_1.it)("female weightMultiplier column is used for female users", () => {
+        const catalog = {
+            pull: ex({
+                exerciseId: "pull",
+                weightMultiplier: { male: 1.0, female: 0.5, default: 0.97 },
+            }),
+        };
+        const sessions = [
+            { date: day(2), exercises: [{ exerciseId: "pull", records: [ro("8")] }] },
+        ];
+        const male = (0, computeNormalisedLoad_1.computeNormalisedLoad)(new Set(["pull"]), sessions, catalog, 80, "male", day(56), NOW);
+        const female = (0, computeNormalisedLoad_1.computeNormalisedLoad)(new Set(["pull"]), sessions, catalog, 80, "female", day(56), NOW);
+        (0, vitest_1.expect)(female.ratio).toBeLessThan(male.ratio);
+    });
+});
+(0, vitest_1.describe)("computeNormalisedLoad — safeParseFloat guards", () => {
+    const catalog = { bench: ex({ exerciseId: "bench" }) };
+    const ids = new Set(["bench"]);
+    (0, vitest_1.it)("malformed kg → 0 load, finite ratio", () => {
+        const s = [
+            {
+                date: day(2),
+                exercises: [{ exerciseId: "bench", records: [wr("abc", "5")] }],
+            },
+        ];
+        const r = (0, computeNormalisedLoad_1.computeNormalisedLoad)(ids, s, catalog, 80, "male", day(56), NOW);
+        (0, vitest_1.expect)(Number.isFinite(r.ratio)).toBe(true);
+        (0, vitest_1.expect)(r.ratio).toBe(0);
+    });
+    (0, vitest_1.it)("negative reps → 0 load", () => {
+        const s = [
+            {
+                date: day(2),
+                exercises: [{ exerciseId: "bench", records: [wr("60", "-5")] }],
+            },
+        ];
+        (0, vitest_1.expect)((0, computeNormalisedLoad_1.computeNormalisedLoad)(ids, s, catalog, 80, "male", day(56), NOW).ratio).toBe(0);
+    });
+    (0, vitest_1.it)("zero bodyweight falls back to default (no divide-by-zero)", () => {
+        const s = [
+            {
+                date: day(2),
+                exercises: [{ exerciseId: "bench", records: [wr("60", "5")] }],
+            },
+        ];
+        const r = (0, computeNormalisedLoad_1.computeNormalisedLoad)(ids, s, catalog, 0, "male", day(56), NOW);
+        (0, vitest_1.expect)(Number.isFinite(r.ratio)).toBe(true);
+    });
+});
+(0, vitest_1.describe)("computeNormalisedLoad — non-strength record types contribute 0", () => {
+    (0, vitest_1.it)("duration set → 0", () => {
+        const catalog = { plank: ex({ exerciseId: "plank" }) };
+        const s = [
+            {
+                date: day(2),
+                exercises: [
+                    {
+                        exerciseId: "plank",
+                        records: [
+                            {
+                                type: "duration",
+                                durationMmSs: "01:00",
+                                auxWeightKg: "0",
+                                isDone: true,
+                                isStrictMode: false,
+                            },
+                        ],
+                    },
+                ],
+            },
+        ];
+        (0, vitest_1.expect)((0, computeNormalisedLoad_1.computeNormalisedLoad)(new Set(["plank"]), s, catalog, 80, "male", day(56), NOW).ratio).toBe(0);
+    });
+});

package/dist/utils/constellation/evaluateConstellation.js

@@ -78,7 +78,7 @@ function scoreAllSessions(input) {
                     muscleScores: (_a = result.muscleScores) !== null && _a !== void 0 ? _a : {},
                 });
             }
-            catch (_b) {
+            catch {
                 exercises.push({
                     exerciseId: ex.exerciseId,
                     score: null,

package/dist/utils/constellation/evaluateConstellation.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/constellation/evaluateConstellation.test.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// shared/src/utils/constellation/evaluateConstellation.test.ts
+const evaluateConstellation_1 = require("./evaluateConstellation");
+const vitest_1 = require("vitest");
+const NOW = Date.UTC(2026, 5, 1);
+const day = (d) => NOW - d * 86400000;
+const wr = (kg, reps) => ({ type: "weight-reps", kg, reps, isDone: true, isStrictMode: false });
+const catalog = {
+    bench: {
+        exerciseId: "bench",
+        name: "Bench",
+        primaryMuscles: ["pectoralis-major"],
+        secondaryMuscles: [],
+        difficultyLevel: 3,
+        movementPattern: "push_horizontal",
+        status: "active",
+    },
+};
+const baseInput = (over = {}) => ({
+    sessions: [
+        {
+            date: day(2),
+            exercises: [{ exerciseId: "bench", records: [wr("60", "5")] }],
+        },
+    ],
+    exerciseCatalog: catalog,
+    user: { weightKg: 80, gender: "male" },
+    now: NOW,
+    ...over,
+});
+(0, vitest_1.describe)("orchestrator — now guard", () => {
+    (0, vitest_1.it)("throws on NaN now", () => {
+        (0, vitest_1.expect)(() => (0, evaluateConstellation_1.evaluateConstellation)(baseInput({ now: NaN }))).toThrow();
+    });
+    (0, vitest_1.it)("throws on Infinity now", () => {
+        (0, vitest_1.expect)(() => (0, evaluateConstellation_1.evaluateConstellation)(baseInput({ now: Infinity }))).toThrow();
+    });
+    (0, vitest_1.it)("accepts a finite now", () => {
+        (0, vitest_1.expect)((0, evaluateConstellation_1.evaluateConstellation)(baseInput()).stars).toHaveLength(6);
+    });
+});
+(0, vitest_1.describe)("orchestrator — shape & aggregate", () => {
+    (0, vitest_1.it)("returns six stars and a figure", () => {
+        const s = (0, evaluateConstellation_1.evaluateConstellation)(baseInput());
+        (0, vitest_1.expect)(s.stars).toHaveLength(6);
+        (0, vitest_1.expect)(s.figure.auraIntensity).toBeGreaterThanOrEqual(0);
+        (0, vitest_1.expect)(s.figure.auraIntensity).toBeLessThanOrEqual(100);
+    });
+    (0, vitest_1.it)("auraIntensity equals the mean star brightness", () => {
+        const s = (0, evaluateConstellation_1.evaluateConstellation)(baseInput());
+        const mean = s.stars.reduce((a, x) => a + x.brightness, 0) / s.stars.length;
+        (0, vitest_1.expect)(s.figure.auraIntensity).toBeCloseTo(Math.round(mean * 10) / 10, 1);
+    });
+    (0, vitest_1.it)("fullStarCount matches tier-3 stars", () => {
+        const s = (0, evaluateConstellation_1.evaluateConstellation)(baseInput());
+        const full = s.stars.filter((x) => x.tier === 3).length;
+        (0, vitest_1.expect)(s.figure.fullStarCount).toBe(full);
+    });
+    (0, vitest_1.it)("evaluatedAt is the ISO of now", () => {
+        const s = (0, evaluateConstellation_1.evaluateConstellation)(baseInput());
+        (0, vitest_1.expect)(s.evaluatedAt).toBe(new Date(NOW).toISOString());
+    });
+});
+(0, vitest_1.describe)("orchestrator — level clamping", () => {
+    (0, vitest_1.it)("undefined level → 1", () => (0, vitest_1.expect)((0, evaluateConstellation_1.evaluateConstellation)(baseInput()).currentLevel).toBe(1));
+    (0, vitest_1.it)("out-of-range level → clamped to 3", () => (0, vitest_1.expect)((0, evaluateConstellation_1.evaluateConstellation)(baseInput({ currentLevel: 99 })).currentLevel).toBe(3));
+    (0, vitest_1.it)("level 2 echoed", () => (0, vitest_1.expect)((0, evaluateConstellation_1.evaluateConstellation)(baseInput({ currentLevel: 2 })).currentLevel).toBe(2));
+});
+(0, vitest_1.describe)("orchestrator — future sessions excluded from scoring", () => {
+    (0, vitest_1.it)("a session dated after now does not light push", () => {
+        const future = (0, evaluateConstellation_1.evaluateConstellation)(baseInput({
+            sessions: [
+                {
+                    date: NOW + 86400000,
+                    exercises: [{ exerciseId: "bench", records: [wr("100", "5")] }],
+                },
+            ],
+        }));
+        (0, vitest_1.expect)(future.stars.find((s) => s.id === "push").brightness).toBe(0);
+    });
+    (0, vitest_1.it)("a present session does light push (control)", () => {
+        (0, vitest_1.expect)((0, evaluateConstellation_1.evaluateConstellation)(baseInput()).stars.find((s) => s.id === "push")
+            .brightness).toBeGreaterThan(0);
+    });
+});
+(0, vitest_1.describe)("orchestrator — empty input is safe", () => {
+    (0, vitest_1.it)("no sessions → all stars resolve, none throw", () => {
+        const s = (0, evaluateConstellation_1.evaluateConstellation)(baseInput({ sessions: [] }));
+        (0, vitest_1.expect)(s.stars).toHaveLength(6);
+        (0, vitest_1.expect)(s.stars.every((x) => Number.isFinite(x.brightness))).toBe(true);
+    });
+});

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

@@ -15,3 +15,4 @@
 export { evaluateConstellation } from "./evaluateConstellation";
 export type { TConstellationInput, TConstellationState, TConstellationFigure, TResolvedStar, TStarId, TStarTier, TFigurePosition, TStarMeasure, TLocalizedText, TSessionRecord, } from "./types";
 export { TIER_THRESHOLDS, deriveTier } from "./starFoundation";
+export { MAX_LEVEL as CONSTELLATION_USER_MAX_LEVEL, clampLevel as constellationClampLevel, type TLevel as TConstellationUserLevel, } from "./levelThresholds";

package/dist/utils/constellation/index.js

@@ -15,7 +15,7 @@
  * implementation detail and intentionally not re-exported.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.deriveTier = exports.TIER_THRESHOLDS = exports.evaluateConstellation = void 0;
+exports.constellationClampLevel = exports.CONSTELLATION_USER_MAX_LEVEL = exports.deriveTier = exports.TIER_THRESHOLDS = exports.evaluateConstellation = void 0;
 // The single entry point.
 var evaluateConstellation_1 = require("./evaluateConstellation");
 Object.defineProperty(exports, "evaluateConstellation", { enumerable: true, get: function () { return evaluateConstellation_1.evaluateConstellation; } });
@@ -24,3 +24,6 @@ Object.defineProperty(exports, "evaluateConstellation", { enumerable: true, get:
 var starFoundation_1 = require("./starFoundation");
 Object.defineProperty(exports, "TIER_THRESHOLDS", { enumerable: true, get: function () { return starFoundation_1.TIER_THRESHOLDS; } });
 Object.defineProperty(exports, "deriveTier", { enumerable: true, get: function () { return starFoundation_1.deriveTier; } });
+var levelThresholds_1 = require("./levelThresholds");
+Object.defineProperty(exports, "CONSTELLATION_USER_MAX_LEVEL", { enumerable: true, get: function () { return levelThresholds_1.MAX_LEVEL; } });
+Object.defineProperty(exports, "constellationClampLevel", { enumerable: true, get: function () { return levelThresholds_1.clampLevel; } });

package/dist/utils/constellation/starFoundation.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/constellation/starFoundation.test.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// shared/src/utils/constellation/starFoundation.test.ts
+const starFoundation_1 = require("./starFoundation");
+const levelThresholds_1 = require("./levelThresholds");
+const vitest_1 = require("vitest");
+(0, vitest_1.describe)("deriveTier — brightness band boundaries", () => {
+    (0, vitest_1.it)("0 brightness → tier 0 (dormant)", () => (0, vitest_1.expect)((0, starFoundation_1.deriveTier)(0)).toBe(0));
+    (0, vitest_1.it)("just below faint (0.9) → tier 0", () => (0, vitest_1.expect)((0, starFoundation_1.deriveTier)(0.9)).toBe(0));
+    (0, vitest_1.it)("exactly faint (1) → tier 1", () => (0, vitest_1.expect)((0, starFoundation_1.deriveTier)(1)).toBe(1));
+    (0, vitest_1.it)("mid faint (33) → tier 1", () => (0, vitest_1.expect)((0, starFoundation_1.deriveTier)(33)).toBe(1));
+    (0, vitest_1.it)("exactly rising (34) → tier 2", () => (0, vitest_1.expect)((0, starFoundation_1.deriveTier)(34)).toBe(2));
+    (0, vitest_1.it)("just below full (99) → tier 2", () => (0, vitest_1.expect)((0, starFoundation_1.deriveTier)(99)).toBe(2));
+    (0, vitest_1.it)("exactly full (100) → tier 3", () => (0, vitest_1.expect)((0, starFoundation_1.deriveTier)(100)).toBe(3));
+    (0, vitest_1.it)("thresholds are the documented values", () => {
+        (0, vitest_1.expect)(starFoundation_1.TIER_THRESHOLDS.faint).toBe(1);
+        (0, vitest_1.expect)(starFoundation_1.TIER_THRESHOLDS.rising).toBe(34);
+        (0, vitest_1.expect)(starFoundation_1.TIER_THRESHOLDS.full).toBe(100);
+    });
+});
+(0, vitest_1.describe)("resolveStar — clamps brightness and packages output", () => {
+    const ctx = {};
+    const make = (brightness) => ({
+        id: "push",
+        displayName: { translationKey: "constellation.push.name" },
+        color: "#fff",
+        figurePosition: "leftArm",
+        objective: { translationKey: "constellation.push.objective" },
+        rationale: { translationKey: "constellation.push.rationale" },
+        evaluate: () => ({
+            brightness,
+            detail: {
+                currentState: {
+                    value: 0,
+                    unit: "bw_ratio",
+                    display: { translationKey: "x" },
+                },
+                target: {
+                    value: 1,
+                    unit: "bw_ratio",
+                    display: { translationKey: "x" },
+                },
+                gap: { translationKey: "g" },
+            },
+        }),
+    });
+    (0, vitest_1.it)("clamps brightness > 100 down to 100", () => {
+        (0, vitest_1.expect)((0, starFoundation_1.resolveStar)(make(150), ctx).brightness).toBe(100);
+    });
+    (0, vitest_1.it)("clamps negative brightness up to 0", () => {
+        (0, vitest_1.expect)((0, starFoundation_1.resolveStar)(make(-20), ctx).brightness).toBe(0);
+    });
+    (0, vitest_1.it)("derives tier from the clamped value", () => {
+        (0, vitest_1.expect)((0, starFoundation_1.resolveStar)(make(150), ctx).tier).toBe(3);
+        (0, vitest_1.expect)((0, starFoundation_1.resolveStar)(make(-20), ctx).tier).toBe(0);
+    });
+    (0, vitest_1.it)("passes through identity + i18n fields unchanged", () => {
+        const r = (0, starFoundation_1.resolveStar)(make(50), ctx);
+        (0, vitest_1.expect)(r.id).toBe("push");
+        (0, vitest_1.expect)(r.figurePosition).toBe("leftArm");
+        (0, vitest_1.expect)(r.displayName.translationKey).toBe("constellation.push.name");
+    });
+});
+(0, vitest_1.describe)("clampLevel — valid level range", () => {
+    (0, vitest_1.it)("undefined → 1", () => (0, vitest_1.expect)((0, levelThresholds_1.clampLevel)(undefined)).toBe(1));
+    (0, vitest_1.it)("0 → 1", () => (0, vitest_1.expect)((0, levelThresholds_1.clampLevel)(0)).toBe(1));
+    (0, vitest_1.it)("negative → 1", () => (0, vitest_1.expect)((0, levelThresholds_1.clampLevel)(-3)).toBe(1));
+    (0, vitest_1.it)("1/2/3 pass through", () => {
+        (0, vitest_1.expect)((0, levelThresholds_1.clampLevel)(1)).toBe(1);
+        (0, vitest_1.expect)((0, levelThresholds_1.clampLevel)(2)).toBe(2);
+        (0, vitest_1.expect)((0, levelThresholds_1.clampLevel)(3)).toBe(3);
+    });
+    (0, vitest_1.it)("above max → 3", () => (0, vitest_1.expect)((0, levelThresholds_1.clampLevel)(99)).toBe(3));
+    (0, vitest_1.it)("fractional floored", () => (0, vitest_1.expect)((0, levelThresholds_1.clampLevel)(2.7)).toBe(2));
+});

package/dist/utils/constellation/stars/consistency.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/constellation/stars/consistency.test.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// shared/src/utils/constellation/stars/consistency.test.ts
+const vitest_1 = require("vitest");
+const starFoundation_1 = require("../starFoundation");
+const consistency_1 = require("../stars/consistency");
+const NOW = Date.UTC(2026, 5, 1);
+const day = (d) => NOW - d * 86400000;
+const set = (isDone = true) => ({
+    type: "weight-reps",
+    kg: "20",
+    reps: "5",
+    isDone,
+    isStrictMode: false,
+});
+const sess = (d, isDone = true) => ({
+    date: day(d),
+    exercises: [{ exerciseId: "x", records: [set(isDone)] }],
+});
+const ctx = (sessions, level = 1) => ({
+    sessions,
+    scoredSessions: [],
+    exerciseCatalog: {},
+    user: { weightKg: 80 },
+    now: NOW,
+    level,
+});
+(0, vitest_1.describe)("consistency — new vs lapsed user", () => {
+    (0, vitest_1.it)("no sessions → getStarted, brightness 0", () => {
+        const r = (0, starFoundation_1.resolveStar)(consistency_1.consistencyStar, ctx([]));
+        (0, vitest_1.expect)(r.brightness).toBe(0);
+        (0, vitest_1.expect)(r.gap.translationKey).toBe("constellation.consistency.gap.getStarted");
+    });
+    (0, vitest_1.it)("one old session (20d ago), none since → broken", () => {
+        const r = (0, starFoundation_1.resolveStar)(consistency_1.consistencyStar, ctx([sess(20)]));
+        (0, vitest_1.expect)(r.gap.translationKey).toBe("constellation.consistency.gap.broken");
+    });
+});
+(0, vitest_1.describe)("consistency — full habit", () => {
+    (0, vitest_1.it)("8 well-spaced sessions in 28d, recent → full", () => {
+        const days = [1, 4, 8, 11, 15, 18, 22, 25];
+        const r = (0, starFoundation_1.resolveStar)(consistency_1.consistencyStar, ctx(days.map((d) => sess(d))));
+        (0, vitest_1.expect)(r.brightness).toBe(100);
+        (0, vitest_1.expect)(r.gap.translationKey).toBe("constellation.consistency.gap.full");
+    });
+    (0, vitest_1.it)("fewer than required → partial + moreSessions gap", () => {
+        const r = (0, starFoundation_1.resolveStar)(consistency_1.consistencyStar, ctx([sess(1), sess(4), sess(8), sess(11)]));
+        (0, vitest_1.expect)(r.brightness).toBeGreaterThan(0);
+        (0, vitest_1.expect)(r.brightness).toBeLessThan(100);
+        (0, vitest_1.expect)(r.gap.translationKey).toBe("constellation.consistency.gap.moreSessions");
+    });
+});
+(0, vitest_1.describe)("consistency — counting rules", () => {
+    (0, vitest_1.it)("sessions with no completed set don't count", () => {
+        const r = (0, starFoundation_1.resolveStar)(consistency_1.consistencyStar, ctx([sess(1, false), sess(4, false)]));
+        (0, vitest_1.expect)(r.brightness).toBe(0);
+        (0, vitest_1.expect)(r.gap.translationKey).toBe("constellation.consistency.gap.getStarted");
+    });
+    (0, vitest_1.it)("two sessions same calendar day count once", () => {
+        const twoSameDay = [
+            { date: day(2), exercises: [{ exerciseId: "x", records: [set()] }] },
+            {
+                date: day(2) + 3600000,
+                exercises: [{ exerciseId: "y", records: [set()] }],
+            },
+        ];
+        const r = (0, starFoundation_1.resolveStar)(consistency_1.consistencyStar, ctx(twoSameDay));
+        // 1 unique day toward 8 → 12.5% * gap (trailing 2d ok) → ~13
+        (0, vitest_1.expect)(r.currentState.value).toBe(1);
+    });
+});
+(0, vitest_1.describe)("consistency — trailing gap behaviour", () => {
+    (0, vitest_1.it)("cooling warning as trailing gap approaches max", () => {
+        // 8 sessions but last was 4 days ago (warningAtIdleDays=4, maxGap=5)
+        const days = [4, 7, 10, 13, 16, 19, 22, 25];
+        const r = (0, starFoundation_1.resolveStar)(consistency_1.consistencyStar, ctx(days.map((d) => sess(d))));
+        (0, vitest_1.expect)(r.gap.translationKey).toBe("constellation.consistency.gap.cooling");
+    });
+    (0, vitest_1.it)("trailing gap beyond max decays brightness below count-only", () => {
+        // enough sessions for full count, but last 10 days ago → gap penalty
+        const days = [10, 12, 14, 16, 18, 20, 22, 24];
+        const r = (0, starFoundation_1.resolveStar)(consistency_1.consistencyStar, ctx(days.map((d) => sess(d))));
+        (0, vitest_1.expect)(r.brightness).toBeLessThan(100);
+    });
+});
+(0, vitest_1.describe)("consistency — level scaling", () => {
+    (0, vitest_1.it)("8 sessions fills L1 but not L2 (needs 12)", () => {
+        const days = [1, 4, 8, 11, 15, 18, 22, 25];
+        const l1 = (0, starFoundation_1.resolveStar)(consistency_1.consistencyStar, ctx(days.map((d) => sess(d)), 1));
+        const l2 = (0, starFoundation_1.resolveStar)(consistency_1.consistencyStar, ctx(days.map((d) => sess(d)), 2));
+        (0, vitest_1.expect)(l1.brightness).toBe(100);
+        (0, vitest_1.expect)(l2.brightness).toBeLessThan(100);
+    });
+});

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// shared/src/utils/constellation/stars/quality.test.ts
+const vitest_1 = require("vitest");
+const starFoundation_1 = require("../starFoundation");
+const quality_1 = require("../stars/quality");
+const NOW = Date.UTC(2026, 5, 1);
+const day = (d) => NOW - d * 86400000;
+/** A scored session whose single exercise has the given score. */
+const scored = (d, score) => ({
+    date: day(d),
+    exercises: [{ exerciseId: "x", score, muscleScores: {} }],
+});
+const ctx = (scoredSessions, level = 1) => ({
+    sessions: [],
+    scoredSessions,
+    exerciseCatalog: {},
+    user: {},
+    now: NOW,
+    level,
+});
+(0, vitest_1.describe)("quality — count-based brightness (L1 bar 70, target 5)", () => {
+    (0, vitest_1.it)("5 of 5 sessions clear → full", () => {
+        const s = [
+            scored(1, 80),
+            scored(3, 75),
+            scored(5, 90),
+            scored(7, 72),
+            scored(9, 85),
+        ];
+        const r = (0, starFoundation_1.resolveStar)(quality_1.qualityStar, ctx(s));
+        (0, vitest_1.expect)(r.brightness).toBe(100);
+        (0, vitest_1.expect)(r.gap.translationKey).toBe("constellation.quality.gap.full");
+    });
+    (0, vitest_1.it)("3 of 5 clear → 60%", () => {
+        const s = [
+            scored(1, 80),
+            scored(3, 60),
+            scored(5, 90),
+            scored(7, 50),
+            scored(9, 75),
+        ];
+        const r = (0, starFoundation_1.resolveStar)(quality_1.qualityStar, ctx(s));
+        (0, vitest_1.expect)(r.brightness).toBeCloseTo(60, 0);
+        (0, vitest_1.expect)(r.gap.translationKey).toBe("constellation.quality.gap.moreQuality");
+    });
+    (0, vitest_1.it)("none clear → 0", () => {
+        const s = [scored(1, 50), scored(3, 40)];
+        (0, vitest_1.expect)((0, starFoundation_1.resolveStar)(quality_1.qualityStar, ctx(s)).brightness).toBe(0);
+    });
+});
+(0, vitest_1.describe)("quality — the bar boundary (>= 70 clears)", () => {
+    (0, vitest_1.it)("exactly 70 clears", () => {
+        (0, vitest_1.expect)((0, starFoundation_1.resolveStar)(quality_1.qualityStar, ctx([scored(1, 70)])).currentState.value).toBe(1);
+    });
+    (0, vitest_1.it)("69 does not clear", () => {
+        (0, vitest_1.expect)((0, starFoundation_1.resolveStar)(quality_1.qualityStar, ctx([scored(1, 69)])).currentState.value).toBe(0);
+    });
+});
+(0, vitest_1.describe)("quality — session averaging & unscorable handling", () => {
+    (0, vitest_1.it)("session score is the average of its exercises", () => {
+        const s = [
+            {
+                date: day(1),
+                exercises: [
+                    { exerciseId: "a", score: 60, muscleScores: {} },
+                    { exerciseId: "b", score: 80, muscleScores: {} }, // avg 70 → clears
+                ],
+            },
+        ];
+        (0, vitest_1.expect)((0, starFoundation_1.resolveStar)(quality_1.qualityStar, ctx(s)).currentState.value).toBe(1);
+    });
+    (0, vitest_1.it)("sessions with no scorable exercises are skipped (neither clear nor fail)", () => {
+        const s = [scored(1, null), scored(3, 80)];
+        const r = (0, starFoundation_1.resolveStar)(quality_1.qualityStar, ctx(s));
+        (0, vitest_1.expect)(r.currentState.value).toBe(1); // only the scorable one counts
+    });
+    (0, vitest_1.it)("no data at all → noData gap", () => {
+        const r = (0, starFoundation_1.resolveStar)(quality_1.qualityStar, ctx([scored(1, null)]));
+        (0, vitest_1.expect)(r.gap.translationKey).toBe("constellation.quality.gap.noData");
+    });
+});
+(0, vitest_1.describe)("quality — window & level scaling", () => {
+    (0, vitest_1.it)("only the most recent N sessions are considered", () => {
+        // L1 window 5: 5 recent good + 3 older bad → still full (bad ones out of window)
+        const s = [
+            scored(1, 90),
+            scored(3, 90),
+            scored(5, 90),
+            scored(7, 90),
+            scored(9, 90),
+            scored(20, 10),
+            scored(22, 10),
+            scored(24, 10),
+        ];
+        (0, vitest_1.expect)((0, starFoundation_1.resolveStar)(quality_1.qualityStar, ctx(s)).brightness).toBe(100);
+    });
+    (0, vitest_1.it)("L2 demands a higher bar (78) so 75s stop clearing", () => {
+        const s = [
+            scored(1, 75),
+            scored(3, 75),
+            scored(5, 75),
+            scored(7, 75),
+            scored(9, 75),
+            scored(11, 75),
+            scored(13, 75),
+            scored(15, 75),
+        ];
+        const l1 = (0, starFoundation_1.resolveStar)(quality_1.qualityStar, ctx(s, 1));
+        const l2 = (0, starFoundation_1.resolveStar)(quality_1.qualityStar, ctx(s, 2));
+        (0, vitest_1.expect)(l1.brightness).toBeGreaterThan(l2.brightness);
+    });
+});

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

@@ -0,0 +1 @@
+export {};