blacktrigram 0.7.2

package/lib/systems/animation/systems/MuscleActivation.js

@@ -0,0 +1,427 @@
+import { KOREAN_STANCE_BIOMECHANICS } from "../builders/MartialArtsConstants.js";
+//#region src/systems/animation/systems/MuscleActivation.ts
+/**
+* Type-safe mapping of TrigramStance to biomechanics keys
+* Defined at module level to avoid recreation at 60fps
+* @korean 자세생체역학매핑
+*/
+var STANCE_TO_BIOMECH_KEY = {
+	geon: "GEON_HEAVEN",
+	tae: "TAE_LAKE",
+	li: "LI_FIRE",
+	jin: "JIN_THUNDER",
+	son: "SON_WIND",
+	gam: "GAM_WATER",
+	gan: "GAN_MOUNTAIN",
+	gon: "GON_EARTH"
+};
+/**
+* Get leg muscle tension for a specific trigram stance
+*
+* Calculates realistic leg muscle activation based on stance biomechanics:
+* - Weight distribution (체중부하) - Which leg bears more load
+* - Knee flexion angles (무릎굽힘각도) - Deep stances require more tension
+* - Isometric contraction (등척성수축) - Holding positions activates muscles
+*
+* Based on authentic Korean martial arts stance mechanics:
+* - Deep stances (Jin 90°, Gon 80°) = High quad/calf tension
+* - Front-weighted (Geon 60/40) = Front leg emphasis
+* - Back-weighted (Tae 10/90, Gam 30/70) = Back leg emphasis
+*
+* @param stance - Trigram stance (e.g., TrigramStance.GEON)
+* @returns Map of leg muscle groups to tension levels (0-1)
+*
+* @example
+* ```typescript
+* const jinMuscles = getMuscleTensionForStance(TrigramStance.JIN);
+* // Returns: Map {
+* //   "QUAD_L" => 0.90,  // Deep 90° knee bend
+* //   "QUAD_R" => 0.90,  // Equal weight distribution
+* //   "CALF_L" => 0.85,  // Isometric hold
+* //   "CALF_R" => 0.85,
+* //   "HAMSTRING_L" => 0.45,
+* //   "HAMSTRING_R" => 0.45,
+* //   "GLUTE_L" => 0.40,
+* //   "GLUTE_R" => 0.40
+* // }
+* ```
+*
+* @korean 자세다리근육긴장도
+*/
+var getMuscleTensionForStance = (stance) => {
+	const activations = /* @__PURE__ */ new Map();
+	const biomech = KOREAN_STANCE_BIOMECHANICS[STANCE_TO_BIOMECH_KEY[stance]];
+	if (!biomech) {
+		activations.set("QUAD_L", .2);
+		activations.set("QUAD_R", .2);
+		activations.set("CALF_L", .1);
+		activations.set("CALF_R", .1);
+		activations.set("HAMSTRING_L", .1);
+		activations.set("HAMSTRING_R", .1);
+		activations.set("GLUTE_L", .1);
+		activations.set("GLUTE_R", .1);
+		return activations;
+	}
+	const frontQuadTensionFromBend = Math.max(0, Math.min(1, (180 - biomech.frontKneeBend) / 110));
+	const backQuadTensionFromBend = Math.max(0, Math.min(1, (180 - biomech.backKneeBend) / 110));
+	const frontQuadTension = Math.min(1, frontQuadTensionFromBend * .6 + biomech.weightDistribution.front * .4);
+	const backQuadTension = Math.min(1, backQuadTensionFromBend * .6 + biomech.weightDistribution.back * .4);
+	activations.set("QUAD_R", frontQuadTension);
+	activations.set("QUAD_L", backQuadTension);
+	const frontHamstringTension = frontQuadTensionFromBend * .5 * biomech.weightDistribution.front;
+	const backHamstringTension = backQuadTensionFromBend * .5 * biomech.weightDistribution.back;
+	activations.set("HAMSTRING_R", Math.min(.8, frontHamstringTension));
+	activations.set("HAMSTRING_L", Math.min(.8, backHamstringTension));
+	const frontCalfTension = biomech.frontKneeBend < 100 ? Math.min(.9, .5 + (100 - biomech.frontKneeBend) / 50 * .4) * biomech.weightDistribution.front : .25 * biomech.weightDistribution.front;
+	const backCalfTension = biomech.backKneeBend < 100 ? Math.min(.9, .5 + (100 - biomech.backKneeBend) / 50 * .4) * biomech.weightDistribution.back : .25 * biomech.weightDistribution.back;
+	activations.set("CALF_R", frontCalfTension);
+	activations.set("CALF_L", backCalfTension);
+	const gluteBaseActivation = (1 - biomech.hipHeight) * .5;
+	activations.set("GLUTE_R", Math.min(.7, gluteBaseActivation + frontQuadTensionFromBend * .2 * biomech.weightDistribution.front));
+	activations.set("GLUTE_L", Math.min(.7, gluteBaseActivation + backQuadTensionFromBend * .2 * biomech.weightDistribution.back));
+	return activations;
+};
+/**
+* Get muscle activation mapping for a specific Korean martial arts technique
+*
+* Maps technique names to muscle groups with tension levels (0-1 scale).
+* Based on authentic Korean martial arts (Taekwondo, Hapkido, Taekyon).
+*
+* @param technique - Technique name (e.g., "jab", "cross", "front_kick", "block")
+* @returns Map of muscle groups to target tension levels
+*
+* @example
+* ```typescript
+* const jabMuscles = getMuscleActivationForTechnique("jab");
+* // Returns: Map {
+* //   "SHOULDER_R" => 0.7,
+* //   "BICEP_R" => 1.0,
+* //   "TRICEP_R" => 0.8,
+* //   "CORE" => 0.5
+* // }
+* ```
+*
+* @korean 기법근육활성화가져오기
+*/
+var getMuscleActivationForTechnique = (technique) => {
+	const activations = /* @__PURE__ */ new Map();
+	switch (technique.toLowerCase()) {
+		case "jab":
+		case "정권":
+			activations.set("SHOULDER_R", .8);
+			activations.set("TRICEP_R", 1);
+			activations.set("BICEP_R", .3);
+			activations.set("CORE", .5);
+			activations.set("PECTORALS", .5);
+			break;
+		case "cross":
+		case "역권":
+			activations.set("SHOULDER_L", .9);
+			activations.set("TRICEP_L", 1);
+			activations.set("BICEP_L", .3);
+			activations.set("CORE", .8);
+			activations.set("PECTORALS", .7);
+			activations.set("OBLIQUES", .8);
+			break;
+		case "hook":
+		case "갈고리주먹":
+			activations.set("SHOULDER_R", 1);
+			activations.set("BICEP_R", .8);
+			activations.set("FOREARM_R", .8);
+			activations.set("CORE", .8);
+			activations.set("OBLIQUES", .9);
+			break;
+		case "uppercut":
+		case "올려치기":
+			activations.set("SHOULDER_R", .95);
+			activations.set("BICEP_R", .9);
+			activations.set("TRICEP_R", .5);
+			activations.set("CORE", .9);
+			activations.set("ABS", .8);
+			activations.set("QUAD_R", .7);
+			activations.set("GLUTE_R", .6);
+			break;
+		case "front_kick":
+		case "앞차기":
+			activations.set("QUAD_R", 1);
+			activations.set("GLUTE_R", .9);
+			activations.set("CALF_R", .7);
+			activations.set("CORE", .6);
+			activations.set("ABS", .7);
+			activations.set("QUAD_L", .4);
+			activations.set("CALF_L", .5);
+			break;
+		case "roundhouse_kick":
+		case "dollyeochagi":
+		case "돌려차기":
+			activations.set("QUAD_R", 1);
+			activations.set("HAMSTRING_R", .8);
+			activations.set("GLUTE_R", .95);
+			activations.set("CORE", .8);
+			activations.set("OBLIQUES", .9);
+			activations.set("QUAD_L", .5);
+			break;
+		case "side_kick":
+		case "옆차기":
+			activations.set("QUAD_R", 1);
+			activations.set("GLUTE_R", 1);
+			activations.set("HAMSTRING_R", .85);
+			activations.set("CALF_R", .8);
+			activations.set("CORE", .7);
+			activations.set("OBLIQUES", .8);
+			break;
+		case "back_kick":
+		case "뒤차기":
+			activations.set("GLUTE_R", 1);
+			activations.set("HAMSTRING_R", .95);
+			activations.set("QUAD_R", .8);
+			activations.set("CORE", .9);
+			activations.set("ABS", .8);
+			break;
+		case "axe_kick":
+		case "내려차기":
+			activations.set("QUAD_R", .9);
+			activations.set("HAMSTRING_R", 1);
+			activations.set("GLUTE_R", .85);
+			activations.set("CORE", .8);
+			activations.set("ABS", .9);
+			break;
+		case "block":
+		case "makgi":
+		case "막기":
+			activations.set("SHOULDER_L", .9);
+			activations.set("SHOULDER_R", .9);
+			activations.set("BICEP_L", .7);
+			activations.set("BICEP_R", .7);
+			activations.set("FOREARM_L", .8);
+			activations.set("FOREARM_R", .8);
+			activations.set("CORE", .8);
+			activations.set("ABS", .7);
+			break;
+		case "parry":
+		case "흘려막기":
+			activations.set("SHOULDER_R", .6);
+			activations.set("FOREARM_R", .7);
+			activations.set("CORE", .5);
+			break;
+		case "elbow_strike":
+		case "팔꿈치치기":
+			activations.set("SHOULDER_R", 1);
+			activations.set("TRICEP_R", .95);
+			activations.set("FOREARM_R", .9);
+			activations.set("CORE", .85);
+			activations.set("OBLIQUES", .8);
+			break;
+		case "knee_strike":
+		case "무릎치기":
+			activations.set("QUAD_R", 1);
+			activations.set("HAMSTRING_R", .9);
+			activations.set("GLUTE_R", .85);
+			activations.set("CORE", .9);
+			activations.set("ABS", .85);
+			break;
+		case "grab":
+		case "잡기":
+			activations.set("FOREARM_L", .9);
+			activations.set("FOREARM_R", .9);
+			activations.set("BICEP_L", .7);
+			activations.set("BICEP_R", .7);
+			activations.set("CORE", .6);
+			break;
+		case "stance_change":
+		case "자세전환":
+			activations.set("CORE", .7);
+			activations.set("ABS", .6);
+			activations.set("QUAD_L", .5);
+			activations.set("QUAD_R", .5);
+			activations.set("CALF_L", .5);
+			activations.set("CALF_R", .5);
+			break;
+		default:
+			activations.set("CORE", .3);
+			break;
+	}
+	return activations;
+};
+/**
+* Muscle activation manager for real-time combat physiology
+*
+* Manages 60fps muscle tension updates, stamina effects, and smooth transitions.
+* Optimized for performance with ref-based updates to avoid React re-renders.
+*
+* @korean 근육활성화관리자
+*/
+var MuscleActivationManager = class {
+	activations;
+	config;
+	scratchMap;
+	/**
+	* Create a new muscle activation manager
+	*
+	* @param config - Optional configuration (uses defaults if not provided)
+	* @korean 생성자
+	*/
+	constructor(config = {}) {
+		this.config = {
+			maxFrameTime: 3,
+			muscleCount: 20,
+			useInstancing: false,
+			relaxationDelay: .3,
+			exhaustionThreshold: 20,
+			shakeFrequency: 20,
+			shakeAmplitude: .02,
+			activationSpeed: 5,
+			relaxationSpeed: 3,
+			shakingTensionThreshold: .3,
+			...config
+		};
+		this.activations = /* @__PURE__ */ new Map();
+		this.scratchMap = /* @__PURE__ */ new Map();
+		[
+			"SHOULDER_L",
+			"SHOULDER_R",
+			"BICEP_L",
+			"BICEP_R",
+			"TRICEP_L",
+			"TRICEP_R",
+			"FOREARM_L",
+			"FOREARM_R",
+			"PECTORALS",
+			"CORE",
+			"ABS",
+			"OBLIQUES",
+			"QUAD_L",
+			"QUAD_R",
+			"HAMSTRING_L",
+			"HAMSTRING_R",
+			"CALF_L",
+			"CALF_R",
+			"GLUTE_L",
+			"GLUTE_R"
+		].forEach((muscle) => {
+			this.activations.set(muscle, {
+				muscleGroup: muscle,
+				tension: 0,
+				targetTension: 0,
+				isShaking: false
+			});
+		});
+	}
+	/**
+	* Update muscle activations for a technique at 60fps
+	*
+	* @param technique - Technique name
+	* @param stamina - Current stamina (0-100)
+	* @param delta - Time since last frame in seconds
+	*
+	* @korean 업데이트
+	*/
+	update(technique, stamina, delta) {
+		const targetActivations = getMuscleActivationForTechnique(technique);
+		const isExhausted = stamina < this.config.exhaustionThreshold;
+		this.activations.forEach((state, muscleGroup) => {
+			const adjustedTarget = (targetActivations.get(muscleGroup) ?? 0) * Math.max(.3, stamina / 100);
+			const lerp = (start, end, t) => start + (end - start) * t;
+			const newTension = lerp(state.tension, adjustedTarget, this.config.activationSpeed * delta);
+			const isShaking = isExhausted && state.tension > this.config.shakingTensionThreshold;
+			state.tension = newTension;
+			state.targetTension = adjustedTarget;
+			state.isShaking = isShaking;
+		});
+	}
+	/**
+	* Gradually relax all muscles to idle state
+	*
+	* Used after technique completion with configurable delay.
+	*
+	* @param delta - Time since last frame in seconds
+	*
+	* @korean 근육이완
+	*/
+	relaxAllMuscles(delta) {
+		this.activations.forEach((state) => {
+			const lerp = (start, end, t) => start + (end - start) * t;
+			state.tension = lerp(state.tension, 0, this.config.relaxationSpeed * delta);
+			state.targetTension = 0;
+			state.isShaking = false;
+		});
+	}
+	/**
+	* Get current tension for a specific muscle group
+	*
+	* @param muscleGroup - Muscle group name
+	* @returns Current tension (0-1) or 0 if not found
+	*
+	* @korean 긴장도가져오기
+	*/
+	getTension(muscleGroup) {
+		return this.activations.get(muscleGroup)?.tension ?? 0;
+	}
+	/**
+	* Get shaking state for a specific muscle group
+	*
+	* @param muscleGroup - Muscle group name
+	* @returns Whether muscle is shaking
+	*
+	* @korean 흔들림상태가져오기
+	*/
+	isShaking(muscleGroup) {
+		return this.activations.get(muscleGroup)?.isShaking ?? false;
+	}
+	/**
+	* Get all current muscle activations
+	*
+	* @returns Map of muscle groups to current states
+	*
+	* @korean 모든활성화가져오기
+	*/
+	getAllActivations() {
+		return this.activations;
+	}
+	/**
+	* Get reusable scratch map with current tension values for state sync
+	*
+	* Populates and returns a reusable Map to avoid allocations during state sync.
+	* This map is cleared and repopulated on each call.
+	*
+	* @returns Reusable Map with current tension values
+	*
+	* @korean 상태동기화맵가져오기
+	*/
+	getScratchMapForSync() {
+		this.scratchMap.clear();
+		this.activations.forEach((state, name) => {
+			this.scratchMap.set(name, state.tension);
+		});
+		return this.scratchMap;
+	}
+	/**
+	* Reset all muscles to relaxed state immediately
+	*
+	* @korean 즉시이완
+	*/
+	reset() {
+		this.activations.forEach((state) => {
+			state.tension = 0;
+			state.targetTension = 0;
+			state.isShaking = false;
+		});
+		this.scratchMap.clear();
+	}
+	/**
+	* Dispose of the muscle activation system
+	*
+	* Clears all internal state and references to prevent memory leaks.
+	* Should be called when the system is no longer needed (e.g., component unmount).
+	*
+	* @korean 근육시스템해제
+	*/
+	dispose() {
+		this.activations.clear();
+		this.scratchMap.clear();
+	}
+};
+//#endregion
+export { MuscleActivationManager, getMuscleActivationForTechnique, getMuscleTensionForStance };
+
+//# sourceMappingURL=MuscleActivation.js.map

