diff --git a/public/models/untitled.glb b/public/models/untitled.glb
new file mode 100644
index 0000000..afd7353
Binary files /dev/null and b/public/models/untitled.glb differ
diff --git a/src/app/app.config.ts b/src/app/app.config.ts
index 94f5f50..9a27e34 100644
--- a/src/app/app.config.ts
+++ b/src/app/app.config.ts
@@ -1,9 +1,9 @@
 import { ApplicationConfig, provideZoneChangeDetection } from '@angular/core';
-import { provideRouter } from '@angular/router';
+import { PreloadAllModules, provideRouter, withPreloading } from '@angular/router';
 
 import { routes } from './app.routes';
 import { provideHttpClient } from '@angular/common/http';
 
 export const appConfig: ApplicationConfig = {
-  providers: [provideZoneChangeDetection({ eventCoalescing: true }), provideRouter(routes), provideHttpClient()]
+  providers: [provideZoneChangeDetection({ eventCoalescing: true }), provideRouter(routes,withPreloading(PreloadAllModules)), provideHttpClient()]
 };
diff --git a/src/app/components/consent/consent.component.ts b/src/app/components/consent/consent.component.ts
index d686adb..3f529e6 100644
--- a/src/app/components/consent/consent.component.ts
+++ b/src/app/components/consent/consent.component.ts
@@ -2,7 +2,6 @@ import { Component, OnInit } from '@angular/core';
 import { Router } from '@angular/router';
 import { CommonModule } from '@angular/common';
 import { FormsModule } from '@angular/forms';
