@trainheroic-unofficial/athlete-mcp 1.3.0 → 1.5.0

package/dist/server.mjs

@@ -160,20 +160,41 @@ const loggedSetSchema = z.object({
 	param2: z.union([z.number(), z.string()]).optional()
 });
 /**
+* A logged set that can name the prescribed position it fills. `slot` is the 1-based set
+* index in the prescription (10 max) the result should land in; omit it to fill the next
+* sequential position (the first entry is set 1, the second set 2, and so on). Targeting a
+* slot lets a partial log land in the right positions of a multi-set prescription — e.g.
+* three top singles into the 4th/5th/6th positions of an `8,5,3,1,1,1` ramp. Used by the
+* by-set logging write (not the by-exercise session log, where each exercise's sets are
+* always sequential).
+*/
+const loggedSetWithSlotSchema = loggedSetSchema.extend({ slot: z.number().int().min(1).max(10).optional() });
+/**
 * Args for the set-logging write. `date` (the workout's day) locates the saved
 * workout via the range endpoint; `savedWorkoutSetId` picks the set to complete; `results`
-* gives, per exercise in it, the entered value of each set (param 1 / param 2 by entry slot).
+* gives, per exercise in it, the entered value of each set. Each set fills the next position by
+* default, or names its `slot` (1-based) to place a partial log at specific positions. A partial
+* log keeps positions already logged in an earlier call and leaves the positions it does not
+* write empty.
 */
 const logSetArgsSchema = z.object({
 	date: dateString,
 	savedWorkoutSetId: idArgSchema,
 	results: z.array(z.object({
 		savedWorkoutSetExerciseId: idArgSchema,
-		sets: z.array(loggedSetSchema).min(1)
+		sets: z.array(loggedSetWithSlotSchema).min(1)
 	})).min(1)
 });
 logSetArgsSchema.extend({ athleteId: idArgSchema });