package/lib/systems/animation/systems/MuscleActivation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MuscleActivation.js","names":[],"sources":["../../../../src/systems/animation/systems/MuscleActivation.ts"],"sourcesContent":["/**\n * Muscle activation system for realistic combat physiology\n *\n * Maps Korean martial arts techniques to anatomically accurate muscle activation patterns.\n * Manages dynamic muscle tension, stamina effects, and smooth relaxation transitions.\n * Includes stance-specific leg muscle tension for isometric holds and weight-bearing.\n *\n * @module systems/animation/MuscleActivation\n * @category Combat Animation\n * @korean 근육활성화시스템\n */\n\nimport type { TrigramStance } from \"@/types/common\";\nimport type {\n  MuscleActivationMap,\n  MuscleActivationState,\n  MuscleGroupName,\n  MuscleSystemConfig,\n} from \"@/types/muscle\";\nimport { KOREAN_STANCE_BIOMECHANICS } from \"../builders/MartialArtsConstants\";\n\n/**\n * Type-safe mapping of TrigramStance to biomechanics keys\n * Defined at module level to avoid recreation at 60fps\n * @korean 자세생체역학매핑\n */\nconst STANCE_TO_BIOMECH_KEY = {\n  geon: \"GEON_HEAVEN\",\n  tae: \"TAE_LAKE\",\n  li: \"LI_FIRE\",\n  jin: \"JIN_THUNDER\",\n  son: \"SON_WIND\",\n  gam: \"GAM_WATER\",\n  gan: \"GAN_MOUNTAIN\",\n  gon: \"GON_EARTH\",\n} as const satisfies Record<\n  TrigramStance,\n  keyof typeof KOREAN_STANCE_BIOMECHANICS\n>;\n\n/**\n * Get leg muscle tension for a specific trigram stance\n *\n * Calculates realistic leg muscle activation based on stance biomechanics:\n * - Weight distribution (체중부하) - Which leg bears more load\n * - Knee flexion angles (무릎굽힘각도) - Deep stances require more tension\n * - Isometric contraction (등척성수축) - Holding positions activates muscles\n *\n * Based on authentic Korean martial arts stance mechanics:\n * - Deep stances (Jin 90°, Gon 80°) = High quad/calf tension\n * - Front-weighted (Geon 60/40) = Front leg emphasis\n * - Back-weighted (Tae 10/90, Gam 30/70) = Back leg emphasis\n *\n * @param stance - Trigram stance (e.g., TrigramStance.GEON)\n * @returns Map of leg muscle groups to tension levels (0-1)\n *\n * @example\n * ```typescript\n * const jinMuscles = getMuscleTensionForStance(TrigramStance.JIN);\n * // Returns: Map {\n * //   \"QUAD_L\" => 0.90,  // Deep 90° knee bend\n * //   \"QUAD_R\" => 0.90,  // Equal weight distribution\n * //   \"CALF_L\" => 0.85,  // Isometric hold\n * //   \"CALF_R\" => 0.85,\n * //   \"HAMSTRING_L\" => 0.45,\n * //   \"HAMSTRING_R\" => 0.45,\n * //   \"GLUTE_L\" => 0.40,\n * //   \"GLUTE_R\" => 0.40\n * // }\n * ```\n *\n * @korean 자세다리근육긴장도\n */\nexport const getMuscleTensionForStance = (\n  stance: TrigramStance,\n): MuscleActivationMap => {\n  const activations = new Map<MuscleGroupName, number>();\n\n  // Get biomechanical data for stance (type-safe lookup)\n  const biomechKey = STANCE_TO_BIOMECH_KEY[stance];\n  const biomech = KOREAN_STANCE_BIOMECHANICS[biomechKey];\n\n  if (!biomech) {\n    // This branch should never execute with proper typing, but kept for safety\n    // Provide conservative defaults for all muscle groups to keep map consistent\n    activations.set(\"QUAD_L\", 0.2);\n    activations.set(\"QUAD_R\", 0.2);\n    activations.set(\"CALF_L\", 0.1);\n    activations.set(\"CALF_R\", 0.1);\n    activations.set(\"HAMSTRING_L\", 0.1);\n    activations.set(\"HAMSTRING_R\", 0.1);\n    activations.set(\"GLUTE_L\", 0.1);\n    activations.set(\"GLUTE_R\", 0.1);\n    return activations;\n  }\n\n  // Calculate quadriceps tension based on knee flexion\n  // Formula (base tension): baseTension = (180° - kneeAngle) / 110°\n  // Range: 90° knee → 0.82 base tension, 180° knee → 0.0 base tension\n  // This base value is then combined with weight distribution for final tension\n  const frontQuadTensionFromBend = Math.max(\n    0,\n    Math.min(1.0, (180 - biomech.frontKneeBend) / 110),\n  );\n  const backQuadTensionFromBend = Math.max(\n    0,\n    Math.min(1.0, (180 - biomech.backKneeBend) / 110),\n  );\n\n  // Apply weight distribution to muscle tension\n  // Front leg quadriceps (체중부하 + 등척성수축)\n  // Base tension from bend + weight factor\n  // Note: Even with 0% weight, deep knee flexion produces tension\n  // (e.g., raised leg in crane stance requires quad engagement to hold position)\n  const frontQuadTension = Math.min(\n    1.0,\n    frontQuadTensionFromBend * 0.6 + biomech.weightDistribution.front * 0.4,\n  );\n\n  // Back leg quadriceps\n  const backQuadTension = Math.min(\n    1.0,\n    backQuadTensionFromBend * 0.6 + biomech.weightDistribution.back * 0.4,\n  );\n\n  // Set quadriceps tension (right = front, left = back in standard stance)\n  activations.set(\"QUAD_R\", frontQuadTension);\n  activations.set(\"QUAD_L\", backQuadTension);\n\n  // Calculate hamstring tension (antagonist muscles, lower activation)\n  // Hamstrings activate more in bent positions for stabilization\n  const frontHamstringTension =\n    frontQuadTensionFromBend * 0.5 * biomech.weightDistribution.front;\n  const backHamstringTension =\n    backQuadTensionFromBend * 0.5 * biomech.weightDistribution.back;\n\n  activations.set(\"HAMSTRING_R\", Math.min(0.8, frontHamstringTension));\n  activations.set(\"HAMSTRING_L\", Math.min(0.8, backHamstringTension));\n\n  // Calculate calf tension for deep stances (isometric hold support)\n  // Very deep stances (< 100° knee angle) require significant calf engagement\n  const frontCalfTension =\n    biomech.frontKneeBend < 100\n      ? Math.min(0.9, 0.5 + ((100 - biomech.frontKneeBend) / 50) * 0.4) *\n        biomech.weightDistribution.front\n      : 0.25 * biomech.weightDistribution.front;\n\n  const backCalfTension =\n    biomech.backKneeBend < 100\n      ? Math.min(0.9, 0.5 + ((100 - biomech.backKneeBend) / 50) * 0.4) *\n        biomech.weightDistribution.back\n      : 0.25 * biomech.weightDistribution.back;\n\n  activations.set(\"CALF_R\", frontCalfTension);\n  activations.set(\"CALF_L\", backCalfTension);\n\n  // Calculate glute activation (hip extension support)\n  // Glutes engage more in deep stances for posture maintenance\n  const gluteBaseActivation = (1.0 - biomech.hipHeight) * 0.5;\n\n  activations.set(\n    \"GLUTE_R\",\n    Math.min(\n      0.7,\n      gluteBaseActivation +\n        frontQuadTensionFromBend * 0.2 * biomech.weightDistribution.front,\n    ),\n  );\n  activations.set(\n    \"GLUTE_L\",\n    Math.min(\n      0.7,\n      gluteBaseActivation +\n        backQuadTensionFromBend * 0.2 * biomech.weightDistribution.back,\n    ),\n  );\n\n  return activations;\n};\n\n/**\n * Get muscle activation mapping for a specific Korean martial arts technique\n *\n * Maps technique names to muscle groups with tension levels (0-1 scale).\n * Based on authentic Korean martial arts (Taekwondo, Hapkido, Taekyon).\n *\n * @param technique - Technique name (e.g., \"jab\", \"cross\", \"front_kick\", \"block\")\n * @returns Map of muscle groups to target tension levels\n *\n * @example\n * ```typescript\n * const jabMuscles = getMuscleActivationForTechnique(\"jab\");\n * // Returns: Map {\n * //   \"SHOULDER_R\" => 0.7,\n * //   \"BICEP_R\" => 1.0,\n * //   \"TRICEP_R\" => 0.8,\n * //   \"CORE\" => 0.5\n * // }\n * ```\n *\n * @korean 기법근육활성화가져오기\n */\nexport const getMuscleActivationForTechnique = (\n  technique: string,\n): MuscleActivationMap => {\n  const activations = new Map<MuscleGroupName, number>();\n\n  switch (technique.toLowerCase()) {\n    // Punching techniques - 주먹 기술\n    case \"jab\":\n    case \"정권\": // Front jab\n      activations.set(\"SHOULDER_R\", 0.8);\n      activations.set(\"TRICEP_R\", 1.0); // Primary mover for arm extension\n      activations.set(\"BICEP_R\", 0.3); // Antagonist - stabilization only\n      activations.set(\"CORE\", 0.5);\n      activations.set(\"PECTORALS\", 0.5); // Shoulder horizontal adduction\n      break;\n\n    case \"cross\":\n    case \"역권\": // Reverse punch\n      activations.set(\"SHOULDER_L\", 0.9);\n      activations.set(\"TRICEP_L\", 1.0); // Primary mover for arm extension\n      activations.set(\"BICEP_L\", 0.3); // Antagonist - stabilization only\n      activations.set(\"CORE\", 0.8); // More core rotation\n      activations.set(\"PECTORALS\", 0.7); // Chest drive for power\n      activations.set(\"OBLIQUES\", 0.8); // Torso rotation for hip transfer\n      break;\n\n    case \"hook\":\n    case \"갈고리주먹\": // Hook punch\n      activations.set(\"SHOULDER_R\", 1.0); // Primary mover for horizontal arc\n      activations.set(\"BICEP_R\", 0.8); // Maintains elbow angle during arc\n      activations.set(\"FOREARM_R\", 0.8);\n      activations.set(\"CORE\", 0.8); // Drives rotational power\n      activations.set(\"OBLIQUES\", 0.9); // Primary torso rotation driver\n      break;\n\n    case \"uppercut\":\n    case \"올려치기\": // Uppercut\n      activations.set(\"SHOULDER_R\", 0.95); // Drives upward arc\n      activations.set(\"BICEP_R\", 0.9); // Maintains elbow angle for upward drive\n      activations.set(\"TRICEP_R\", 0.5); // Partial extension\n      activations.set(\"CORE\", 0.9);\n      activations.set(\"ABS\", 0.8);\n      activations.set(\"QUAD_R\", 0.7); // Lower body drive (legs push up)\n      activations.set(\"GLUTE_R\", 0.6); // Hip extension for power\n      break;\n\n    // Kicking techniques - 발차기 기술\n    case \"front_kick\":\n    case \"앞차기\": // Mae Chagi\n      activations.set(\"QUAD_R\", 1.0); // Kicking leg fully flexed\n      activations.set(\"GLUTE_R\", 0.9);\n      activations.set(\"CALF_R\", 0.7);\n      activations.set(\"CORE\", 0.6); // Balance\n      activations.set(\"ABS\", 0.7);\n      activations.set(\"QUAD_L\", 0.4); // Support leg tensed\n      activations.set(\"CALF_L\", 0.5);\n      break;\n\n    case \"roundhouse_kick\":\n    case \"dollyeochagi\":\n    case \"돌려차기\": // Dollyeo Chagi\n      activations.set(\"QUAD_R\", 1.0);\n      activations.set(\"HAMSTRING_R\", 0.8);\n      activations.set(\"GLUTE_R\", 0.95);\n      activations.set(\"CORE\", 0.8);\n      activations.set(\"OBLIQUES\", 0.9); // Hip rotation\n      activations.set(\"QUAD_L\", 0.5);\n      break;\n\n    case \"side_kick\":\n    case \"옆차기\": // Yeop Chagi\n      activations.set(\"QUAD_R\", 1.0);\n      activations.set(\"GLUTE_R\", 1.0);\n      activations.set(\"HAMSTRING_R\", 0.85);\n      activations.set(\"CALF_R\", 0.8);\n      activations.set(\"CORE\", 0.7);\n      activations.set(\"OBLIQUES\", 0.8);\n      break;\n\n    case \"back_kick\":\n    case \"뒤차기\": // Dwi Chagi\n      activations.set(\"GLUTE_R\", 1.0);\n      activations.set(\"HAMSTRING_R\", 0.95);\n      activations.set(\"QUAD_R\", 0.8);\n      activations.set(\"CORE\", 0.9);\n      activations.set(\"ABS\", 0.8);\n      break;\n\n    case \"axe_kick\":\n    case \"내려차기\": // Naeryeo Chagi\n      activations.set(\"QUAD_R\", 0.9);\n      activations.set(\"HAMSTRING_R\", 1.0); // Maximum hamstring flex\n      activations.set(\"GLUTE_R\", 0.85);\n      activations.set(\"CORE\", 0.8);\n      activations.set(\"ABS\", 0.9);\n      break;\n\n    // Defensive techniques - 방어 기술\n    case \"block\":\n    case \"makgi\":\n    case \"막기\": // Block\n      activations.set(\"SHOULDER_L\", 0.9);\n      activations.set(\"SHOULDER_R\", 0.9);\n      activations.set(\"BICEP_L\", 0.7);\n      activations.set(\"BICEP_R\", 0.7);\n      activations.set(\"FOREARM_L\", 0.8);\n      activations.set(\"FOREARM_R\", 0.8);\n      activations.set(\"CORE\", 0.8); // Brace for impact\n      activations.set(\"ABS\", 0.7);\n      break;\n\n    case \"parry\":\n    case \"흘려막기\": // Deflecting block\n      activations.set(\"SHOULDER_R\", 0.6);\n      activations.set(\"FOREARM_R\", 0.7);\n      activations.set(\"CORE\", 0.5);\n      break;\n\n    // Elbow techniques - 팔꿈치 기술\n    case \"elbow_strike\":\n    case \"팔꿈치치기\": // Palkumchi Chigi\n      activations.set(\"SHOULDER_R\", 1.0);\n      activations.set(\"TRICEP_R\", 0.95);\n      activations.set(\"FOREARM_R\", 0.9);\n      activations.set(\"CORE\", 0.85);\n      activations.set(\"OBLIQUES\", 0.8);\n      break;\n\n    // Knee techniques - 무릎 기술\n    case \"knee_strike\":\n    case \"무릎치기\": // Mureup Chigi\n      activations.set(\"QUAD_R\", 1.0);\n      activations.set(\"HAMSTRING_R\", 0.9);\n      activations.set(\"GLUTE_R\", 0.85);\n      activations.set(\"CORE\", 0.9);\n      activations.set(\"ABS\", 0.85);\n      break;\n\n    // Grappling techniques - 잡기 기술 (Hapkido)\n    case \"grab\":\n    case \"잡기\":\n      activations.set(\"FOREARM_L\", 0.9);\n      activations.set(\"FOREARM_R\", 0.9);\n      activations.set(\"BICEP_L\", 0.7);\n      activations.set(\"BICEP_R\", 0.7);\n      activations.set(\"CORE\", 0.6);\n      break;\n\n    // Stance changes - 자세 전환\n    case \"stance_change\":\n    case \"자세전환\":\n      activations.set(\"CORE\", 0.7);\n      activations.set(\"ABS\", 0.6);\n      activations.set(\"QUAD_L\", 0.5);\n      activations.set(\"QUAD_R\", 0.5);\n      activations.set(\"CALF_L\", 0.5);\n      activations.set(\"CALF_R\", 0.5);\n      break;\n\n    // Default - minimal activation\n    default:\n      activations.set(\"CORE\", 0.3);\n      break;\n  }\n\n  return activations;\n};\n\n/**\n * Muscle activation manager for real-time combat physiology\n *\n * Manages 60fps muscle tension updates, stamina effects, and smooth transitions.\n * Optimized for performance with ref-based updates to avoid React re-renders.\n *\n * @korean 근육활성화관리자\n */\nexport class MuscleActivationManager {\n  private activations: Map<MuscleGroupName, MuscleActivationState>;\n  private config: MuscleSystemConfig;\n  private scratchMap: Map<string, number>; // Reusable map for state sync to avoid allocations\n\n  /**\n   * Create a new muscle activation manager\n   *\n   * @param config - Optional configuration (uses defaults if not provided)\n   * @korean 생성자\n   */\n  constructor(config: Partial<MuscleSystemConfig> = {}) {\n    this.config = {\n      maxFrameTime: 3,\n      muscleCount: 20,\n      useInstancing: false,\n      relaxationDelay: 0.3,\n      exhaustionThreshold: 20,\n      shakeFrequency: 20,\n      shakeAmplitude: 0.02,\n      activationSpeed: 5.0,\n      relaxationSpeed: 3.0,\n      shakingTensionThreshold: 0.3,\n      ...config,\n    };\n\n    // Initialize all muscle groups to relaxed state\n    this.activations = new Map();\n    // Initialize reusable scratch map for state sync\n    this.scratchMap = new Map();\n    const allMuscles: MuscleGroupName[] = [\n      \"SHOULDER_L\",\n      \"SHOULDER_R\",\n      \"BICEP_L\",\n      \"BICEP_R\",\n      \"TRICEP_L\",\n      \"TRICEP_R\",\n      \"FOREARM_L\",\n      \"FOREARM_R\",\n      \"PECTORALS\",\n      \"CORE\",\n      \"ABS\",\n      \"OBLIQUES\",\n      \"QUAD_L\",\n      \"QUAD_R\",\n      \"HAMSTRING_L\",\n      \"HAMSTRING_R\",\n      \"CALF_L\",\n      \"CALF_R\",\n      \"GLUTE_L\",\n      \"GLUTE_R\",\n    ];\n\n    allMuscles.forEach((muscle) => {\n      this.activations.set(muscle, {\n        muscleGroup: muscle,\n        tension: 0,\n        targetTension: 0,\n        isShaking: false,\n      });\n    });\n  }\n\n  /**\n   * Update muscle activations for a technique at 60fps\n   *\n   * @param technique - Technique name\n   * @param stamina - Current stamina (0-100)\n   * @param delta - Time since last frame in seconds\n   *\n   * @korean 업데이트\n   */\n  update(technique: string, stamina: number, delta: number): void {\n    const targetActivations = getMuscleActivationForTechnique(technique);\n    const isExhausted = stamina < this.config.exhaustionThreshold;\n\n    // Update each muscle group\n    this.activations.forEach((state, muscleGroup) => {\n      const targetTension = targetActivations.get(muscleGroup) ?? 0;\n\n      // Adjust tension based on stamina (exhaustion reduces muscle effectiveness)\n      const staminaFactor = Math.max(0.3, stamina / 100); // Minimum 30% even when exhausted\n      const adjustedTarget = targetTension * staminaFactor;\n\n      // Smooth transition to target tension using lerp\n      const lerp = (start: number, end: number, t: number) =>\n        start + (end - start) * t;\n      const newTension = lerp(\n        state.tension,\n        adjustedTarget,\n        this.config.activationSpeed * delta,\n      );\n\n      // Update shaking state for exhaustion\n      const isShaking =\n        isExhausted && state.tension > this.config.shakingTensionThreshold;\n\n      // Update state directly for performance\n      state.tension = newTension;\n      state.targetTension = adjustedTarget;\n      state.isShaking = isShaking;\n    });\n  }\n\n  /**\n   * Gradually relax all muscles to idle state\n   *\n   * Used after technique completion with configurable delay.\n   *\n   * @param delta - Time since last frame in seconds\n   *\n   * @korean 근육이완\n   */\n  relaxAllMuscles(delta: number): void {\n    this.activations.forEach((state) => {\n      // Use configured relaxation speed (slower than activation for realism)\n      const lerp = (start: number, end: number, t: number) =>\n        start + (end - start) * t;\n      const newTension = lerp(\n        state.tension,\n        0,\n        this.config.relaxationSpeed * delta,\n      );\n\n      state.tension = newTension;\n      state.targetTension = 0;\n      state.isShaking = false;\n    });\n  }\n\n  /**\n   * Get current tension for a specific muscle group\n   *\n   * @param muscleGroup - Muscle group name\n   * @returns Current tension (0-1) or 0 if not found\n   *\n   * @korean 긴장도가져오기\n   */\n  getTension(muscleGroup: MuscleGroupName): number {\n    return this.activations.get(muscleGroup)?.tension ?? 0;\n  }\n\n  /**\n   * Get shaking state for a specific muscle group\n   *\n   * @param muscleGroup - Muscle group name\n   * @returns Whether muscle is shaking\n   *\n   * @korean 흔들림상태가져오기\n   */\n  isShaking(muscleGroup: MuscleGroupName): boolean {\n    return this.activations.get(muscleGroup)?.isShaking ?? false;\n  }\n\n  /**\n   * Get all current muscle activations\n   *\n   * @returns Map of muscle groups to current states\n   *\n   * @korean 모든활성화가져오기\n   */\n  getAllActivations(): ReadonlyMap<MuscleGroupName, MuscleActivationState> {\n    return this.activations;\n  }\n\n  /**\n   * Get reusable scratch map with current tension values for state sync\n   *\n   * Populates and returns a reusable Map to avoid allocations during state sync.\n   * This map is cleared and repopulated on each call.\n   *\n   * @returns Reusable Map with current tension values\n   *\n   * @korean 상태동기화맵가져오기\n   */\n  getScratchMapForSync(): Map<string, number> {\n    this.scratchMap.clear();\n    this.activations.forEach((state, name) => {\n      this.scratchMap.set(name, state.tension);\n    });\n    return this.scratchMap;\n  }\n\n  /**\n   * Reset all muscles to relaxed state immediately\n   *\n   * @korean 즉시이완\n   */\n  reset(): void {\n    this.activations.forEach((state) => {\n      state.tension = 0;\n      state.targetTension = 0;\n      state.isShaking = false;\n    });\n    this.scratchMap.clear();\n  }\n\n  /**\n   * Dispose of the muscle activation system\n   *\n   * Clears all internal state and references to prevent memory leaks.\n   * Should be called when the system is no longer needed (e.g., component unmount).\n   *\n   * @korean 근육시스템해제\n   */\n  dispose(): void {\n    this.activations.clear();\n    this.scratchMap.clear();\n  }\n}\n"],"mappings":"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"}