-import { ArLoggerService } from '../../services/ar-logger.service';
 
 @Component({
   selector: 'app-consent',
@@ -17,7 +16,6 @@ export class ConsentComponent implements OnInit {
 
   constructor(
     private router: Router,
-    private logger: ArLoggerService
   ) {}
 
   ngOnInit(): void {
@@ -26,8 +24,18 @@ export class ConsentComponent implements OnInit {
     if (this.isIosDevice) {
       console.log("iOS device detected. Study will be disabled.");
     }
+    this.preloadTestSuite();
   }
 
+  preloadTestSuite(): void {
+    import('../test-suite/test-suite.component')
+      .then(() => {
+      })
+      .catch(err => {
+      });
+  }
+
+
   isIOS(): boolean {
     const win = window as any;
     return /iPad|iPhone|iPod/.test(navigator.userAgent) && !win.MSStream;
@@ -41,7 +49,6 @@ export class ConsentComponent implements OnInit {
 
   startTestSuite(): void {
     if (this.consentGiven && !this.isIosDevice) {
-      this.logger.initializeSession();
       this.router.navigate(['/test-suite']);
     }
   }
diff --git a/src/app/components/test-suite/assessments/spatial-position-assessment/spatial-position-assessment.component.html b/src/app/components/test-suite/assessments/spatial-position-assessment/spatial-position-assessment.component.html
index 4ccea7e..5518755 100644
--- a/src/app/components/test-suite/assessments/spatial-position-assessment/spatial-position-assessment.component.html
+++ b/src/app/components/test-suite/assessments/spatial-position-assessment/spatial-position-assessment.component.html
@@ -2,7 +2,7 @@
   <model-viewer
     #modelViewer
     class="absolute inset-0 w-full h-full"
-    src="https://modelviewer.dev/shared-assets/models/Astronaut.glb"
+    src="models/untitled.glb"
     ar 
     ar-modes="webxr" 
     ar-placement="ceiling" 
diff --git a/src/app/components/test-suite/assessments/spatial-stability-assessment/spatial-stability-assessment.component.html b/src/app/components/test-suite/assessments/spatial-stability-assessment/spatial-stability-assessment.component.html
index eb0d07e..5871ec7 100644
--- a/src/app/components/test-suite/assessments/spatial-stability-assessment/spatial-stability-assessment.component.html
+++ b/src/app/components/test-suite/assessments/spatial-stability-assessment/spatial-stability-assessment.component.html
@@ -2,7 +2,7 @@
   <model-viewer
     #modelViewer
     class="absolute inset-0 w-full h-full"
-    src="https://modelviewer.dev/shared-assets/models/Astronaut.glb"
+    src="models/untitled.glb"
     ar 
     ar-modes="webxr" 
     ar-placement="ceiling" 
diff --git a/src/app/components/test-suite/assessments/text-legibility-assessment/text-legibility-assessment.component.html b/src/app/components/test-suite/assessments/text-legibility-assessment/text-legibility-assessment.component.html
index ce79dee..1bb01ec 100644
--- a/src/app/components/test-suite/assessments/text-legibility-assessment/text-legibility-assessment.component.html
+++ b/src/app/components/test-suite/assessments/text-legibility-assessment/text-legibility-assessment.component.html
@@ -1,6 +1,10 @@
 <div class="w-full h-full relative">
   <model-viewer #modelViewer class="absolute inset-0 w-full h-full"
-    src="https://modelviewer.dev/shared-assets/models/Astronaut.glb" ar ar-modes="webxr" ar-placement="ceiling"
+  src="models/untitled.glb"
+  ar ar-modes="webxr" ar-placement="ceiling"
+  loading="eager"
+  (preload)="onModelPreload()"
+  (load)="onModelLoad()"
     reveal="manual" camera-orbit="0deg 75deg 2m">
 
     <button slot="ar-button" id="ar-button-legibility" (click)="logInteraction($event)"
diff --git a/src/app/components/test-suite/assessments/text-legibility-assessment/text-legibility-assessment.component.ts b/src/app/components/test-suite/assessments/text-legibility-assessment/text-legibility-assessment.component.ts
index 5a98395..0acc4fb 100644
--- a/src/app/components/test-suite/assessments/text-legibility-assessment/text-legibility-assessment.component.ts
+++ b/src/app/components/test-suite/assessments/text-legibility-assessment/text-legibility-assessment.component.ts
@@ -34,7 +34,8 @@ export class TextLegibilityAssessmentComponent implements AfterViewInit, OnDestr
   public isArActive = false;
   public isModelPlaced = false;
   public isDescriptionVisible = true;
-
+  
+  isModelLoading: boolean = true;
   minSize = 2;
   maxSize = 64;
   currentSize = 16;
@@ -147,4 +148,12 @@ export class TextLegibilityAssessmentComponent implements AfterViewInit, OnDestr
   ngOnDestroy() {
     this.metricsService.stopTracking();
   }
+
+  onModelPreload() {
+    this.isModelLoading = true;
+  }
+
+  onModelLoad() {
+    this.isModelLoading = false;
+  }
 }
diff --git a/src/app/components/test-suite/test-suite.component.ts b/src/app/components/test-suite/test-suite.component.ts
index d87f62f..3cc2c34 100644
--- a/src/app/components/test-suite/test-suite.component.ts
+++ b/src/app/components/test-suite/test-suite.component.ts
@@ -2,26 +2,19 @@ import { Component, OnInit, OnDestroy } from '@angular/core';
 import { CommonModule } from '@angular/common';
 import { Subject, takeUntil } from 'rxjs';
 import { TestProgressService } from '../../services/test-progress.service';
-import { ArLoggerService } from '../../services/ar-logger.service';
 
 import { SpatialStabilityAssessmentComponent } from './assessments/spatial-stability-assessment/spatial-stability-assessment.component';
-import { ErgonomicAssessmentComponent } from './assessments/ergonomic-assessment/ergonomic-assessment.component';
 import { TextLegibilityAssessmentComponent } from './assessments/text-legibility-assessment/text-legibility-assessment.component';
-import { ScaleReferenceAssessmentComponent } from './assessments/scale-reference-assessment/scale-reference-assessment.component';
 import { SpatialPositionAssessmentComponent } from './assessments/spatial-position-assessment/spatial-position-assessment.component';
 import { DemographicsFeedbackComponent } from './assessments/demographics-feedback/demographics-feedback.component';
-import { FirstInputAssessmentComponent } from './assessments/first-input-assesment/first-input-assesment.component';
 
 @Component({
   selector: 'app-test-suite',
   standalone: true,
   imports: [
     CommonModule,
-    FirstInputAssessmentComponent,
     SpatialStabilityAssessmentComponent,
-    ErgonomicAssessmentComponent,
     TextLegibilityAssessmentComponent,
-    ScaleReferenceAssessmentComponent,
     SpatialPositionAssessmentComponent,
     DemographicsFeedbackComponent,
     DemographicsFeedbackComponent
@@ -38,7 +31,6 @@ export class TestSuiteComponent implements OnInit, OnDestroy {
 
   constructor(
     private progressService: TestProgressService,
-    private logger: ArLoggerService
   ) {}
 
   ngOnInit(): void {
@@ -46,7 +38,6 @@ export class TestSuiteComponent implements OnInit, OnDestroy {
       .pipe(takeUntil(this.destroy$))
       .subscribe(test => {
         this.currentTest = test;
-        this.logger.setCurrentTest(test);
       });
 
     this.progressService.progress$
@@ -55,13 +46,7 @@ export class TestSuiteComponent implements OnInit, OnDestroy {
         this.progress = progress;
       });
 
-    this.logger.status$
-      .pipe(takeUntil(this.destroy$))
-      .subscribe(status => {
-      });
-
     this.totalTests = this.progressService.getTotalTests();
-    this.logger.updateStatus('Test suite initialized - Assessment 1 ready');
   }
 
   ngOnDestroy(): void {
@@ -78,7 +63,6 @@ export class TestSuiteComponent implements OnInit, OnDestroy {
   }
 
   forceNextTest(): void {
-    this.logger.updateStatus(`Forcefully skipped to next test from test ${this.currentTest}.`);
     this.progressService.nextTest();
   }
 }
\ No newline at end of file
diff --git a/src/app/services/ar-logger.service.ts b/src/app/services/ar-logger.service.ts
deleted file mode 100644
index a8b1c8c..0000000
--- a/src/app/services/ar-logger.service.ts
+++ /dev/null
@@ -1,1067 +0,0 @@
-import { Injectable } from '@angular/core';
-import { BehaviorSubject, interval, Subscription } from 'rxjs';
-
-
-export interface DeviceInfo {
-  sessionId: string;
-  userAgent: string;
-  displayWidth: number;
-  displayHeight: number;
-  pixelRatio: number;
-  platform: string;
-  language: string;
-  timestamp: string;
-  deviceType: 'mobile' | 'tablet' | 'desktop' | 'vr' | 'unknown';
-  browserName: string;
-  browserVersion: string;
-  operatingSystem: string;
-  screenOrientation: string;
-  hasGyroscope: boolean;
-  hasAccelerometer: boolean;
-  hasVRSupport: boolean;
-  hasARSupport: boolean;
-  maxTouchPoints: number;
-  connectionType?: string;
-  batteryLevel?: number;
-}
-
-export interface GyroscopeData {
-  timestamp: number;
-  relativeTime: number; // Time since session start
-  testPhase: number;
-  alpha: number | null; // Z-axis rotation (0-360°)
-  beta: number | null;  // X-axis rotation (-180 to 180°)
-  gamma: number | null; // Y-axis rotation (-90 to 90°)
-  absoluteAlpha?: number | null;
-  accuracy?: number;
-}
-
-export interface AccelerometerData {
-  timestamp: number;
-  relativeTime: number;
-  testPhase: number;
-  x: number;
-  y: number;
-  z: number;
-  acceleration?: {
-    x: number;
-    y: number;
-    z: number;
-  };
-  rotationRate?: {
-    alpha: number;
-    beta: number;
-    gamma: number;
-  };
-}
-
-export interface UserInput {
-  timestamp: number;
-  relativeTime: number;
-  testPhase: number;
-  inputType: 'touch' | 'mouse' | 'keyboard' | 'controller' | 'gesture' | 'voice';
-  action: 'start' | 'move' | 'end' | 'click' | 'tap' | 'drag' | 'pinch' | 'rotate';
-  coordinates?: {
-    x: number;
-    y: number;
-    screenX: number;
-    screenY: number;
-  };
-  pressure?: number;
-  touches?: number;
-  target?: string;
-  duration?: number;
-  velocity?: number;
-  success: boolean;
-  errorType?: string;
-}
-
-export interface ModelPlacementData {
-  timestamp: number;
-  relativeTime: number;
-  testPhase: number;
-  placed: boolean;
-  position?: {
-    x: number;
-    y: number;
-    z: number;
-  };
-  rotation?: {
-    x: number;
-    y: number;
-    z: number;
-  };
-  scale?: number;
-  distanceFromUser?: number;
-  placementAttempts: number;
-  placementSuccess: boolean;
-  surfaceDetected: boolean;
-  lightingCondition?: 'poor' | 'adequate' | 'good' | 'excellent';
-}
-
-export interface SliderInteraction {
-  timestamp: number;
-  relativeTime: number;
-  testPhase: number;
-  sliderType: string;
-  previousValue: number;
-  newValue: number;
-  changeAmount: number;
-  interactionDuration: number;
-  inputMethod: 'touch' | 'mouse' | 'controller';
-  coordinatesStart?: { x: number; y: number };
-  coordinatesEnd?: { x: number; y: number };
-}
-
-export interface PerformanceMetrics {
-  timestamp: number;
-  relativeTime: number;
-  testPhase: number;
-  frameRate: number;
-  memoryUsage?: number;
-  cpuUsage?: number;
-  batteryLevel?: number;
-  networkLatency?: number;
-  renderTime?: number;
-  loadingTime?: number;
-}
-
-export interface ComfortMetrics {
-  timestamp: number;
-  relativeTime: number;
-  testPhase: number;
-  headTiltAngle: number; // Derived from gyroscope
-  neckStrainIndicator: number; // 0-10 scale based on angle thresholds
-  rapidMovements: number; // Count of sudden movements
-  restPeriods: number; // Count of stationary periods
-  gazeDirection: 'ceiling' | 'walls' | 'floor' | 'device';
-  estimatedFatigue: number; // 0-10 scale
-}
-
-export interface WebXRSessionData {
-  sessionId: string;
-  sessionType: 'immersive-ar' | 'immersive-vr' | 'inline';
-  startTime: number;
-  endTime?: number;
-  duration?: number;
-  featureRequested: string[];
-  featuresEnabled: string[];
-  referenceSpaceType?: string;
-  inputSources: any[];
-  frameRate?: number;
-  poses: any[];
-  hitTests?: any[];
-}
-
-export interface TestResult {
-  duration: number;
-  completedSuccessfully: boolean;
-  interactionCount: number;
-  timeInVR: number;
-  startTime: number;
-  endTime?: number;
-  errorCount: number;
-  successRate: number;
-  averageResponseTime: number;
-  retryAttempts: number;
-  userSatisfaction?: number;
-  taskDifficulty?: number;
-  cognitiveLoad?: number;
-}
-
-export type TestResultKey = 'firstInputTest' | 'speedTest' | 'ergonomicTest' | 'textTest' | 'referenceTest' | 'ceilingTest' | 'demographics';
-
-export interface AssessmentData {
-  device: DeviceInfo;
-  session: {
-    startTime: number;
-    endTime?: number;
-    totalDuration?: number;
-    webXRSessions: WebXRSessionData[];
-  };
-  tracking: {
-    gyroscopeData: GyroscopeData[];
-    accelerometerData: AccelerometerData[];
-    userInputs: UserInput[];
-    modelPlacements: ModelPlacementData[];
-    sliderInteractions: SliderInteraction[];
-    performanceMetrics: PerformanceMetrics[];
-    comfortMetrics: ComfortMetrics[];
-  };
-  results: {
-    firstInputTest: TestResult & {
-      firstInputType: string | null;
-      firstInputData: any;
-      motionFrames: number;
-      naturalBehaviorPattern: string;
-    };
-    speedTest: TestResult & {
-      finalSpeed: number;
-      adjustments: SliderInteraction[];
-      optimalSpeedFound: boolean;
-      speedPreferences: number[];
-    };
-    ergonomicTest: TestResult & {
-      finalDistance: number;
-      finalAngle: number;
-      distanceAdjustments: SliderInteraction[];
-      angleAdjustments: SliderInteraction[];
-      comfortZone: { minDistance: number; maxDistance: number; optimalAngle: number };
-    };
-    textTest: TestResult & {
-      finalTextSize: number;
-      adjustments: SliderInteraction[];
-      readabilityScores: number[];
-      eyeStrainIndicators: ComfortMetrics[];
-    };
-    referenceTest: TestResult & {
-      finalScale: number;
-      adjustments: SliderInteraction[];
-      scalePerception: string;
-      depthPerceptionAccuracy: number;
-    };
-    ceilingTest: TestResult & {
-      finalXPosition: number;
-      finalYPosition: number;
-      xAdjustments: SliderInteraction[];
-      yAdjustments: SliderInteraction[];
-      spatialAwareness: number;
-      optimalPlacementZone: { x: number; y: number; radius: number };
-    };
-    demographics: {
-      age: number | null;
-      feedback: string;
-      overallRating: number | null;
-      arExperience: 'none' | 'beginner' | 'intermediate' | 'advanced';
-      vrExperience: 'none' | 'beginner' | 'intermediate' | 'advanced';
-      visionProblems: boolean;
-      motionSickness: boolean;
-      handedness: 'left' | 'right' | 'ambidextrous';
-      techComfort: number; // 1-10 scale
-    };
-  };
-  analysis: {
-    inputHeatMap: { x: number; y: number; intensity: number }[];
-    gyroscopeHeatMap: { alpha: number; beta: number; gamma: number; frequency: number }[];
-    comfortZoneAnalysis: any;
-    usabilityScore: number;
-    recommendedSettings: any;
-  };
-}
-
-
-@Injectable({
-  providedIn: 'root'
-})
-export class ArLoggerService {
-  private sessionId: string = '';
-  private startTime: number = 0;
-  private currentTest = 0;
-  private testData: AssessmentData;
-  private gyroscopeSubscription?: Subscription;
-  private performanceSubscription?: Subscription;
-  private isTracking = false;
-  private currentFrameRate = 60;
-  private isMeasuringFps = false;
-  
-  // Status observable for components to subscribe to
-  private statusSubject = new BehaviorSubject<string>('Ready to begin assessments');
-  status$ = this.statusSubject.asObservable();
-
-  constructor() {
-    this.testData = this.initializeTestData();
-    this.detectDeviceCapabilities();
-  }
-
-
-  initializeSession(): void {
-    this.sessionId = this.generateSessionId();
-    this.startTime = Date.now();
-    this.testData.device.sessionId = this.sessionId;
-    this.testData.device.timestamp = new Date().toISOString();
-    this.testData.session.startTime = this.startTime;
-    
-    this.startContinuousTracking();
-    this.updateStatus('Session initialized - Ready to begin');
-  }
-
-  private generateSessionId(): string {
-    return 'CEILING_AR_' + Date.now() + '_' + Math.random().toString(36).substr(2, 9);
-  }
-
-  private initializeTestData(): AssessmentData {
-    const data: AssessmentData = {
-      device: this.getDeviceInfo(),
-      session: {
-        startTime: 0,
-        webXRSessions: []
-      },
-      tracking: {
-        gyroscopeData: [],
-        accelerometerData: [],
-        userInputs: [],
-        modelPlacements: [],
-        sliderInteractions: [],
-        performanceMetrics: [],
-        comfortMetrics: []
-      },
-      results: {
-        firstInputTest: { ...this.createBaseTestResult(), firstInputType: null, firstInputData: null, motionFrames: 0, naturalBehaviorPattern: '' },
-        speedTest: { ...this.createBaseTestResult(), finalSpeed: 50, adjustments: [], optimalSpeedFound: false, speedPreferences: [] },
-        ergonomicTest: { 
-          ...this.createBaseTestResult(), 
-          finalDistance: 2.0, 
-          finalAngle: 75, 
-          distanceAdjustments: [], 
-          angleAdjustments: [],
-          comfortZone: { minDistance: 1.0, maxDistance: 4.0, optimalAngle: 75 }
-        },
-        textTest: { 
-          ...this.createBaseTestResult(), 
-          finalTextSize: 16, 
-          adjustments: [], 
-          readabilityScores: [],
-          eyeStrainIndicators: []
-        },
-        referenceTest: { 
-          ...this.createBaseTestResult(), 
-          finalScale: 100, 
-          adjustments: [],
-          scalePerception: 'accurate',
-          depthPerceptionAccuracy: 0.8
-        },
-        ceilingTest: { 
-          ...this.createBaseTestResult(), 
-          finalXPosition: 0, 
-          finalYPosition: 0, 
-          xAdjustments: [], 
-          yAdjustments: [],
-          spatialAwareness: 0.7,
-          optimalPlacementZone: { x: 0, y: 0, radius: 1.0 }
-        },
-        demographics: {
-          age: null,
-          feedback: '',
-          overallRating: null,
-          arExperience: 'none',
-          vrExperience: 'none',
-          visionProblems: false,
-          motionSickness: false,
-          handedness: 'right',
-          techComfort: 5
-        }
-      },
-      analysis: {
-        inputHeatMap: [],
-        gyroscopeHeatMap: [],
-        comfortZoneAnalysis: {},
-        usabilityScore: 0,
-        recommendedSettings: {}
-      }
-    };
-    return data;
-  }
-
-  private createBaseTestResult(): TestResult & any {
-    return {
-      duration: 0,
-      completedSuccessfully: false,
-      interactionCount: 0,
-      timeInVR: 0,
-      startTime: 0,
-      errorCount: 0,
-      successRate: 0,
-      averageResponseTime: 0,
-      retryAttempts: 0
-    };
-  }
-
-
-  private getDeviceInfo(): DeviceInfo {
-    const userAgent = navigator.userAgent;
-    
-    return {
-      sessionId: '',
-      userAgent: userAgent,
-      displayWidth: window.innerWidth,
-      displayHeight: window.innerHeight,
-      pixelRatio: window.devicePixelRatio,
-      platform: navigator.platform,
-      language: navigator.language,
-      timestamp: '',
-      deviceType: this.detectDeviceType(),
-      browserName: this.detectBrowser().name,
-      browserVersion: this.detectBrowser().version,
-      operatingSystem: this.detectOS(),
-      screenOrientation: this.getScreenOrientation(),
-      hasGyroscope: 'DeviceOrientationEvent' in window,
-      hasAccelerometer: 'DeviceMotionEvent' in window,
-      hasVRSupport: 'xr' in navigator,
-      hasARSupport: false, // Will be updated when WebXR session starts
-      maxTouchPoints: navigator.maxTouchPoints || 0,
-      connectionType: this.getConnectionType(),
-      batteryLevel: undefined
-    };
-  }
-
-  private detectDeviceType(): 'mobile' | 'tablet' | 'desktop' | 'vr' | 'unknown' {
-    const userAgent = navigator.userAgent.toLowerCase();
-    
-    if (/mobile|android|iphone|ipod|blackberry|opera mini|iemobile/i.test(userAgent)) {
-      return 'mobile';
-    }
-    if (/tablet|ipad|playbook|silk/i.test(userAgent)) {
-      return 'tablet';
-    }
-    if (/oculus|vive|pico|quest/i.test(userAgent)) {
-      return 'vr';
-    }
-    if (!/mobile|tablet/i.test(userAgent)) {
-      return 'desktop';
-    }
-    
-    return 'unknown';
-  }
-
-  private detectBrowser(): { name: string; version: string } {
-    const userAgent = navigator.userAgent;
-    let name = 'unknown';
-    let version = 'unknown';
-
-    if (userAgent.includes('Chrome')) {
-      name = 'Chrome';
-      version = userAgent.match(/Chrome\/(\d+)/)?.[1] || 'unknown';
-    } else if (userAgent.includes('Firefox')) {
-      name = 'Firefox';
-      version = userAgent.match(/Firefox\/(\d+)/)?.[1] || 'unknown';
-    } else if (userAgent.includes('Safari')) {
-      name = 'Safari';
-      version = userAgent.match(/Version\/(\d+)/)?.[1] || 'unknown';
-    } else if (userAgent.includes('Edge')) {
-      name = 'Edge';
-      version = userAgent.match(/Edge\/(\d+)/)?.[1] || 'unknown';
-    }
-
-    return { name, version };
-  }
-
-  private detectOS(): string {
-    const userAgent = navigator.userAgent;
-    
-    if (/Windows/i.test(userAgent)) return 'Windows';
-    if (/Mac/i.test(userAgent)) return 'macOS';
-    if (/Linux/i.test(userAgent)) return 'Linux';
-    if (/Android/i.test(userAgent)) return 'Android';
-    if (/iOS|iPhone|iPad/i.test(userAgent)) return 'iOS';
-    
-    return 'Unknown';
-  }
-
-  private getScreenOrientation(): string {
-    if (screen.orientation) {
-      return screen.orientation.type;
-    }
-    return window.innerWidth > window.innerHeight ? 'landscape' : 'portrait';
-  }
-
-  private getConnectionType(): string | undefined {
-    const connection = (navigator as any).connection || (navigator as any).mozConnection || (navigator as any).webkitConnection;
-    return connection?.effectiveType;
-  }
-
-  private async detectDeviceCapabilities(): Promise<void> {
-    // Check AR support
-    if ('xr' in navigator) {
-      try {
-        const isARSupported = await (navigator as any).xr.isSessionSupported('immersive-ar');
-        this.testData.device.hasARSupport = isARSupported;
-      } catch (error) {
-        this.testData.device.hasARSupport = false;
-      }
-    }
-
-    // Check battery API
-    if ('getBattery' in navigator) {
-      try {
-        const battery = await (navigator as any).getBattery();
-        this.testData.device.batteryLevel = battery.level;
-      } catch (error) {
-        // Battery API not available
-      }
-    }
-  }
-
-  private startContinuousTracking(): void {
-    this.isTracking = true;
-    this.startGyroscopeTracking();
-    this.startPerformanceTracking();
-    this.setupInputListeners();
-    this.startFrameRateMeasurement();
-  }
-
-  private startGyroscopeTracking(): void {
-    if (!this.testData.device.hasGyroscope) return;
-
-    // Request permission for iOS devices
-    if (typeof (DeviceOrientationEvent as any).requestPermission === 'function') {
-      (DeviceOrientationEvent as any).requestPermission()
-        .then((response: string) => {
-          if (response === 'granted') {
-            this.setupGyroscopeListener();
-          }
-        });
-    } else {
-      this.setupGyroscopeListener();
-    }
-
-    // Setup accelerometer if available
-    if (this.testData.device.hasAccelerometer) {
-      this.setupAccelerometerListener();
-    }
-  }
-
-  private setupGyroscopeListener(): void {
-    window.addEventListener('deviceorientation', (event) => {
-      if (!this.isTracking) return;
-
-      const gyroData: GyroscopeData = {
-        timestamp: Date.now(),
-        relativeTime: Date.now() - this.startTime,
-        testPhase: this.currentTest,
-        alpha: event.alpha,
-        beta: event.beta,
-        gamma: event.gamma,
-        absoluteAlpha: event.absolute ? event.alpha : undefined
-      };
-
-      this.testData.tracking.gyroscopeData.push(gyroData);
-      
-      this.generateComfortMetrics(gyroData);
-      
-      // Limit array size to prevent memory issues
-      if (this.testData.tracking.gyroscopeData.length > 10000) {
-        this.testData.tracking.gyroscopeData = this.testData.tracking.gyroscopeData.slice(-5000);
-      }
-    });
-  }
-
-  private setupAccelerometerListener(): void {
-    window.addEventListener('devicemotion', (event) => {
-      if (!this.isTracking) return;
-
-      const accelData: AccelerometerData = {
-        timestamp: Date.now(),
-        relativeTime: Date.now() - this.startTime,
-        testPhase: this.currentTest,
-        x: event.acceleration?.x || 0,
-        y: event.acceleration?.y || 0,
-        z: event.acceleration?.z || 0,
-        acceleration: {
-          x: event.acceleration?.x || 0,
-          y: event.acceleration?.y || 0,
-          z: event.acceleration?.z || 0
-        },
-        rotationRate: {
-          alpha: event.rotationRate?.alpha || 0,
-          beta: event.rotationRate?.beta || 0,
-          gamma: event.rotationRate?.gamma || 0
-        }
-      };
-
-      this.testData.tracking.accelerometerData.push(accelData);
-
-      if (this.testData.tracking.accelerometerData.length > 5000) {
-        this.testData.tracking.accelerometerData = this.testData.tracking.accelerometerData.slice(-2500);
-      }
-    });
-  }
-
-  private startPerformanceTracking(): void {
-    this.performanceSubscription = interval(1000).subscribe(() => {
-      if (!this.isTracking) return;
-
-      const perfData: PerformanceMetrics = {
-        timestamp: Date.now(),
-        relativeTime: Date.now() - this.startTime,
-        testPhase: this.currentTest,
-        frameRate: this.currentFrameRate, 
-        memoryUsage: (performance as any).memory?.usedJSHeapSize,
-        batteryLevel: this.getBatteryLevel()
-      };
-
-      this.testData.tracking.performanceMetrics.push(perfData);
-    });
-  }
-
-  private startFrameRateMeasurement(): void {
-    if (this.isMeasuringFps) {
-      return;
-    }
-    this.isMeasuringFps = true;
-
-    let frames = 0;
-    let lastTime = performance.now();
-
-    const measureFrame = () => {
-      if (!this.isTracking) {
-        this.isMeasuringFps = false;
-        return;
-      }
-
-      frames++;
-      const now = performance.now();
-      const elapsed = now - lastTime;
-
-      if (elapsed >= 1000) {
-        this.currentFrameRate = Math.round((frames * 1000) / elapsed);
-        lastTime = now;
-        frames = 0;
-      }
-      
-      requestAnimationFrame(measureFrame);
-    };
-
-    requestAnimationFrame(measureFrame);
-  }
-
-  private getBatteryLevel(): number | undefined {
-    return this.testData.device.batteryLevel;
-  }
-
-  private generateComfortMetrics(gyroData: GyroscopeData): void {
-    if (!gyroData.beta || !gyroData.gamma) return;
-
-    const headTiltAngle = Math.abs(gyroData.beta);
-    const neckStrainIndicator = this.calculateNeckStrain(headTiltAngle);
-    
-    const comfortMetric: ComfortMetrics = {
-      timestamp: gyroData.timestamp,
-      relativeTime: gyroData.relativeTime,
-      testPhase: gyroData.testPhase,
-      headTiltAngle: headTiltAngle,
-      neckStrainIndicator: neckStrainIndicator,
-      rapidMovements: this.detectRapidMovements(),
-      restPeriods: this.detectRestPeriods(),
-      gazeDirection: this.estimateGazeDirection(gyroData),
-      estimatedFatigue: this.estimateFatigue()
-    };
-
-    this.testData.tracking.comfortMetrics.push(comfortMetric);
-  }
-
-  private calculateNeckStrain(headTiltAngle: number): number {
-    if (headTiltAngle <= 30) return Math.round((headTiltAngle / 30) * 3);
-    if (headTiltAngle <= 60) return Math.round(3 + ((headTiltAngle - 30) / 30) * 4);
-    return Math.min(10, Math.round(7 + ((headTiltAngle - 60) / 30) * 3));
-  }
-
-  private detectRapidMovements(): number {
-    const recentGyroData = this.testData.tracking.gyroscopeData.slice(-10);
-    let rapidMovements = 0;
-    
-    for (let i = 1; i < recentGyroData.length; i++) {
-      const current = recentGyroData[i];
-      const previous = recentGyroData[i - 1];
-      
-      if (current.beta && previous.beta && current.gamma && previous.gamma) {
-        const betaDiff = Math.abs(current.beta - previous.beta);
-        const gammaDiff = Math.abs(current.gamma - previous.gamma);
-        
-        if (betaDiff > 20 || gammaDiff > 20) {
-          rapidMovements++;
-        }
-      }
-    }
-    
-    return rapidMovements;
-  }
-
-  private detectRestPeriods(): number {
-    const recentGyroData = this.testData.tracking.gyroscopeData.slice(-20);
-    let restPeriods = 0;
-    let consecutiveStillFrames = 0;
-    
-    for (let i = 1; i < recentGyroData.length; i++) {
-      const current = recentGyroData[i];
-      const previous = recentGyroData[i - 1];
-      
-      if (current.beta && previous.beta && current.gamma && previous.gamma) {
-        const betaDiff = Math.abs(current.beta - previous.beta);
-        const gammaDiff = Math.abs(current.gamma - previous.gamma);
-        
-        if (betaDiff < 2 && gammaDiff < 2) {
-          consecutiveStillFrames++;
-        } else {
-          if (consecutiveStillFrames >= 5) {
-            restPeriods++;
-          }
-          consecutiveStillFrames = 0;
-        }
-      }
-    }
-    
-    return restPeriods;
-  }
-
-  private estimateGazeDirection(gyroData: GyroscopeData): 'ceiling' | 'walls' | 'floor' | 'device' {
-    if (!gyroData.beta) return 'device';
-    
-    const tiltAngle = gyroData.beta;
-    
-    if (tiltAngle > 45) return 'ceiling';
-    if (tiltAngle < -30) return 'floor';
-    if (Math.abs(tiltAngle) < 15) return 'device';
-    
-    return 'walls';
-  }
-
-  private estimateFatigue(): number {
-    const recentComfort = this.testData.tracking.comfortMetrics.slice(-60);
-    
-    if (recentComfort.length === 0) return 0;
-    
-    const averageStrain = recentComfort.reduce((sum, metric) => sum + metric.neckStrainIndicator, 0) / recentComfort.length;
-    const totalRapidMovements = recentComfort.reduce((sum, metric) => sum + metric.rapidMovements, 0);
-    const sessionDuration = (Date.now() - this.startTime) / (1000 * 60);
-    
-    let fatigueScore = averageStrain * 0.4;
-    fatigueScore += Math.min(totalRapidMovements * 0.1, 3);
-    fatigueScore += Math.min(sessionDuration * 0.1, 2);
-    
-    return Math.min(10, Math.round(fatigueScore));
-  }
-
-
-  private setupInputListeners(): void {
-    // Touch events
-    document.addEventListener('touchstart', (e) => this.logUserInput(e, 'touch', 'start'));
-    document.addEventListener('touchmove', (e) => this.logUserInput(e, 'touch', 'move'));
-    document.addEventListener('touchend', (e) => this.logUserInput(e, 'touch', 'end'));
-    
-    // Mouse events
-    document.addEventListener('mousedown', (e) => this.logUserInput(e, 'mouse', 'start'));
-    document.addEventListener('mousemove', (e) => this.logUserInput(e, 'mouse', 'move'));
-    document.addEventListener('mouseup', (e) => this.logUserInput(e, 'mouse', 'end'));
-    document.addEventListener('click', (e) => this.logUserInput(e, 'mouse', 'click'));
-    
-    // Keyboard events
-    document.addEventListener('keydown', (e) => this.logUserInput(e, 'keyboard', 'start'));
-    document.addEventListener('keyup', (e) => this.logUserInput(e, 'keyboard', 'end'));
-  }
-
-  private logUserInput(event: Event, inputType: UserInput['inputType'], action: UserInput['action']): void {
-    if (!this.isTracking) return;
-
-    const input: UserInput = {
-      timestamp: Date.now(),
-      relativeTime: Date.now() - this.startTime,
-      testPhase: this.currentTest,
-      inputType: inputType,
-      action: action,
-      success: true,
-      target: (event.target as HTMLElement)?.tagName || 'unknown'
-    };
-
-    if (event instanceof TouchEvent && event.touches.length > 0) {
-      const touch = event.touches[0];
-      input.coordinates = {
-        x: touch.clientX,
-        y: touch.clientY,
-        screenX: touch.screenX,
-        screenY: touch.screenY
-      };
-      input.pressure = (touch as any).force || 1;
-      input.touches = event.touches.length;
-    } else if (event instanceof MouseEvent) {
-      input.coordinates = {
-        x: event.clientX,
-        y: event.clientY,
-        screenX: event.screenX,
-        screenY: event.screenY
-      };
-    }
-
-    this.testData.tracking.userInputs.push(input);
-
-    if (this.testData.tracking.userInputs.length > 5000) {
-      this.testData.tracking.userInputs = this.testData.tracking.userInputs.slice(-2500);
-    }
-  }
-
-  logSliderInteraction(sliderType: string, previousValue: number, newValue: number, interactionStart: number, inputMethod: 'touch' | 'mouse' | 'controller', coordinates?: { start: { x: number; y: number }, end: { x: number; y: number } }): void {
-    const interaction: SliderInteraction = {
-      timestamp: Date.now(),
-      relativeTime: Date.now() - this.startTime,
-      testPhase: this.currentTest,
-      sliderType: sliderType,
-      previousValue: previousValue,
-      newValue: newValue,
-      changeAmount: newValue - previousValue,
-      interactionDuration: Date.now() - interactionStart,
-      inputMethod: inputMethod,
-      coordinatesStart: coordinates?.start,
-      coordinatesEnd: coordinates?.end
-    };
-
-    this.testData.tracking.sliderInteractions.push(interaction);
-    
-    this.logParameterAdjustment(sliderType, 'value', newValue);
-  }
-
-  logModelPlacement(placed: boolean, position?: { x: number; y: number; z: number }, rotation?: { x: number; y: number; z: number }, scale?: number, attempts = 1, success = true): void {
-    const placement: ModelPlacementData = {
-      timestamp: Date.now(),
-      relativeTime: Date.now() - this.startTime,
-      testPhase: this.currentTest,
-      placed: placed,
-      position: position,
-      rotation: rotation,
-      scale: scale,
-      placementAttempts: attempts,
-      placementSuccess: success,
-      surfaceDetected: !!position,
-      distanceFromUser: position ? Math.sqrt(position.x ** 2 + position.y ** 2 + position.z ** 2) : undefined,
-      lightingCondition: this.assessLightingCondition()
-    };
-
-    this.testData.tracking.modelPlacements.push(placement);
-  }
-
-  private assessLightingCondition(): 'poor' | 'adequate' | 'good' | 'excellent' {
-    const hour = new Date().getHours();
-    
-    if (hour >= 10 && hour <= 16) return 'excellent'; // Daytime
-    if (hour >= 8 && hour <= 18) return 'good'; // Extended day hours
-    if (hour >= 6 && hour <= 20) return 'adequate'; // Dawn/dusk
-    
-    return 'poor';
-  }
-
-  logWebXRSession(sessionData: Partial<WebXRSessionData>): void {
-    const session: WebXRSessionData = {
-      sessionId: this.generateSessionId(),
-      sessionType: sessionData.sessionType || 'immersive-ar',
-      startTime: Date.now(),
-      featureRequested: sessionData.featureRequested || [],
-      featuresEnabled: sessionData.featuresEnabled || [],
-      inputSources: sessionData.inputSources || [],
-      poses: [],
-      ...sessionData
-    };
-
-    this.testData.session.webXRSessions.push(session);
-  }
-
-  generateHeatMaps(): void {
-    this.testData.analysis.inputHeatMap = this.generateInputHeatMap();
-    
-    this.testData.analysis.gyroscopeHeatMap = this.generateGyroscopeHeatMap();
-  }
-
-  private generateInputHeatMap(): { x: number; y: number; intensity: number }[] {
-    const heatMap: { [key: string]: number } = {};
-    const gridSize = 50;
-    
-    this.testData.tracking.userInputs.forEach(input => {
-      if (input.coordinates) {
-        const gridX = Math.floor(input.coordinates.x / gridSize) * gridSize;
-        const gridY = Math.floor(input.coordinates.y / gridSize) * gridSize;
-        const key = `${gridX},${gridY}`;
-        
-        heatMap[key] = (heatMap[key] || 0) + 1;
-      }
-    });
-
-    return Object.entries(heatMap).map(([key, intensity]) => {
-      const [x, y] = key.split(',').map(Number);
-      return { x, y, intensity };
-    });
-  }
-
-  private generateGyroscopeHeatMap(): { alpha: number; beta: number; gamma: number; frequency: number }[] {
-    const heatMap: { [key: string]: number } = {};
-    const angleStep = 10;
-    
-    this.testData.tracking.gyroscopeData.forEach(gyro => {
-      if (gyro.alpha !== null && gyro.beta !== null && gyro.gamma !== null) {
-        const gridAlpha = Math.floor((gyro.alpha || 0) / angleStep) * angleStep;
-        const gridBeta = Math.floor((gyro.beta || 0) / angleStep) * angleStep;
-        const gridGamma = Math.floor((gyro.gamma || 0) / angleStep) * angleStep;
-        const key = `${gridAlpha},${gridBeta},${gridGamma}`;
-        
-        heatMap[key] = (heatMap[key] || 0) + 1;
-      }
-    });
-
-    return Object.entries(heatMap).map(([key, frequency]) => {
-      const [alpha, beta, gamma] = key.split(',').map(Number);
-      return { alpha, beta, gamma, frequency };
-    });
-  }
-
-  logParameterAdjustment(testType: string, parameter: string, value: any): void {
-    const adjustment = {
-      timestamp: Date.now(),
-      parameter: parameter,
-      value: value
-    };
-
-    const testNames: { [key: string]: TestResultKey } = {
-      'speed': 'speedTest',
-      'ergonomic': 'ergonomicTest',
-      'text': 'textTest',
-      'reference': 'referenceTest',
-      'ceiling': 'ceilingTest'
-    };
-
-    const testName = testNames[testType];
-    if (testName && this.testData.results[testName]) {
-      const testResult = this.testData.results[testName] as any;
-
-      if (!testResult.adjustments) {
-        testResult.adjustments = [];
-      }
-      testResult.adjustments.push(adjustment);
-      testResult.interactionCount++;
-    }
-  }
-
-
-  markTestComplete(testName: TestResultKey): void {
-    if (testName === 'demographics') return; // Demographics is not a test to be completed.
-
-    const testResult = this.testData.results[testName];
-
-    if (this.isTestResult(testResult)) {
-      testResult.completedSuccessfully = true;
-      testResult.endTime = Date.now();
-      if (testResult.startTime > 0) {
-        testResult.duration = testResult.endTime - testResult.startTime;
-      }
-    }
-  }
-
-
-
-  updateStatus(message: string): void {
-    this.statusSubject.next(message);
-  }
-
-  exportToCSV(): string[][] {
-    this.generateHeatMaps();
-    
-    const csvData: string[][] = [];
-    
-    csvData.push([
-      'SessionID', 'TestType', 'Parameter', 'Value', 'Timestamp', 'RelativeTime',
-      'DeviceWidth', 'DeviceHeight', 'DeviceType', 'Browser', 'OS',
-      'Age', 'OverallRating', 'Completed', 'UsabilityScore',
-      'TotalGyroPoints', 'TotalInputs', 'ComfortScore', 'FatigueScore'
-    ]);
-
-    (Object.keys(this.testData.results) as Array<TestResultKey>).forEach(testName => {
-      const testResults = this.testData.results[testName] as any;
-      Object.keys(testResults).forEach(param => {
-        csvData.push([
-          this.sessionId,
-          testName,
-          param,
-          JSON.stringify(testResults[param]),
-          Date.now().toString(),
-          (Date.now() - this.startTime).toString(),
-          this.testData.device.displayWidth.toString(),
-          this.testData.device.displayHeight.toString(),
-          this.testData.device.deviceType,
-          this.testData.device.browserName,
-          this.testData.device.operatingSystem,
-          this.testData.results.demographics.age?.toString() || 'N/A',
-          this.testData.results.demographics.overallRating?.toString() || 'N/A',
-          testResults.completedSuccessfully?.toString() || 'false',
-          this.testData.analysis.usabilityScore?.toString() || '0',
-          this.testData.tracking.gyroscopeData.length.toString(),
-          this.testData.tracking.userInputs.length.toString(),
-          this.calculateComfortScore().toString(),
-          this.calculateAverageFatigue().toString()
-        ]);
-      });
-    });
-
-    return csvData;
-  }
-
-  exportDetailedData(): any {
-    this.generateHeatMaps();
-    
-    return {
-      ...this.testData,
-      exportTimestamp: new Date().toISOString(),
-      analysisMetrics: {
-        totalSessionDuration: Date.now() - this.startTime,
-        totalGyroPoints: this.testData.tracking.gyroscopeData.length,
-        totalInputs: this.testData.tracking.userInputs.length,
-        totalSliderInteractions: this.testData.tracking.sliderInteractions.length,
-        averageComfortScore: this.calculateComfortScore(),
-        averageFatigueScore: this.calculateAverageFatigue(),
-        completedTests: Object.values(this.testData.results).filter((result: any) => result.completedSuccessfully).length
-      }
-    };
-  }
-
-  private calculateComfortScore(): number {
-    if (this.testData.tracking.comfortMetrics.length === 0) return 0;
-    
-    const avgNeckStrain = this.testData.tracking.comfortMetrics.reduce((sum, metric) => sum + metric.neckStrainIndicator, 0) / this.testData.tracking.comfortMetrics.length;
-    const avgFatigue = this.calculateAverageFatigue();
-    
-    return Math.max(0, Math.min(10, 10 - (avgNeckStrain * 0.6) - (avgFatigue * 0.4)));
-  }
-
-  private calculateAverageFatigue(): number {
-    if (this.testData.tracking.comfortMetrics.length === 0) return 0;
-    
-    return this.testData.tracking.comfortMetrics.reduce((sum, metric) => sum + metric.estimatedFatigue, 0) / this.testData.tracking.comfortMetrics.length;
-  }
-
-  getTestData(): AssessmentData {
-    return { ...this.testData };
-  }
-
-  getCurrentTest(): number {
-    return this.currentTest;
-  }
-
-  private isTestResult(obj: any): obj is TestResult {
-    return obj && typeof obj.completedSuccessfully !== 'undefined';
-  }
-
-  setCurrentTest(testNumber: number): void {
-    this.currentTest = testNumber;
-    
-    const testNames: (TestResultKey | '')[] = ['', 'firstInputTest', 'speedTest', 'ergonomicTest', 'textTest', 'referenceTest', 'ceilingTest'];
-    const testName = testNames[testNumber];
-
-    if (testName && testName !== 'demographics') {
-      const testResult = this.testData.results[testName];
-      if (this.isTestResult(testResult) && testResult.startTime === 0) {
-        testResult.startTime = Date.now();
-      }
-    }
-  }
-
-
-  stopTracking(): void {
-    this.isTracking = false;
-    this.testData.session.endTime = Date.now();
-    this.testData.session.totalDuration = this.testData.session.endTime - this.testData.session.startTime;
-    
-    if (this.gyroscopeSubscription) {
-      this.gyroscopeSubscription.unsubscribe();
-    }
-    if (this.performanceSubscription) {
-      this.performanceSubscription.unsubscribe();
-    }
-    
-    this.generateHeatMaps();
-    this.updateStatus('Session completed - Tracking stopped');
-  }
-}
\ No newline at end of file