coursecode 0.1.57 → 0.1.58

package/framework/js/managers/video-manager.js

@@ -18,6 +18,10 @@
 import { eventBus } from '../core/event-bus.js';
 import stateManager from '../state/index.js';
 import { logger } from '../utilities/logger.js';
+import {
+    DEFAULT_MEDIA_COMPLETION_THRESHOLD,
+    normalizeCompletionThreshold
+} from '../utilities/media-utils.js';
 
 /**
  * @typedef {Object} VideoState
@@ -44,9 +48,6 @@ import { logger } from '../utilities/logger.js';
  * @property {number} [completionThreshold=0.95] - Percentage (0-1) required for completion
  */
 
-/** Default completion threshold (95%) */
-const DEFAULT_COMPLETION_THRESHOLD = 0.95;
-
 class VideoManager {
     constructor() {
         /** @type {boolean} */
@@ -63,7 +64,7 @@ class VideoManager {
             duration: 0,
             volume: 1,
             required: false,
-            completionThreshold: DEFAULT_COMPLETION_THRESHOLD,
+            completionThreshold: DEFAULT_MEDIA_COMPLETION_THRESHOLD,
             isCompleted: false
         };
 
@@ -78,6 +79,9 @@ class VideoManager {
 
         /** @type {number|null} */
         this.updateInterval = null;
+
+        /** @type {HTMLVideoElement|null} */
+        this.activeVideo = null;
     }
 
     /**
@@ -116,41 +120,78 @@ class VideoManager {
             throw new Error('VideoManager.attachVideo: contextId is required');
         }
 
-        // Save position of current context before switching
-        if (this.state.contextId && this.state.contextId !== contextId) {
-            this._savePosition();
-        }
-
-        // Update state
-        this.state.currentSrc = config.src;
-        this.state.contextId = contextId;
-        this.state.contextType = config.contextType || 'standalone';
-        this.state.duration = 0;
-        this.state.isPlaying = false;
-        this.state.position = 0;
-        this.state.required = config.required || false;
-        this.state.completionThreshold = config.completionThreshold ?? DEFAULT_COMPLETION_THRESHOLD;
-        this.maxPositionReached = 0;
-
-        // Check if already completed (from previous session)
-        this.state.isCompleted = this._isContextCompleted(contextId);
-
-        // Check for saved position
         const savedPosition = this._getSavedPosition(contextId);
 
+        video._videoManagerState = {
+            currentSrc: config.src,
+            contextId,
+            contextType: config.contextType || 'standalone',
+            duration: 0,
+            position: 0,
+            required: config.required || false,
+            completionThreshold: normalizeCompletionThreshold(config.completionThreshold),
+            isCompleted: this._isContextCompleted(contextId),
+            maxPositionReached: savedPosition
+        };
+
         // Set up event listeners
         this._setupVideoListeners(video, contextId, savedPosition);
 
+        if (!this.activeVideo) {
+            this._activateVideo(video);
+        }
+
         // Emit loadStart event
         eventBus.emit('video:loadStart', {
             contextId,
-            contextType: this.state.contextType,
+            contextType: video._videoManagerState.contextType,
             src: config.src
         });
 
         logger.debug(`[VideoManager] Attached video: ${contextId}`);
     }
 
+    /**
+     * Activates a rendered video, pausing and saving the previous context so
+     * playback and completion events cannot be attributed to another player.
+     * @private
+     * @param {HTMLVideoElement} video
+     */
+    _activateVideo(video) {
+        const localState = video?._videoManagerState;
+        if (!localState || this.activeVideo === video) return;
+
+        const previousVideo = this.activeVideo;
+        if (previousVideo) {
+            if (Number.isFinite(previousVideo.currentTime)) {
+                this.state.position = previousVideo.currentTime;
+            }
+            this._savePosition();
+            if (!previousVideo.paused) {
+                previousVideo.pause();
+            }
+        }
+
+        this._stopPositionUpdates();
+        this.activeVideo = video;
+        this.maxPositionReached = localState.maxPositionReached;
+        this.state = {
+            currentSrc: localState.currentSrc,
+            contextId: localState.contextId,
+            contextType: localState.contextType,
+            position: video.currentTime || localState.position || 0,
+            isPlaying: !video.paused,
+            isMuted: video.muted,
+            duration: Number.isFinite(video.duration) && video.duration > 0
+                ? video.duration
+                : localState.duration,
+            volume: video.volume,
+            required: localState.required,
+            completionThreshold: localState.completionThreshold,
+            isCompleted: localState.isCompleted
+        };
+    }
+
     /**
      * Sets up event listeners on a video element.
      * @private
@@ -164,50 +205,66 @@ class VideoManager {
         video._videoManagerListeners = {};
 
         const listeners = video._videoManagerListeners;
+        const localState = video._videoManagerState;
 
         listeners.loadedmetadata = () => {
-            if (isFinite(video.duration) && video.duration > 0) {
-                this.state.duration = video.duration;
+            if (Number.isFinite(video.duration) && video.duration > 0) {
+                localState.duration = video.duration;
             }
 
             // Restore position if we have one saved
             if (savedPosition > 0 && savedPosition < video.duration) {
                 video.currentTime = savedPosition;
-                this.state.position = savedPosition;
-                this.maxPositionReached = savedPosition;
+                localState.position = savedPosition;
+                localState.maxPositionReached = savedPosition;
+            }
+
+            if (this.activeVideo === video) {
+                this.state.duration = localState.duration;
+                this.state.position = localState.position;
+                this.maxPositionReached = localState.maxPositionReached;
             }
 
             eventBus.emit('video:loaded', {
-                src: this.state.currentSrc,
-                duration: this.state.duration,
+                src: localState.currentSrc,
+                duration: localState.duration,
                 contextId,
-                contextType: this.state.contextType
+                contextType: localState.contextType
             });
         };
 
         listeners.play = () => {
+            this._activateVideo(video);
             this.state.isPlaying = true;
             this._startPositionUpdates(video);
             eventBus.emit('video:play', {
                 contextId,
-                contextType: this.state.contextType
+                contextType: localState.contextType
             });
         };
 
         listeners.pause = () => {
-            this.state.isPlaying = false;
-            this._stopPositionUpdates();
-            this._savePosition();
+            localState.position = video.currentTime;
+            if (this.activeVideo === video) {
+                this.state.position = video.currentTime;
+                this.state.isPlaying = false;
+                this._stopPositionUpdates();
+                this._savePosition();
+            }
             eventBus.emit('video:pause', {
                 contextId,
-                contextType: this.state.contextType,
-                position: this.state.position
+                contextType: localState.contextType,
+                position: localState.position
             });
         };
 
         listeners.ended = () => {
+            this._activateVideo(video);
+            localState.position = video.duration;
+            localState.maxPositionReached = video.duration;
             this.state.isPlaying = false;
             this.state.position = video.duration;
+            this.maxPositionReached = video.duration;
             this._stopPositionUpdates();
 
             // Mark as completed when video ends
@@ -217,31 +274,38 @@ class VideoManager {
         };
 
         listeners.timeupdate = () => {
-            this.state.position = video.currentTime;
+            localState.position = video.currentTime;
 
             // Track max position for completion calculation
-            if (video.currentTime > this.maxPositionReached) {
-                this.maxPositionReached = video.currentTime;
+            if (video.currentTime > localState.maxPositionReached) {
+                localState.maxPositionReached = video.currentTime;
             }
 
-            // Check for completion threshold during playback
-            this._checkAndMarkCompleted();
+            if (this.activeVideo === video) {
+                this.state.position = video.currentTime;
+                this.maxPositionReached = localState.maxPositionReached;
+                this._checkAndMarkCompleted();
+            }
         };
 
         listeners.volumechange = () => {
-            this.state.volume = video.volume;
-            this.state.isMuted = video.muted;
-            this._persistMuteState();
+            if (this.activeVideo === video) {
+                this.state.volume = video.volume;
+                this.state.isMuted = video.muted;
+                this._persistMuteState();
+            }
         };
 
         listeners.error = () => {
             const error = video.error;
             const errorMessage = error ? `${error.code}: ${error.message}` : 'Unknown error';
 
-            this.state.isPlaying = false;
-            this._stopPositionUpdates();
+            if (this.activeVideo === video) {
+                this.state.isPlaying = false;
+                this._stopPositionUpdates();
+            }
 
-            logger.error(`[VideoManager] Video playback error: ${errorMessage}`, { domain: 'video', operation: 'playback', src: this.state.currentSrc, contextId });
+            logger.error(`[VideoManager] Video playback error: ${errorMessage}`, { domain: 'video', operation: 'playback', src: localState.currentSrc, contextId });
         };
 
         // Attach all listeners
@@ -260,8 +324,14 @@ class VideoManager {
     detachVideo(video) {
         if (!video || !video._videoManagerListeners) return;
 
+        const localState = video._videoManagerState;
+        const wasActive = this.activeVideo === video;
+
         // Save position before detaching
-        if (video._videoManagerContextId === this.state.contextId) {
+        if (wasActive) {
+            this.state.position = Number.isFinite(video.currentTime)
+                ? video.currentTime
+                : this.state.position;
             this._savePosition();
         }
 
@@ -272,32 +342,38 @@ class VideoManager {
 
         delete video._videoManagerListeners;
         delete video._videoManagerContextId;
-
-        this._stopPositionUpdates();
+        delete video._videoManagerState;
 
         // Clear state if this was the active video
-        if (video._videoManagerContextId === this.state.contextId) {
-            const wasMuted = this.state.isMuted;
-            this.state = {
-                currentSrc: null,
-                contextId: null,
-                contextType: 'standalone',
-                position: 0,
-                isPlaying: false,
-                isMuted: wasMuted,
-                duration: 0,
-                volume: this.state.volume,
-                required: false,
-                completionThreshold: DEFAULT_COMPLETION_THRESHOLD,
-                isCompleted: false
-            };
-            this.maxPositionReached = 0;
+        if (wasActive) {
+            this._stopPositionUpdates();
+            this.activeVideo = null;
+            this._resetActiveState();
         }
 
-        eventBus.emit('video:unloaded', { contextType: this.state.contextType });
+        eventBus.emit('video:unloaded', { contextType: localState?.contextType || 'standalone' });
         logger.debug('[VideoManager] Detached video');
     }
 
+    /** @private */
+    _resetActiveState() {
+        const { isMuted, volume } = this.state;
+        this.state = {
+            currentSrc: null,
+            contextId: null,
+            contextType: 'standalone',
+            position: 0,
+            isPlaying: false,
+            isMuted,
+            duration: 0,
+            volume,
+            required: false,
+            completionThreshold: DEFAULT_MEDIA_COMPLETION_THRESHOLD,
+            isCompleted: false
+        };
+        this.maxPositionReached = 0;
+    }
+
     /**
      * Gets the current video state.
      * @returns {VideoState}
@@ -404,6 +480,9 @@ class VideoManager {
 
         if (completionPercentage >= this.state.completionThreshold) {
             this.state.isCompleted = true;
+            if (this.activeVideo?._videoManagerState) {
+                this.activeVideo._videoManagerState.isCompleted = true;
+            }
             this._markContextCompleted(this.state.contextId);
 
             logger.debug(`[VideoManager] Video completed: ${this.state.contextId}`);
@@ -421,7 +500,7 @@ class VideoManager {
      * @private
      */
     _savePosition() {
-        if (!this.state.contextId || !this.state.position) return;
+        if (!this.state.contextId || !Number.isFinite(this.state.position)) return;
 
         this.positionCache.set(this.state.contextId, this.state.position);
         this._persistPositions();

package/framework/js/navigation/NavigationActions.js

@@ -698,8 +698,7 @@ async function _performNavigation(slideId, context = {}, updateBookmark = true)
 
     // Update progress measure to reflect slide visit
     // Count only sequential slides (excludes remedial/conditional slides)
-    const totalSequentialSlides = slides.filter(s => isSlideInSequence(s, stateManager, assessmentConfigs)).length;
-    stateManager.updateProgressMeasure(totalSequentialSlides);
+    syncProgressMeasure();
 
     // Set bookmark as FINAL step after successful navigation
     // We use slide ID as the bookmark value (unique, stable, human-readable)
@@ -880,13 +879,14 @@ export function sync() {
         const hasBeenVisited = visitedSlides.includes(slide.id);
 
         if (slide.type === 'assessment') {
-            const config = assessmentConfigs.get(slide.assessmentId);
+            const assessmentId = AssessmentManager.resolveAssessmentId(slide);
+            const config = assessmentConfigs.get(assessmentId);
             const requirements = config?.completionRequirements;
             let requirementsMet = false;
 
             // Only check requirements if they are defined in the assessment's config
             if (requirements) {
-                requirementsMet = AssessmentManager.meetsCompletionRequirements(slide.assessmentId, requirements);
+                requirementsMet = AssessmentManager.meetsCompletionRequirements(assessmentId, requirements);
             }
 
             // Mark as "visited" (i.e., show checkmark) only if visited AND requirements are met.
@@ -1071,6 +1071,20 @@ export function getAllSlides() {
     return slides;
 }
 
+/**
+ * Recalculates LMS progress using only slides in the learner's active sequence.
+ * Remedial and currently excluded conditional slides must not inflate the
+ * numerator or allow progress_measure to reach 100% early.
+ */
+export function syncProgressMeasure() {
+    _requireInitialized();
+    const activeSlides = slides.filter(slide => isSlideInSequence(slide, stateManager, assessmentConfigs));
+    return stateManager.updateProgressMeasure(
+        activeSlides.length,
+        activeSlides.map(slide => slide.id)
+    );
+}
+
 /**
  * Gets the current slide object.
  * @returns {object|null} The current slide, or null if not found.

package/framework/js/navigation/document-gallery.js

@@ -16,6 +16,7 @@
 import { iconManager } from '../utilities/icons.js';
 import { logger } from '../utilities/logger.js';
 import { open as openLightbox } from '../components/ui-components/lightbox.js';
+import { resolvePortableAssetUrl } from '../utilities/portable-assets.js';
 
 /** @type {HTMLElement|null} */
 let galleryContainer = null;
@@ -69,14 +70,18 @@ export async function init(courseConfig) {
  */
 async function _fetchManifest() {
     try {
-        const response = await fetch('./_gallery-manifest.json');
+        const response = await fetch(resolvePortableAssetUrl('./_gallery-manifest.json'));
         if (!response.ok) {
             // Manifest doesn't exist yet (dev mode or no docs) — not an error
             logger.debug('[DocumentGallery] No gallery manifest found (this is normal in dev mode)');
             return null;
         }
         const manifest = await response.json();
-        return manifest.items || [];
+        return (manifest.items || []).map(item => ({
+            ...item,
+            src: resolvePortableAssetUrl(item.src),
+            thumbnail: resolvePortableAssetUrl(item.thumbnail)
+        }));
     } catch (_error) {
         logger.debug('[DocumentGallery] Could not load gallery manifest');
         return null;

package/framework/js/navigation/navigation-validators.js

@@ -146,13 +146,14 @@ export function validateNavigationFrom(slide, assessmentConfigs) {
 
     // Check if this is an assessment with completion requirements that block navigation
     if (slide.type === 'assessment') {
-        const config = assessmentConfigs.get(slide.assessmentId);
+        const assessmentId = AssessmentManager.resolveAssessmentId(slide);
+        const config = assessmentConfigs.get(assessmentId);
         const requirements = config?.completionRequirements;
 
         // Only block if blockNavigation is explicitly true
         if (requirements?.blockNavigation === true) {
             const requirementsMet = AssessmentManager.meetsCompletionRequirements(
-                slide.assessmentId,
+                assessmentId,
                 requirements
             );
 

package/framework/js/state/lms-connection.js

@@ -327,21 +327,33 @@ class LMSConnection {
         window.addEventListener('pagehide', () => {
             if (this.isTerminated) return;
 
-            // Startup Guard: Ignore pagehide events < 2s after startup
-            if (Date.now() - this.sessionStartTime < 2000) {
-                logger.debug('[LMSConnection] Page unload detected immediately after startup (< 2s). Ignoring.');
-                return;
-            }
-
             logger.debug('[LMSConnection] Page unload detected. Attempting emergency save...');
 
-            // Use emergencySave() for any driver that supports it (sendBeacon guaranteed delivery)
+            try {
+                stateManager.prepareEmergencySave();
+            } catch (error) {
+                logger.error('[LMSConnection] Failed to stage emergency state', {
+                    domain: 'state',
+                    operation: 'prepareEmergencySave',
+                    format: this.format,
+                    error: error.message,
+                    stack: error.stack
+                });
+            }
+
+            // Use the driver's best-effort unload transport when available.
             if (this.driver?.emergencySave) {
                 try {
                     this.driver.emergencySave();
-                    logger.debug('[LMSConnection] Emergency save completed via sendBeacon');
-                } catch (e) {
-                    logger.debug('[LMSConnection] Emergency save failed:', e.message);
+                    logger.debug('[LMSConnection] Emergency save staged via driver transport');
+                } catch (error) {
+                    logger.error('[LMSConnection] Driver emergency save failed', {
+                        domain: 'lms',
+                        operation: 'emergencySave',
+                        format: this.format,
+                        error: error.message,
+                        stack: error.stack
+                    });
                 }
                 return;
             }
@@ -351,12 +363,24 @@ class LMSConnection {
                 // Delegate to StateManager to save exit status
                 const exitPromise = stateManager.exitCourseWithSuspend();
                 if (exitPromise && typeof exitPromise.catch === 'function') {
-                    exitPromise.catch(e => {
-                        logger.debug('[LMSConnection] Best-effort save during unload did not complete:', e.message);
+                    exitPromise.catch(error => {
+                        logger.error('[LMSConnection] Best-effort unload save did not complete', {
+                            domain: 'lms',
+                            operation: 'exitCourseWithSuspend',
+                            format: this.format,
+                            error: error.message,
+                            stack: error.stack
+                        });
                     });
                 }
-            } catch (e) {
-                logger.debug('[LMSConnection] Best-effort save during unload did not complete:', e.message);
+            } catch (error) {
+                logger.error('[LMSConnection] Best-effort unload save did not start', {
+                    domain: 'lms',
+                    operation: 'exitCourseWithSuspend',
+                    format: this.format,
+                    error: error.message,
+                    stack: error.stack
+                });
             }
         });
     }
@@ -368,8 +392,8 @@ class LMSConnection {
     _startKeepAlive() {
         this._stopKeepAlive();
 
-        // Only SCORM formats need keep-alive (cmi5/LTI use stateless HTTP)
-        if (this.format.startsWith('cmi5') || this.format === 'lti') {
+        // Only SCORM formats need keep-alive (HTTP and standalone drivers do not)
+        if (this.format.startsWith('cmi5') || this.format === 'lti' || this.format === 'standalone') {
             return;
         }
 
@@ -402,6 +426,7 @@ class LMSConnection {
         if (this.format === 'scorm1.2') return 'strict-scorm12';
         if (this.format === 'scorm2004') return 'conservative-scorm2004';
         if (this.format.startsWith('cmi5') || this.format === 'lti') return 'modern-http';
+        if (this.format === 'standalone') return 'balanced';
         return 'balanced';
     }
 

package/framework/js/state/state-commits.js

@@ -10,6 +10,7 @@ import { classifyLmsError } from './lms-error-utils.js';
 
 // Auto-batch debounce delay in milliseconds
 const AUTO_BATCH_DELAY_MS = 500;
+const MAX_RETRY_DELAY_MS = 60000;
 
 export class CommitScheduler {
     /**
@@ -26,6 +27,7 @@ export class CommitScheduler {
         this._autoBatchDirty = false;
         this._autoBatchSuspendDirty = false;
         this._inFlightCommit = null;
+        this._retryDelayMs = AUTO_BATCH_DELAY_MS;
     }
 
     /**
@@ -43,7 +45,7 @@ export class CommitScheduler {
         }
 
         this._autoBatchTimer = setTimeout(() => {
-            this._executeCommit();
+            void this._executeCommit(false);
         }, AUTO_BATCH_DELAY_MS);
 
         logger.debug(`[StateManager] Auto-batch scheduled (${AUTO_BATCH_DELAY_MS}ms debounce)`);
@@ -60,7 +62,7 @@ export class CommitScheduler {
 
         if (this._autoBatchDirty) {
             logger.debug('[StateManager] Force-flushing pending writes (critical action)');
-            await this._executeCommit();
+            await this._executeCommit(true);
             return;
         }
 
@@ -148,7 +150,7 @@ export class CommitScheduler {
 
     // --- Private ---
 
-    async _executeCommit() {
+    async _executeCommit(propagateError = false) {
         this._autoBatchTimer = null;
 
         if (!this._autoBatchDirty) return;
@@ -175,6 +177,7 @@ export class CommitScheduler {
             await this._inFlightCommit;
 
             logger.debug('[StateManager] Auto-batch committed');
+            this._retryDelayMs = AUTO_BATCH_DELAY_MS;
             eventBus.emit('state:commitSuccess');
             eventBus.emit('state:committed');
         } catch (error) {
@@ -186,14 +189,16 @@ export class CommitScheduler {
             }
             logger.error('[StateManager] Auto-batch commit failed:', { domain: 'state', operation: 'autoBatchCommit', stack: error.stack });
             eventBus.emit('state:commitFailed', { error: error.message, classification });
+            this._retryDelayMs = Math.min(this._retryDelayMs * 2, MAX_RETRY_DELAY_MS);
+            if (propagateError) throw error;
         } finally {
             this._inFlightCommit = null;
 
             // If writes happened during commit, schedule follow-up commit.
             if (this._autoBatchDirty && !this._autoBatchTimer) {
                 this._autoBatchTimer = setTimeout(() => {
-                    this._executeCommit();
-                }, AUTO_BATCH_DELAY_MS);
+                    void this._executeCommit(false);
+                }, this._retryDelayMs);
             }
         }
     }