package/lib/systems/animation/systems/RecoveryVisualization.d.ts

@@ -0,0 +1,142 @@
+/**
+ * Recovery Phase Visualization Utilities
+ *
+ * Provides helper functions to visualize and debug recovery phases during development.
+ * Useful for tuning recovery timing and muscle tension curves.
+ *
+ * @module systems/animation/RecoveryVisualization
+ * @category Animation System
+ * @korean 복귀시각화
+ */
+import type { SkeletalAnimation } from "../../../types/skeletal";
+import { validateRecoveryPhase, type RecoveryPhaseConfig } from "../core/RecoveryPhaseEnhancer";
+/**
+ * Recovery phase timeline point for visualization
+ *
+ * **Korean**: 복귀 타임라인 포인트
+ *
+ * @korean 복귀타임라인포인트
+ */
+export interface RecoveryTimelinePoint {
+    /** Time in animation (seconds) */
+    readonly time: number;
+    /** Muscle tension at this time (0-1) */
+    readonly tension: number;
+    /** Phase name for labeling */
+    readonly phase: string;
+    /** Phase name in Korean */
+    readonly phaseKorean: string;
+}
+/**
+ * Recovery phase visualization data
+ *
+ * **Korean**: 복귀 시각화 데이터
+ *
+ * @korean 복귀시각화데이터
+ */
+export interface RecoveryVisualization {
+    /** Animation name */
+    readonly name: string;
+    /** Korean name */
+    readonly koreanName: string;
+    /** Timeline points for plotting */
+    readonly timeline: RecoveryTimelinePoint[];
+    /** Validation result */
+    readonly validation: ReturnType<typeof validateRecoveryPhase>;
+    /** Recovery start time */
+    readonly recoveryStartTime: number;
+    /** Recovery end time */
+    readonly recoveryEndTime: number;
+}
+/**
+ * Generate visualization data for recovery phase
+ *
+ * **Korean**: 복귀 단계 시각화 데이터 생성
+ *
+ * Creates timeline data suitable for plotting muscle tension curves.
+ * Samples tension at regular intervals for smooth visualization.
+ *
+ * @param animation - Animation with recovery phase
+ * @param config - Recovery configuration used
+ * @param sampleRate - Samples per second (default: 60 for 60fps)
+ * @returns Visualization data
+ *
+ * @example
+ * ```typescript
+ * import { generateRecoveryVisualization } from './RecoveryVisualization';
+ *
+ * const viz = generateRecoveryVisualization(JAB_ANIMATION_ENHANCED);
+ * console.log('Recovery phase analysis:');
+ * viz.timeline.forEach(point => {
+ *   console.log(`${point.time.toFixed(3)}s: ${point.phase} - Tension: ${point.tension.toFixed(2)}`);
+ * });
+ * ```
+ *
+ * @korean 복귀시각화생성
+ */
+export declare function generateRecoveryVisualization(animation: SkeletalAnimation, config?: RecoveryPhaseConfig, sampleRate?: number): RecoveryVisualization;
+/**
+ * Format recovery visualization as console output
+ *
+ * **Korean**: 복귀 시각화 콘솔 출력
+ *
+ * Prints a formatted analysis of the recovery phase to console.
+ * Useful for debugging and development.
+ *
+ * @param viz - Visualization data
+ *
+ * @example
+ * ```typescript
+ * const viz = generateRecoveryVisualization(JAB_ANIMATION_ENHANCED);
+ * printRecoveryAnalysis(viz);
+ * ```
+ *
+ * @korean 복귀분석출력
+ */
+export declare function printRecoveryAnalysis(viz: RecoveryVisualization): void;
+/**
+ * Generate ASCII art visualization of tension curve
+ *
+ * **Korean**: 근육 긴장도 곡선 ASCII 시각화
+ *
+ * Creates a simple ASCII chart of muscle tension over time.
+ *
+ * @param viz - Visualization data
+ * @param width - Chart width in characters (default: 60)
+ * @param height - Chart height in characters (default: 10)
+ *
+ * @example
+ * ```typescript
+ * const viz = generateRecoveryVisualization(JAB_ANIMATION_ENHANCED);
+ * const chart = generateTensionChart(viz);
+ * console.log(chart);
+ * ```
+ *
+ * @korean 긴장도차트생성
+ */
+export declare function generateTensionChart(viz: RecoveryVisualization, width?: number, height?: number): string;
+/**
+ * Compare multiple recovery phases side-by-side
+ *
+ * **Korean**: 복귀 단계 비교
+ *
+ * Generates a comparison table of multiple animations' recovery characteristics.
+ *
+ * @param animations - Map of animation name to animation
+ * @param config - Recovery configuration used
+ * @returns Formatted comparison table
+ *
+ * @example
+ * ```typescript
+ * const comparison = compareRecoveryPhases({
+ *   'Jab': JAB_ANIMATION_ENHANCED,
+ *   'Cross': CROSS_ANIMATION_ENHANCED,
+ *   'Elbow': ELBOW_STRIKE_ANIMATION_ENHANCED,
+ * });
+ * console.log(comparison);
+ * ```
+ *
+ * @korean 복귀비교
+ */
+export declare function compareRecoveryPhases(animations: Record<string, SkeletalAnimation>, config?: RecoveryPhaseConfig): string;
+//# sourceMappingURL=RecoveryVisualization.d.ts.map

