scorm-again 3.0.4 → 3.1.0

package/dist/scorm-again.js

@@ -252,6 +252,15 @@
     };
   }
 
+  const appendQueryParam = (url, name, value) => {
+    const fragmentIndex = url.indexOf("#");
+    const baseUrl = fragmentIndex === -1 ? url : url.slice(0, fragmentIndex);
+    const fragment = fragmentIndex === -1 ? "" : url.slice(fragmentIndex);
+    const separator = baseUrl.includes("?") ? baseUrl.endsWith("?") || baseUrl.endsWith("&") ? "" : "&" : "?";
+    const queryParam = `${encodeURIComponent(name)}=${encodeURIComponent(String(value))}`;
+    return `${baseUrl}${separator}${queryParam}${fragment}`;
+  };
+
   var __defProp$1d = Object.defineProperty;
   var __defNormalProp$1d = (obj, key, value) => key in obj ? __defProp$1d(obj, key, {
     enumerable: true,
@@ -642,7 +651,10 @@
     READ_ONLY_ELEMENT: 403,
     WRITE_ONLY_ELEMENT: 404,
     TYPE_MISMATCH: 405,
-    VALUE_OUT_OF_RANGE: 407,
+    // SCORM 1.2 has no out-of-range error code; an out-of-range value is reported
+    // as 405 (incorrect data type), per the SCORM 1.2 RTE error table and the ADL
+    // 1.2 CTS (DataModelValidator.checkScoreDecimal failure -> CMICategory 405).
+    VALUE_OUT_OF_RANGE: 405,
     DEPENDENCY_NOT_ESTABLISHED: 408
   };
   const scorm2004_errors = {
@@ -799,6 +811,7 @@
     xhrWithCredentials: false,
     fetchMode: "cors",
     asyncModeBeaconBehavior: "never",
+    includeCommitSequence: false,
     responseHandler: async function (response) {
       if (typeof response !== "undefined") {
         let httpResult = null;
@@ -1159,6 +1172,11 @@
     progress_range: "0#1"
   };
 
+  const PERFORMANCE_STEP_NAME = "^$|" + scorm2004_regex.CMIShortIdentifier;
+  const PERFORMANCE_CHARACTERSTRING = "(?![\\s\\S]*(?:\\[,\\]|\\[\\.\\]|\\[:\\]))[\\s\\S]{1,250}";
+  const PERFORMANCE_NUMERIC_RANGE = "(?:-?\\d+(?:\\.\\d+)?)?\\[:\\](?:-?\\d+(?:\\.\\d+)?)?";
+  const CR_PERFORMANCE_STEP_ANSWER = "^(?:|" + PERFORMANCE_NUMERIC_RANGE + "|" + PERFORMANCE_CHARACTERSTRING + ")$";
+  const LR_PERFORMANCE_STEP_ANSWER = "^(?:|" + PERFORMANCE_CHARACTERSTRING + ")$";
   const LearnerResponses = {
     "true-false": {
       format: "^true$|^false$",
@@ -1193,8 +1211,8 @@
       unique: false
     },
     performance: {
-      format: "^$|" + scorm2004_regex.CMIShortIdentifier,
-      format2: scorm2004_regex.CMIDecimal + "|^$|" + scorm2004_regex.CMIShortIdentifier,
+      format: PERFORMANCE_STEP_NAME,
+      format2: LR_PERFORMANCE_STEP_ANSWER,
       max: 250,
       delimiter: "[,]",
       delimiter2: "[.]",
@@ -1270,10 +1288,10 @@
       delimiter2: "[.]",
       unique: false,
       duplicate: false,
-      // step_name must be a non-empty short identifier
-      format: scorm2004_regex.CMIShortIdentifier,
-      // step_answer may be short identifier or numeric range (<decimal>[:<decimal>])
-      format2: `^(${scorm2004_regex.CMIShortIdentifier})$|^(?:\\d+(?:\\.\\d+)?(?::\\d+(?:\\.\\d+)?)?)$`
+      // step_name: optional short_identifier_type
+      format: PERFORMANCE_STEP_NAME,
+      // step_answer: optional characterstring (spaces allowed) or numeric range
+      format2: CR_PERFORMANCE_STEP_ANSWER
     },
     sequencing: {
       max: 36,
@@ -1349,7 +1367,7 @@
     wrapper() {
       if (!this._cancelled) {
         if (this._API.isInitialized()) {
-          (async () => await this._API.commit(this._callback))();
+          (async () => await this._API.commit(this._callback, false, "autocommit"))();
         }
       }
     }
@@ -4822,6 +4840,7 @@
      * @param {ErrorCode} error_codes - The error codes object
      */
     constructor(settings, error_codes) {
+      __publicField$Y(this, "reportsRequestCompletion", true);
       __publicField$Y(this, "settings");
       __publicField$Y(this, "error_codes");
       this.settings = settings;
@@ -4840,13 +4859,17 @@
      * @param {boolean} immediate - Whether to send the request immediately without waiting
      * @param {Function} apiLog - Function to log API messages with appropriate levels
      * @param {Function} processListeners - Function to trigger event listeners for commit events
+     * @param {CommitMetadata} metadata - Metadata describing the captured commit
+     * @param {Function} onRequestComplete - Callback invoked after the background request settles
      * @return {ResultObject} - Immediate optimistic success result
      */
     processHttpRequest(url, params) {
       let immediate = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
       let apiLog = arguments.length > 3 ? arguments[3] : undefined;
       let processListeners = arguments.length > 4 ? arguments[4] : undefined;
-      this._performAsyncRequest(url, params, immediate, apiLog, processListeners);
+      let metadata = arguments.length > 5 ? arguments[5] : undefined;
+      let onRequestComplete = arguments.length > 6 ? arguments[6] : undefined;
+      this._performAsyncRequest(url, params, immediate, apiLog, processListeners, metadata, onRequestComplete);
       return {
         result: global_constants.SCORM_TRUE,
         errorCode: 0
@@ -4859,11 +4882,14 @@
      * @param {boolean} immediate - Whether this is an immediate request
      * @param apiLog - Function to log API messages
      * @param {Function} processListeners - Function to process event listeners
+     * @param {CommitMetadata} metadata - Metadata describing the captured commit
+     * @param {Function} onRequestComplete - Callback invoked after the request settles
      * @private
      */
-    async _performAsyncRequest(url, params, immediate, apiLog, processListeners) {
+    async _performAsyncRequest(url, params, immediate, apiLog, processListeners, metadata, onRequestComplete) {
       try {
-        const processedParams = this.settings.requestHandler(params);
+        const handledParams = metadata === void 0 ? this.settings.requestHandler(params) : this.settings.requestHandler(params, metadata);
+        const processedParams = handledParams;
         let response;
         if (immediate && this.settings.asyncModeBeaconBehavior !== "never") {
           response = await this.performBeacon(url, processedParams);
@@ -4879,7 +4905,9 @@
       } catch (e) {
         const message = e instanceof Error ? e.message : String(e);
         apiLog("processHttpRequest", `Async request failed: ${message}`, LogLevelEnum.ERROR);
-        processListeners("CommitError");
+        processListeners("CommitError", void 0, this.error_codes.GENERAL_COMMIT_FAILURE || 391);
+      } finally {
+        onRequestComplete?.();
       }
     }
     /**
@@ -5041,10 +5069,13 @@
     }
     /**
      * Gets the appropriate error code for undefined data model elements.
-     * SCORM 2004 uses UNDEFINED_DATA_MODEL, SCORM 1.2 uses GENERAL.
+     * Both SCORM 2004 and SCORM 1.2 use UNDEFINED_DATA_MODEL (401): an
+     * unrecognized element is "Not implemented", not a general exception. SCORM
+     * 1.2 previously returned GENERAL (101) here, which is non-conformant — the
+     * ADL 1.2 CTS and the SCORM 1.2 RTE spec expect 401 for an unknown element.
      */
-    getUndefinedDataModelErrorCode(scorm2004) {
-      return scorm2004 ? getErrorCode(this.context.errorCodes, "UNDEFINED_DATA_MODEL") : getErrorCode(this.context.errorCodes, "GENERAL");
+    getUndefinedDataModelErrorCode() {
+      return getErrorCode(this.context.errorCodes, "UNDEFINED_DATA_MODEL");
     }
     /**
      * Sets a value on a CMI element path
@@ -5068,7 +5099,7 @@
       let returnValue = global_constants.SCORM_FALSE;
       let foundFirstIndex = false;
       const invalidErrorMessage = `The data model element passed to ${methodName} (${CMIElement}) is not a valid SCORM data model element.`;
-      const invalidErrorCode = this.getUndefinedDataModelErrorCode(scorm2004);
+      const invalidErrorCode = this.getUndefinedDataModelErrorCode();
       for (let idx = 0; idx < structure.length; idx++) {
         const attribute = structure[idx];
         if (idx === structure.length - 1) {
@@ -5108,12 +5139,13 @@
         this.context.throwSCORMError(CMIElement, getErrorCode(this.context.errorCodes, "GENERAL_GET_FAILURE"), "The _version keyword was used incorrectly");
         return "";
       }
+      this.context.setLastErrorCode("0");
       const structure = CMIElement.split(".");
       let refObject = this.context.getDataModel();
       let attribute = null;
       const uninitializedErrorMessage = `The data model element passed to ${methodName} (${CMIElement}) has not been initialized.`;
       const invalidErrorMessage = `The data model element passed to ${methodName} (${CMIElement}) is not a valid SCORM data model element.`;
-      const invalidErrorCode = this.getUndefinedDataModelErrorCode(scorm2004);
+      const invalidErrorCode = this.getUndefinedDataModelErrorCode();
       for (let idx = 0; idx < structure.length; idx++) {
         attribute = structure[idx];
         const validationResult = this.validateGetAttribute(refObject, attribute, CMIElement, scorm2004, invalidErrorCode, invalidErrorMessage, idx === structure.length - 1);
@@ -5298,7 +5330,13 @@
       if (!scorm2004) {
         if (isFinalAttribute) {
           if (typeof attribute === "undefined" || !this.context.checkObjectHasProperty(refObject, attribute)) {
-            this.context.throwSCORMError(CMIElement, invalidErrorCode, invalidErrorMessage);
+            if (attribute === "_children") {
+              this.context.throwSCORMError(CMIElement, getErrorCode(this.context.errorCodes, "CHILDREN_ERROR"));
+            } else if (attribute === "_count") {
+              this.context.throwSCORMError(CMIElement, getErrorCode(this.context.errorCodes, "COUNT_ERROR"));
+            } else {
+              this.context.throwSCORMError(CMIElement, invalidErrorCode, invalidErrorMessage);
+            }
             return {
               error: true
             };
@@ -5833,8 +5871,9 @@ ${stackTrace}`);
      * @param {string} functionName - The name of the function that triggered the event
      * @param {string} CMIElement - The CMI element that was affected
      * @param {any} value - The value that was set
+     * @param {CommitEventContext} context - Optional context for commit lifecycle events
      */
-    processListeners(functionName, CMIElement, value) {
+    processListeners(functionName, CMIElement, value, context) {
       this.apiLog(functionName, value, LogLevelEnum.INFO, CMIElement);
       const listeners = this.listenerMap.get(functionName);
       if (!listeners) return;
@@ -5854,9 +5893,17 @@ ${stackTrace}`);
           if (functionName.startsWith("Sequence")) {
             listener.callback(value);
           } else if (functionName === "CommitError") {
-            listener.callback(value);
+            if (context !== void 0) {
+              listener.callback(value, context);
+            } else {
+              listener.callback(value);
+            }
           } else if (functionName === "CommitSuccess") {
-            listener.callback();
+            if (context !== void 0) {
+              listener.callback(context);
+            } else {
+              listener.callback();
+            }
           } else {
             listener.callback(CMIElement, value);
           }
@@ -5965,16 +6012,23 @@ ${stackTrace}`);
      * Store commit data offline
      * @param {string} courseId - Identifier for the course
      * @param {CommitObject} commitData - The data to store offline
+     * @param {OfflineCommitMetadata} metadata - Metadata captured with the original commit
      * @returns {ResultObject} - Result of the storage operation
      */
-    storeOffline(courseId, commitData) {
+    storeOffline(courseId, commitData, metadata) {
       try {
         const queueItem = {
           id: `${courseId}_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`,
           courseId,
           timestamp: Date.now(),
           data: commitData,
-          syncAttempts: 0
+          syncAttempts: 0,
+          ...(metadata?.isTerminateCommit !== void 0 ? {
+            isTerminateCommit: metadata.isTerminateCommit
+          } : {}),
+          ...(metadata?.sequence !== void 0 ? {
+            sequence: metadata.sequence
+          } : {})
         };
         const currentQueue = this.getFromStorage(this.syncQueue) || [];
         currentQueue.push(queueItem);
@@ -6033,7 +6087,14 @@ ${stackTrace}`);
             continue;
           }
           try {
-            const syncResult = await this.sendDataToLMS(item.data);
+            const syncResult = await this.sendDataToLMS(item.data, {
+              ...(item.isTerminateCommit !== void 0 ? {
+                isTerminateCommit: item.isTerminateCommit
+              } : {}),
+              ...(item.sequence !== void 0 ? {
+                sequence: item.sequence
+              } : {})
+            });
             if (syncResult.result === true || syncResult.result === global_constants.SCORM_TRUE) {
               this.apiLog("OfflineStorageService", `Successfully synced item ${item.id}`, LogLevelEnum.INFO);
             } else {
@@ -6060,17 +6121,27 @@ ${stackTrace}`);
     /**
      * Send data to the LMS when online
      * @param {CommitObject} data - The data to send to the LMS
+     * @param {OfflineCommitMetadata} metadata - Metadata captured with the original commit
      * @returns {Promise<ResultObject>} - Result of the sync operation
      */
-    async sendDataToLMS(data) {
-      if (!this.settings.lmsCommitUrl) {
+    async sendDataToLMS(data, metadata) {
+      const configuredCommitUrl = this.settings.lmsCommitUrl;
+      if (!configuredCommitUrl) {
         return {
           result: global_constants.SCORM_FALSE,
           errorCode: this.error_codes.GENERAL || 101
         };
       }
       try {
-        const processedData = this.settings.requestHandler(data);
+        const lmsCommitUrl = String(configuredCommitUrl);
+        const processedData = this.settings.requestHandler(data, {
+          isTerminateCommit: metadata?.isTerminateCommit ?? false,
+          trigger: "offline-replay",
+          ...(metadata?.sequence !== void 0 ? {
+            sequence: metadata.sequence
+          } : {})
+        });
+        const requestUrl = metadata?.isTerminateCommit && this.settings.terminateCommitParam ? appendQueryParam(lmsCommitUrl, this.settings.terminateCommitParam, "true") : lmsCommitUrl;
         const init = {
           method: "POST",
           mode: this.settings.fetchMode,
@@ -6083,7 +6154,7 @@ ${stackTrace}`);
         if (this.settings.xhrWithCredentials) {
           init.credentials = "include";
         }
-        const response = await fetch(this.settings.lmsCommitUrl, init);
+        const response = await fetch(requestUrl, init);
         const result = typeof this.settings.responseHandler === "function" ? await this.settings.responseHandler(response) : await response.json();
         if (response.status >= 200 && response.status <= 299 && (result.result === true || result.result === global_constants.SCORM_TRUE)) {
           if (!Object.hasOwnProperty.call(result, "errorCode")) {
@@ -14980,6 +15051,8 @@ ${stackTrace}`);
      * @param {boolean} immediate - Whether this is a termination commit (use sendBeacon)
      * @param {Function} _apiLog - Function to log API messages (unused in synchronous mode - errors returned directly)
      * @param {Function} _processListeners - Function to trigger event listeners (unused in synchronous mode - no async events)
+     * @param {CommitMetadata} metadata - Metadata describing the captured commit
+     * @param {Function} _onRequestComplete - Completion callback (unused because requests settle before return)
      * @return {ResultObject} - The result of the request (synchronous)
      *
      * @remarks
@@ -14991,20 +15064,23 @@ ${stackTrace}`);
      */
     processHttpRequest(url, params) {
       let immediate = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+      let metadata = arguments.length > 5 ? arguments[5] : undefined;
       if (immediate) {
-        return this._handleImmediateRequest(url, params);
+        return this._handleImmediateRequest(url, params, metadata);
       }
-      return this._performSyncXHR(url, params);
+      return this._performSyncXHR(url, params, metadata);
     }
     /**
      * Handles an immediate request using sendBeacon
      * @param {string} url - The URL to send the request to
      * @param {CommitObject|StringKeyMap|Array} params - The parameters to include in the request
+     * @param {CommitMetadata} metadata - Metadata describing the captured commit
      * @return {ResultObject} - The result based on beacon success
      * @private
      */
-    _handleImmediateRequest(url, params) {
-      const requestPayload = this.settings.requestHandler(params) ?? params;
+    _handleImmediateRequest(url, params, metadata) {
+      const handledPayload = metadata === void 0 ? this.settings.requestHandler(params) : this.settings.requestHandler(params, metadata);
+      const requestPayload = handledPayload ?? params;
       const {
         body
       } = this._prepareRequestBody(requestPayload);
@@ -15020,11 +15096,13 @@ ${stackTrace}`);
      * Performs a synchronous XMLHttpRequest
      * @param {string} url - The URL to send the request to
      * @param {CommitObject|StringKeyMap|Array} params - The parameters to include in the request
+     * @param {CommitMetadata} metadata - Metadata describing the captured commit
      * @return {ResultObject} - The result of the request
      * @private
      */
-    _performSyncXHR(url, params) {
-      const requestPayload = this.settings.requestHandler(params) ?? params;
+    _performSyncXHR(url, params, metadata) {
+      const handledPayload = metadata === void 0 ? this.settings.requestHandler(params) : this.settings.requestHandler(params, metadata);
+      const requestPayload = handledPayload ?? params;
       const {
         body,
         contentType
@@ -15097,9 +15175,16 @@ ${stackTrace}`);
      * @param {number} invalidTypeCode - The error code for invalid type
      * @param {number} invalidRangeCode - The error code for invalid range
      * @param {typeof BaseScormValidationError} errorClass - The error class to use for validation errors
+     * @param {boolean} allowEmptyString - When true, an empty string is accepted (clears the value).
+     *                                     SCORM 1.2 score elements may be blank per the ADL 1.2 CTS
+     *                                     (DataModelValidator.checkScoreDecimal treats blank as valid).
      * @return {boolean} - True if validation passes, throws an error otherwise
      */
     validateScore(CMIElement, value, decimalRegex, scoreRange, invalidTypeCode, invalidRangeCode, errorClass) {
+      let allowEmptyString = arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : false;
+      if (allowEmptyString && value === "") {
+        return true;
+      }
       return checkValidFormat(CMIElement, value, decimalRegex, invalidTypeCode, errorClass) && (!scoreRange || checkValidRange(CMIElement, value, scoreRange, invalidRangeCode, errorClass));
     }
     /**
@@ -15195,6 +15280,21 @@ ${stackTrace}`);
       __publicField$w(this, "_offlineStorageService");
       __publicField$w(this, "_cmiValueAccessService");
       __publicField$w(this, "_courseId", "");
+      __publicField$w(this, "_pendingCommitCount", 0);
+      /**
+       * Monotonic sequence for commits captured by this API instance. It is
+       * intentionally not reset by reset().
+       */
+      __publicField$w(this, "_commitSequence", 0);
+      __publicField$w(this, "_commitSettleWaiters", []);
+      /**
+       * Canonical paths of every CMI element that has been explicitly assigned a
+       * value via SetValue / loadFromJSON (both funnel through _commonSetCMIValue).
+       * Used by standards that must tell "implemented but never set" apart from a
+       * legitimately empty value when answering GetValue (SCORM 2004 error 403).
+       * Cleared on reset so a fresh SCO attempt starts with nothing "set".
+       */
+      __publicField$w(this, "_setCMIElements", /* @__PURE__ */new Set());
       __publicField$w(this, "startingData");
       __publicField$w(this, "currentState");
       if (new.target === BaseAPI) {
@@ -15341,6 +15441,7 @@ ${stackTrace}`);
       this.lastErrorCode = "0";
       this._eventService.reset();
       this.startingData = {};
+      this._setCMIElements.clear();
       if (this._offlineStorageService) {
         this._offlineStorageService.updateSettings(this.settings);
         if (settings?.courseId) {
@@ -15424,6 +15525,54 @@ ${stackTrace}`);
         this._loggingService?.setLogHandler(settings.onLogMessage);
       }
     }
+    /**
+     * Gets the number of captured commit requests that have not yet settled.
+     *
+     * @return {number} The number of in-flight commits
+     */
+    get pendingCommitCount() {
+      return this._pendingCommitCount;
+    }
+    /**
+     * Resolves when all currently in-flight commits have settled. A timeout is
+     * best-effort: the promise resolves when it elapses even if commits remain,
+     * and callers can inspect pendingCommitCount afterward to detect that case.
+     *
+     * @param {Object} [options] - Settle options
+     * @param {number} [options.timeoutMs] - Maximum time to wait in milliseconds
+     * @return {Promise<void>} A promise that resolves after the drain or timeout
+     */
+    whenCommitsSettled(options) {
+      if (this._pendingCommitCount === 0) {
+        return Promise.resolve();
+      }
+      return new Promise(resolve => {
+        const waiter = {
+          resolve
+        };
+        if (options?.timeoutMs !== void 0) {
+          waiter.timeoutId = setTimeout(() => {
+            const waiterIndex = this._commitSettleWaiters.indexOf(waiter);
+            if (waiterIndex === -1) {
+              return;
+            }
+            this._commitSettleWaiters.splice(waiterIndex, 1);
+            resolve();
+          }, options.timeoutMs);
+        }
+        this._commitSettleWaiters.push(waiter);
+      });
+    }
+    /** Resolve and clear every waiter after the pending count reaches zero. */
+    _flushCommitSettleWaiters() {
+      const waiters = this._commitSettleWaiters.splice(0);
+      for (const waiter of waiters) {
+        if (waiter.timeoutId !== void 0) {
+          clearTimeout(waiter.timeoutId);
+        }
+        waiter.resolve();
+      }
+    }
     /**
      * Terminates the current run of the API
      * @param {string} callbackName
@@ -15444,7 +15593,7 @@ ${stackTrace}`);
       } else {
         stateCheckPassed = true;
         this.processListeners("BeforeTerminate");
-        const result = this.storeData(true);
+        const result = this.storeData(true, "terminate");
         if ((result.errorCode ?? 0) > 0) {
           if (result.errorMessage) {
             this.apiLog("terminate", `Terminate failed with error: ${result.errorMessage}`, LogLevelEnum.ERROR);
@@ -15484,6 +15633,9 @@ ${stackTrace}`);
         } catch (e) {
           returnValue = this.handleValueAccessException(CMIElement, e, returnValue);
         }
+        if (this.lastErrorCode === "0") {
+          this.checkUninitializedGet(CMIElement, returnValue);
+        }
         this.processListeners(callbackName, CMIElement);
       }
       this.apiLog(callbackName, ": returned: " + returnValue, LogLevelEnum.INFO, CMIElement);
@@ -15493,6 +15645,10 @@ ${stackTrace}`);
       if (this.lastErrorCode === "0") {
         this.clearSCORMError(returnValue);
       }
+      const rawReturn = returnValue;
+      if (typeof rawReturn === "number" || typeof rawReturn === "boolean") {
+        return String(rawReturn);
+      }
       return returnValue;
     }
     /**
@@ -15536,10 +15692,12 @@ ${stackTrace}`);
      * Orders LMS to store all content parameters
      * @param {string} callbackName
      * @param {boolean} checkTerminated
+     * @param {CommitTrigger} trigger - What initiated the commit
      * @return {string}
      */
     commit(callbackName) {
       let checkTerminated = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+      let trigger = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : "manual";
       this.clearScheduledCommit();
       let returnValue = global_constants.SCORM_TRUE;
       if (this.isNotInitialized()) {
@@ -15551,20 +15709,21 @@ ${stackTrace}`);
         this.throwSCORMError("api", errorCode);
         if (errorCode === 143) returnValue = global_constants.SCORM_FALSE;
       } else {
-        const result = this.storeData(false);
-        if ((result.errorCode ?? 0) > 0) {
+        const result = this.storeData(false, trigger);
+        const errorCode = result.errorCode ?? 0;
+        if (errorCode > 0) {
           if (result.errorMessage) {
             this.apiLog("commit", `Commit failed with error: ${result.errorMessage}`, LogLevelEnum.ERROR);
           }
           if (result.errorDetails) {
             this.apiLog("commit", `Error details: ${JSON.stringify(result.errorDetails)}`, LogLevelEnum.DEBUG);
           }
-          this.throwSCORMError("api", result.errorCode);
+          this.throwSCORMError("api", errorCode);
         }
         const resultValue = result?.result ?? global_constants.SCORM_FALSE;
         returnValue = typeof resultValue === "boolean" ? String(resultValue) : resultValue;
         this.apiLog(callbackName, " Result: " + returnValue, LogLevelEnum.DEBUG, "HttpRequest");
-        if (checkTerminated) this.lastErrorCode = "0";
+        if (checkTerminated && errorCode === 0) this.lastErrorCode = "0";
         this.processListeners(callbackName);
         if (this.settings.enableOfflineSupport && this._offlineStorageService && this._offlineStorageService.isDeviceOnline() && this._courseId) {
           this._offlineStorageService.hasPendingOfflineData(this._courseId).then(hasPendingData => {
@@ -15771,7 +15930,11 @@ ${stackTrace}`);
      * @return {string}
      */
     _commonSetCMIValue(methodName, scorm2004, CMIElement, value) {
-      return this._cmiValueAccessService.setCMIValue(methodName, scorm2004, CMIElement, value);
+      const result = this._cmiValueAccessService.setCMIValue(methodName, scorm2004, CMIElement, value);
+      if (result === global_constants.SCORM_TRUE) {
+        this._setCMIElements.add(CMIElement);
+      }
+      return result;
     }
     /**
      * Gets a value from the CMI Object.
@@ -15785,6 +15948,17 @@ ${stackTrace}`);
     _commonGetCMIValue(methodName, scorm2004, CMIElement) {
       return this._cmiValueAccessService.getCMIValue(methodName, scorm2004, CMIElement);
     }
+    /**
+     * Hook invoked by getValue after a successful resolution. Standards that must
+     * distinguish "implemented but never set, no default value" from a
+     * legitimately empty value override this to raise VALUE_NOT_INITIALIZED.
+     * Default is a no-op, so SCORM 1.2 / AICC keep returning "" with code 0.
+     *
+     * @param {string} _CMIElement - the element that was read
+     * @param {any} _returnValue - the value getCMIValue resolved
+     * @protected
+     */
+    checkUninitializedGet(_CMIElement, _returnValue) {}
     /**
      * Returns true if the API's current state is STATE_INITIALIZED
      *
@@ -15867,9 +16041,14 @@ ${stackTrace}`);
      * @param {string} functionName - The name of the function/event that occurred
      * @param {string} CMIElement - Optional CMI element involved in the event
      * @param {any} value - Optional value associated with the event
+     * @param {CommitEventContext} context - Optional context for commit lifecycle events
      */
-    processListeners(functionName, CMIElement, value) {
-      this._eventService.processListeners(functionName, CMIElement, value);
+    processListeners(functionName, CMIElement, value, context) {
+      if (context !== void 0) {
+        this._eventService.processListeners(functionName, CMIElement, value, context);
+      } else {
+        this._eventService.processListeners(functionName, CMIElement, value);
+      }
     }
     /**
      * Throws a SCORM error with the specified error number and optional message.
@@ -15991,23 +16170,97 @@ ${stackTrace}`);
      * @param {string} url - The URL to send the request to
      * @param {CommitObject | StringKeyMap | Array<any>} params - The parameters to send
      * @param {boolean} immediate - Whether to send the request immediately without waiting
+     * @param {CommitTrigger} [trigger] - What initiated the commit
      * @returns {ResultObject} - The result of the request
      */
     processHttpRequest(url, params) {
       let immediate = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-      if (this.settings.enableOfflineSupport && this._offlineStorageService && !this._offlineStorageService.isDeviceOnline() && this._courseId) {
-        this.apiLog("processHttpRequest", "Device is offline, storing data locally", LogLevelEnum.INFO);
-        if (params && typeof params === "object" && "cmi" in params) {
-          return this._offlineStorageService.storeOffline(this._courseId, params);
-        } else {
-          this.apiLog("processHttpRequest", "Invalid commit data format for offline storage", LogLevelEnum.ERROR);
-          return {
-            result: global_constants.SCORM_FALSE,
-            errorCode: this._error_codes.GENERAL ?? 101
-          };
+      let trigger = arguments.length > 3 ? arguments[3] : undefined;
+      const sequence = ++this._commitSequence;
+      this._pendingCommitCount += 1;
+      let settled = false;
+      let completionDeferred = false;
+      const settle = () => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        this._pendingCommitCount -= 1;
+        if (this._pendingCommitCount === 0) {
+          this._flushCommitSettleWaiters();
+        }
+      };
+      try {
+        const resolvedTrigger = trigger ?? (immediate ? "terminate" : "manual");
+        let finalParams = params;
+        if (immediate && this.settings.terminateCommitPayloadField) {
+          const field = this.settings.terminateCommitPayloadField;
+          if (Array.isArray(finalParams)) {
+            finalParams = [...finalParams, `${encodeURIComponent(field)}=true`];
+          } else if (finalParams && typeof finalParams === "object") {
+            finalParams = {
+              ...finalParams,
+              [field]: true
+            };
+          }
+        }
+        if (this.settings.includeCommitSequence === true) {
+          if (Array.isArray(finalParams)) {
+            finalParams = [...finalParams, `commitSequence=${sequence}`];
+          } else if (finalParams && typeof finalParams === "object") {
+            finalParams = {
+              ...finalParams,
+              commitSequence: sequence
+            };
+          }
+        }
+        const finalUrl = immediate && this.settings.terminateCommitParam ? appendQueryParam(url, this.settings.terminateCommitParam, "true") : url;
+        const metadata = {
+          isTerminateCommit: immediate,
+          trigger: resolvedTrigger,
+          sequence
+        };
+        const context = {
+          url: finalUrl,
+          trigger: resolvedTrigger,
+          isTerminateCommit: immediate,
+          sequence
+        };
+        if (this.settings.enableOfflineSupport && this._offlineStorageService && !this._offlineStorageService.isDeviceOnline() && this._courseId) {
+          this.apiLog("processHttpRequest", "Device is offline, storing data locally", LogLevelEnum.INFO);
+          if (finalParams && typeof finalParams === "object" && "cmi" in finalParams) {
+            return this._offlineStorageService.storeOffline(this._courseId, finalParams, {
+              isTerminateCommit: immediate,
+              sequence
+            });
+          } else {
+            this.apiLog("processHttpRequest", "Invalid commit data format for offline storage", LogLevelEnum.ERROR);
+            return {
+              result: global_constants.SCORM_FALSE,
+              errorCode: this._error_codes.GENERAL ?? 101
+            };
+          }
+        }
+        const apiLog = (functionName, message, level, element) => this.apiLog(functionName, message, level, element);
+        const processListeners = (functionName, CMIElement, value) => {
+          if (functionName === "CommitSuccess" || functionName === "CommitError") {
+            if (functionName === "CommitError" && typeof value === "number") {
+              context.errorCode = value;
+            }
+            settle();
+            this.processListeners(functionName, CMIElement, value, context);
+          } else {
+            this.processListeners(functionName, CMIElement, value);
+          }
+        };
+        const result = this._httpService.processHttpRequest(finalUrl, finalParams, immediate, apiLog, processListeners, metadata, settle);
+        completionDeferred = this._httpService.reportsRequestCompletion === true;
+        return result;
+      } finally {
+        if (!completionDeferred) {
+          settle();
         }
       }
-      return this._httpService.processHttpRequest(url, params, immediate, (functionName, message, level, element) => this.apiLog(functionName, message, level, element), (functionName, CMIElement, value) => this.processListeners(functionName, CMIElement, value));
     }
     /**
      * Schedules a commit operation to occur after a specified delay.
@@ -16191,6 +16444,11 @@ ${stackTrace}`);
       __publicField$v(this, "__invalid_range_code");
       __publicField$v(this, "__decimal_regex");
       __publicField$v(this, "__error_class");
+      /**
+       * When true, an empty string is a valid value (clears the element). SCORM 1.2
+       * score elements may be blank per the ADL 1.2 CTS; SCORM 2004 leaves this off.
+       */
+      __publicField$v(this, "__allow_empty_string");
       __publicField$v(this, "_raw", "");
       __publicField$v(this, "_min", "");
       __publicField$v(this, "_max");
@@ -16202,6 +16460,7 @@ ${stackTrace}`);
       this.__invalid_range_code = params.invalidRangeCode || scorm12_errors.VALUE_OUT_OF_RANGE;
       this.__decimal_regex = params.decimalRegex || scorm12_regex.CMIDecimal;
       this.__error_class = params.errorClass;
+      this.__allow_empty_string = params.allowEmptyString ?? false;
     }
     /**
      * Called when the API has been reset
@@ -16241,7 +16500,7 @@ ${stackTrace}`);
      * @param {string} raw
      */
     set raw(raw) {
-      if (validationService.validateScore(this._cmi_element + ".raw", raw, this.__decimal_regex, this.__score_range, this.__invalid_type_code, this.__invalid_range_code, this.__error_class)) {
+      if (validationService.validateScore(this._cmi_element + ".raw", raw, this.__decimal_regex, this.__score_range, this.__invalid_type_code, this.__invalid_range_code, this.__error_class, this.__allow_empty_string)) {
         this._raw = raw;
       }
     }
@@ -16257,7 +16516,7 @@ ${stackTrace}`);
      * @param {string} min
      */
     set min(min) {
-      if (validationService.validateScore(this._cmi_element + ".min", min, this.__decimal_regex, this.__score_range, this.__invalid_type_code, this.__invalid_range_code, this.__error_class)) {
+      if (validationService.validateScore(this._cmi_element + ".min", min, this.__decimal_regex, this.__score_range, this.__invalid_type_code, this.__invalid_range_code, this.__error_class, this.__allow_empty_string)) {
         this._min = min;
       }
     }
@@ -16273,7 +16532,7 @@ ${stackTrace}`);
      * @param {string} max
      */
     set max(max) {
-      if (validationService.validateScore(this._cmi_element + ".max", max, this.__decimal_regex, this.__score_range, this.__invalid_type_code, this.__invalid_range_code, this.__error_class)) {
+      if (validationService.validateScore(this._cmi_element + ".max", max, this.__decimal_regex, this.__score_range, this.__invalid_type_code, this.__invalid_range_code, this.__error_class, this.__allow_empty_string)) {
         this._max = max;
       }
     }
@@ -16350,7 +16609,9 @@ ${stackTrace}`);
         invalidErrorCode: scorm12_errors.INVALID_SET_VALUE,
         invalidTypeCode: scorm12_errors.TYPE_MISMATCH,
         invalidRangeCode: scorm12_errors.VALUE_OUT_OF_RANGE,
-        errorClass: Scorm12ValidationError
+        errorClass: Scorm12ValidationError,
+        // SCORM 1.2 score elements may be set blank (clears the value), per ADL 1.2 CTS.
+        allowEmptyString: true
       });
     }
     /**
@@ -16718,7 +16979,9 @@ ${stackTrace}`);
         invalidErrorCode: scorm12_errors.INVALID_SET_VALUE,
         invalidTypeCode: scorm12_errors.TYPE_MISMATCH,
         invalidRangeCode: scorm12_errors.VALUE_OUT_OF_RANGE,
-        errorClass: Scorm12ValidationError
+        errorClass: Scorm12ValidationError,
+        // SCORM 1.2 score elements may be set blank (clears the value), per ADL 1.2 CTS.
+        allowEmptyString: true
       });
     }
     /**
@@ -18155,16 +18418,17 @@ ${stackTrace}`);
      * Attempts to store the data to the LMS
      *
      * @param {boolean} terminateCommit
+     * @param {CommitTrigger} [trigger] - What initiated the commit
      * @return {ResultObject}
      */
-    storeData(terminateCommit) {
+    storeData(terminateCommit, trigger) {
       if (terminateCommit) {
         const originalStatus = this.cmi.core.lesson_status;
         if (this.cmi.core.lesson_mode === "browse") {
           const startingStatus = this.startingData?.cmi?.core?.lesson_status || "";
           if (startingStatus === "" && originalStatus === "not attempted") {
             this.cmi.core.lesson_status = "browsed";
-            return this.processCommitData(terminateCommit);
+            return this.processCommitData(terminateCommit, trigger);
           }
         }
         if (!this.cmi.core.lesson_status || !this.statusSetByModule && this.cmi.core.lesson_status === "not attempted") {
@@ -18193,12 +18457,12 @@ ${stackTrace}`);
           }
         }
       }
-      return this.processCommitData(terminateCommit);
+      return this.processCommitData(terminateCommit, trigger);
     }
-    processCommitData(terminateCommit) {
+    processCommitData(terminateCommit, trigger) {
       const commitObject = this.getCommitObject(terminateCommit);
       if (typeof this.settings.lmsCommitUrl === "string") {
-        return this.processHttpRequest(this.settings.lmsCommitUrl, commitObject, terminateCommit);
+        return this.processHttpRequest(this.settings.lmsCommitUrl, commitObject, terminateCommit, trigger);
       } else {
         return {
           result: global_constants.SCORM_TRUE,
@@ -18349,6 +18613,49 @@ ${stackTrace}`);
     }
   }
 
+  function stripBrackets(delim) {
+    return delim.replace(/[[\]]/g, "");
+  }
+  function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+  function splitDelimited(value, bracketed) {
+    if (!bracketed) {
+      return [value];
+    }
+    if (value.includes(bracketed)) {
+      return value.split(bracketed);
+    }
+    const bare = stripBrackets(bracketed);
+    if (!bare) {
+      return [value];
+    }
+    const splitRe = new RegExp(`(?<!\\\\)${escapeRegex(bare)}`, "g");
+    const unescapeRe = new RegExp(`\\\\${escapeRegex(bare)}`, "g");
+    return value.split(splitRe).map(part => part.replace(unescapeRe, bare));
+  }
+  function splitFirstDelimited(value, bracketed) {
+    if (!bracketed) {
+      return [value];
+    }
+    if (value.includes(bracketed)) {
+      const idx = value.indexOf(bracketed);
+      return [value.slice(0, idx), value.slice(idx + bracketed.length)];
+    }
+    const bare = stripBrackets(bracketed);
+    if (!bare) {
+      return [value];
+    }
+    const splitRe = new RegExp(`(?<!\\\\)${escapeRegex(bare)}`);
+    const unescapeRe = new RegExp(`\\\\${escapeRegex(bare)}`, "g");
+    const parts = value.split(splitRe);
+    const first = (parts[0] ?? "").replace(unescapeRe, bare);
+    if (parts.length === 1) {
+      return [first];
+    }
+    return [first, parts.slice(1).join(bare).replace(unescapeRe, bare)];
+  }
+
   var __defProp$l = Object.defineProperty;
   var __defNormalProp$l = (obj, key, value) => key in obj ? __defProp$l(obj, key, {
     enumerable: true,
@@ -18544,8 +18851,7 @@ ${stackTrace}`);
         const response_type = LearnerResponses[this.type];
         if (response_type) {
           if (response_type?.delimiter) {
-            const delimiter = response_type.delimiter === "[,]" ? "," : response_type.delimiter;
-            nodes = learner_response.split(delimiter);
+            nodes = splitDelimited(learner_response, response_type.delimiter);
           } else {
             nodes[0] = learner_response;
           }
@@ -18553,10 +18859,10 @@ ${stackTrace}`);
             const formatRegex = new RegExp(response_type.format);
             for (let i = 0; i < nodes.length; i++) {
               if (response_type?.delimiter2) {
-                const delimiter2 = response_type.delimiter2 === "[.]" ? "." : response_type.delimiter2;
-                const values = nodes[i]?.split(delimiter2);
+                const node = nodes[i] ?? "";
+                const values = this.type === "performance" ? splitFirstDelimited(node, response_type.delimiter2) : splitDelimited(node, response_type.delimiter2);
                 if (values?.length === 2) {
-                  if (this.type === "performance" && (values[0] === "" || values[1] === "")) {
+                  if (this.type === "performance" && values[0] === "" && values[1] === "") {
                     throw new Scorm2004ValidationError(this._cmi_element + ".learner_response", scorm2004_errors.TYPE_MISMATCH);
                   }
                   if (!values[0]?.match(formatRegex)) {
@@ -18737,37 +19043,19 @@ ${stackTrace}`);
       return result;
     }
   }
-  function stripBrackets(delim) {
-    return delim.replace(/[[\]]/g, "");
-  }
-  function escapeRegex(s) {
-    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  }
-  function splitUnescaped(text, delim) {
-    const reDelim = escapeRegex(delim);
-    const splitRe = new RegExp(`(?<!\\\\)${reDelim}`, "g");
-    const unescapeRe = new RegExp(`\\\\${reDelim}`, "g");
-    return text.split(splitRe).map(part => part.replace(unescapeRe, delim));
-  }
-  function splitFirstUnescaped(text, delim) {
-    const reDelim = escapeRegex(delim);
-    const splitRe = new RegExp(`(?<!\\\\)${reDelim}`);
-    const unescapeRe = new RegExp(`\\\\${reDelim}`, "g");
-    const parts = text.split(splitRe);
-    const firstPart = parts[0] ?? "";
-    if (parts.length === 1) {
-      return [firstPart.replace(unescapeRe, delim)];
+  const RESPONSE_PREFIX_RE = /^\{(?:lang|case_matters|order_matters)=[^}]+\}/;
+  function stripResponsePrefixes(node) {
+    let result = node;
+    while (RESPONSE_PREFIX_RE.test(result)) {
+      result = result.replace(RESPONSE_PREFIX_RE, "");
     }
-    const part1 = firstPart.replace(unescapeRe, delim);
-    const part2 = parts.slice(1).join(delim).replace(unescapeRe, delim);
-    return [part1, part2];
+    return result;
   }
   function validatePattern(type, pattern, responseDef) {
     if (pattern.trim() !== pattern) {
       throw new Scorm2004ValidationError("cmi.interactions.n.correct_responses.n.pattern", scorm2004_errors.TYPE_MISMATCH);
     }
-    const subDelim1 = responseDef.delimiter ? stripBrackets(responseDef.delimiter) : null;
-    const rawNodes = subDelim1 ? splitUnescaped(pattern, subDelim1) : [pattern];
+    const rawNodes = responseDef.delimiter ? splitDelimited(pattern, responseDef.delimiter) : [pattern];
     for (const raw of rawNodes) {
       if (raw.trim() !== raw) {
         throw new Scorm2004ValidationError("cmi.interactions.n.correct_responses.n.pattern", scorm2004_errors.TYPE_MISMATCH);
@@ -18776,17 +19064,11 @@ ${stackTrace}`);
     if (type === "fill-in" && pattern === "") {
       return;
     }
-    const delim1 = responseDef.delimiter ? stripBrackets(responseDef.delimiter) : null;
-    let nodes;
-    if (delim1) {
-      nodes = splitUnescaped(pattern, delim1);
-    } else {
-      nodes = [pattern];
-    }
+    const nodes = responseDef.delimiter ? splitDelimited(pattern, responseDef.delimiter) : [pattern];
     if (!responseDef.delimiter && pattern.includes(",")) {
       throw new Scorm2004ValidationError("cmi.interactions.n.correct_responses.n.pattern", scorm2004_errors.TYPE_MISMATCH);
     }
-    if (responseDef.unique || responseDef.duplicate === false) {
+    if (type !== "numeric" && (responseDef.unique || responseDef.duplicate === false)) {
       const seen = new Set(nodes);
       if (seen.size !== nodes.length) {
         throw new Scorm2004ValidationError("cmi.interactions.n.correct_responses.n.pattern", scorm2004_errors.TYPE_MISMATCH);
@@ -18806,8 +19088,7 @@ ${stackTrace}`);
       if (!delimBracketed) {
         throw new Scorm2004ValidationError("cmi.interactions.n.correct_responses.n.pattern", scorm2004_errors.TYPE_MISMATCH);
       }
-      const delim = stripBrackets(delimBracketed);
-      const parts = value.split(new RegExp(`(?<!\\\\)${escapeRegex(delim)}`, "g")).map(n => n.replace(new RegExp(`\\\\${escapeRegex(delim)}`, "g"), delim));
+      const parts = splitDelimited(value, delimBracketed);
       if (parts.length !== 2 || parts[0] === "" || parts[1] === "") {
         throw new Scorm2004ValidationError("cmi.interactions.n.correct_responses.n.pattern", scorm2004_errors.TYPE_MISMATCH);
       }
@@ -18819,12 +19100,14 @@ ${stackTrace}`);
       switch (type) {
         case "numeric":
           {
-            const numDelim = responseDef.delimiter ? stripBrackets(responseDef.delimiter) : ":";
-            const nums = node.split(numDelim);
-            if (nums.length < 1 || nums.length > 2) {
-              throw new Scorm2004ValidationError("cmi.interactions.n.correct_responses.n.pattern", scorm2004_errors.TYPE_MISMATCH);
+            if (node === "") {
+              const bracketedRange = nodes.length >= 2 && !!responseDef.delimiter && pattern.includes(responseDef.delimiter);
+              if (!bracketedRange) {
+                throw new Scorm2004ValidationError("cmi.interactions.n.correct_responses.n.pattern", scorm2004_errors.TYPE_MISMATCH);
+              }
+              break;
             }
-            nums.forEach(checkSingle);
+            checkSingle(node);
             break;
           }
         case "performance":
@@ -18833,13 +19116,13 @@ ${stackTrace}`);
             if (!delimBracketed) {
               throw new Scorm2004ValidationError("cmi.interactions.n.correct_responses.n.pattern", scorm2004_errors.TYPE_MISMATCH);
             }
-            const delim = stripBrackets(delimBracketed);
-            const parts = splitFirstUnescaped(node, delim);
+            const record = stripResponsePrefixes(node);
+            const parts = splitFirstDelimited(record, delimBracketed);
             if (parts.length !== 2) {
               throw new Scorm2004ValidationError("cmi.interactions.n.correct_responses.n.pattern", scorm2004_errors.TYPE_MISMATCH);
             }
             const [part1, part2] = parts;
-            if (part1 === "" || part2 === "" || part1 === part2) {
+            if (part1 === "" && part2 === "") {
               throw new Scorm2004ValidationError("cmi.interactions.n.correct_responses.n.pattern", scorm2004_errors.TYPE_MISMATCH);
             }
             if (part1 === void 0 || !fmt1.test(part1)) {
@@ -21625,7 +21908,7 @@ ${stackTrace}`);
     checkValidResponseType(CMIElement, response_type, value, interaction_type) {
       let nodes = [];
       if (response_type?.delimiter) {
-        nodes = String(value).split(response_type.delimiter);
+        nodes = splitDelimited(String(value), response_type.delimiter);
       } else {
         nodes[0] = value;
       }
@@ -21723,26 +22006,33 @@ ${stackTrace}`);
           nodes[i] = this.removeCorrectResponsePrefixes(CMIElement, nodes[i]);
         }
         if (response?.delimiter2) {
-          const values = nodes[i].split(response.delimiter2);
+          const values = interaction_type === "performance" ? splitFirstDelimited(nodes[i], response.delimiter2) : splitDelimited(nodes[i], response.delimiter2);
           if (values.length === 2) {
-            const matches = values[0].match(formatRegex);
-            if (!matches) {
+            if (interaction_type === "performance" && values[0] === "" && values[1] === "") {
               this.context.throwSCORMError(CMIElement, scorm2004_errors.TYPE_MISMATCH, `${interaction_type}: ${value}`);
             } else {
-              if (!response.format2 || !values[1].match(new RegExp(response.format2))) {
+              const matches = values[0]?.match(formatRegex);
+              if (!matches) {
                 this.context.throwSCORMError(CMIElement, scorm2004_errors.TYPE_MISMATCH, `${interaction_type}: ${value}`);
+              } else {
+                if (!response.format2 || !values[1]?.match(new RegExp(response.format2))) {
+                  this.context.throwSCORMError(CMIElement, scorm2004_errors.TYPE_MISMATCH, `${interaction_type}: ${value}`);
+                }
               }
             }
           } else {
             this.context.throwSCORMError(CMIElement, scorm2004_errors.TYPE_MISMATCH, `${interaction_type}: ${value}`);
           }
         } else {
+          if (interaction_type === "numeric" && nodes.length > 1 && nodes[i] === "" && !!response.delimiter && String(value).includes(response.delimiter)) {
+            continue;
+          }
           const matches = nodes[i].match(formatRegex);
           if (!matches && value !== "" || !matches && interaction_type === "true-false") {
             this.context.throwSCORMError(CMIElement, scorm2004_errors.TYPE_MISMATCH, `${interaction_type}: ${value}`);
           } else {
             if (interaction_type === "numeric" && nodes.length > 1) {
-              if (Number(nodes[0]) > Number(nodes[1])) {
+              if (nodes[0] !== "" && nodes[1] !== "" && Number(nodes[0]) > Number(nodes[1])) {
                 this.context.throwSCORMError(CMIElement, scorm2004_errors.TYPE_MISMATCH, `${interaction_type}: ${value}`);
               }
             } else {
@@ -23421,6 +23711,10 @@ ${stackTrace}`);
     value
   }) : obj[key] = value;
   var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  const NO_DEFAULT_2004_ELEMENTS = /* @__PURE__ */new Set(["cmi.suspend_data", "cmi.location", "cmi.scaled_passing_score", "cmi.max_time_allowed", "cmi.completion_threshold", "cmi.progress_measure", "cmi.score.scaled", "cmi.score.raw", "cmi.score.min", "cmi.score.max", "cmi.objectives.N.score.scaled", "cmi.objectives.N.score.raw", "cmi.objectives.N.score.min", "cmi.objectives.N.score.max", "cmi.objectives.N.progress_measure", "cmi.objectives.N.description", "cmi.interactions.N.weighting", "cmi.interactions.N.type", "cmi.interactions.N.timestamp", "cmi.interactions.N.result", "cmi.interactions.N.latency", "cmi.interactions.N.learner_response", "cmi.interactions.N.description", "cmi.comments_from_learner.N.timestamp"]);
+  function normalizeCMIIndices(CMIElement) {
+    return CMIElement.replace(/\.\d+(?=\.|$)/g, ".N");
+  }
   class Scorm2004API extends BaseAPI {
     /**
      * Constructor for SCORM 2004 API
@@ -23920,6 +24214,35 @@ ${stackTrace}`);
     getCMIValue(CMIElement) {
       return this._commonGetCMIValue("GetValue", true, CMIElement);
     }
+    /**
+     * Raises 403 (VALUE_NOT_INITIALIZED) when an implemented, no-default element is
+     * read before it has ever been set, per IEEE 1484.11.2 / SCORM 2004 RTE.
+     *
+     * Invoked by BaseAPI.getValue after an otherwise-successful resolution, so it
+     * only sees values the data model already returned cleanly. The decision is
+     * deliberately gated to this public boundary (never the getters) to keep
+     * serialization/commit/rollup — which read the getters directly — unaffected.
+     *
+     * A 403 is raised only when all hold:
+     *  - the resolved value is "" — any non-empty value is by definition set,
+     *    including values written by internal sequencing/activity-tree paths that
+     *    bypass _commonSetCMIValue (those only ever write non-empty values);
+     *  - the element was never set — _setCMIElements records every successful
+     *    SetValue, loadFromJSON, and global-objective restore (all route through
+     *    _commonSetCMIValue), so an explicit SetValue(x, "") still reads back as
+     *    "" with code 0; and
+     *  - the element has no spec-defined default ({@link NO_DEFAULT_2004_ELEMENTS}).
+     *
+     * @param {string} CMIElement
+     * @param {*} returnValue - the value getCMIValue resolved
+     * @protected
+     */
+    checkUninitializedGet(CMIElement, returnValue) {
+      if (returnValue !== "") return;
+      if (this._setCMIElements.has(CMIElement)) return;
+      if (!NO_DEFAULT_2004_ELEMENTS.has(normalizeCMIIndices(CMIElement))) return;
+      this.throwSCORMError(CMIElement, this._error_codes.VALUE_NOT_INITIALIZED ?? 403, `The data model element passed to GetValue (${CMIElement}) has not been initialized.`);
+    }
     /**
      * Returns the message that corresponds to errorNumber.
      * @param {(string|number)} errorNumber
@@ -23968,9 +24291,10 @@ ${stackTrace}`);
     /**
      * Attempts to store the data to the LMS
      * @param {boolean} terminateCommit
+     * @param {CommitTrigger} [trigger] - What initiated the commit
      * @return {ResultObject}
      */
-    storeData(terminateCommit) {
+    storeData(terminateCommit, trigger) {
       if (terminateCommit) {
         if (this.cmi.mode === "normal") {
           if (this.cmi.credit === "credit") {
@@ -24011,7 +24335,7 @@ ${stackTrace}`);
       }
       this._globalObjectiveManager.syncCmiToSequencingActivity(completionStatusEnum, successStatusEnum, scoreObject);
       if (typeof this.settings.lmsCommitUrl === "string") {
-        const result = this.processHttpRequest(this.settings.lmsCommitUrl, commitObject, terminateCommit);
+        const result = this.processHttpRequest(this.settings.lmsCommitUrl, commitObject, terminateCommit, trigger);
         if (navRequest && result.navRequest !== void 0 && result.navRequest !== "" && typeof result.navRequest === "string") {
           const parsed = parseNavigationRequest(result.navRequest);
           if (!parsed.valid) {