@doenet/v06-to-v07 0.7.24-dev.496 → 0.7.24-dev.498

package/{index-Co6vf-pO.js → index-CMbGEQt0.js}

@@ -45857,7 +45857,7 @@ async function cidFromArrayBuffer(data) {
       await crypto.subtle.digest("SHA-256", new Uint8Array());
       digest = (data2) => crypto.subtle.digest("SHA-256", data2);
     } catch (e22) {
-      const sha256 = (await import("./sha256-DT5xJ2Hv-CN9l-ne8-DSzmsKLe.js").then((n2) => n2.s)).default;
+      const sha256 = (await import("./sha256-DT5xJ2Hv-DQlQsFFB-CzLWg3kc.js").then((n2) => n2.s)).default;
       digest = (data2) => sha256(data2, {
         asBytes: true
       });
@@ -70713,6 +70713,9 @@ class StatePersistence {
     this.saveDocStateTimeoutID = null;
     this.docStateToBeSavedToDatabase = null;
     this.changesToBeSaved = false;
+    this.scoreToBeSavedToDatabase = 0;
+    this._saveSequence = 0;
+    this._storedSequence = 0;
   }
   /**
    * Cancel any pending saves and clear the buffered payload. Called from
@@ -70729,7 +70732,9 @@ class StatePersistence {
       this.saveDocStateTimeoutID = null;
     }
     this.docStateToBeSavedToDatabase = null;
+    this.scoreToBeSavedToDatabase = 0;
     this.changesToBeSaved = false;
+    this._storedSequence = ++this._saveSequence;
   }
   /**
    * Schedule a debounced `saveState` after `delayMs` milliseconds, replacing
@@ -70794,7 +70799,18 @@ class StatePersistence {
     if (!core2.flags.allowSaveState && !core2.flags.allowLocalState) {
       return;
     }
+    const sequence = ++this._saveSequence;
     const { payload, coreStateString, rendererStateString } = this.buildDocStatePayload(onSubmission);
+    const score = core2.flags.allowSaveState ? await core2.document.stateValues.creditAchieved : 0;
+    if (!this._claimSave(sequence)) {
+      await this._standDownSupersededSave(overrideThrottle, onSubmission);
+      return;
+    }
+    if (core2.flags.allowSaveState) {
+      this.docStateToBeSavedToDatabase = payload;
+      this.scoreToBeSavedToDatabase = score;
+      this.changesToBeSaved = true;
+    }
     if (core2.flags.allowLocalState) {
       await set(
         `${core2.activityId}|${core2.docId}|${core2.attemptNumber}|${core2.cid}`,
@@ -70805,11 +70821,54 @@ class StatePersistence {
           coreInfo: core2.coreInfoString
         }
       );
+      if (!this._claimSave(sequence)) {
+        await this._standDownSupersededSave(
+          overrideThrottle,
+          onSubmission
+        );
+        return;
+      }
     }
     if (!core2.flags.allowSaveState) {
       return;
     }
-    this.docStateToBeSavedToDatabase = payload;
+    await this.saveChangesToDatabase(overrideThrottle);
+  }
+  /**
+   * Whether this save is still the newest to have got this far, taking the
+   * claim if so. A claim is only good until the next await, so a save that
+   * yields after taking one has to take it again on the far side.
+   */
+  _claimSave(sequence) {
+    if (sequence < this._storedSequence) {
+      return false;
+    }
+    this._storedSequence = sequence;
+    return true;
+  }
+  /**
+   * Give up on a save that a later one overtook — while it resolved its
+   * score, or while it wrote local state — without giving up what only
+   * *this* save knew.
+   *
+   * The work itself is not lost: the save that overtook it was built later,
+   * so the pair now stored holds at least as much. What does not survive the
+   * hand-off is why this save was made. A submission's save says a
+   * submission happened and overrides the 60-second throttle so the host
+   * hears about it now; an ordinary save that overtook it does neither, and
+   * simply returning here would leave a graded answer sitting behind the
+   * throttle as an unreported mirror.
+   */
+  async _standDownSupersededSave(overrideThrottle, onSubmission) {
+    if (!this.docStateToBeSavedToDatabase) {
+      return;
+    }
+    if (onSubmission) {
+      this.docStateToBeSavedToDatabase.onSubmission = true;
+    }
+    if (!overrideThrottle && !onSubmission) {
+      return;
+    }
     this.changesToBeSaved = true;
     await this.saveChangesToDatabase(overrideThrottle);
   }
@@ -70833,6 +70892,41 @@ class StatePersistence {
     await this.saveImmediately();
     return true;
   }
+  /**
+   * Hand the currently buffered database payload to the main realm through
+   * `reportScoreAndStateCallback`.
+   *
+   * With `pending: true` this is a *mirror* of the payload the 60-second
+   * throttle is holding back, not a report for the host to save
+   * (Doenet/DoenetML#1726). A page can go away without the viewer
+   * unmounting — the tab is closed, a new URL is typed, a backgrounded
+   * mobile tab is discarded — and `pagehide` offers no budget for a Comlink
+   * round-trip into this worker, so the payload has to already be over
+   * there. `DocViewer` buffers a `pending` report rather than handing it to
+   * the host, and delivers it as an ordinary report when the page hides.
+   *
+   * A mirror goes out on every throttled save, so it is never further behind
+   * the screen than the one-second save debounce. Any real report that
+   * follows (throttle expiry, submission, `SPLICE.flushState`, the
+   * `saveImmediately` in `terminate`) carries the same or newer state and
+   * supersedes it.
+   *
+   * The pair it sends was captured together by the `saveState` that built
+   * it, so this needs no `await` and cannot interleave with anything: the
+   * score always belongs to the payload beside it, and a page hide is never
+   * handed a reader's state under a credit from the wrong side of it.
+   */
+  _reportStateToMainRealm(pending) {
+    const payload = this.docStateToBeSavedToDatabase;
+    if (!payload) {
+      return;
+    }
+    this.core.reportScoreAndStateCallback({
+      state: { ...payload },
+      score: this.scoreToBeSavedToDatabase,
+      pending
+    });
+  }
   async saveChangesToDatabase(overrideThrottle = false) {
     if (!this.changesToBeSaved) {
       return;
@@ -70841,6 +70935,7 @@ class StatePersistence {
       if (overrideThrottle) {
         clearTimeout(this.saveStateToDBTimerId);
       } else {
+        this._reportStateToMainRealm(true);
         return;
       }
     }
@@ -70851,11 +70946,7 @@ class StatePersistence {
         reportTimerError(TimerLabels.throttledSaveChanges)
       );
     }, 6e4);
-    this.core.reportScoreAndStateCallback({
-      state: { ...this.docStateToBeSavedToDatabase },
-      score: await this.core.document.stateValues.creditAchieved
-    });
-    return;
+    this._reportStateToMainRealm(false);
   }
 }
 class StateVariableEvaluator {
@@ -237361,4 +237452,4 @@ export {
   getDefaultExportFromCjs$1 as g,
   updateSyntaxFromV06toV07 as u
 };
-//# sourceMappingURL=index-Co6vf-pO.js.map
+//# sourceMappingURL=index-CMbGEQt0.js.map