package/lib/systems/animation/systems/RecoveryVisualization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RecoveryVisualization.d.ts","sourceRoot":"","sources":["../../../../src/systems/animation/systems/RecoveryVisualization.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAC1D,OAAO,EAEL,qBAAqB,EACrB,KAAK,mBAAmB,EACzB,MAAM,+BAA+B,CAAC;AAUvC;;;;;;GAMG;AACH,MAAM,WAAW,qBAAqB;IACpC,kCAAkC;IAClC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,wCAAwC;IACxC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,8BAA8B;IAC9B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,2BAA2B;IAC3B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,qBAAqB;IACpC,qBAAqB;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,kBAAkB;IAClB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,mCAAmC;IACnC,QAAQ,CAAC,QAAQ,EAAE,qBAAqB,EAAE,CAAC;IAC3C,wBAAwB;IACxB,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC,OAAO,qBAAqB,CAAC,CAAC;IAC9D,0BAA0B;IAC1B,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACnC,wBAAwB;IACxB,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;CAClC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,6BAA6B,CAC3C,SAAS,EAAE,iBAAiB,EAC5B,MAAM,GAAE,mBAAwB,EAChC,UAAU,GAAE,MAAW,GACtB,qBAAqB,CAuDvB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,qBAAqB,GAAG,IAAI,CA0EtE;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,oBAAoB,CAClC,GAAG,EAAE,qBAAqB,EAC1B,KAAK,GAAE,MAAW,EAClB,MAAM,GAAE,MAAW,GAClB,MAAM,CAyDR;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,EAC7C,MAAM,GAAE,mBAAwB,GAC/B,MAAM,CA+CR"}