-logSetArgsSchema.extend({ athleteId: idArgSchema });
+z.object({
+	date: dateString,
+	savedWorkoutSetId: idArgSchema,
+	athleteId: idArgSchema,
+	results: z.array(z.object({
+		savedWorkoutSetExerciseId: idArgSchema,
+		sets: z.array(loggedSetSchema).min(1)
+	})).min(1)
+});
 z.object({
 	savedWorkoutSetExerciseId: idArgSchema,
 	exerciseId: idArgSchema
@@ -453,7 +474,20 @@ async function confirmGate(server, requestId, message, confirmArg) {
 const SERVER_INSTRUCTIONS = "Speak to the user in plain, everyday language about their training. Describe what you are doing in the TrainHeroic app's own terms (for example, say you are creating a workout rather than naming a tool). Do not surface internal tool names (the snake_case identifiers such as athlete_session_create), raw parameter names, or numeric ids in your replies unless the user explicitly asks for them; they are implementation details. The tool descriptions cross-reference each other by name only so you can chain them correctly. Keep that wiring to yourself.";
 //#endregion
 //#region ../js/src/auth.ts
-const AUTH_URL = "https://apis.trainheroic.com/auth";
+const DEFAULT_AUTH_URL = "https://apis.trainheroic.com/auth";
+/**
+* The login endpoint, allowing an env override so a test harness can authenticate against a local
+* fake backend. Precedence: an explicit `TH_AUTH_URL`, else `${TH_APIS_BASE}/auth` (login lives on
+* the apis host, so it follows that base), else the real endpoint. Read via `globalThis.process`
+* (no `import process`) to keep this module workerd-safe, and per call so a child-env override wins.
+*/
+function authUrl() {
+	const env = globalThis.process?.env;
+	if (env?.TH_AUTH_URL && env.TH_AUTH_URL.length > 0) return env.TH_AUTH_URL;
+	const apis = env?.TH_APIS_BASE;
+	if (apis && apis.length > 0) return `${apis.replace(/\/$/, "")}/auth`;
+	return DEFAULT_AUTH_URL;
+}
 /**
 * Authenticate against TrainHeroic. Returns the session bundle, or null on bad
 * credentials. TrainHeroic returns only { id, scope, role, session_id } (verified in
@@ -461,7 +495,7 @@ const AUTH_URL = "https://apis.trainheroic.com/auth";
 * is sent as the `session-token` header and works against both API hosts.
 */
 async function loginTrainHeroic(email, password) {
-	const res = await fetch(AUTH_URL, {
+	const res = await fetch(authUrl(), {
 		method: "POST",
 		headers: {
 			"content-type": "application/x-www-form-urlencoded",
@@ -484,8 +518,19 @@ async function loginTrainHeroic(email, password) {
 }
 //#endregion
 //#region ../js/src/client.ts
-const COACH_BASE = "https://api.trainheroic.com";
-const APIS_BASE = "https://apis.trainheroic.com";
+const DEFAULT_COACH_BASE = "https://api.trainheroic.com";
+const DEFAULT_APIS_BASE = "https://apis.trainheroic.com";
+/**
+* Resolve an API host, allowing an env override. The override exists so a test harness can point
+* the client at a local fake backend (and it doubles as a staging knob); production leaves these
+* unset and gets the real hosts. Read through `globalThis.process?.env` — not an `import process`
+* — so the runtime-agnostic `.` entry stays free of `node:*` and runs unchanged on workerd, and
+* read per request (not at module load) so a value the harness sets in the child env always wins.
+*/
+function envBase(key, fallback) {
+	const v = (globalThis.process?.env)?.[key];
+	return v && v.length > 0 ? v : fallback;
+}
 var TrainHeroicAuthError = class extends Error {
 	name = "TrainHeroicAuthError";
 };
@@ -524,7 +569,7 @@ var TrainHeroicClient = class {
 		return this.#sessionId;
 	}
 	async request(method, path, options = {}) {
-		const url = `${options.base === "apis" ? APIS_BASE : COACH_BASE}/${path.replace(/^\//, "")}`;
+		const url = `${options.base === "apis" ? envBase("TH_APIS_BASE", DEFAULT_APIS_BASE) : envBase("TH_COACH_BASE", DEFAULT_COACH_BASE)}/${path.replace(/^\//, "")}`;
 		let session = await this.#ensureSession();
 		let res = await this.#send(method, url, session, options.body);
 		if (res.status === 401 || res.status === 403) {
@@ -611,6 +656,10 @@ function exerciseUnits(param1, param2) {
 function isRecord(x) {
 	return typeof x === "object" && x !== null && !Array.isArray(x);
 }
+/** A non-empty string, or null. Narrows a loosely-typed API field to a usable string. */
+function str(v) {
+	return typeof v === "string" && v !== "" ? v : null;
+}
 /**
 * Rank candidate rows for a free-text query (FTS5 replacement). Higher is better:
 * exact title, then prefix, then count of matched tokens, with shorter titles and
@@ -696,7 +745,6 @@ function fetchLeaderboard(client, workoutId, opts = {}) {
 	const query = qs.toString();
 	return getJson(client, `/3.0/athlete/leaderboard/${workoutId}${query ? `?${query}` : ""}`, "athlete leaderboard");
 }
-const SLOTS = 10;
 function nonEmpty(value) {
 	return value !== void 0 && value !== null && String(value).trim() !== "";
 }
@@ -707,7 +755,7 @@ function nonEmpty(value) {
 */
 function prescribedSets(ex) {
 	const out = [];
-	for (let i = 1; i <= SLOTS; i += 1) {
+	for (let i = 1; i <= 10; i += 1) {
 		const p1 = ex[`param_1_data_${i}`];
 		const p2 = ex[`param_2_data_${i}`];
 		const has1 = nonEmpty(p1);
@@ -728,7 +776,7 @@ function prescribedSets(ex) {
 */
 function performedSets(ex) {
 	const out = [];
-	for (let i = 1; i <= SLOTS; i += 1) {
+	for (let i = 1; i <= 10; i += 1) {
 		if (coerceInt(ex[`param_${i}_made`]) !== 1) continue;
 		const p1 = ex[`param_1_data_${i}`];
 		const p2 = ex[`param_2_data_${i}`];
@@ -762,9 +810,6 @@ function presentBlock(set, performedById) {
 		exercises: exercises.filter(isRecord).map((ex) => presentExercise(ex, performedById))
 	};
 }
-function str(v) {
-	return typeof v === "string" && v !== "" ? v : null;
-}
 /** Every logged set (programmed + athlete-added) in the saved copy, paired with its exercises. */
 function savedSets(saved) {
 	const out = [];
@@ -894,7 +939,52 @@ function summarizeAthleteWorkouts(list) {
 		};
 	});
 }
-const MAX_PARAM_SLOTS = 10;
+/** Flatten `/v5/exercises/{id}/history` into PRs + a session time-series. */
+function presentExerciseHistory(detail) {
+	return {
+		liftPRs: (detail.liftPRs ?? []).map((p) => ({
+			description: p.description ?? null,
+			reps: p.reps ?? null,
+			weight: p.weight ?? null,
+			units: p.units ?? null,
+			date: p.dateCompleted ?? null
+		})),
+		sessions: (detail.history ?? []).map((h) => ({
+			date: h.dateCompleted,
+			abr: h.abr ?? null,
+			estimated1RM: h.bestEstimated1RM ?? null,
+			sets: (h.sets ?? []).map((s) => ({
+				setNumber: s.setNumber,
+				value: s.formattedValue ?? null
+			}))
+		}))
+	};
+}
+//#endregion
+//#region ../js/src/athlete-set-write.ts
+/**
+* Coerce the loosely-typed `results` from a validated log/prescribe args object into the SDK's
+* {@link SetResult}[]. The dto schemas validate ids as a number or a numeric string and leave
+* empty param slots optional; this narrows the id to a number and copies only the present per-set
+* values (so the per-set type stays free of `undefined` under exactOptionalPropertyTypes). Shared
+* by the MCP tools and the CLI so the mapping lives in one place rather than once per surface.
+*/
+function toSetResults(results) {
+	return results.map((r) => {
+		const id = coerceInt(r.savedWorkoutSetExerciseId);
+		if (id === null) throw new Error(`Invalid savedWorkoutSetExerciseId: ${String(r.savedWorkoutSetExerciseId)}`);
+		return {
+			savedWorkoutSetExerciseId: id,
+			sets: r.sets.map((s) => {
+				const set = {};
+				if (s.param1 !== void 0) set.param1 = s.param1;
+				if (s.param2 !== void 0) set.param2 = s.param2;
+				if (s.slot !== void 0) set.slot = s.slot;
+				return set;
+			})
+		};
+	});
+}
 /**
 * Build the body for `PUT /1.0/{role}/savedworkoutsetexercise/{id}`. The body uses snake_case
 * keys matching the live API response shape. Each set slot (1-10) carries `param_1_data_N` /
@@ -902,36 +992,96 @@ const MAX_PARAM_SLOTS = 10;
 *
 * `mode` selects which write this is — the same endpoint serves both:
 *   - `"log"`: the values ARE a performed result, so `param_N_made` is 1 where the slot has data
-*     and the exercise `completed` flag is 1 when any set has data.
+*     and the exercise `completed` flag is 1 when any set has logged data.
 *   - `"prescribe"`: the values are prescribed targets, written with every `param_N_made` and
 *     `completed` left at 0 so the set is not marked done. This matches what the app sends when a
 *     coach edits an athlete's prescribed reps/weight.
 *
+* Each set fills a 1-based slot: its explicit `slot`, or its sequential position in `results`
+* when `slot` is omitted. A `log` carrying the live exercise record in `existing` keeps the slots
+* it does not write that were ALREADY performed (`param_N_made === 1`), so logging a second part of
+* a set does not wipe the earlier-logged sets. A slot holding only un-logged prescription pre-fill
+* (`param_N_made === 0`) is left blank rather than carried over: marking the set completed makes
+* the server flag every data-bearing slot performed, so preserving that pre-fill would fabricate
+* sets the athlete never did. The prescription is unaffected (it lives in the separate `workout`
+* copy, not this saved copy). A `prescribe` ignores `existing` and replaces the whole prescription.
+*
 * Only `savedWorkoutSetExerciseId`, `savedWorkoutSetId`, and `workoutSetExerciseId` are
-* required from the live exercise record; everything else is derived from `results`.
+* required from the live exercise record; everything else is derived from `results` and the
+* preserved slots of `existing`.
 *
 * Exported for unit testing — callers should use `logAthleteSet` / `prescribeForAthlete` instead.
 */
-function buildExerciseSetPayload(savedWorkoutSetExerciseId, savedWorkoutSetId, workoutSetExerciseId, results, mode) {
-	if (results.length > MAX_PARAM_SLOTS) throw new Error(`At most ${MAX_PARAM_SLOTS} sets are supported per exercise; got ${results.length}.`);
+function buildExerciseSetPayload(savedWorkoutSetExerciseId, savedWorkoutSetId, workoutSetExerciseId, results, mode, existing) {
+	if (results.length > 10) throw new Error(`At most 10 sets are supported per exercise; got ${results.length}.`);
+	const bySlot = /* @__PURE__ */ new Map();
+	results.forEach((set, i) => {
+		const slot = set.slot ?? i + 1;
+		if (slot < 1 || slot > 10) throw new Error(`Set slot ${slot} is out of range; slots are 1–10.`);
+		if (bySlot.has(slot)) throw new Error(`Two sets target slot ${slot}; each slot can be written once.`);
+		bySlot.set(slot, set);
+	});
 	const performed = mode === "log";
-	const hasData = results.some((s) => s.param1 !== void 0 || s.param2 !== void 0);
+	const carryOver = performed && existing !== void 0;
 	const body = {
 		id: savedWorkoutSetExerciseId,
 		saved_workout_set_id: savedWorkoutSetId,
-		workout_set_exercise_id: workoutSetExerciseId,
-		completed: performed && hasData ? 1 : 0
+		workout_set_exercise_id: workoutSetExerciseId
 	};
-	for (let i = 1; i <= MAX_PARAM_SLOTS; i += 1) {
-		const slot = results[i - 1];
-		const p1 = slot?.param1 !== void 0 ? String(slot.param1) : "";
-		const p2 = slot?.param2 !== void 0 ? String(slot.param2) : "";
-		body[`param_${i}_made`] = performed && (p1 !== "" || p2 !== "") ? 1 : 0;
+	let anyMade = false;
+	for (let i = 1; i <= 10; i += 1) {
+		const target = bySlot.get(i);
+		let p1;
+		let p2;
+		let made;
+		if (target) {
+			p1 = target.param1 !== void 0 ? String(target.param1) : "";
+			p2 = target.param2 !== void 0 ? String(target.param2) : "";
+			made = performed && (p1 !== "" || p2 !== "") ? 1 : 0;
+		} else if (carryOver && coerceInt(existing?.[`param_${i}_made`]) === 1) {
+			p1 = existingSlotData(existing, `param_1_data_${i}`);
+			p2 = existingSlotData(existing, `param_2_data_${i}`);
+			made = 1;
+		} else {
+			p1 = "";
+			p2 = "";
+			made = 0;
+		}
+		if (made === 1) anyMade = true;
+		body[`param_${i}_made`] = made;
 		body[`param_1_data_${i}`] = p1;
 		body[`param_2_data_${i}`] = p2;
 	}
+	body.completed = performed && anyMade ? 1 : 0;
 	return body;
 }
+/** Read a saved-copy slot value (`param_1_data_N` / `param_2_data_N`) as the string the body uses. */
+function existingSlotData(existing, key) {
+	const v = existing?.[key];
+	return v === void 0 || v === null ? "" : String(v);
+}
+/** True when a saved-copy exercise already carries a performed slot (any `param_N_made` === 1). */
+function exerciseHasLoggedData(ex) {
+	for (let i = 1; i <= 10; i += 1) if (coerceInt(ex[`param_${i}_made`]) === 1) return true;
+	return false;
+}
+/** True when a result carries at least one non-empty param value (so it produces a performed slot). */
+function resultHasData(result) {
+	return result.sets.some((s) => s.param1 !== void 0 && String(s.param1) !== "" || s.param2 !== void 0 && String(s.param2) !== "");
+}
+/**
+* Whether every exercise in a saved workout set now has logged data — either written with data in
+* this call (`loggedIds`) or already carrying a performed slot. Gates the set-completion PUT: a
+* superset/circuit stays open until the last exercise is logged, so completing it on a partial log
+* does not flip its still-empty siblings to "done". An exercise written with only empty values does
+* not count (it would not be marked performed), so an all-empty log never completes the set.
+*/
+function isSetFullyLogged(exercises, loggedIds) {
+	return exercises.every((ex) => {
+		const id = coerceInt(ex.id);
+		return id !== null && loggedIds.has(id) || exerciseHasLoggedData(ex);
+	});
+}
 /**
 * Locate the target saved workout set across all program workouts on the given day.
 * Returns the `savedWorkoutId`, the matching set's `workoutSetExercises` array so callers
@@ -1030,7 +1180,8 @@ async function logAthleteSet(client, args) {
 	const r = await writeSetResults(client, { role: "athlete" }, await fetchAthleteWorkouts(client, args.date, args.date), args.savedWorkoutSetId, args.results, "log");
 	return {
 		savedWorkoutSetId: r.savedWorkoutSetId,
-		exercisesLogged: r.exercisesWritten
+		exercisesLogged: r.exercisesWritten,
+		setCompleted: r.setCompleted
 	};
 }
 /**
@@ -1051,7 +1202,8 @@ async function logForAthlete(client, args) {
 	}, workouts, args.savedWorkoutSetId, args.results, "log");
 	return {
 		savedWorkoutSetId: r.savedWorkoutSetId,
-		exercisesLogged: r.exercisesWritten
+		exercisesLogged: r.exercisesWritten,
+		setCompleted: r.setCompleted
 	};
 }
 /**
@@ -1082,9 +1234,9 @@ async function writeSetResults(client, target, workouts, savedWorkoutSetId, resu
 			throw new Error(`savedWorkoutSetExerciseId ${result.savedWorkoutSetExerciseId} not found in saved workout set ${savedWorkoutSetId}. Exercises in this set: ${valid.join(", ") || "none"}.`);
 		}
 		const workoutSetExerciseId = coerceInt(ex.workout_set_exercise_id);
-		if (!workoutSetExerciseId) throw new Error(`Could not resolve workout_set_exercise_id for exercise ${result.savedWorkoutSetExerciseId}.`);
+		if (!workoutSetExerciseId) throw new Error(`savedWorkoutSetExercise ${result.savedWorkoutSetExerciseId} is missing its workout_set_exercise_id (the prescription-template pointer the write needs). This is the savedWorkoutSetExerciseId, not an exercise_id — re-read the ids from athlete_saved_workouts.`);
 		const body = {
-			...buildExerciseSetPayload(result.savedWorkoutSetExerciseId, savedWorkoutSetId, workoutSetExerciseId, result.sets, mode),
+			...buildExerciseSetPayload(result.savedWorkoutSetExerciseId, savedWorkoutSetId, workoutSetExerciseId, result.sets, mode, ex),
 			...extra
 		};
 		const res = await client.request("PUT", `/1.0/${target.role}/savedworkoutsetexercise/${result.savedWorkoutSetExerciseId}${suffix}`, { body });
@@ -1094,17 +1246,22 @@ async function writeSetResults(client, target, workouts, savedWorkoutSetId, resu
 		}
 		exercisesWritten += 1;
 	}
+	let setCompleted = false;
 	if (mode === "log") {
-		const setBody = {
-			...buildSetCompletePayload(rawSet, exercises.map((e) => coerceInt(e.id)).filter((n) => n !== null), true),
-			...extra
-		};
-		const setRes = await client.request("PUT", `/1.0/${target.role}/savedworkoutset/${savedWorkoutSetId}${suffix}`, { body: setBody });
-		if (!setRes.ok) throw new Error(`Failed to mark workout set ${savedWorkoutSetId} completed (HTTP ${setRes.status}).`);
+		if (isSetFullyLogged(exercises, new Set(results.filter(resultHasData).map((r) => r.savedWorkoutSetExerciseId)))) {
+			const setBody = {
+				...buildSetCompletePayload(rawSet, exercises.map((e) => coerceInt(e.id)).filter((n) => n !== null), true),
+				...extra
+			};
+			const setRes = await client.request("PUT", `/1.0/${target.role}/savedworkoutset/${savedWorkoutSetId}${suffix}`, { body: setBody });
+			if (!setRes.ok) throw new Error(`Failed to mark workout set ${savedWorkoutSetId} completed (HTTP ${setRes.status}).`);
+			setCompleted = true;
+		}
 	}
 	return {
 		savedWorkoutSetId,
-		exercisesWritten
+		exercisesWritten,
+		setCompleted
 	};
 }
 /**
@@ -1211,7 +1368,10 @@ async function logResolvedExercises(client, target, date, resolved) {
 			savedWorkoutSetId,
 			results
 		});
-		out.push(written);
+		out.push({
+			savedWorkoutSetId: written.savedWorkoutSetId,
+			exercisesLogged: written.exercisesLogged
+		});
 	}
 	return out;
 }
@@ -1254,27 +1414,6 @@ async function logAdHocSession(client, args) {
 		sets
 	};
 }
-/** Flatten `/v5/exercises/{id}/history` into PRs + a session time-series. */
-function presentExerciseHistory(detail) {
-	return {
-		liftPRs: (detail.liftPRs ?? []).map((p) => ({
-			description: p.description ?? null,
-			reps: p.reps ?? null,
-			weight: p.weight ?? null,
-			units: p.units ?? null,
-			date: p.dateCompleted ?? null
-		})),
-		sessions: (detail.history ?? []).map((h) => ({
-			date: h.dateCompleted,
-			abr: h.abr ?? null,
-			estimated1RM: h.bestEstimated1RM ?? null,
-			sets: (h.sets ?? []).map((s) => ({
-				setNumber: s.setNumber,
-				value: s.formattedValue ?? null
-			}))
-		}))
-	};
-}
 //#endregion
 //#region ../core/src/history.ts
 /**
@@ -1499,7 +1638,7 @@ function registerLogTool(server, ctx) {
 	}));
 	server.registerTool("athlete_log_set", {
 		title: "Log completed set results",
-		description: "Athlete-facing write: record entered results (reps/weight per set) for a saved workout set on a given day, marking the set completed. Writes to the athlete's (coach-visible) training log and shows in exercise history. Get savedWorkoutSetId + savedWorkoutSetExerciseId from athlete_workouts (raw:true). Requires confirmation (elicitation or confirm:true).",
+		description: "Athlete-facing write: record entered results (reps/weight per set) for a saved workout set on a given day. Writes to the athlete's (coach-visible) training log and shows in exercise history. Each set fills the next position in order; give a set a 1-based `slot` to place it at a specific position — e.g. log three top singles into positions 4-6 of an 8,5,3,1,1,1 ramp. A partial log records only the positions you send (plus any logged in an earlier call) and leaves the rest unlogged, so it does not mark untouched sets as performed. In a superset/circuit the block is marked done only once every exercise in it has logged results, so logging one exercise leaves its siblings untouched (the response's `setCompleted` reports whether the block was completed). Get savedWorkoutSetId + savedWorkoutSetExerciseId from athlete_workouts (raw:true). Requires confirmation (elicitation or confirm:true).",
 		inputSchema: {
 			...logSetArgsSchema.shape,
 			confirm: z.boolean().optional()
@@ -1507,19 +1646,10 @@ function registerLogTool(server, ctx) {
 		annotations: DESTRUCTIVE
 	}, ({ date, savedWorkoutSetId, results, confirm }, extra) => attempt(async () => {
 		if (!await confirmGate(server, extra.requestId, `Log results to saved workout set ${toId(savedWorkoutSetId)} on ${date}? This writes to your coach-visible training log.`, confirm)) return errorResult(NOT_CONFIRMED);
-		const mapped = results.map((r) => ({
-			savedWorkoutSetExerciseId: toId(r.savedWorkoutSetExerciseId),
-			sets: r.sets.map((s) => {
-				const slot = {};
-				if (s.param1 !== void 0) slot.param1 = s.param1;
-				if (s.param2 !== void 0) slot.param2 = s.param2;
-				return slot;
-			})
-		}));
 		return jsonResult(await logAthleteSet(ctx.client, {
 			date,
 			savedWorkoutSetId: toId(savedWorkoutSetId),
-			results: mapped
+			results: toSetResults(results)
 		}));
 	}));
 }
@@ -1550,7 +1680,7 @@ function registerAthleteTrainingTools(server, ctx) {
 }
 //#endregion
 //#region package.json
-var version = "1.3.0";
+var version = "1.5.0";
 //#endregion
 //#region src/server.ts
 async function main() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trainheroic-unofficial/athlete-mcp",
-  "version": "1.3.0",
+  "version": "1.5.0",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -21,8 +21,8 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
     "zod": "^4.4.3",
-    "@trainheroic-unofficial/core": "1.3.0",
-    "@trainheroic-unofficial/js": "1.3.0"
+    "@trainheroic-unofficial/core": "1.5.0",
+    "@trainheroic-unofficial/js": "1.5.0"
   },
   "devDependencies": {
     "@types/node": "^26.0.0",