@holoscript/plugin-fitness-wellness 2.0.1 → 2.0.2

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@holoscript/plugin-fitness-wellness",
-  "version": "2.0.1",
+  "version": "2.0.2",
   "main": "src/index.ts",
   "peerDependencies": {
-    "@holoscript/core": "8.0.6"
+    "@holoscript/core": ">=8.0.0"
   },
   "license": "MIT",
   "scripts": {
     "test": "vitest run --passWithNoTests",
     "test:coverage": "vitest run --coverage --passWithNoTests"
   }
-}
+}

package/src/__tests__/fitnesssolver.test.ts

@@ -45,11 +45,11 @@ describe('oneRepMax', () => {
 
   it('Brzycki formula: 100 kg × 5 reps ≈ 112.5 kg', () => {
     const r = oneRepMax(100, 5);
-    expect(r.brzycki).toBeCloseTo(100 * 36 / 32, 3);
+    expect(r.brzycki).toBeCloseTo((100 * 36) / 32, 3);
   });
 
   it('higher reps → higher 1RM estimate', () => {
-    const r5  = oneRepMax(100, 5);
+    const r5 = oneRepMax(100, 5);
     const r10 = oneRepMax(100, 10);
     expect(r10.average).toBeGreaterThan(r5.average);
   });
@@ -125,7 +125,7 @@ describe('vo2MaxNonExercise', () => {
 
   it('older age → lower VO2max (all else equal)', () => {
     const rYoung = vo2MaxNonExercise(25, 25, 5, true);
-    const rOld   = vo2MaxNonExercise(55, 25, 5, true);
+    const rOld = vo2MaxNonExercise(55, 25, 5, true);
     expect(rOld.vo2MaxMlKgMin).toBeLessThan(rYoung.vo2MaxMlKgMin);
   });
 
@@ -241,7 +241,7 @@ describe('jacksonPollockSkinfold', () => {
 
   it('body density ~1.07 (plausible for lean male)', () => {
     expect(male.bodyDensityGcc).toBeGreaterThan(1.04);
-    expect(male.bodyDensityGcc).toBeLessThan(1.10);
+    expect(male.bodyDensityGcc).toBeLessThan(1.1);
   });
 
   it('higher skinfolds → higher body fat %', () => {
@@ -357,7 +357,7 @@ describe('acuteChronicWorkloadRatio — risk-band classification', () => {
 describe('analyzeFitness', () => {
   it('returns all sub-results when all inputs provided', () => {
     const r = analyzeFitness({
-      oneRM:  { weightKg: 100, reps: 5 },
+      oneRM: { weightKg: 100, reps: 5 },
       vo2Max: { method: 'cooper', distanceM: 2400 },
       hrZones: { hrRest: 60, hrMax: 190 },
       calories: { met: 9.8, bodyMassKg: 70, durationMin: 30 },

package/src/__tests__/runtime-integration.test.ts

@@ -57,9 +57,7 @@ describe('fitness-wellness -> HoloScript runtime integration (one_rep_max)', ()
       solved.push(e as Record<string, unknown>);
     });
 
-    await runtime.executeNode(
-      oneRepMaxOrb({ weightKg: TEST_WEIGHT_KG, reps: TEST_REPS }) as never,
-    );
+    await runtime.executeNode(oneRepMaxOrb({ weightKg: TEST_WEIGHT_KG, reps: TEST_REPS }) as never);
     await flush();
 
     expect(solved).toHaveLength(1);
@@ -79,9 +77,7 @@ describe('fitness-wellness -> HoloScript runtime integration (one_rep_max)', ()
     const solved: unknown[] = [];
     runtime.on('one_rep_max_solved', (e: unknown) => solved.push(e));
 
-    await runtime.executeNode(
-      oneRepMaxOrb({ weightKg: TEST_WEIGHT_KG, reps: TEST_REPS }) as never,
-    );
+    await runtime.executeNode(oneRepMaxOrb({ weightKg: TEST_WEIGHT_KG, reps: TEST_REPS }) as never);
     await flush();
 
     expect(solved).toHaveLength(0);
@@ -91,9 +87,7 @@ describe('fitness-wellness -> HoloScript runtime integration (one_rep_max)', ()
     const runtime = new HoloScriptRuntime();
     registerFitnessWellnessTraitHandlers(runtime);
 
-    await runtime.executeNode(
-      oneRepMaxOrb({ weightKg: TEST_WEIGHT_KG, reps: TEST_REPS }) as never,
-    );
+    await runtime.executeNode(oneRepMaxOrb({ weightKg: TEST_WEIGHT_KG, reps: TEST_REPS }) as never);
     await flush();
 
     const state = runtime.getState() as Record<string, unknown>;
@@ -119,9 +113,7 @@ describe('fitness-wellness -> HoloScript runtime integration (one_rep_max)', ()
     // reps = 0 is invalid — the real solver throws "reps must be a positive
     // integer", which the handler's try/catch turns into a one_rep_max_error
     // rather than a throw through the runtime.
-    await runtime.executeNode(
-      oneRepMaxOrb({ weightKg: TEST_WEIGHT_KG, reps: 0 }) as never,
-    );
+    await runtime.executeNode(oneRepMaxOrb({ weightKg: TEST_WEIGHT_KG, reps: 0 }) as never);
     await flush();
 
     expect(errors).toHaveLength(1);

package/src/fitnesssolver.ts

@@ -120,15 +120,23 @@ export function oneRepMax(weightKg: number, reps: number): OneRepMaxResult {
   if (weightKg <= 0) throw new Error('weightKg must be positive');
   if (reps < 1 || !Number.isInteger(reps)) throw new Error('reps must be a positive integer');
   if (reps === 1) {
-    return { weightKg, reps, epley: weightKg, brzycki: weightKg, lander: weightKg, lombardi: weightKg, average: weightKg };
+    return {
+      weightKg,
+      reps,
+      epley: weightKg,
+      brzycki: weightKg,
+      lander: weightKg,
+      lombardi: weightKg,
+      average: weightKg,
+    };
   }
   if (reps > 30) throw new Error('reps > 30 is outside the validated range');
 
-  const epley    = weightKg * (1 + reps / 30);
-  const brzycki  = weightKg * 36 / (37 - reps);
-  const lander   = 100 * weightKg / (101.3 - 2.67123 * reps);
-  const lombardi = weightKg * Math.pow(reps, 0.10);
-  const average  = (epley + brzycki + lander + lombardi) / 4;
+  const epley = weightKg * (1 + reps / 30);
+  const brzycki = (weightKg * 36) / (37 - reps);
+  const lander = (100 * weightKg) / (101.3 - 2.67123 * reps);
+  const lombardi = weightKg * Math.pow(reps, 0.1);
+  const average = (epley + brzycki + lander + lombardi) / 4;
 
   return { weightKg, reps, epley, brzycki, lander, lombardi, average };
 }
@@ -142,7 +150,11 @@ export function oneRepMax(weightKg: number, reps: number): OneRepMaxResult {
 export function vo2MaxCooper(distanceMeters: number): VO2MaxResult {
   if (distanceMeters <= 0) throw new Error('distanceMeters must be positive');
   const vo2 = (distanceMeters - 504.9) / 44.73;
-  return { vo2MaxMlKgMin: Math.max(0, vo2), method: 'cooper-12min', fitnessClass: classifyVO2(vo2) };
+  return {
+    vo2MaxMlKgMin: Math.max(0, vo2),
+    method: 'cooper-12min',
+    fitnessClass: classifyVO2(vo2),
+  };
 }
 
 /**
@@ -157,7 +169,7 @@ export function vo2MaxAstrand(
   workRateWatts: number,
   hrSteadyState: number,
   bodyMassKg: number,
-  ageYears: number,
+  ageYears: number
 ): VO2MaxResult {
   if (workRateWatts <= 0) throw new Error('workRateWatts must be positive');
   if (hrSteadyState <= 0 || hrSteadyState > 250) throw new Error('hrSteadyState out of range');
@@ -172,7 +184,11 @@ export function vo2MaxAstrand(
   const correctionFactor = hrMax / hrSteadyState;
   const vo2Max = vo2Gross * correctionFactor * 0.836; // empirical scaling
 
-  return { vo2MaxMlKgMin: Math.max(0, vo2Max), method: 'astrand-rhyming', fitnessClass: classifyVO2(vo2Max) };
+  return {
+    vo2MaxMlKgMin: Math.max(0, vo2Max),
+    method: 'astrand-rhyming',
+    fitnessClass: classifyVO2(vo2Max),
+  };
 }
 
 /**
@@ -184,15 +200,21 @@ export function vo2MaxNonExercise(
   ageYears: number,
   bmi: number,
   physicalActivityRating: number, // PA-R: 0-10 Likert scale
-  isMale: boolean,
+  isMale: boolean
 ): VO2MaxResult {
   if (ageYears < 10 || ageYears > 100) throw new Error('ageYears out of range [10, 100]');
   if (bmi <= 10 || bmi > 70) throw new Error('BMI out of plausible range');
-  if (physicalActivityRating < 0 || physicalActivityRating > 10) throw new Error('PA_R must be in [0, 10]');
+  if (physicalActivityRating < 0 || physicalActivityRating > 10)
+    throw new Error('PA_R must be in [0, 10]');
 
   const sex = isMale ? 1 : 0;
-  const vo2 = 56.363 + 1.921 * physicalActivityRating - 0.381 * ageYears - 0.754 * bmi + 10.987 * sex;
-  return { vo2MaxMlKgMin: Math.max(10, vo2), method: 'non-exercise', fitnessClass: classifyVO2(vo2) };
+  const vo2 =
+    56.363 + 1.921 * physicalActivityRating - 0.381 * ageYears - 0.754 * bmi + 10.987 * sex;
+  return {
+    vo2MaxMlKgMin: Math.max(10, vo2),
+    method: 'non-exercise',
+    fitnessClass: classifyVO2(vo2),
+  };
 }
 
 function classifyVO2(vo2: number): VO2MaxResult['fitnessClass'] {
@@ -220,13 +242,15 @@ export function heartRateZones(hrRest: number, hrMax: number): HeartRateZoneResu
   });
 
   return {
-    hrRest, hrMax, hrr,
+    hrRest,
+    hrMax,
+    hrr,
     zones: {
-      zone1: { ...zone(0.50, 0.60), label: 'Recovery / Active Rest' },
-      zone2: { ...zone(0.60, 0.70), label: 'Aerobic Base / Fat Burn' },
-      zone3: { ...zone(0.70, 0.80), label: 'Aerobic / Tempo' },
-      zone4: { ...zone(0.80, 0.90), label: 'Lactate Threshold' },
-      zone5: { ...zone(0.90, 1.00), label: 'VO2max / Neuromuscular' },
+      zone1: { ...zone(0.5, 0.6), label: 'Recovery / Active Rest' },
+      zone2: { ...zone(0.6, 0.7), label: 'Aerobic Base / Fat Burn' },
+      zone3: { ...zone(0.7, 0.8), label: 'Aerobic / Tempo' },
+      zone4: { ...zone(0.8, 0.9), label: 'Lactate Threshold' },
+      zone5: { ...zone(0.9, 1.0), label: 'VO2max / Neuromuscular' },
     },
   };
 }
@@ -235,21 +259,21 @@ export function heartRateZones(hrRest: number, hrMax: number): HeartRateZoneResu
 
 /** Common activity METs from the Compendium of Physical Activities (2011) */
 export const ACTIVITY_METS: Record<string, number> = {
-  running_6mph:        9.8,
-  running_8mph:       11.8,
-  running_10mph:      14.5,
-  cycling_moderate:    8.0,
-  cycling_vigorous:   12.0,
-  swimming_moderate:   6.0,
-  swimming_vigorous:   9.8,
-  walking_3mph:        3.5,
-  walking_4mph:        5.0,
-  strength_training:   3.5,
-  yoga:                2.5,
-  rowing_moderate:     7.0,
-  rowing_vigorous:    12.0,
-  basketball:          8.0,
-  soccer:              7.0,
+  running_6mph: 9.8,
+  running_8mph: 11.8,
+  running_10mph: 14.5,
+  cycling_moderate: 8.0,
+  cycling_vigorous: 12.0,
+  swimming_moderate: 6.0,
+  swimming_vigorous: 9.8,
+  walking_3mph: 3.5,
+  walking_4mph: 5.0,
+  strength_training: 3.5,
+  yoga: 2.5,
+  rowing_moderate: 7.0,
+  rowing_vigorous: 12.0,
+  basketball: 8.0,
+  soccer: 7.0,
 };
 
 /**
@@ -257,7 +281,11 @@ export const ACTIVITY_METS: Record<string, number> = {
  * Gross: MET × bodyMassKg × durationHours
  * Net: gross − BMR_rate × duration (approximate BMR ≈ 1 MET contribution)
  */
-export function calorieBurn(met: number, bodyMassKg: number, durationMin: number): CalorieBurnResult {
+export function calorieBurn(
+  met: number,
+  bodyMassKg: number,
+  durationMin: number
+): CalorieBurnResult {
   if (met <= 0) throw new Error('MET must be positive');
   if (bodyMassKg <= 0) throw new Error('bodyMassKg must be positive');
   if (durationMin <= 0) throw new Error('durationMin must be positive');
@@ -284,9 +312,10 @@ export function jacksonPollockSkinfold(
   s3Mm: number,
   ageYears: number,
   isMale: boolean,
-  bodyMassKg: number,
+  bodyMassKg: number
 ): BodyCompositionResult {
-  if (s1Mm <= 0 || s2Mm <= 0 || s3Mm <= 0) throw new Error('Skinfold measurements must be positive');
+  if (s1Mm <= 0 || s2Mm <= 0 || s3Mm <= 0)
+    throw new Error('Skinfold measurements must be positive');
   if (ageYears < 18 || ageYears > 80) throw new Error('Age must be in [18, 80]');
   if (bodyMassKg <= 0) throw new Error('bodyMassKg must be positive');
 
@@ -304,8 +333,8 @@ export function jacksonPollockSkinfold(
   }
 
   // Siri equation
-  const bodyFatPct = (4.95 / density - 4.50) * 100;
-  const fatMassKg = bodyMassKg * bodyFatPct / 100;
+  const bodyFatPct = (4.95 / density - 4.5) * 100;
+  const fatMassKg = (bodyMassKg * bodyFatPct) / 100;
   const leanMassKg = bodyMassKg - fatMassKg;
 
   return { skinfoldSumMm: sum, bodyDensityGcc: density, bodyFatPct, fatMassKg, leanMassKg };
@@ -356,12 +385,26 @@ export function acuteChronicWorkloadRatio(workloads: number[]): TrainingLoadResu
 
 export interface FitnessAnalysisInput {
   oneRM?: { weightKg: number; reps: number };
-  vo2Max?: { method: 'cooper'; distanceM: number } |
-           { method: 'astrand'; workRateW: number; hrSteady: number; bodyMassKg: number; ageYears: number } |
-           { method: 'non-exercise'; ageYears: number; bmi: number; paRating: number; isMale: boolean };
+  vo2Max?:
+    | { method: 'cooper'; distanceM: number }
+    | {
+        method: 'astrand';
+        workRateW: number;
+        hrSteady: number;
+        bodyMassKg: number;
+        ageYears: number;
+      }
+    | { method: 'non-exercise'; ageYears: number; bmi: number; paRating: number; isMale: boolean };
   hrZones?: { hrRest: number; hrMax: number };
   calories?: { met: number; bodyMassKg: number; durationMin: number };
-  bodyComp?: { s1: number; s2: number; s3: number; ageYears: number; isMale: boolean; bodyMassKg: number };
+  bodyComp?: {
+    s1: number;
+    s2: number;
+    s3: number;
+    ageYears: number;
+    isMale: boolean;
+    bodyMassKg: number;
+  };
   trainingLoad?: { workloads: number[] };
 }
 
@@ -383,17 +426,24 @@ export function analyzeFitness(input: FitnessAnalysisInput): FitnessAnalysisResu
   if (input.vo2Max) {
     const v = input.vo2Max;
     if (v.method === 'cooper') result.vo2Max = vo2MaxCooper(v.distanceM);
-    else if (v.method === 'astrand') result.vo2Max = vo2MaxAstrand(v.workRateW, v.hrSteady, v.bodyMassKg, v.ageYears);
+    else if (v.method === 'astrand')
+      result.vo2Max = vo2MaxAstrand(v.workRateW, v.hrSteady, v.bodyMassKg, v.ageYears);
     else result.vo2Max = vo2MaxNonExercise(v.ageYears, v.bmi, v.paRating, v.isMale);
   }
 
   if (input.hrZones) result.hrZones = heartRateZones(input.hrZones.hrRest, input.hrZones.hrMax);
-  if (input.calories) result.calories = calorieBurn(input.calories.met, input.calories.bodyMassKg, input.calories.durationMin);
+  if (input.calories)
+    result.calories = calorieBurn(
+      input.calories.met,
+      input.calories.bodyMassKg,
+      input.calories.durationMin
+    );
   if (input.bodyComp) {
     const b = input.bodyComp;
     result.bodyComp = jacksonPollockSkinfold(b.s1, b.s2, b.s3, b.ageYears, b.isMale, b.bodyMassKg);
   }
-  if (input.trainingLoad) result.trainingLoad = acuteChronicWorkloadRatio(input.trainingLoad.workloads);
+  if (input.trainingLoad)
+    result.trainingLoad = acuteChronicWorkloadRatio(input.trainingLoad.workloads);
 
   return result;
 }
@@ -402,15 +452,21 @@ export function analyzeFitness(input: FitnessAnalysisInput): FitnessAnalysisResu
 
 export function buildFitnessReceipt(
   result: FitnessAnalysisResult,
-  options?: FitnessReceiptOptions,
+  options?: FitnessReceiptOptions
 ): DomainSimulationReceipt {
   const violations: Array<{ criterion: string; message: string }> = [];
 
   if (result.bodyComp && (result.bodyComp.bodyFatPct < 3 || result.bodyComp.bodyFatPct > 60)) {
-    violations.push({ criterion: 'body_fat', message: `body fat ${result.bodyComp.bodyFatPct.toFixed(1)}% outside plausible range [3%, 60%]` });
+    violations.push({
+      criterion: 'body_fat',
+      message: `body fat ${result.bodyComp.bodyFatPct.toFixed(1)}% outside plausible range [3%, 60%]`,
+    });
   }
   if (result.trainingLoad && result.trainingLoad.riskCategory === 'very-high') {
-    violations.push({ criterion: 'acwr', message: `ACWR ${result.trainingLoad.acwr.toFixed(2)} is very high (>1.5) — injury risk elevated` });
+    violations.push({
+      criterion: 'acwr',
+      message: `ACWR ${result.trainingLoad.acwr.toFixed(2)} is very high (>1.5) — injury risk elevated`,
+    });
   }
 
   return buildDomainSimulationReceipt({
@@ -425,7 +481,11 @@ export function buildFitnessReceipt(
       bodyFatPct: result.bodyComp?.bodyFatPct ?? null,
       acwr: result.trainingLoad?.acwr ?? null,
     },
-    cael: { version: 'cael.v1', event: 'fitness_wellness.fitness_analysis', solverType: 'fitness-wellness.analytics' },
+    cael: {
+      version: 'cael.v1',
+      event: 'fitness_wellness.fitness_analysis',
+      solverType: 'fitness-wellness.analytics',
+    },
     acceptance: { accepted: violations.length === 0, violations },
   });
 }

package/src/index.ts

@@ -1,7 +1,21 @@
-export { createWorkoutHandler, type WorkoutConfig, type WorkoutType, type ExerciseSet } from './traits/WorkoutTrait';
+export {
+  createWorkoutHandler,
+  type WorkoutConfig,
+  type WorkoutType,
+  type ExerciseSet,
+} from './traits/WorkoutTrait';
 export { createRepCounterHandler, type RepCounterConfig } from './traits/RepCounterTrait';
-export { createExerciseLibraryHandler, type ExerciseLibraryConfig, type Exercise, type MuscleGroup } from './traits/ExerciseLibraryTrait';
-export { createProgressTrackerHandler, type ProgressTrackerConfig, type ProgressEntry } from './traits/ProgressTrackerTrait';
+export {
+  createExerciseLibraryHandler,
+  type ExerciseLibraryConfig,
+  type Exercise,
+  type MuscleGroup,
+} from './traits/ExerciseLibraryTrait';
+export {
+  createProgressTrackerHandler,
+  type ProgressTrackerConfig,
+  type ProgressEntry,
+} from './traits/ProgressTrackerTrait';
 export * from './traits/types';
 
 import { createWorkoutHandler } from './traits/WorkoutTrait';
@@ -25,5 +39,25 @@ export {
   type TraitRegistrar,
 } from './runtime';
 
-export const pluginMeta = { name: '@holoscript/plugin-fitness-wellness', version: '1.0.0', traits: ['workout', 'rep_counter', 'exercise_library', 'progress_tracker', 'one_rep_max', 'vo2max', 'hr_zones', 'calorie_burn', 'body_composition', 'training_load_acwr'] };
-export const traitHandlers = [createWorkoutHandler(), createRepCounterHandler(), createExerciseLibraryHandler(), createProgressTrackerHandler()];
+export const pluginMeta = {
+  name: '@holoscript/plugin-fitness-wellness',
+  version: '1.0.0',
+  traits: [
+    'workout',
+    'rep_counter',
+    'exercise_library',
+    'progress_tracker',
+    'one_rep_max',
+    'vo2max',
+    'hr_zones',
+    'calorie_burn',
+    'body_composition',
+    'training_load_acwr',
+  ],
+};
+export const traitHandlers = [
+  createWorkoutHandler(),
+  createRepCounterHandler(),
+  createExerciseLibraryHandler(),
+  createProgressTrackerHandler(),
+];

package/src/runtime.ts

@@ -66,7 +66,7 @@ export interface RuntimeTraitHandler {
     node: unknown,
     config: OneRepMaxTraitConfig,
     context: TraitDispatchContext,
-    delta: number,
+    delta: number
   ) => void;
 }
 
@@ -81,7 +81,7 @@ interface OneRepMaxNode {
 function solveOntoNode(
   node: unknown,
   config: OneRepMaxTraitConfig | undefined,
-  context: TraitDispatchContext,
+  context: TraitDispatchContext
 ): void {
   const carrier = node as OneRepMaxNode;
   const nodeId = carrier.id ?? carrier.name ?? 'unknown';
@@ -91,8 +91,7 @@ function solveOntoNode(
   if (typeof weightKg !== 'number' || typeof reps !== 'number') {
     context.emit('one_rep_max_error', {
       nodeId,
-      error:
-        'one_rep_max trait requires config.weightKg (number) and config.reps (number)',
+      error: 'one_rep_max trait requires config.weightKg (number) and config.reps (number)',
     });
     return;
   }

package/src/traits/ExerciseLibraryTrait.ts

@@ -1,20 +1,62 @@
 /** @exercise_library Trait — Exercise database. @trait exercise_library */
 import type { TraitHandler, HSPlusNode, TraitContext, TraitEvent } from './types';
 
-export type MuscleGroup = 'chest' | 'back' | 'shoulders' | 'biceps' | 'triceps' | 'quadriceps' | 'hamstrings' | 'glutes' | 'calves' | 'core' | 'full_body';
-export interface Exercise { id: string; name: string; primaryMuscle: MuscleGroup; secondaryMuscles: MuscleGroup[]; equipment: string[]; instructions: string; videoUrl?: string; }
-export interface ExerciseLibraryConfig { exercises: Exercise[]; categories: string[]; }
+export type MuscleGroup =
+  | 'chest'
+  | 'back'
+  | 'shoulders'
+  | 'biceps'
+  | 'triceps'
+  | 'quadriceps'
+  | 'hamstrings'
+  | 'glutes'
+  | 'calves'
+  | 'core'
+  | 'full_body';
+export interface Exercise {
+  id: string;
+  name: string;
+  primaryMuscle: MuscleGroup;
+  secondaryMuscles: MuscleGroup[];
+  equipment: string[];
+  instructions: string;
+  videoUrl?: string;
+}
+export interface ExerciseLibraryConfig {
+  exercises: Exercise[];
+  categories: string[];
+}
 
 const defaultConfig: ExerciseLibraryConfig = { exercises: [], categories: [] };
 
 export function createExerciseLibraryHandler(): TraitHandler<ExerciseLibraryConfig> {
-  return { name: 'exercise_library', defaultConfig,
-    onAttach(n: HSPlusNode, c: ExerciseLibraryConfig, ctx: TraitContext) { n.__libState = { loaded: c.exercises.length }; ctx.emit?.('library:loaded', { exercises: c.exercises.length }); },
-    onDetach(n: HSPlusNode, _c: ExerciseLibraryConfig, ctx: TraitContext) { delete n.__libState; ctx.emit?.('library:unloaded'); },
+  return {
+    name: 'exercise_library',
+    defaultConfig,
+    onAttach(n: HSPlusNode, c: ExerciseLibraryConfig, ctx: TraitContext) {
+      n.__libState = { loaded: c.exercises.length };
+      ctx.emit?.('library:loaded', { exercises: c.exercises.length });
+    },
+    onDetach(n: HSPlusNode, _c: ExerciseLibraryConfig, ctx: TraitContext) {
+      delete n.__libState;
+      ctx.emit?.('library:unloaded');
+    },
     onUpdate() {},
     onEvent(_n: HSPlusNode, c: ExerciseLibraryConfig, ctx: TraitContext, e: TraitEvent) {
-      if (e.type === 'library:search') { const muscle = e.payload?.muscle as MuscleGroup; const results = c.exercises.filter(ex => ex.primaryMuscle === muscle || ex.secondaryMuscles.includes(muscle)); ctx.emit?.('library:results', { count: results.length, exercises: results.map(r => r.name) }); }
-      if (e.type === 'library:random') { const ex = c.exercises[Math.floor(Math.random() * c.exercises.length)]; if (ex) ctx.emit?.('library:suggestion', { exercise: ex.name, muscle: ex.primaryMuscle }); }
+      if (e.type === 'library:search') {
+        const muscle = e.payload?.muscle as MuscleGroup;
+        const results = c.exercises.filter(
+          (ex) => ex.primaryMuscle === muscle || ex.secondaryMuscles.includes(muscle)
+        );
+        ctx.emit?.('library:results', {
+          count: results.length,
+          exercises: results.map((r) => r.name),
+        });
+      }
+      if (e.type === 'library:random') {
+        const ex = c.exercises[Math.floor(Math.random() * c.exercises.length)];
+        if (ex) ctx.emit?.('library:suggestion', { exercise: ex.name, muscle: ex.primaryMuscle });
+      }
     },
   };
 }

package/src/traits/ProgressTrackerTrait.ts

@@ -1,28 +1,67 @@
 /** @progress_tracker Trait — Fitness progress over time. @trait progress_tracker */
 import type { TraitHandler, HSPlusNode, TraitContext, TraitEvent } from './types';
 
-export interface ProgressEntry { date: string; metric: string; value: number; unit: string; }
-export interface ProgressTrackerConfig { userId: string; metrics: string[]; goalValues: Record<string, number>; trackingPeriodDays: number; }
-export interface ProgressTrackerState { entries: ProgressEntry[]; streakDays: number; lastLogDate: string | null; goalsReached: string[]; }
+export interface ProgressEntry {
+  date: string;
+  metric: string;
+  value: number;
+  unit: string;
+}
+export interface ProgressTrackerConfig {
+  userId: string;
+  metrics: string[];
+  goalValues: Record<string, number>;
+  trackingPeriodDays: number;
+}
+export interface ProgressTrackerState {
+  entries: ProgressEntry[];
+  streakDays: number;
+  lastLogDate: string | null;
+  goalsReached: string[];
+}
 
-const defaultConfig: ProgressTrackerConfig = { userId: '', metrics: ['weight', 'body_fat', 'bench_press_1rm'], goalValues: {}, trackingPeriodDays: 90 };
+const defaultConfig: ProgressTrackerConfig = {
+  userId: '',
+  metrics: ['weight', 'body_fat', 'bench_press_1rm'],
+  goalValues: {},
+  trackingPeriodDays: 90,
+};
 
 export function createProgressTrackerHandler(): TraitHandler<ProgressTrackerConfig> {
-  return { name: 'progress_tracker', defaultConfig,
-    onAttach(n: HSPlusNode, _c: ProgressTrackerConfig, ctx: TraitContext) { n.__progressState = { entries: [], streakDays: 0, lastLogDate: null, goalsReached: [] }; ctx.emit?.('progress:initialized'); },
-    onDetach(n: HSPlusNode, _c: ProgressTrackerConfig, ctx: TraitContext) { delete n.__progressState; ctx.emit?.('progress:removed'); },
+  return {
+    name: 'progress_tracker',
+    defaultConfig,
+    onAttach(n: HSPlusNode, _c: ProgressTrackerConfig, ctx: TraitContext) {
+      n.__progressState = { entries: [], streakDays: 0, lastLogDate: null, goalsReached: [] };
+      ctx.emit?.('progress:initialized');
+    },
+    onDetach(n: HSPlusNode, _c: ProgressTrackerConfig, ctx: TraitContext) {
+      delete n.__progressState;
+      ctx.emit?.('progress:removed');
+    },
     onUpdate() {},
     onEvent(n: HSPlusNode, c: ProgressTrackerConfig, ctx: TraitContext, e: TraitEvent) {
-      const s = n.__progressState as ProgressTrackerState | undefined; if (!s) return;
+      const s = n.__progressState as ProgressTrackerState | undefined;
+      if (!s) return;
       if (e.type === 'progress:log') {
-        const entry: ProgressEntry = { date: new Date().toISOString().split('T')[0], metric: (e.payload?.metric as string) ?? '', value: (e.payload?.value as number) ?? 0, unit: (e.payload?.unit as string) ?? '' };
+        const entry: ProgressEntry = {
+          date: new Date().toISOString().split('T')[0],
+          metric: (e.payload?.metric as string) ?? '',
+          value: (e.payload?.value as number) ?? 0,
+          unit: (e.payload?.unit as string) ?? '',
+        };
         s.entries.push(entry);
         const today = entry.date;
-        if (s.lastLogDate && s.lastLogDate !== today) { const diff = (new Date(today).getTime() - new Date(s.lastLogDate).getTime()) / 86400000; s.streakDays = diff <= 1 ? s.streakDays + 1 : 1; }
-        else if (!s.lastLogDate) s.streakDays = 1;
+        if (s.lastLogDate && s.lastLogDate !== today) {
+          const diff = (new Date(today).getTime() - new Date(s.lastLogDate).getTime()) / 86400000;
+          s.streakDays = diff <= 1 ? s.streakDays + 1 : 1;
+        } else if (!s.lastLogDate) s.streakDays = 1;
         s.lastLogDate = today;
         const goal = c.goalValues[entry.metric];
-        if (goal !== undefined && entry.value >= goal && !s.goalsReached.includes(entry.metric)) { s.goalsReached.push(entry.metric); ctx.emit?.('progress:goal_reached', { metric: entry.metric, value: entry.value }); }
+        if (goal !== undefined && entry.value >= goal && !s.goalsReached.includes(entry.metric)) {
+          s.goalsReached.push(entry.metric);
+          ctx.emit?.('progress:goal_reached', { metric: entry.metric, value: entry.value });
+        }
         ctx.emit?.('progress:logged', { metric: entry.metric, streak: s.streakDays });
       }
     },

package/src/traits/RepCounterTrait.ts

@@ -1,25 +1,65 @@
 /** @rep_counter Trait — Repetition counting and form tracking. @trait rep_counter */
 import type { TraitHandler, HSPlusNode, TraitContext, TraitEvent } from './types';
 
-export interface RepCounterConfig { targetReps: number; exerciseName: string; formCheckEnabled: boolean; tempoUp: number; tempoDown: number; }
-export interface RepCounterState { currentReps: number; goodFormReps: number; badFormReps: number; isTracking: boolean; }
+export interface RepCounterConfig {
+  targetReps: number;
+  exerciseName: string;
+  formCheckEnabled: boolean;
+  tempoUp: number;
+  tempoDown: number;
+}
+export interface RepCounterState {
+  currentReps: number;
+  goodFormReps: number;
+  badFormReps: number;
+  isTracking: boolean;
+}
 
-const defaultConfig: RepCounterConfig = { targetReps: 10, exerciseName: '', formCheckEnabled: true, tempoUp: 2, tempoDown: 3 };
+const defaultConfig: RepCounterConfig = {
+  targetReps: 10,
+  exerciseName: '',
+  formCheckEnabled: true,
+  tempoUp: 2,
+  tempoDown: 3,
+};
 
 export function createRepCounterHandler(): TraitHandler<RepCounterConfig> {
-  return { name: 'rep_counter', defaultConfig,
-    onAttach(n: HSPlusNode, _c: RepCounterConfig, ctx: TraitContext) { n.__repState = { currentReps: 0, goodFormReps: 0, badFormReps: 0, isTracking: false }; ctx.emit?.('rep:ready'); },
-    onDetach(n: HSPlusNode, _c: RepCounterConfig, ctx: TraitContext) { delete n.__repState; ctx.emit?.('rep:stopped'); },
+  return {
+    name: 'rep_counter',
+    defaultConfig,
+    onAttach(n: HSPlusNode, _c: RepCounterConfig, ctx: TraitContext) {
+      n.__repState = { currentReps: 0, goodFormReps: 0, badFormReps: 0, isTracking: false };
+      ctx.emit?.('rep:ready');
+    },
+    onDetach(n: HSPlusNode, _c: RepCounterConfig, ctx: TraitContext) {
+      delete n.__repState;
+      ctx.emit?.('rep:stopped');
+    },
     onUpdate() {},
     onEvent(n: HSPlusNode, c: RepCounterConfig, ctx: TraitContext, e: TraitEvent) {
-      const s = n.__repState as RepCounterState | undefined; if (!s) return;
-      if (e.type === 'rep:start') { s.isTracking = true; s.currentReps = 0; s.goodFormReps = 0; s.badFormReps = 0; ctx.emit?.('rep:tracking'); }
+      const s = n.__repState as RepCounterState | undefined;
+      if (!s) return;
+      if (e.type === 'rep:start') {
+        s.isTracking = true;
+        s.currentReps = 0;
+        s.goodFormReps = 0;
+        s.badFormReps = 0;
+        ctx.emit?.('rep:tracking');
+      }
       if (e.type === 'rep:count' && s.isTracking) {
         s.currentReps++;
         const goodForm = (e.payload?.goodForm as boolean) ?? true;
-        if (goodForm) s.goodFormReps++; else s.badFormReps++;
-        ctx.emit?.('rep:counted', { reps: s.currentReps, target: c.targetReps, formRate: s.goodFormReps / s.currentReps });
-        if (s.currentReps >= c.targetReps) { s.isTracking = false; ctx.emit?.('rep:target_reached', { total: s.currentReps, goodForm: s.goodFormReps }); }
+        if (goodForm) s.goodFormReps++;
+        else s.badFormReps++;
+        ctx.emit?.('rep:counted', {
+          reps: s.currentReps,
+          target: c.targetReps,
+          formRate: s.goodFormReps / s.currentReps,
+        });
+        if (s.currentReps >= c.targetReps) {
+          s.isTracking = false;
+          ctx.emit?.('rep:target_reached', { total: s.currentReps, goodForm: s.goodFormReps });
+        }
       }
     },
   };

package/src/traits/WorkoutTrait.ts

@@ -1,23 +1,96 @@
 /** @workout Trait — Workout session definition. @trait workout */
 import type { TraitHandler, HSPlusNode, TraitContext, TraitEvent } from './types';
 
-export type WorkoutType = 'strength' | 'cardio' | 'hiit' | 'yoga' | 'pilates' | 'crossfit' | 'swimming' | 'cycling' | 'running';
-export interface ExerciseSet { exerciseId: string; reps: number; weightKg?: number; durationS?: number; restS: number; }
-export interface WorkoutConfig { name: string; type: WorkoutType; exercises: ExerciseSet[]; estimatedDurationMin: number; difficulty: 'beginner' | 'intermediate' | 'advanced'; calorieTarget?: number; }
-export interface WorkoutState { isActive: boolean; currentExercise: number; elapsedS: number; caloriesBurned: number; completedSets: number; }
+export type WorkoutType =
+  | 'strength'
+  | 'cardio'
+  | 'hiit'
+  | 'yoga'
+  | 'pilates'
+  | 'crossfit'
+  | 'swimming'
+  | 'cycling'
+  | 'running';
+export interface ExerciseSet {
+  exerciseId: string;
+  reps: number;
+  weightKg?: number;
+  durationS?: number;
+  restS: number;
+}
+export interface WorkoutConfig {
+  name: string;
+  type: WorkoutType;
+  exercises: ExerciseSet[];
+  estimatedDurationMin: number;
+  difficulty: 'beginner' | 'intermediate' | 'advanced';
+  calorieTarget?: number;
+}
+export interface WorkoutState {
+  isActive: boolean;
+  currentExercise: number;
+  elapsedS: number;
+  caloriesBurned: number;
+  completedSets: number;
+}
 
-const defaultConfig: WorkoutConfig = { name: '', type: 'strength', exercises: [], estimatedDurationMin: 30, difficulty: 'intermediate' };
+const defaultConfig: WorkoutConfig = {
+  name: '',
+  type: 'strength',
+  exercises: [],
+  estimatedDurationMin: 30,
+  difficulty: 'intermediate',
+};
 
 export function createWorkoutHandler(): TraitHandler<WorkoutConfig> {
-  return { name: 'workout', defaultConfig,
-    onAttach(n: HSPlusNode, _c: WorkoutConfig, ctx: TraitContext) { n.__workoutState = { isActive: false, currentExercise: 0, elapsedS: 0, caloriesBurned: 0, completedSets: 0 }; ctx.emit?.('workout:ready'); },
-    onDetach(n: HSPlusNode, _c: WorkoutConfig, ctx: TraitContext) { delete n.__workoutState; ctx.emit?.('workout:ended'); },
-    onUpdate(n: HSPlusNode, _c: WorkoutConfig, _ctx: TraitContext, delta: number) { const s = n.__workoutState as WorkoutState | undefined; if (s?.isActive) { s.elapsedS += delta / 1000; s.caloriesBurned += (delta / 1000) * 0.15; } },
+  return {
+    name: 'workout',
+    defaultConfig,
+    onAttach(n: HSPlusNode, _c: WorkoutConfig, ctx: TraitContext) {
+      n.__workoutState = {
+        isActive: false,
+        currentExercise: 0,
+        elapsedS: 0,
+        caloriesBurned: 0,
+        completedSets: 0,
+      };
+      ctx.emit?.('workout:ready');
+    },
+    onDetach(n: HSPlusNode, _c: WorkoutConfig, ctx: TraitContext) {
+      delete n.__workoutState;
+      ctx.emit?.('workout:ended');
+    },
+    onUpdate(n: HSPlusNode, _c: WorkoutConfig, _ctx: TraitContext, delta: number) {
+      const s = n.__workoutState as WorkoutState | undefined;
+      if (s?.isActive) {
+        s.elapsedS += delta / 1000;
+        s.caloriesBurned += (delta / 1000) * 0.15;
+      }
+    },
     onEvent(n: HSPlusNode, c: WorkoutConfig, ctx: TraitContext, e: TraitEvent) {
-      const s = n.__workoutState as WorkoutState | undefined; if (!s) return;
-      if (e.type === 'workout:start') { s.isActive = true; ctx.emit?.('workout:started', { type: c.type }); }
-      if (e.type === 'workout:complete_set') { s.completedSets++; if (s.completedSets >= c.exercises.length) { s.isActive = false; ctx.emit?.('workout:completed', { calories: Math.round(s.caloriesBurned), duration: Math.round(s.elapsedS) }); } else { s.currentExercise++; ctx.emit?.('workout:next_exercise', { index: s.currentExercise }); } }
-      if (e.type === 'workout:pause') { s.isActive = false; ctx.emit?.('workout:paused'); }
+      const s = n.__workoutState as WorkoutState | undefined;
+      if (!s) return;
+      if (e.type === 'workout:start') {
+        s.isActive = true;
+        ctx.emit?.('workout:started', { type: c.type });
+      }
+      if (e.type === 'workout:complete_set') {
+        s.completedSets++;
+        if (s.completedSets >= c.exercises.length) {
+          s.isActive = false;
+          ctx.emit?.('workout:completed', {
+            calories: Math.round(s.caloriesBurned),
+            duration: Math.round(s.elapsedS),
+          });
+        } else {
+          s.currentExercise++;
+          ctx.emit?.('workout:next_exercise', { index: s.currentExercise });
+        }
+      }
+      if (e.type === 'workout:pause') {
+        s.isActive = false;
+        ctx.emit?.('workout:paused');
+      }
     },
   };
 }

package/src/traits/types.ts

@@ -1,4 +1,22 @@
-export interface HSPlusNode { id?: string; properties?: Record<string, unknown>; [key: string]: unknown; }
-export interface TraitContext { emit?: (event: string, payload?: unknown) => void; [key: string]: unknown; }
-export interface TraitEvent { type: string; payload?: Record<string, unknown>; [key: string]: unknown; }
-export interface TraitHandler<T = unknown> { name: string; defaultConfig: T; onAttach(n: HSPlusNode, c: T, ctx: TraitContext): void; onDetach(n: HSPlusNode, c: T, ctx: TraitContext): void; onUpdate(n: HSPlusNode, c: T, ctx: TraitContext, d: number): void; onEvent(n: HSPlusNode, c: T, ctx: TraitContext, e: TraitEvent): void; }
+export interface HSPlusNode {
+  id?: string;
+  properties?: Record<string, unknown>;
+  [key: string]: unknown;
+}
+export interface TraitContext {
+  emit?: (event: string, payload?: unknown) => void;
+  [key: string]: unknown;
+}
+export interface TraitEvent {
+  type: string;
+  payload?: Record<string, unknown>;
+  [key: string]: unknown;
+}
+export interface TraitHandler<T = unknown> {
+  name: string;
+  defaultConfig: T;
+  onAttach(n: HSPlusNode, c: T, ctx: TraitContext): void;
+  onDetach(n: HSPlusNode, c: T, ctx: TraitContext): void;
+  onUpdate(n: HSPlusNode, c: T, ctx: TraitContext, d: number): void;
+  onEvent(n: HSPlusNode, c: T, ctx: TraitContext, e: TraitEvent): void;
+}

package/tsconfig.json

@@ -1 +1,5 @@
-{ "extends": "../../../tsconfig.json", "compilerOptions": { "outDir": "dist", "rootDir": "src", "declaration": true }, "include": ["src"] }
+{
+  "extends": "../../../tsconfig.json",
+  "compilerOptions": { "outDir": "dist", "rootDir": "src", "declaration": true },
+  "include": ["src"]
+}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025-2026 HoloScript Contributors
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.