package/lib/systems/animation/systems/RecoveryVisualization.js

@@ -0,0 +1 @@
+import "../core/RecoveryPhaseEnhancer.js";

package/lib/systems/animation/systems/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Runtime animation systems sub-package
+ *
+ * Facial expressions, head and body tracking, advanced joint movement helpers,
+ * fall handling, and recovery visualizations.
+ */
+export { calculateFacialDamage, createDefaultExpressionState, createDefaultFacialDamage, createExpressionTransition, DEFAULT_TRANSITION_CONFIG, getExpressionFromCombatState, getExpressionIntensity, resetFacialDamage, updateExpressionState, } from "./FacialExpressions";
+export type { ExpressionTransitionConfig } from "./FacialExpressions";
+export { applyHeadMovementKeyframe, calculateSmoothHeadRotation, createHeadDropAnimation, createHeadNodAnimation, createHeadRecoilAnimation, createHeadShakeAnimation, createHeadTiltAnimation, createHeadTurnAnimation, getHeadMovementByType, isHeadMovementComplete, } from "./HeadMovements";
+export { determineFallDirection, determineFallFromStance, FALL_BACKWARD_KEYFRAMES, FALL_FORWARD_KEYFRAMES, FALL_IMPACT_FRAMES, FALL_SIDE_KEYFRAMES, getFallKeyframes, getImpactFrame, } from "./FallAnimations";
+export { BodyFacingSystem, bodyFacingSystem, calculateAngleDifference, calculateAngleToTarget, createDefaultBodyFacing, DEFAULT_ROTATION_SPEED, getFacingAngleRadians, getHeadAngleRadians, getHipRotationRadians, getTorsoRotationRadians, HEAD_TRACKING_SMOOTHING, isTurning, lockFacing, MAX_HEAD_ROTATION, MAX_TORSO_ROTATION, normalizeAngle, TURN_ANIMATION_DURATION, TURN_THRESHOLD_ANGLE, unlockFacing, updateBodyFacing, updateFacingTowardOpponent, } from "./BodyFacingSystem";
+export { ADVANCED_JOINT_CONSTRAINTS, applyHipRotationToEuler, calculateAnkleArticulation, calculateHipRotationForKick, calculateKickPowerFromHipRotation, calculateKneeDrive, calculateKneeStrikePowerModifier, calculateShoulderElevation, calculateSpinalFlexion, calculateWristSnap, calculateWristSnapPowerModifier, } from "./AdvancedJointMovements";
+export type { AnkleArticulationState, BodySide, HandStrikeType, HipRotationState, KickHeight, KickType, KneeDriveState, KneePhase, KneeTechniqueType, ShoulderElevationState, ShoulderPhase, ShoulderTechniqueType, SpinalFlexionState, SpinalMovementType, StrikePhase, TechniquePhase, WristSnapState, } from "./AdvancedJointMovements";
+export { compareRecoveryPhases, generateRecoveryVisualization, generateTensionChart, printRecoveryAnalysis, } from "./RecoveryVisualization";
+export type { RecoveryTimelinePoint, RecoveryVisualization, } from "./RecoveryVisualization";
+export * from "./MuscleActivation";
+//# sourceMappingURL=index.d.ts.map

