@qualified-salesforce/web 0.0.1-oidc-bootstrap → 0.1.0

package/widget/multimodal_v2/stores/meeting_store.js

@@ -154,18 +154,17 @@ class MeetingStore {
    * content first renders, whether that is the slot grid or the no-availability
    * empty state. Empty availability is a successful render (backend responded
    * with no open times), not a booker failure.
-   */ /**
-   * @param offerMessageId The offer this render is reporting. Callers should pass
-   *   the id they rendered with rather than relying on the default: the default
-   *   reads live state, and a second offer landing between the render and this
-   *   call would report the newer id, which the intent tracker rejects as
-   *   belonging to a different intent — silently dropping the timing.
+   *
+   * @param offerMessageId The offer this render is reporting. Pass the id you
+   *   rendered with rather than relying on the default, which reads live state
+   *   and would report a newer offer that landed in between. Both trackers
+   *   reject a mark for an offer other than the one they armed.
    */ markShown(offerMessageId) {
         if (offerMessageId === void 0) offerMessageId = (()=>{
             var _this_activeOfferMessage_value;
             return (_this_activeOfferMessage_value = this.activeOfferMessage.value) == null ? void 0 : _this_activeOfferMessage_value.id;
         })();
-        this.outcomeTracker.markShown();
+        this.outcomeTracker.markShown(offerMessageId);
         // Closes the pre-offer window's visitor-experienced total (intent -> shown).
         // No-ops unless this offer was preceded by an intent signal on this page.
         if (offerMessageId) this.rootStore.bookerIntentTracker.markShown(offerMessageId);
@@ -372,7 +371,9 @@ class MeetingStore {
             const slot = this.selectedTimeSlot.value;
             if (!slot) return [];
             const tz = this.timeZone.value;
-            const locale = this.rootStore.translationStore.effectiveLocale.value;
+            // Already Intl-normalized; buildCalendarDays/formatDayShort re-normalize internally,
+            // which is a no-op here since toIntlLocale is idempotent on hyphenated input.
+            const locale = this.rootStore.translationStore.effectiveIntlLocale.value;
             return buildCalendarDays(slot, tz, this.sortedSlots.value, locale);
         });
         this.hasPrevWeek = signals_core_module_w(()=>$exists(this.prevSlotBeforeWeek).value);
@@ -382,7 +383,9 @@ class MeetingStore {
         this.displayedTimeSlotItems = signals_core_module_w(()=>{
             const slot = this.selectedTimeSlot.value;
             const tz = this.timeZone.value;
-            const locale = this.rootStore.translationStore.effectiveLocale.value;
+            // Already Intl-normalized; formatTimeShort re-normalizes internally, which is a
+            // no-op here since toIntlLocale is idempotent on hyphenated input.
+            const locale = this.rootStore.translationStore.effectiveIntlLocale.value;
             return this.displayedTimeSlots.value.map((s)=>({
                     slot: s,
                     label: formatTimeShort(s.startsAt, tz, locale),
@@ -426,7 +429,9 @@ class MeetingStore {
             if (!slot) return null;
             const d = new Date(slot.startsAt);
             const key = d.getFullYear() + "-" + ("" + (d.getMonth() + 1)).padStart(2, "0") + "-" + ("" + d.getDate()).padStart(2, "0");
-            const locale = this.rootStore.translationStore.effectiveLocale.value;
+            // Already Intl-normalized; formatMonthTitle re-normalizes internally, which is a
+            // no-op here since toIntlLocale is idempotent on hyphenated input.
+            const locale = this.rootStore.translationStore.effectiveIntlLocale.value;
             return formatMonthTitle(key, locale);
         });
         this.minDate = signals_core_module_w(()=>{

package/widget/multimodal_v2/stores/presentation_ga_adapter.js

@@ -0,0 +1,64 @@
+import { PRESENTATION_TYPE_LABELS, buildCustEvChatPresentationSlidePayload, buildCustEvChatPresentationStartPayload, buildCustEvChatPresentationEndPayload } from "../components/helpers/content_click_payloads.js";
+
+
+class PresentationGaAdapter {
+    dispose() {
+        this.unsubscribe();
+    }
+    emitEvent(event) {
+        if (event.type === "start") {
+            const data = buildCustEvChatPresentationStartPayload({
+                conversationId: this.options.conversationId(),
+                formJoinIDUnique: this.options.formJoinIDUnique(),
+                title: event.title,
+                type: PRESENTATION_TYPE_LABELS[event.contentType],
+                totalSlides: event.totalSlides,
+                triggeredBy: event.triggeredBy
+            });
+            this.options.emit({
+                name: "custEv_chatPresentationStart",
+                data
+            });
+        } else if (event.type === "slide") {
+            const data = buildCustEvChatPresentationSlidePayload({
+                conversationId: this.options.conversationId(),
+                formJoinIDUnique: this.options.formJoinIDUnique(),
+                title: event.title,
+                type: PRESENTATION_TYPE_LABELS[event.contentType],
+                slideTitle: event.slideTitle,
+                slidePosition: event.slidePosition
+            });
+            this.options.emit({
+                name: "custEv_chatPresentationSlide",
+                data
+            });
+        } else {
+            const data = buildCustEvChatPresentationEndPayload({
+                conversationId: this.options.conversationId(),
+                formJoinIDUnique: this.options.formJoinIDUnique(),
+                title: event.title,
+                type: PRESENTATION_TYPE_LABELS[event.contentType],
+                slidesShown: event.slidesShown,
+                secondsWatched: Math.floor(event.activeMilliseconds / 1000)
+            });
+            this.options.emit({
+                name: "custEv_chatPresentationEnd",
+                data
+            });
+        }
+    }
+    constructor(options){
+        this.options = options;
+        this.handleEvent = (event)=>{
+            if (!this.options.isEnabled()) return;
+            try {
+                this.emitEvent(event);
+            } catch (unused) {
+            // GA delivery cannot alter presentation lifecycle or persistence.
+            }
+        };
+        this.unsubscribe = options.telemetry.subscribe(this.handleEvent);
+    }
+}
+
+export { PresentationGaAdapter };

package/widget/multimodal_v2/stores/presentation_telemetry_store.js

@@ -0,0 +1,556 @@
+import { __webpack_require__ } from "../../../js/runtime.js";
+import "../../utils/native_globals.js";
+import { esm_browser_v4 } from "../../../js/4101.js";
+
+/* provided dependency */ var __nativeDocumentRemoveEventListener = __webpack_require__(68034).LA;
+/* provided dependency */ var __nativeWindowRemoveEventListener = __webpack_require__(68034).kZ;
+/* provided dependency */ var presentation_telemetry_store_setTimeout = __webpack_require__(68034).pS;
+/* provided dependency */ var presentation_telemetry_store_clearTimeout = __webpack_require__(68034).Kj;
+/* provided dependency */ var __nativeDocumentAddEventListener = __webpack_require__(68034).Qj;
+/* provided dependency */ var __nativeWindowAddEventListener = __webpack_require__(68034).zh;
+function _extends() {
+    _extends = Object.assign || function(target) {
+        for(var i = 1; i < arguments.length; i++){
+            var source = arguments[i];
+            for(var key in source){
+                if (Object.prototype.hasOwnProperty.call(source, key)) {
+                    target[key] = source[key];
+                }
+            }
+        }
+        return target;
+    };
+    return _extends.apply(this, arguments);
+}
+
+const CHECKPOINT_MS = 5000;
+const PERSISTENCE_RETRY_MS = 5000;
+const MAX_PERSISTED_SEQUENCE = 2000;
+const MAX_TERMINAL_FLUSH_ACTIVITIES = 100;
+class PresentationTelemetryStore {
+    onLiveArtifactVisible(message) {
+        const assetKey = assetKeyFor(message);
+        if (this.lifecycle && !this.lifecycle.ended && this.lifecycle.assetKey !== assetKey) {
+            this.end("replaced");
+        }
+        if ((!this.lifecycle || this.lifecycle.ended) && typeof document !== "undefined" && document.visibilityState !== "visible") {
+            this.pendingVisiblePresentation = {
+                message
+            };
+            return;
+        }
+        this.pendingVisiblePresentation = null;
+        if (!this.lifecycle || this.lifecycle.ended) {
+            this.lifecycle = this.createLifecycle(message);
+            this.emit({
+                type: "start",
+                lifecycleId: this.lifecycle.lifecycleId,
+                messageId: this.lifecycle.originatingMessageId,
+                contentType: this.lifecycle.contentType,
+                title: this.lifecycle.title,
+                totalSlides: this.lifecycle.totalSlides,
+                triggeredBy: this.lifecycle.triggeredBy
+            });
+            this.enqueueActivity(this.createActivity("started"));
+            if (message.type === "present_content") {
+                this.recordSlide(message.slideId, 0, this.lifecycle.title);
+            }
+        } else {
+            const isNewMessage = this.lifecycle.currentMessageId !== message.id;
+            if (!isNewMessage) return;
+            this.lifecycle.currentMessageId = message.id;
+            this.lifecycle.interrupted = false;
+            if (message.type === "present_video") {
+                this.demoPlaybackState = {
+                    playing: false,
+                    buffering: false,
+                    seeking: false
+                };
+            }
+        }
+        if (message.type === "present_deck") {
+            var _ref, _message_slideIndex, _message_pageId, _ref1, _message_pageTitle;
+            var _message_slides_, _message_slides, _message_slides1;
+            const slideIndex = (_ref = (_message_slideIndex = message.slideIndex) != null ? _message_slideIndex : (_message_slides = message.slides) == null ? void 0 : (_message_slides_ = _message_slides[0]) == null ? void 0 : _message_slides_.slideIndex) != null ? _ref : 0;
+            const slide = (_message_slides1 = message.slides) == null ? void 0 : _message_slides1.find((candidate)=>candidate.slideIndex === slideIndex);
+            const slideId = (_message_pageId = message.pageId) != null ? _message_pageId : slide == null ? void 0 : slide.pageId;
+            const slideTitle = (_ref1 = (_message_pageTitle = message.pageTitle) != null ? _message_pageTitle : slide == null ? void 0 : slide.pageTitle) != null ? _ref1 : "Slide " + (slideIndex + 1);
+            this.recordSlide(slideId, slideIndex, slideTitle);
+        }
+        this.startActiveInterval();
+    }
+    recordPendingTrigger(context) {
+        this.pendingTrigger = context;
+    }
+    onDeckSlideRendered(slideId, slideIndex, slideTitle) {
+        var _this_pendingVisiblePresentation, _this_lifecycle;
+        if (((_this_pendingVisiblePresentation = this.pendingVisiblePresentation) == null ? void 0 : _this_pendingVisiblePresentation.message.type) === "present_deck" && (!this.lifecycle || this.lifecycle.ended)) {
+            this.pendingVisiblePresentation.latestDeckSlide = {
+                slideId,
+                slideIndex,
+                slideTitle: slideTitle != null ? slideTitle : "Slide " + (slideIndex + 1)
+            };
+            return;
+        }
+        if (((_this_lifecycle = this.lifecycle) == null ? void 0 : _this_lifecycle.contentType) !== "present_deck" || this.lifecycle.ended) return;
+        this.recordSlide(slideId, slideIndex, slideTitle != null ? slideTitle : "Slide " + (slideIndex + 1));
+    }
+    onDeckInterrupted() {
+        if (!this.lifecycle || this.lifecycle.contentType !== "present_deck") return;
+        this.lifecycle.interrupted = true;
+        this.pauseActiveInterval();
+    }
+    onDeckFinalDisplayIntervalComplete() {
+        var _this_pendingVisiblePresentation, _this_lifecycle;
+        if (((_this_pendingVisiblePresentation = this.pendingVisiblePresentation) == null ? void 0 : _this_pendingVisiblePresentation.message.type) === "present_deck") {
+            this.pendingVisiblePresentation = null;
+            return;
+        }
+        if (((_this_lifecycle = this.lifecycle) == null ? void 0 : _this_lifecycle.contentType) === "present_deck") this.end("completed");
+    }
+    onDemoPlaybackState(messageId, state) {
+        var _this_pendingVisiblePresentation, _this_lifecycle;
+        if (((_this_pendingVisiblePresentation = this.pendingVisiblePresentation) == null ? void 0 : _this_pendingVisiblePresentation.message.type) === "present_video" && this.pendingVisiblePresentation.message.id === messageId) {
+            this.pendingVisiblePresentation.demoPlaybackState = state;
+            return;
+        }
+        if (((_this_lifecycle = this.lifecycle) == null ? void 0 : _this_lifecycle.contentType) !== "present_video" || this.lifecycle.ended || this.lifecycle.currentMessageId !== messageId) {
+            return;
+        }
+        this.demoPlaybackState = state;
+        if (this.canAccumulate()) this.startActiveInterval();
+        else this.pauseActiveInterval();
+    }
+    onDemoInterrupted() {
+        if (!this.lifecycle || this.lifecycle.contentType !== "present_video") return;
+        this.lifecycle.interrupted = true;
+        this.pauseActiveInterval();
+    }
+    onDemoNaturalCompletion(messageId) {
+        var _this_pendingVisiblePresentation, _this_lifecycle;
+        if (((_this_pendingVisiblePresentation = this.pendingVisiblePresentation) == null ? void 0 : _this_pendingVisiblePresentation.message.type) === "present_video" && this.pendingVisiblePresentation.message.id === messageId) {
+            this.pendingVisiblePresentation = null;
+            return;
+        }
+        if (((_this_lifecycle = this.lifecycle) == null ? void 0 : _this_lifecycle.contentType) === "present_video" && this.lifecycle.currentMessageId === messageId) {
+            this.end("completed");
+        }
+    }
+    onVisitorDismiss(messageId) {
+        this.onArtifactHidden(messageId, "dismissed");
+    }
+    onAgentHide(messageId) {
+        this.onArtifactHidden(messageId, "agent_hidden");
+    }
+    onArtifactHidden(messageId, reason) {
+        if (reason === void 0) reason = "dismissed";
+        var _this_pendingVisiblePresentation, _this_lifecycle;
+        if (((_this_pendingVisiblePresentation = this.pendingVisiblePresentation) == null ? void 0 : _this_pendingVisiblePresentation.message.id) === messageId) {
+            this.pendingVisiblePresentation = null;
+        }
+        if (((_this_lifecycle = this.lifecycle) == null ? void 0 : _this_lifecycle.currentMessageId) === messageId) this.end(reason);
+    }
+    onCallEnded() {
+        this.pendingTrigger = null;
+        this.pendingVisiblePresentation = null;
+        this.end("call_ended");
+    }
+    onConversationEnded() {
+        this.pendingTrigger = null;
+        this.pendingVisiblePresentation = null;
+        this.end("conversation_ended");
+    }
+    onExperienceReplaced() {
+        this.pendingTrigger = null;
+        this.pendingVisiblePresentation = null;
+        this.end("replaced");
+        this.flushTerminalActivities();
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return ()=>this.listeners.delete(listener);
+    }
+    dispose() {
+        this.disposed = true;
+        if (typeof document !== "undefined") {
+            __nativeDocumentRemoveEventListener("visibilitychange", this.handleVisibilityChange);
+        }
+        if (typeof window !== "undefined") {
+            __nativeWindowRemoveEventListener("pagehide", this.handlePageHide);
+            __nativeWindowRemoveEventListener("pageshow", this.handlePageShow);
+        }
+        this.clearCheckpointTimer();
+        this.clearPersistenceRetryTimer();
+        this.pendingVisiblePresentation = null;
+        this.listeners.clear();
+    }
+    resumeVisibleLifecycle() {
+        const pendingPresentation = this.pendingVisiblePresentation;
+        this.pendingVisiblePresentation = null;
+        if (pendingPresentation) {
+            const currentArtifact = this.rootStore.artifact.message.peek();
+            if ((currentArtifact == null ? void 0 : currentArtifact.id) === pendingPresentation.message.id) {
+                const message = pendingPresentation.message.type === "present_deck" && pendingPresentation.latestDeckSlide ? _extends({}, pendingPresentation.message, {
+                    pageId: pendingPresentation.latestDeckSlide.slideId,
+                    slideIndex: pendingPresentation.latestDeckSlide.slideIndex,
+                    pageTitle: pendingPresentation.latestDeckSlide.slideTitle
+                }) : pendingPresentation.message;
+                this.onLiveArtifactVisible(message);
+                if (message.type === "present_video" && pendingPresentation.demoPlaybackState) {
+                    this.onDemoPlaybackState(message.id, pendingPresentation.demoPlaybackState);
+                }
+                return;
+            }
+        }
+        const { lifecycle } = this;
+        const pendingSlide = lifecycle == null ? void 0 : lifecycle.pendingVisibleSlide;
+        if (pendingSlide) {
+            lifecycle.pendingVisibleSlide = undefined;
+            this.recordSlide(pendingSlide.slideId, pendingSlide.slideIndex, pendingSlide.slideTitle);
+        }
+        this.startActiveInterval();
+    }
+    createLifecycle(message) {
+        const contentType = message.type;
+        const triggeredBy = this.triggerMatches(message) ? "cta" : "conversational";
+        if (triggeredBy === "cta") this.pendingTrigger = null;
+        if (contentType === "present_video") {
+            this.demoPlaybackState = {
+                playing: false,
+                buffering: false,
+                seeking: false
+            };
+        }
+        return {
+            assetKey: assetKeyFor(message),
+            contentType,
+            lifecycleId: createLifecycleId(),
+            originatingMessageId: message.id,
+            currentMessageId: message.id,
+            title: titleFor(message),
+            totalSlides: totalSlidesFor(message),
+            triggeredBy,
+            uniqueSlideIds: new Set(),
+            activeMilliseconds: 0,
+            activeSince: null,
+            interrupted: false,
+            ended: false,
+            nextSequence: 1,
+            lastCheckpointActiveMilliseconds: 0
+        };
+    }
+    triggerMatches(message) {
+        var _this_pendingTrigger;
+        const trigger = (_this_pendingTrigger = this.pendingTrigger) == null ? void 0 : _this_pendingTrigger.trigger;
+        if (!trigger) return false;
+        return message.type === "present_deck" && trigger.type === "start_deck" && trigger.deckId === message.deckId || message.type === "present_video" && trigger.type === "start_presentation" && trigger.presentationId === message.presentationId;
+    }
+    recordSlide(slideId, slideIndex, slideTitle) {
+        const { lifecycle } = this;
+        if (!lifecycle || lifecycle.contentType === "present_video") return;
+        if (typeof document !== "undefined" && document.visibilityState !== "visible") {
+            lifecycle.pendingVisibleSlide = {
+                slideId,
+                slideIndex,
+                slideTitle
+            };
+            return;
+        }
+        lifecycle.pendingVisibleSlide = undefined;
+        lifecycle.uniqueSlideIds.add(slideId);
+        this.emit({
+            type: "slide",
+            lifecycleId: lifecycle.lifecycleId,
+            messageId: lifecycle.originatingMessageId,
+            contentType: lifecycle.contentType,
+            title: lifecycle.title,
+            slideTitle,
+            slidePosition: slideIndex + 1
+        });
+        this.enqueueActivity(this.createActivity("slide_shown", {
+            slideId,
+            slideIndex
+        }));
+    }
+    end(reason) {
+        const { lifecycle } = this;
+        if (!lifecycle || lifecycle.ended) return;
+        if (lifecycle.activeSince !== null) {
+            lifecycle.activeMilliseconds = this.currentActiveMilliseconds();
+            lifecycle.activeSince = null;
+        }
+        this.clearCheckpointTimer();
+        lifecycle.pendingVisibleSlide = undefined;
+        lifecycle.ended = true;
+        lifecycle.endReason = reason;
+        this.emit({
+            type: "end",
+            lifecycleId: lifecycle.lifecycleId,
+            messageId: lifecycle.originatingMessageId,
+            contentType: lifecycle.contentType,
+            title: lifecycle.title,
+            slidesShown: lifecycle.uniqueSlideIds.size,
+            activeMilliseconds: Math.floor(lifecycle.activeMilliseconds),
+            endReason: reason
+        });
+        const ended = this.createActivity("ended", {
+            endReason: reason
+        });
+        this.enqueueActivity(ended);
+    }
+    startActiveInterval() {
+        if (!this.lifecycle || this.lifecycle.ended || this.lifecycle.activeSince != null) return;
+        if (!this.canAccumulate()) return;
+        this.lifecycle.activeSince = performance.now();
+        this.scheduleCheckpoint();
+    }
+    pauseActiveInterval() {
+        const { lifecycle } = this;
+        if (!lifecycle || lifecycle.activeSince === null) return;
+        lifecycle.activeMilliseconds = this.currentActiveMilliseconds();
+        lifecycle.activeSince = null;
+        this.clearCheckpointTimer();
+        this.checkpointIfChanged();
+    }
+    currentActiveMilliseconds() {
+        const { lifecycle } = this;
+        if (!lifecycle) return 0;
+        if (lifecycle.activeSince === null) return lifecycle.activeMilliseconds;
+        return lifecycle.activeMilliseconds + performance.now() - lifecycle.activeSince;
+    }
+    checkpointIfChanged() {
+        const { lifecycle } = this;
+        if (!lifecycle || lifecycle.ended) return;
+        const activeMilliseconds = Math.floor(this.currentActiveMilliseconds());
+        if (activeMilliseconds <= lifecycle.lastCheckpointActiveMilliseconds) return;
+        const checkpoint = this.createActivity("exposure_checkpoint");
+        if (!checkpoint) return;
+        lifecycle.lastCheckpointActiveMilliseconds = checkpoint.activeMilliseconds;
+        this.enqueueActivity(checkpoint);
+    }
+    scheduleCheckpoint() {
+        this.clearCheckpointTimer();
+        const { lifecycle } = this;
+        if (!lifecycle) return;
+        const elapsedIntoInterval = lifecycle.activeMilliseconds % CHECKPOINT_MS;
+        const delay = Math.ceil(elapsedIntoInterval === 0 ? CHECKPOINT_MS : CHECKPOINT_MS - elapsedIntoInterval);
+        this.checkpointTimer = presentation_telemetry_store_setTimeout(()=>{
+            const current = this.lifecycle;
+            if (!current || current.activeSince === null) return;
+            current.activeMilliseconds = this.currentActiveMilliseconds();
+            current.activeSince = performance.now();
+            this.checkpointIfChanged();
+            if (this.canAccumulate()) this.scheduleCheckpoint();
+        }, delay);
+    }
+    clearCheckpointTimer() {
+        if (this.checkpointTimer !== null) presentation_telemetry_store_clearTimeout(this.checkpointTimer);
+        this.checkpointTimer = null;
+    }
+    clearPersistenceRetryTimer() {
+        if (this.persistenceRetryTimer !== null) presentation_telemetry_store_clearTimeout(this.persistenceRetryTimer);
+        this.persistenceRetryTimer = null;
+    }
+    canAccumulate() {
+        const { lifecycle } = this;
+        if (!lifecycle || lifecycle.ended || lifecycle.interrupted || typeof document !== "undefined" && document.visibilityState !== "visible") {
+            return false;
+        }
+        return lifecycle.contentType !== "present_video" || this.demoPlaybackState.playing && !this.demoPlaybackState.buffering && !this.demoPlaybackState.seeking;
+    }
+    createActivity(activityType, options) {
+        if (options === void 0) options = {};
+        const { lifecycle } = this;
+        if (!lifecycle) throw new Error("Cannot create presentation activity without a lifecycle");
+        const { slideId, slideIndex, endReason } = options;
+        if (activityType !== "ended" && lifecycle.nextSequence >= MAX_PERSISTED_SEQUENCE) {
+            return null;
+        }
+        return _extends({
+            presentationMessageId: lifecycle.originatingMessageId,
+            lifecycleId: lifecycle.lifecycleId,
+            sequence: activityType === "ended" ? Math.min(lifecycle.nextSequence++, MAX_PERSISTED_SEQUENCE) : lifecycle.nextSequence++,
+            activityType,
+            contentType: lifecycle.contentType,
+            occurredAt: new Date().toISOString(),
+            activeMilliseconds: Math.floor(this.currentActiveMilliseconds())
+        }, slideId !== undefined && {
+            slideId
+        }, slideIndex !== undefined && {
+            slideIndex
+        }, endReason !== undefined && {
+            endReason
+        });
+    }
+    enqueueActivity(activity) {
+        if (this.disposed || !activity) return;
+        if (activity.activityType === "exposure_checkpoint") {
+            const firstReplaceableIndex = this.persistenceInFlight || this.persistenceRetryTimer !== null ? 1 : 0;
+            for(let index = this.persistenceQueue.length - 1; index >= firstReplaceableIndex; index--){
+                const queued = this.persistenceQueue[index];
+                if (queued.lifecycleId === activity.lifecycleId && queued.activityType === "exposure_checkpoint") {
+                    this.persistenceQueue.splice(index, 1);
+                    break;
+                }
+            }
+        }
+        this.persistenceQueue.push(activity);
+        this.persistNextActivity();
+    }
+    persistNextActivity() {
+        if (this.disposed || this.persistenceInFlight || this.persistenceRetryTimer !== null || this.persistenceQueue.length === 0) {
+            return;
+        }
+        const activity = this.persistenceQueue[0];
+        this.persistenceInFlight = activity;
+        try {
+            Promise.resolve(this.persistActivity(activity)).then((result)=>this.settlePersistence(activity, !result.error), ()=>this.settlePersistence(activity, false));
+        } catch (unused) {
+            this.settlePersistence(activity, false);
+        }
+    }
+    settlePersistence(activity, acknowledged) {
+        if (this.persistenceInFlight !== activity) return;
+        this.persistenceInFlight = null;
+        if (this.disposed) return;
+        if (acknowledged && this.persistenceQueue[0] === activity) {
+            this.persistenceQueue.shift();
+            this.persistNextActivity();
+            return;
+        }
+        this.persistenceRetryTimer = presentation_telemetry_store_setTimeout(()=>{
+            this.persistenceRetryTimer = null;
+            this.persistNextActivity();
+        }, PERSISTENCE_RETRY_MS);
+    }
+    persistActivity(activity) {
+        return this.rootStore.channel.perform("record_presentation_activity", this.activityPayload(activity), {
+            reportTimeout: false
+        });
+    }
+    activityPayload(activity) {
+        return _extends({
+            presentation_message_id: activity.presentationMessageId,
+            lifecycle_id: activity.lifecycleId,
+            sequence: activity.sequence,
+            activity_type: activity.activityType,
+            content_type: activity.contentType,
+            occurred_at: activity.occurredAt,
+            active_milliseconds: activity.activeMilliseconds
+        }, activity.slideId !== undefined && {
+            slide_id: activity.slideId
+        }, activity.slideIndex !== undefined && {
+            slide_index: activity.slideIndex
+        }, activity.endReason !== undefined && {
+            end_reason: activity.endReason
+        });
+    }
+    flushTerminalActivities() {
+        if (this.disposed || this.terminalFlushSent || this.persistenceQueue.length === 0 || typeof fetch === "undefined") {
+            return;
+        }
+        const pending = this.persistenceQueue.length <= MAX_TERMINAL_FLUSH_ACTIVITIES ? this.persistenceQueue : [
+            this.persistenceQueue[0],
+            ...this.persistenceQueue.slice(-(MAX_TERMINAL_FLUSH_ACTIVITIES - 1))
+        ];
+        this.terminalFlushSent = true;
+        try {
+            void fetch(this.rootStore.visitor.resourceUrl("presentation_activities", {}), {
+                method: "POST",
+                body: JSON.stringify({
+                    activities: pending.map((activity)=>this.activityPayload(activity))
+                }),
+                headers: {
+                    "Content-Type": "text/plain;charset=UTF-8"
+                },
+                keepalive: true,
+                credentials: "omit"
+            }).catch(()=>undefined);
+        } catch (unused) {
+        // Page teardown cannot wait for or recover from a synchronous transport failure.
+        }
+    }
+    emit(event) {
+        this.listeners.forEach((listener)=>{
+            try {
+                listener(event);
+            } catch (unused) {
+            // Lifecycle consumers must not change presentation behavior.
+            }
+        });
+    }
+    constructor(rootStore){
+        this.rootStore = rootStore;
+        this.lifecycle = null;
+        this.pendingTrigger = null;
+        this.pendingVisiblePresentation = null;
+        this.demoPlaybackState = {
+            playing: false,
+            buffering: false,
+            seeking: false
+        };
+        this.checkpointTimer = null;
+        this.listeners = new Set();
+        this.persistenceQueue = [];
+        this.persistenceInFlight = null;
+        this.persistenceRetryTimer = null;
+        this.terminalFlushSent = false;
+        this.disposed = false;
+        this.handleVisibilityChange = ()=>{
+            if (document.visibilityState === "visible") this.resumeVisibleLifecycle();
+            else this.pauseActiveInterval();
+        };
+        this.handlePageHide = (event)=>{
+            if (event.persisted) {
+                this.pauseActiveInterval();
+                return;
+            }
+            this.pendingVisiblePresentation = null;
+            this.end("page_exit");
+            this.flushTerminalActivities();
+        };
+        this.handlePageShow = ()=>{
+            this.resumeVisibleLifecycle();
+        };
+        if (typeof document !== "undefined") {
+            __nativeDocumentAddEventListener("visibilitychange", this.handleVisibilityChange);
+        }
+        if (typeof window !== "undefined") {
+            __nativeWindowAddEventListener("pagehide", this.handlePageHide);
+            __nativeWindowAddEventListener("pageshow", this.handlePageShow);
+        }
+    }
+}
+function assetKeyFor(message) {
+    switch(message.type){
+        case "present_deck":
+            return message.type + ":" + message.deckId;
+        case "present_video":
+            return message.type + ":" + message.presentationId;
+        case "present_content":
+            return message.type + ":" + message.slideId;
+    }
+}
+function titleFor(message) {
+    var _ref, _message_deckTitle, _message_presentationTitle, _message_slideTitle;
+    if (message.type === "present_deck") return (_ref = (_message_deckTitle = message.deckTitle) != null ? _message_deckTitle : message.pageTitle) != null ? _ref : "";
+    if (message.type === "present_video") return (_message_presentationTitle = message.presentationTitle) != null ? _message_presentationTitle : message.sectionTitle;
+    return (_message_slideTitle = message.slideTitle) != null ? _message_slideTitle : "";
+}
+function totalSlidesFor(message) {
+    var _message_slides, _message_slideImageUrls;
+    if (message.type === "present_content") return 1;
+    if (message.type === "present_video") return 0;
+    return message.totalSlides || ((_message_slides = message.slides) == null ? void 0 : _message_slides.length) || ((_message_slideImageUrls = message.slideImageUrls) == null ? void 0 : _message_slideImageUrls.length) || 1;
+}
+function createLifecycleId() {
+    if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+        return crypto.randomUUID();
+    }
+    return esm_browser_v4();
+}
+/* export default */ const presentation_telemetry_store = ((/* unused pure expression or super */ null && (PresentationTelemetryStore)));
+
+var presentation_telemetry_store_default = /* unused export */ undefined;
+export { PresentationTelemetryStore };
+export default presentation_telemetry_store_default;