@sunsteel/contracts 0.69.0 → 0.71.0

package/dist/index.cjs

@@ -37,6 +37,8 @@ __export(index_exports, {
   ACTIVITY_REACTIONS: () => ACTIVITY_REACTIONS,
   ACTIVITY_TYPES: () => ACTIVITY_TYPES,
   ACTIVITY_TYPE_SECTIONS: () => ACTIVITY_TYPE_SECTIONS,
+  BAR_CHOICES_KG: () => BAR_CHOICES_KG,
+  BAR_WARM_UP_STEPS: () => BAR_WARM_UP_STEPS,
   BLOCKED_MEMBERS_MAX: () => BLOCKED_MEMBERS_MAX,
   CLONE_ROUTINE_REFUSALS: () => CLONE_ROUTINE_REFUSALS,
   COMEBACK_MIN_INACTIVE_DAYS: () => COMEBACK_MIN_INACTIVE_DAYS,
@@ -64,6 +66,8 @@ __export(index_exports, {
   FOLLOW_SUGGESTIONS_DEFAULT_LIMIT: () => FOLLOW_SUGGESTIONS_DEFAULT_LIMIT,
   FOLLOW_SUGGESTIONS_MAX_LIMIT: () => FOLLOW_SUGGESTIONS_MAX_LIMIT,
   FOLLOW_SUGGESTION_REASONS: () => FOLLOW_SUGGESTION_REASONS,
+  LIMITED_SHORTFALL_KG: () => LIMITED_SHORTFALL_KG,
+  MAX_SETS_PER_EXERCISE: () => MAX_SETS_PER_EXERCISE,
   MEASURABLE_GOALS_MAX: () => MEASURABLE_GOALS_MAX,
   MEASURABLE_GOAL_DIRECTIONS: () => MEASURABLE_GOAL_DIRECTIONS,
   MEASURABLE_GOAL_TYPES: () => MEASURABLE_GOAL_TYPES,
@@ -79,12 +83,14 @@ __export(index_exports, {
   NOTIFICATIONS_RETENTION_DAYS: () => NOTIFICATIONS_RETENTION_DAYS,
   NOTIFICATION_CATEGORIES: () => NOTIFICATION_CATEGORIES,
   NOTIFICATION_KINDS: () => NOTIFICATION_KINDS,
+  OTHER_WARM_UP_STEPS: () => OTHER_WARM_UP_STEPS,
   PLATEAU_MIN_DAYS_SINCE_BEST: () => PLATEAU_MIN_DAYS_SINCE_BEST,
   PLATEAU_MIN_SESSIONS: () => PLATEAU_MIN_SESSIONS,
   PLATEAU_MIN_SESSIONS_MAX: () => PLATEAU_MIN_SESSIONS_MAX,
   PLATEAU_MIN_SESSIONS_MIN: () => PLATEAU_MIN_SESSIONS_MIN,
   PLATEAU_RECENT_DAYS: () => PLATEAU_RECENT_DAYS,
   PLATEAU_WINDOW_DAYS: () => PLATEAU_WINDOW_DAYS,
+  PLATE_SETS: () => PLATE_SETS,
   PREFERRED_TRAINING_STYLE_VALUES: () => PREFERRED_TRAINING_STYLE_VALUES,
   PROFILE_BIO_MAX_LENGTH: () => PROFILE_BIO_MAX_LENGTH,
   PROFILE_FAVORITE_EXERCISES_MAX: () => PROFILE_FAVORITE_EXERCISES_MAX,
@@ -140,6 +146,8 @@ __export(index_exports, {
   SESSION_SHARE_DEFAULT_FIELDS: () => SESSION_SHARE_DEFAULT_FIELDS,
   SESSION_SHARE_FIELDS: () => SESSION_SHARE_FIELDS,
   SESSION_SHARE_MAX_ACTIVE_LINKS: () => SESSION_SHARE_MAX_ACTIVE_LINKS,
+  SET_KINDS: () => SET_KINDS,
+  SET_KIND_LABELS: () => SET_KIND_LABELS,
   SEXES: () => SEXES,
   SHARED_ROUTINE_SOURCES: () => SHARED_ROUTINE_SOURCES,
   STARRED_EXERCISES_MAX: () => STARRED_EXERCISES_MAX,
@@ -175,15 +183,27 @@ __export(index_exports, {
   WORKOUT_SESSION_STATUSES: () => WORKOUT_SESSION_STATUSES,
   accountExportFileName: () => accountExportFileName,
   applyDeload: () => applyDeload,
+  buildWarmUpRamp: () => buildWarmUpRamp,
+  calculatePlateLoading: () => calculatePlateLoading,
+  countsAsWork: () => countsAsWork,
+  countsForProgression: () => countsForProgression,
+  defaultWarmUpEquipment: () => defaultWarmUpEquipment,
   deloadLengthDays: () => deloadLengthDays,
+  followWorkingLoad: () => followWorkingLoad,
+  isBarLoaded: () => isBarLoaded,
+  isSetKind: () => isSetKind,
   isWithinQuietHours: () => isWithinQuietHours,
+  leadWorkingWeight: () => leadWorkingWeight,
   matchesDeletionConfirmation: () => matchesDeletionConfirmation,
+  requiredToFinish: () => requiredToFinish,
   resolveActiveTrainingBlock: () => resolveActiveTrainingBlock,
   resolveRoutinePlan: () => resolveRoutinePlan,
   routineDayLabel: () => routineDayLabel,
   sessionCorrectionWindow: () => sessionCorrectionWindow,
+  setKindOf: () => setKindOf,
   setLogValuesDiffer: () => setLogValuesDiffer,
-  trainingBlockCovers: () => trainingBlockCovers
+  trainingBlockCovers: () => trainingBlockCovers,
+  warmUpLoad: () => warmUpLoad
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -511,6 +531,283 @@ var COMEBACK_WINDOW_DAYS = 14;
 var COMEBACK_SESSION_LOOKBACK = 500;
 var COMEBACK_RECOGNITION_LIMIT = 20;
 
+// src/set-kinds.ts
+var SET_KINDS = ["WORKING", "WARMUP", "DROP", "OPTIONAL"];
+var SET_KIND_LABELS = {
+  WORKING: "Working",
+  WARMUP: "Warm-up",
+  DROP: "Drop",
+  OPTIONAL: "Optional"
+};
+function isSetKind(value) {
+  return SET_KINDS.includes(value);
+}
+function setKindOf(item) {
+  return item?.kind ?? "WORKING";
+}
+function countsAsWork(kind) {
+  return (kind ?? "WORKING") !== "WARMUP";
+}
+function countsForProgression(kind) {
+  const k = kind ?? "WORKING";
+  return k === "WORKING" || k === "OPTIONAL";
+}
+function requiredToFinish(kind) {
+  const k = kind ?? "WORKING";
+  return k === "WORKING" || k === "DROP";
+}
+
+// src/plate-loading.ts
+var CANONICAL_SCALE = 1e4;
+var DENSE_CAPACITY_LIMIT = 2e5;
+var toCanonicalUnits = (weightKg) => Math.round(weightKg * CANONICAL_SCALE);
+var fromCanonicalUnits = (units) => units / CANONICAL_SCALE;
+var greatestCommonDivisor = (left, right) => {
+  let a = Math.abs(left);
+  let b = Math.abs(right);
+  while (b > 0) {
+    const remainder = a % b;
+    a = b;
+    b = remainder;
+  }
+  return a;
+};
+var buildChunks = (plates, divisor) => {
+  const chunks = [];
+  plates.forEach((plate, plateIndex) => {
+    const pairValue = Math.round(
+      toCanonicalUnits(plate.weightKg) * 2 / divisor
+    );
+    let remaining = plate.pairCount;
+    let chunkSize = 1;
+    while (remaining > 0) {
+      const quantity = Math.min(chunkSize, remaining);
+      chunks.push({
+        plateIndex,
+        quantity,
+        value: pairValue * quantity
+      });
+      remaining -= quantity;
+      chunkSize *= 2;
+    }
+  });
+  return chunks;
+};
+var reconstructSelection = (best, chunks, previousSum, previousChunk, plateCount) => {
+  const selection = Array.from({ length: plateCount }, () => 0);
+  let current = best;
+  while (current > 0) {
+    const chunkIndex = previousChunk(current);
+    if (chunkIndex < 0) break;
+    const chunk = chunks[chunkIndex];
+    selection[chunk.plateIndex] += chunk.quantity;
+    current = previousSum(current);
+  }
+  return selection;
+};
+var solveDense = (capacity, chunks, plateCount) => {
+  const reachable = new Uint8Array(capacity + 1);
+  const previousSum = new Int32Array(capacity + 1);
+  const previousChunk = new Int16Array(capacity + 1);
+  previousSum.fill(-1);
+  previousChunk.fill(-1);
+  reachable[0] = 1;
+  chunks.forEach((chunk, chunkIndex) => {
+    for (let sum = capacity; sum >= chunk.value; sum -= 1) {
+      if (!reachable[sum] && reachable[sum - chunk.value]) {
+        reachable[sum] = 1;
+        previousSum[sum] = sum - chunk.value;
+        previousChunk[sum] = chunkIndex;
+      }
+    }
+  });
+  let best = capacity;
+  while (best > 0 && !reachable[best]) best -= 1;
+  return {
+    best,
+    selection: reconstructSelection(
+      best,
+      chunks,
+      (sum) => previousSum[sum],
+      (sum) => previousChunk[sum],
+      plateCount
+    )
+  };
+};
+var solveSparse = (capacity, chunks, plateCount) => {
+  const reachable = /* @__PURE__ */ new Map();
+  reachable.set(0, { previous: -1, chunkIndex: -1 });
+  chunks.forEach((chunk, chunkIndex) => {
+    const currentSums = Array.from(reachable.keys());
+    for (const sum of currentSums) {
+      const next = sum + chunk.value;
+      if (next <= capacity && !reachable.has(next)) {
+        reachable.set(next, { previous: sum, chunkIndex });
+      }
+    }
+  });
+  let best = 0;
+  for (const sum of reachable.keys()) {
+    if (sum > best) best = sum;
+  }
+  return {
+    best,
+    selection: reconstructSelection(
+      best,
+      chunks,
+      (sum) => reachable.get(sum)?.previous ?? -1,
+      (sum) => reachable.get(sum)?.chunkIndex ?? -1,
+      plateCount
+    )
+  };
+};
+var heaviestFirst = (target, pairValues, counts) => {
+  let remaining = target;
+  const selection = pairValues.map((value, index) => {
+    const take = Math.min(counts[index], Math.floor(remaining / value));
+    remaining -= take * value;
+    return take;
+  });
+  return remaining === 0 ? selection : null;
+};
+var plateTotal = (selection) => selection.reduce((total, count) => total + count, 0);
+var calculatePlateLoading = (targetWeightKg, barWeightKg, availablePlatePairs) => {
+  const targetUnits = Math.max(0, toCanonicalUnits(targetWeightKg));
+  const barUnits = Math.max(0, toCanonicalUnits(barWeightKg));
+  if (targetUnits < barUnits) {
+    return {
+      targetWeightKg: fromCanonicalUnits(targetUnits),
+      loadedWeightKg: fromCanonicalUnits(barUnits),
+      differenceKg: fromCanonicalUnits(barUnits - targetUnits),
+      status: "over",
+      platesPerSide: []
+    };
+  }
+  const plates = availablePlatePairs.filter((plate) => plate.weightKg > 0 && plate.pairCount > 0).sort((left, right) => right.weightKg - left.weightKg);
+  const pairValues = plates.map((plate) => toCanonicalUnits(plate.weightKg) * 2);
+  const divisor = pairValues.reduce(greatestCommonDivisor, 0) || 1;
+  const residualUnits = targetUnits - barUnits;
+  const requestedCapacity = Math.floor(residualUnits / divisor);
+  const inventoryCapacity = pairValues.reduce(
+    (total, value, index) => total + value / divisor * plates[index].pairCount,
+    0
+  );
+  const capacity = Math.min(requestedCapacity, inventoryCapacity);
+  const chunks = buildChunks(plates, divisor);
+  const solution = capacity <= DENSE_CAPACITY_LIMIT ? solveDense(capacity, chunks, plates.length) : solveSparse(capacity, chunks, plates.length);
+  const greedy = heaviestFirst(
+    solution.best,
+    pairValues.map((value) => value / divisor),
+    plates.map((plate) => plate.pairCount)
+  );
+  const selection = greedy && plateTotal(greedy) <= plateTotal(solution.selection) ? greedy : solution.selection;
+  const plateUnits = solution.best * divisor;
+  const loadedUnits = barUnits + plateUnits;
+  const differenceUnits = targetUnits - loadedUnits;
+  return {
+    targetWeightKg: fromCanonicalUnits(targetUnits),
+    loadedWeightKg: fromCanonicalUnits(loadedUnits),
+    differenceKg: fromCanonicalUnits(differenceUnits),
+    status: differenceUnits === 0 ? "exact" : "short",
+    platesPerSide: plates.flatMap(
+      (plate, index) => selection[index] > 0 ? [
+        {
+          weightKg: plate.weightKg,
+          platesPerSide: selection[index]
+        }
+      ] : []
+    )
+  };
+};
+
+// src/warm-ups.ts
+var MAX_SETS_PER_EXERCISE = 10;
+var BAR_WARM_UP_STEPS = [
+  { share: 0, reps: 10 },
+  { share: 0.4, reps: 5 },
+  { share: 0.6, reps: 3 },
+  { share: 0.8, reps: 2 }
+];
+var OTHER_WARM_UP_STEPS = [
+  { share: 0.5, reps: 8 },
+  { share: 0.75, reps: 3 }
+];
+var BAR_LOADED = /* @__PURE__ */ new Set(["barbell", "ez-bar", "smith-machine"]);
+var isBarLoaded = (equipmentRequired) => (equipmentRequired ?? []).some((item) => BAR_LOADED.has(item));
+var POUNDS_PER_KILOGRAM = 2.2046226218;
+var lb = (pounds) => pounds / POUNDS_PER_KILOGRAM;
+var BAR_CHOICES_KG = {
+  KG: [20, 15, 10],
+  LB: [lb(45), lb(35), lb(15)]
+};
+var pairs = (weights, heaviestPairs) => weights.map((weightKg, index) => ({
+  weightKg,
+  pairCount: index === 0 ? heaviestPairs : 2
+}));
+var PLATE_SETS = {
+  KG: {
+    STANDARD: pairs([25, 20, 15, 10, 5, 2.5, 1.25], 4),
+    LIGHT: pairs([20, 15, 10, 5, 2.5, 1.25], 2)
+  },
+  LB: {
+    STANDARD: pairs([45, 35, 25, 10, 5, 2.5].map(lb), 4),
+    LIGHT: pairs([25, 10, 5, 2.5].map(lb), 2)
+  }
+};
+var LIMITED_SHORTFALL_KG = 2.5;
+var defaultWarmUpEquipment = (unit) => ({
+  barWeightKg: BAR_CHOICES_KG[unit][0],
+  platePairs: PLATE_SETS[unit].STANDARD
+});
+var round = (value) => Math.round(value * 1e4) / 1e4;
+function warmUpLoad(share, workingWeightKg, equipment) {
+  const target = share * workingWeightKg;
+  if (equipment.barLoaded) {
+    const loading = calculatePlateLoading(
+      Math.max(target, equipment.barWeightKg),
+      equipment.barWeightKg,
+      [...equipment.platePairs]
+    );
+    return {
+      weightKg: round(loading.loadedWeightKg),
+      platesPerSide: loading.platesPerSide,
+      limited: share > 0 && loading.status === "short" && loading.differenceKg >= LIMITED_SHORTFALL_KG - 1e-9
+    };
+  }
+  const increment = equipment.incrementKg > 0 ? equipment.incrementKg : 2.5;
+  return {
+    weightKg: round(Math.floor(target / increment + 1e-9) * increment),
+    limited: false
+  };
+}
+function buildWarmUpRamp(input) {
+  const work = input.workingWeightKg;
+  if (!(work > 0)) return { sets: [], leftOut: 0 };
+  const steps = input.barLoaded ? BAR_WARM_UP_STEPS : OTHER_WARM_UP_STEPS;
+  const sets = [];
+  for (const step of steps) {
+    const load = warmUpLoad(step.share, work, input);
+    const previous = sets[sets.length - 1];
+    if (load.weightKg <= 0 || load.weightKg >= work - 1e-9) continue;
+    if (previous && load.weightKg <= previous.weightKg + 1e-9) continue;
+    sets.push({ ...load, reps: step.reps, share: step.share });
+  }
+  const room = Math.max(0, input.room);
+  const kept = sets.slice(Math.max(0, sets.length - room));
+  return { sets: kept, leftOut: sets.length - kept.length };
+}
+function leadWorkingWeight(sets) {
+  const lead = sets.find((set) => countsForProgression(set.kind));
+  return typeof lead?.weight === "number" && lead.weight > 0 ? lead.weight : null;
+}
+function followWorkingLoad(sets, equipment) {
+  const work = leadWorkingWeight(sets);
+  if (work === null) return [...sets];
+  return sets.map(
+    (set) => set.kind === "WARMUP" && typeof set.warmUpShare === "number" ? { ...set, weight: warmUpLoad(set.warmUpShare, work, equipment).weightKg } : set
+  );
+}
+
 // src/routine.ts
 var ROUTINE_SCHEDULE_MODES = ["WEEKLY", "ROTATION"];
 var ROUTINE_DAYS_MAX = 7;
@@ -632,13 +929,18 @@ var lighterOnGrid = (original, target, increment) => {
   const stepped = Math.round(Math.round(target / step) * step * 1e3) / 1e3;
   return stepped > 0 && stepped < original ? stepped : original;
 };
+function halveSets(sets) {
+  const work = sets.filter((set) => countsAsWork(set.kind));
+  const keep = new Set(work.slice(0, Math.ceil(work.length / 2)));
+  return sets.filter((set) => !countsAsWork(set.kind) || keep.has(set)).map((set, index) => ({ ...set, setNumber: index + 1 }));
+}
 function applyDeload(setup, options) {
   const factor = 1 - options.loadReductionPercent / 100;
   let lighter = false;
   const days = setup.days.map((day) => ({
     ...day,
     exercises: day.exercises.map((exercise) => {
-      const kept = options.setMode === "HALF" ? exercise.sets.slice(0, Math.ceil(exercise.sets.length / 2)) : exercise.sets;
+      const kept = options.setMode === "HALF" ? halveSets(exercise.sets) : exercise.sets;
       if (kept.length < exercise.sets.length) lighter = true;
       return {
         ...exercise,
@@ -931,6 +1233,8 @@ function accountExportFileName(username, exportedAt) {
   ACTIVITY_REACTIONS,
   ACTIVITY_TYPES,
   ACTIVITY_TYPE_SECTIONS,
+  BAR_CHOICES_KG,
+  BAR_WARM_UP_STEPS,
   BLOCKED_MEMBERS_MAX,
   CLONE_ROUTINE_REFUSALS,
   COMEBACK_MIN_INACTIVE_DAYS,
@@ -958,6 +1262,8 @@ function accountExportFileName(username, exportedAt) {
   FOLLOW_SUGGESTIONS_DEFAULT_LIMIT,
   FOLLOW_SUGGESTIONS_MAX_LIMIT,
   FOLLOW_SUGGESTION_REASONS,
+  LIMITED_SHORTFALL_KG,
+  MAX_SETS_PER_EXERCISE,
   MEASURABLE_GOALS_MAX,
   MEASURABLE_GOAL_DIRECTIONS,
   MEASURABLE_GOAL_TYPES,
@@ -973,12 +1279,14 @@ function accountExportFileName(username, exportedAt) {
   NOTIFICATIONS_RETENTION_DAYS,
   NOTIFICATION_CATEGORIES,
   NOTIFICATION_KINDS,
+  OTHER_WARM_UP_STEPS,
   PLATEAU_MIN_DAYS_SINCE_BEST,
   PLATEAU_MIN_SESSIONS,
   PLATEAU_MIN_SESSIONS_MAX,
   PLATEAU_MIN_SESSIONS_MIN,
   PLATEAU_RECENT_DAYS,
   PLATEAU_WINDOW_DAYS,
+  PLATE_SETS,
   PREFERRED_TRAINING_STYLE_VALUES,
   PROFILE_BIO_MAX_LENGTH,
   PROFILE_FAVORITE_EXERCISES_MAX,
@@ -1034,6 +1342,8 @@ function accountExportFileName(username, exportedAt) {
   SESSION_SHARE_DEFAULT_FIELDS,
   SESSION_SHARE_FIELDS,
   SESSION_SHARE_MAX_ACTIVE_LINKS,
+  SET_KINDS,
+  SET_KIND_LABELS,
   SEXES,
   SHARED_ROUTINE_SOURCES,
   STARRED_EXERCISES_MAX,
@@ -1069,13 +1379,25 @@ function accountExportFileName(username, exportedAt) {
   WORKOUT_SESSION_STATUSES,
   accountExportFileName,
   applyDeload,
+  buildWarmUpRamp,
+  calculatePlateLoading,
+  countsAsWork,
+  countsForProgression,
+  defaultWarmUpEquipment,
   deloadLengthDays,
+  followWorkingLoad,
+  isBarLoaded,
+  isSetKind,
   isWithinQuietHours,
+  leadWorkingWeight,
   matchesDeletionConfirmation,
+  requiredToFinish,
   resolveActiveTrainingBlock,
   resolveRoutinePlan,
   routineDayLabel,
   sessionCorrectionWindow,
+  setKindOf,
   setLogValuesDiffer,
-  trainingBlockCovers
+  trainingBlockCovers,
+  warmUpLoad
 });