package/lib/systems/animation/systems/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/systems/animation/systems/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EACL,qBAAqB,EACrB,4BAA4B,EAC5B,yBAAyB,EACzB,0BAA0B,EAC1B,yBAAyB,EACzB,4BAA4B,EAC5B,sBAAsB,EACtB,iBAAiB,EACjB,qBAAqB,GACtB,MAAM,qBAAqB,CAAC;AAC7B,YAAY,EAAE,0BAA0B,EAAE,MAAM,qBAAqB,CAAC;AAEtE,OAAO,EACL,yBAAyB,EACzB,2BAA2B,EAC3B,uBAAuB,EACvB,sBAAsB,EACtB,yBAAyB,EACzB,wBAAwB,EACxB,uBAAuB,EACvB,uBAAuB,EACvB,qBAAqB,EACrB,sBAAsB,GACvB,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EACL,sBAAsB,EACtB,uBAAuB,EACvB,uBAAuB,EACvB,sBAAsB,EACtB,kBAAkB,EAClB,mBAAmB,EACnB,gBAAgB,EAChB,cAAc,GACf,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EACL,gBAAgB,EAChB,gBAAgB,EAChB,wBAAwB,EACxB,sBAAsB,EACtB,uBAAuB,EACvB,sBAAsB,EACtB,qBAAqB,EACrB,mBAAmB,EACnB,qBAAqB,EACrB,uBAAuB,EACvB,uBAAuB,EACvB,SAAS,EACT,UAAU,EACV,iBAAiB,EACjB,kBAAkB,EAClB,cAAc,EACd,uBAAuB,EACvB,oBAAoB,EACpB,YAAY,EACZ,gBAAgB,EAChB,0BAA0B,GAC3B,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EACL,0BAA0B,EAC1B,uBAAuB,EACvB,0BAA0B,EAC1B,2BAA2B,EAC3B,iCAAiC,EACjC,kBAAkB,EAClB,gCAAgC,EAChC,0BAA0B,EAC1B,sBAAsB,EACtB,kBAAkB,EAClB,+BAA+B,GAChC,MAAM,0BAA0B,CAAC;AAClC,YAAY,EACV,sBAAsB,EACtB,QAAQ,EACR,cAAc,EACd,gBAAgB,EAChB,UAAU,EACV,QAAQ,EACR,cAAc,EACd,SAAS,EACT,iBAAiB,EACjB,sBAAsB,EACtB,aAAa,EACb,qBAAqB,EACrB,kBAAkB,EAClB,kBAAkB,EAClB,WAAW,EACX,cAAc,EACd,cAAc,GACf,MAAM,0BAA0B,CAAC;AAElC,OAAO,EACL,qBAAqB,EACrB,6BAA6B,EAC7B,oBAAoB,EACpB,qBAAqB,GACtB,MAAM,yBAAyB,CAAC;AACjC,YAAY,EACV,qBAAqB,EACrB,qBAAqB,GACtB,MAAM,yBAAyB,CAAC;AAEjC,cAAc,oBAAoB,CAAC"}

package/lib/systems/animation/systems/index.js

@@ -0,0 +1,7 @@
+import "./FacialExpressions.js";
+import "./HeadMovements.js";
+import "./FallAnimations.js";
+import "./BodyFacingSystem.js";
+import "./AdvancedJointMovements.js";
+import "./RecoveryVisualization.js";
+import "./MuscleActivation.js";