@qualified-salesforce/web 0.0.1-oidc-bootstrap

package/widget/api_handler/base_api_handler.js

@@ -0,0 +1,249 @@
+import { __webpack_require__ } from "../../js/runtime.js";
+import { _class_private_field_loose_base, _class_private_field_loose_key } from "../../js/4101.js";
+import { isIframed } from "../../src/iframes.js";
+import { isIn } from "../../src/utils.js";
+import { default as WidgetObject } from "../widget_object.js";
+
+__webpack_require__("67353");
+const isFunction = __webpack_require__("42902");
+var isFunction_default = /*#__PURE__*/__webpack_require__.n(isFunction);
+
+
+
+
+
+
+
+const API_VERBS = (/* unused pure expression or super */ null && ([
+    "initialize",
+    "open",
+    "initPardotForm",
+    "initPardotFormThankYou",
+    "parsePardotForm",
+    "parsePardotFormForLandingPage",
+    "saveFormData",
+    "saveSmartFormData",
+    "sendSmartFormData",
+    "pardotFormSubmitted",
+    "showExperience",
+    "endExperience",
+    "registerForm",
+    "showForm",
+    "showFormExperience",
+    "showExperienceForForm",
+    "refreshVisitorState",
+    "getIdentity",
+    "handleEvents",
+    "handleMessengerEvents",
+    "handleWidgetEvents",
+    "identify",
+    "page",
+    "setCookieConsent",
+    "teardown",
+    "emitFormFill",
+    "submitEmbeddedForm",
+    "logDebugEvent",
+    "setChatIsVisible",
+    "startCall",
+    "startChat"
+]));
+const API_VERBS_ALLOWED_FOR_ACTIONS = [
+    "open",
+    "showExperience"
+];
+const PARDOT_EMAIL_SELECTOR = "p.email input, div.email input";
+/**
+ * List of API properties that should be preserved when the qualified object is replaced.
+ * These are sub-APIs that can be registered independently (e.g., via separate scripts).
+ */ const API_PROPERTIES = [
+    "docking",
+    "sentinel"
+];
+var // TODO get classPrivateMethods working for eslint below....
+// E.g. <button data-qualified-action="doit"
+//              data-qualified-arg="value1"
+//              data-qualified-arg-1="value2"/>
+//
+_initDeclarativeApi = /*#__PURE__*/ _class_private_field_loose_key("_initDeclarativeApi"), _initSmartForms = /*#__PURE__*/ _class_private_field_loose_key("_initSmartForms"), /**
+   * Extract only the known API properties from an object.
+   */ _getPreservedProperties = /*#__PURE__*/ _class_private_field_loose_key("_getPreservedProperties");
+class BaseApiHandler extends WidgetObject {
+    init() {
+        var _this = this;
+        // Ensure all public facing objects exist. Usually created by the preamble before <script> we
+        // give to customers in the snippet.
+        if (!window.QualifiedObject) {
+            window.QualifiedObject = "qualified";
+        }
+        const qObjName = window.QualifiedObject, qObj = window[qObjName], hasEnqueued = isFunction_default()(qObj) && Array.isArray(qObj.q) && qObj.q.length > 0;
+        if (hasEnqueued) {
+            const queue = qObj.q;
+            // Prioritize execution of the first 'initialize' call if present.
+            const initializeIdx = queue.findIndex((fn)=>fn && fn[0] === "initialize");
+            if (initializeIdx !== -1) {
+                this.execute(...queue[initializeIdx]);
+                queue.splice(initializeIdx, 1);
+            }
+            // Save off remaining enqueued api calls
+            this.queue = queue;
+            delete qObj.q;
+        }
+        // Redefine public-facing API to use this handler.
+        // Preserve known sub-API properties (like .docking) from the old qualified object
+        const preservedProps = _class_private_field_loose_base(this, _getPreservedProperties)[_getPreservedProperties](qObj);
+        window[qObjName] = function() {
+            for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+                args[_key] = arguments[_key];
+            }
+            _this.execute(...args); // eslint-disable-line prefer-rest-params
+        };
+        Object.defineProperties(window[qObjName], preservedProps);
+        this.initialized = true;
+    }
+    cleanup() {
+        if (this.initialized) {
+            // Restore snippet's original qualified(...) function that queues up API calls.
+            // Preserve known sub-API properties (like .docking) from the current qualified object
+            const preservedProps = _class_private_field_loose_base(this, _getPreservedProperties)[_getPreservedProperties](window[window.QualifiedObject]);
+            window[window.QualifiedObject] = function() {
+                for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+                    args[_key] = arguments[_key];
+                }
+                window[window.QualifiedObject].q.push(args);
+            };
+            window[window.QualifiedObject].q = [];
+            Object.defineProperties(window[window.QualifiedObject], preservedProps);
+            this.initialized = false;
+        }
+        super.cleanup();
+    }
+    markReady() {
+        this.ready = true;
+        if (this.queue.length > 0) {
+            this.queue.forEach((args)=>this.execute(...args));
+            this.queue = [];
+        }
+    }
+    execute(fn) {
+        for(var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++){
+            args[_key - 1] = arguments[_key];
+        }
+        if (fn && this.handlers[fn]) {
+            if (this.ready || fn === "initialize") {
+                // Should execute immediately?
+                this.handlers[fn].apply(undefined, args);
+            } else {
+                this.queue.push([
+                    fn,
+                    ...args
+                ]);
+            }
+        } else {
+            console.warn("Qualified: Invalid API call '" + fn + "'."); // eslint-disable-line no-console
+        }
+    }
+    constructor(injectionProps, handlers){
+        super(injectionProps), Object.defineProperty(this, _getPreservedProperties, {
+            value: getPreservedProperties
+        }), Object.defineProperty(this, _initDeclarativeApi, {
+            writable: true,
+            value: void 0
+        }), Object.defineProperty(this, _initSmartForms, {
+            writable: true,
+            value: void 0
+        }), this.initialized = false, this.ready = false, _class_private_field_loose_base(this, _initDeclarativeApi)[_initDeclarativeApi] = ()=>{
+            [].slice.call(document.querySelectorAll("[data-qualified-action]")).forEach((el)=>{
+                // Parse API args from data attributes
+                const fn = el.dataset.qualifiedAction;
+                if (!isIn(API_VERBS_ALLOWED_FOR_ACTIONS, fn)) return;
+                const args = Object.keys(el.dataset).sort().reduce((args, name)=>{
+                    if (/^qualifiedArg/.test(name)) {
+                        var _exec;
+                        const foo = Number((_exec = /^qualifiedArg-([0-9])+/.exec(name)) == null ? void 0 : _exec[1]) || 0;
+                        args[foo] = el.dataset[name];
+                    }
+                    return args;
+                }, []);
+                const exec = ()=>this.execute(fn, ...args);
+                // Execute API call on click
+                // TODO: event type support?
+                el.addEventListener("click", exec);
+                this.callOnDispose(()=>el.removeEventListener("click", exec));
+            });
+        }, _class_private_field_loose_base(this, _initSmartForms)[_initSmartForms] = ()=>{
+            // TODO: mutation observer for dynamically generated forms
+            [].slice.call(document.querySelectorAll("[data-qualified-smart-form]")).forEach((el)=>{
+                // Save the original on submit and wrap it with our own
+                const { onsubmit } = el;
+                // Old smart form api specified data-qualified-smart-form="true"
+                const botApiName = el.dataset.qualifiedSmartForm === "true" ? "default" : el.dataset.qualifiedSmartForm, trigger = el.dataset.qualifiedSmartFormTrigger;
+                el.onsubmit = (e)=>{
+                    const returnValue = onsubmit ? onsubmit.call(el, e) : true;
+                    // eslint-disable-next-line no-useless-catch
+                    try {
+                        const fields = [].slice.call(e.target.querySelectorAll("[data-qualified-field]"));
+                        const fieldValues = fields.reduce((values, param)=>{
+                            let { dataset: { qualifiedField: apiName }, value, checked, type } = param;
+                            switch(type){
+                                case "checkbox":
+                                    values[apiName] = checked;
+                                    break;
+                                case "radio":
+                                    checked && (values[apiName] = value);
+                                    break;
+                                case "password":
+                                    break; // Never capture password fields
+                                default:
+                                    value.trim() && (values[apiName] = value);
+                            }
+                            return values;
+                        }, {});
+                        // If return value is `false`, or if `e.preventDefault()` was called,
+                        // the form will not submit and we can save gathered field values and
+                        // bot api name right away. Otherwise, they'll be sent the next time
+                        // the messenger loads.
+                        //
+                        // If iframed, always trigger save immediately and it will be bubbled
+                        // up to the parent window.
+                        if (trigger === "submit" || trigger !== "redirect" && (returnValue === false || e.defaultPrevented) || isIframed()) {
+                            this.execute("sendSmartFormData", fieldValues, botApiName);
+                        } else {
+                            this.execute("saveSmartFormData", fieldValues, botApiName);
+                        }
+                    } catch (e) {
+                        // TODO: sentry
+                        throw e;
+                    }
+                    return returnValue;
+                };
+                this.callOnDispose(()=>el.onsubmit = onsubmit);
+            });
+        };
+        // For safety, check that a handler is defined for all verbs and that all
+        // verbs are declared
+        if (false) {}
+        this.handlers = handlers;
+        this.queue = [];
+        _class_private_field_loose_base(this, _initDeclarativeApi)[_initDeclarativeApi]();
+        _class_private_field_loose_base(this, _initSmartForms)[_initSmartForms]();
+    }
+}
+function getPreservedProperties(obj) {
+    if (!obj) return {};
+    const descriptors = {};
+    for (const key of API_PROPERTIES){
+        if (key in obj) {
+            const descriptor = Object.getOwnPropertyDescriptor(obj, key);
+            if (descriptor) {
+                descriptors[key] = descriptor;
+            }
+        }
+    }
+    return descriptors;
+}
+/* export default */ const base_api_handler = (BaseApiHandler);
+
+var base_api_handler_API_VERBS = /* unused export */ undefined;
+var base_api_handler_API_VERBS_ALLOWED_FOR_ACTIONS = /* unused export */ undefined;
+export { PARDOT_EMAIL_SELECTOR, base_api_handler_API_VERBS as API_VERBS, base_api_handler_API_VERBS_ALLOWED_FOR_ACTIONS as API_VERBS_ALLOWED_FOR_ACTIONS };
+export default base_api_handler;

package/widget/booker_intent_tracker.js

@@ -0,0 +1,391 @@
+import { __webpack_require__ } from "../js/runtime.js";
+import "./utils/native_globals.js";
+import { _extends } from "../js/4101.js";
+
+/* provided dependency */ var __nativeWindowAddEventListener = __webpack_require__(68034).zh;
+/* provided dependency */ var __nativeDocumentAddEventListener = __webpack_require__(68034).Qj;
+/* provided dependency */ var __nativeWindowRemoveEventListener = __webpack_require__(68034).kZ;
+/* provided dependency */ var __nativeDocumentRemoveEventListener = __webpack_require__(68034).LA;
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Booker *intent* SLI — the window BEFORE an offer exists.
+//
+// `booker_outcome` (booker_outcome_tracker.ts) arms once an offer exists and
+// measures offer -> booker shown. This tracker measures the step before that:
+// something decided to offer a meeting -> the offer actually arrived. On the AI
+// pathway that window holds an LLM turn, meeting routing, and offer creation —
+// time the visitor sits waiting, without knowing why. It is invisible to
+// `booker_outcome`, which cannot arm until the offer it measures exists.
+//
+// The `outcome` facet is emitted exactly ONCE per intent (`offered` |
+// `abandoned_pre_offer` | `no_offer`) so the offer-made rate is a straight count
+// over the facet rather than a join.
+//
+// `no_offer` is only reportable where the client can see a terminal non-meeting
+// result. The form/CTA pathway can (the trigger response says so). The AI pathway
+// cannot — when the AI decides not to offer, the conversation simply continues —
+// so it sources that leg server-side from the `ai_offer_meeting_booker`
+// `decision_outcome` instead.
+//
+// Surface-agnostic on purpose: the form/CTA pathway arms the same tracker from a
+// click/submit instead of an AI signal.
+// ─────────────────────────────────────────────────────────────────────────────
+const BOOKER_INTENT_OUTCOME = {
+    OFFERED: "offered",
+    ABANDONED_PRE_OFFER: "abandoned_pre_offer",
+    /**
+   * The trigger resolved to something that is not a meeting. Only for pathways
+   * where the client can observe a *terminal* non-meeting result — on the AI
+   * pathway it cannot (the conversation just continues), so that one sources
+   * `no_offer` from the server `decision_outcome` instead.
+   */ NO_OFFER: "no_offer"
+};
+// Client-observed stages, deliberately NOT reused from the server's
+// `meeting_stage` vocabulary: the server's stages mean "the step executed",
+// these mean "the visitor experienced it". Colliding them would make the two
+// uncomparable within one facet.
+const BOOKER_INTENT_MEETING_STAGE = "booker_intent";
+const INTENT_TO_BOOKER_SHOWN_MEETING_STAGE = "intent_to_booker_shown";
+/**
+ * Trigger -> the questions arrived on the wire. **Not** the paint: the caller
+ * resolves this from `channel.ts`'s inbound handler, which runs before the
+ * payload is emitted to either renderer, so render and paint are excluded. Named
+ * `received` rather than `shown` for that reason — every other client stage here
+ * means "the visitor saw it", and this one cannot, because the questions render
+ * inside the messenger iframe while the trigger fired in the host realm.
+ *
+ * The *rest* of the qualification lifecycle is deliberately absent for the same
+ * cross-realm reason: the submit moment is unobservable from the host, and any
+ * interval spanning it would blend visitor think-time with our latency. That
+ * split is sourced from the server's `triggered_to_qq` / `qq_to_meeting_booker`.
+ */ const INTENT_TO_QUALIFICATION_RECEIVED_MEETING_STAGE = "intent_to_qualification_received";
+/**
+ * How long after a `visibilitychange` to hidden a `pagehide` still counts as the
+ * same unload sequence.
+ *
+ * Browsers dispatch `visibilitychange` -> hidden immediately *before* `pagehide`
+ * on an ordinary navigation, so a naive "was the tab ever hidden?" check treats
+ * every abandonment as backgrounded and silently drops its duration. The two
+ * events are sub-frame apart during unload, whereas a genuine background
+ * interval is orders of magnitude longer, so a short grace window separates them
+ * without needing to distinguish the event causes.
+ */ const UNLOAD_VISIBILITY_GRACE_MS = 200;
+/**
+ * Prefix for the per-intent "already counted" marker.
+ *
+ * `sessionStorage`, not `localStorage`: the marker only needs to outlive a reload
+ * within the same tab, which is exactly its scope, and it should not leak into a
+ * later visit.
+ */ const RESOLVED_INTENT_KEY_PREFIX = "qlfd:booker_intent_resolved:";
+class BookerIntentTracker {
+    /** True while an intent is being tracked, for callers that gate on it. */ get isArmed() {
+        return this.intent !== null;
+    }
+    arm(param) {
+        let { intentId, pathwayOrigin, conversationType, botApiName, scriptId, fromHistory = false } = param;
+        this.safely(()=>{
+            var _this_intent;
+            if (((_this_intent = this.intent) == null ? void 0 : _this_intent.intentId) === intentId) return;
+            // A reload mid-wait sends the old page a non-persisted `pagehide`, which
+            // already reported this intent's terminal outcome. Re-arming from the
+            // hydrated message would let the same intent report a second one — an
+            // `offered` here against the `abandoned_pre_offer` the old page sent — and
+            // put one journey in the SLI denominator twice. `fromHistory` alone cannot
+            // see that: the outcome was emitted by a different JS context.
+            if (fromHistory && this.alreadyResolved(intentId)) return;
+            this.teardown();
+            const hidden = !this.documentVisible();
+            this.intent = {
+                intentId,
+                pathwayOrigin,
+                conversationType,
+                botApiName,
+                scriptId,
+                startedAtMs: this.nowMs(),
+                // No `performance` means no honest duration; keep the outcome, drop the timing.
+                measureTiming: !fromHistory && typeof performance !== "undefined",
+                fromHistory,
+                outcomeEmitted: false,
+                shownEmitted: false,
+                qualificationReceivedEmitted: false,
+                // A tab already hidden at arm time is as untrustworthy as one hidden later.
+                wasEverHidden: hidden,
+                hiddenAtMs: hidden ? this.nowMs() : undefined
+            };
+            if (typeof window !== "undefined") {
+                __nativeWindowAddEventListener("pagehide", this.handlePagehide);
+            }
+            if (typeof document !== "undefined") {
+                __nativeDocumentAddEventListener("visibilitychange", this.handleVisibilityChange);
+            }
+        });
+    }
+    /**
+   * The qualification questions arrived on the wire — **not** painted. Callers
+   * resolve this from the inbound channel handler, which runs before the payload
+   * reaches a renderer, so the emitted `intent_to_qualification_received` excludes
+   * render and paint. Naming it otherwise would invite consumers to read this
+   * latency as time-to-visible, which it is not and cannot be from the host realm.
+   *
+   * Then **stays armed**: the questions are not a terminal outcome — the
+   * booker can still arrive in a later broadcast once they are answered, and
+   * resolving here would misclassify every questions-then-booker journey as a
+   * failure. Most questions journeys do not reach a booker (prod 7d:
+   * `triggered_to_qq` 24,543 vs `qq_to_meeting_booker` 2,532), which is expected
+   * product behaviour and must never count as a booker failure.
+   */ markQualificationReceived() {
+        this.safely(()=>{
+            const { intent } = this;
+            if (!intent || intent.qualificationReceivedEmitted) return;
+            // Claimed before the timing check, deliberately. Untrustworthy timing is
+            // monotonic within an intent: `measureTiming` is fixed at arm, and
+            // `wasEverHidden` latches true the moment a hidden tab returns and is never
+            // cleared. So a call that finds no timing guarantees every later call finds
+            // none either — leaving the flag unset would invite a retry that cannot
+            // succeed.
+            //
+            // Single-shot is also the only correct model, and not merely a duplicate
+            // guard. A flow can paint many gathers — the server strips exactly this
+            // case in `remove_looped_messages` when a rematching visitor loops the
+            // questions. Only `intent -> first gather` is free of visitor input; every
+            // later interval contains the visitor answering the previous gather, so
+            // emitting one under this stage would mix think-time into a latency facet.
+            intent.qualificationReceivedEmitted = true;
+            // Timing-only line, no `outcome` facet: with no trustworthy duration there
+            // is nothing left to report, so skip it rather than emit an empty row. Same
+            // rule as `markShown`.
+            const timing = this.timing(intent);
+            if (timing.timing === undefined) return;
+            this.emit(intent, _extends({
+                meeting_stage: INTENT_TO_QUALIFICATION_RECEIVED_MEETING_STAGE
+            }, timing));
+        });
+    }
+    /**
+   * The trigger reached a terminal non-meeting result. Callers must pass only
+   * genuinely terminal signals — never "qualification questions were shown",
+   * which is a waypoint (see `markQualificationReceived`).
+   */ markNoOffer() {
+        this.safely(()=>{
+            const { intent } = this;
+            if (!intent || intent.outcomeEmitted) return;
+            intent.outcomeEmitted = true;
+            const timing = this.timing(intent);
+            // Release before emitting: a throwing transport must not strand the
+            // listeners, and `safely()` would otherwise unwind past this cleanup.
+            this.teardown();
+            this.intent = null;
+            this.emit(intent, _extends({
+                meeting_stage: BOOKER_INTENT_MEETING_STAGE,
+                outcome: BOOKER_INTENT_OUTCOME.NO_OFFER
+            }, timing));
+        });
+    }
+    /** The offer arrived: closes the outcome facet, keeps the window open for `shown`. */ markOffered(offerMessageId, param) {
+        let { calendarEventTypeId } = param === void 0 ? {} : param;
+        this.safely(()=>{
+            const { intent } = this;
+            if (!intent || intent.outcomeEmitted) return;
+            intent.outcomeEmitted = true;
+            intent.offerMessageId = offerMessageId;
+            // Only knowable once an offer exists, so it is absent from any line emitted
+            // before this point rather than backfilled onto them.
+            intent.calendarEventTypeId = calendarEventTypeId;
+            this.emit(intent, _extends({
+                meeting_stage: BOOKER_INTENT_MEETING_STAGE,
+                outcome: BOOKER_INTENT_OUTCOME.OFFERED,
+                offer_message_id: offerMessageId
+            }, this.timing(intent)));
+        });
+    }
+    /**
+   * The booker painted: emits the visitor-experienced total (intent -> shown).
+   * With `booker_outcome`'s offer -> shown timing this decomposes as
+   * `total = intent->offer + offer->shown`, so a bad total attributes to either
+   * the upstream wait or the client render.
+   */ markShown(offerMessageId) {
+        this.safely(()=>{
+            const { intent } = this;
+            if (!intent || !intent.outcomeEmitted || intent.shownEmitted) return;
+            // Only the offer this intent produced closes this window; a later offer
+            // belongs to its own intent.
+            if (intent.offerMessageId !== offerMessageId) return;
+            intent.shownEmitted = true;
+            // Unlike the outcome events, this line exists *only* to carry the timing —
+            // it has no `outcome` facet (which would double-count the SLI denominator).
+            // With no trustworthy timing there is nothing left to report, so skip it.
+            const timing = this.timing(intent);
+            // Release before emitting: a throwing transport must not strand the
+            // listeners, and `safely()` would otherwise unwind past this cleanup.
+            this.teardown();
+            this.intent = null;
+            if (timing.timing !== undefined) {
+                this.emit(intent, _extends({
+                    meeting_stage: INTENT_TO_BOOKER_SHOWN_MEETING_STAGE,
+                    offer_message_id: offerMessageId
+                }, timing));
+            }
+        });
+    }
+    dispose() {
+        this.safely(()=>{
+            this.teardown();
+            this.intent = null;
+        });
+    }
+    /**
+   * Elapsed time since intent, or nothing when it cannot be trusted.
+   *
+   * Backgrounded tabs carry the whole backgrounded interval in their wall clock —
+   * the defect CORE-2607 fixed on the standalone TTI metric, where the 30-day max
+   * reached ~9 days. Omitting the field (rather than emitting a wrong number)
+   * keeps the outcome counts complete while leaving the latency distribution
+   * honest. No rAF deferral is needed: the callers already fire from a rendered
+   * component's effect, i.e. after the paint they report on.
+   */ timing(intent, param) {
+        let { atUnload = false } = param === void 0 ? {} : param;
+        if (!intent.measureTiming) return {};
+        if (intent.wasEverHidden) return {};
+        if (intent.hiddenAtMs !== undefined) {
+            // Hidden right now. During unload that is just the `visibilitychange` that
+            // precedes `pagehide`; any longer stretch is a real background interval.
+            const hiddenForMs = this.nowMs() - intent.hiddenAtMs;
+            if (!atUnload || hiddenForMs > UNLOAD_VISIBILITY_GRACE_MS) return {};
+        } else if (!atUnload && !this.documentVisible()) {
+            return {};
+        }
+        const elapsed = Math.round(this.nowMs() - intent.startedAtMs);
+        return Number.isFinite(elapsed) && elapsed >= 0 ? {
+            timing: elapsed
+        } : {};
+    }
+    emit(intent, extra, fireAndForget) {
+        if (fireAndForget === void 0) fireAndForget = false;
+        // Marked here rather than at each call site: this is the one place a terminal
+        // outcome leaves the tracker, and lines without an `outcome` facet (the
+        // timing-only `intent_to_booker_shown`) must not claim the intent.
+        if (extra.outcome) this.markResolved(intent.intentId);
+        this.log(_extends({
+            type: "log",
+            message: "booker_intent",
+            extra: _extends({}, this.surface ? {
+                surface: this.surface
+            } : {}, {
+                pathway_origin: intent.pathwayOrigin,
+                conversation_type: intent.conversationType
+            }, intent.botApiName ? {
+                bot_api_name: intent.botApiName
+            } : {}, intent.scriptId ? {
+                script_id: intent.scriptId
+            } : {}, intent.calendarEventTypeId ? {
+                calendar_event_type_id: intent.calendarEventTypeId
+            } : {}, extra)
+        }, fireAndForget ? {
+            fireAndForget: true
+        } : {}));
+    }
+    /**
+   * Records that this intent has reported a terminal outcome, so a later page in
+   * the same tab does not report a second one.
+   *
+   * Storage can be unavailable — third-party-cookie blocking and some embeds throw
+   * on access. Failing silently degrades to the previous behaviour (a reload
+   * mid-wait may double-count) rather than breaking the booker, which is the right
+   * trade for instrumentation.
+   */ markResolved(intentId) {
+        try {
+            window.sessionStorage.setItem("" + RESOLVED_INTENT_KEY_PREFIX + intentId, "1");
+        } catch (unused) {
+        // Intentionally swallowed — see above.
+        }
+    }
+    alreadyResolved(intentId) {
+        try {
+            return window.sessionStorage.getItem("" + RESOLVED_INTENT_KEY_PREFIX + intentId) !== null;
+        } catch (unused) {
+            return false;
+        }
+    }
+    nowMs() {
+        return typeof performance !== "undefined" ? performance.now() : 0;
+    }
+    documentVisible() {
+        if (typeof document === "undefined") return true;
+        return document.visibilityState === "visible";
+    }
+    teardown() {
+        if (typeof window !== "undefined") {
+            __nativeWindowRemoveEventListener("pagehide", this.handlePagehide);
+        }
+        if (typeof document !== "undefined") {
+            __nativeDocumentRemoveEventListener("visibilitychange", this.handleVisibilityChange);
+        }
+    }
+    // This tracker is pure observability; a fault here must never disrupt the
+    // booker it instruments. Every public entry point and event handler runs
+    // through this guard, so a broken transport (or an exotic browser API) drops
+    // one SLI datapoint instead of throwing into the conversation's message path.
+    safely(fn) {
+        try {
+            fn();
+        } catch (unused) {
+        // Intentionally swallowed: losing a datapoint is strictly preferable to
+        // breaking the meeting booker.
+        }
+    }
+    constructor({ surface, log }){
+        this.intent = null;
+        // Abandonment rides on `pagehide` (fires reliably on tab close, navigation,
+        // refresh) but skips bfcache transitions (`persisted`) — the page can be
+        // restored, so the visitor has not left. `visibilitychange:hidden` is
+        // deliberately not used as the trigger; it fires on plain tab switches too.
+        this.handlePagehide = (event)=>{
+            this.safely(()=>{
+                if (event.persisted) return;
+                const { intent } = this;
+                if (!intent || intent.outcomeEmitted) return;
+                // Once the offer exists, leaving is `booker_outcome`'s `abandoned`.
+                // Emitting here as well would count one visitor in two SLIs.
+                // A hydrated intent never reports abandonment at all (see `fromHistory`).
+                if (intent.fromHistory) return;
+                intent.outcomeEmitted = true;
+                const timing = this.timing(intent, {
+                    atUnload: true
+                });
+                // Release before emitting, as in `markShown`.
+                this.teardown();
+                this.intent = null;
+                this.emit(intent, _extends({
+                    meeting_stage: BOOKER_INTENT_MEETING_STAGE,
+                    outcome: BOOKER_INTENT_OUTCOME.ABANDONED_PRE_OFFER
+                }, timing), // Fires during page teardown; cannot wait for a response.
+                true);
+            });
+        };
+        /**
+   * Records backgrounding, but only counts it against the timing once the tab
+   * comes *back*. A tab that goes hidden and never returns is either the unload
+   * sequence (harmless, handled by the grace window) or a background interval
+   * that `timing` catches via `hiddenAtMs`.
+   */ this.handleVisibilityChange = ()=>{
+            this.safely(()=>{
+                const { intent } = this;
+                if (!intent) return;
+                if (this.documentVisible()) {
+                    if (intent.hiddenAtMs !== undefined) intent.wasEverHidden = true;
+                    intent.hiddenAtMs = undefined;
+                } else {
+                    intent.hiddenAtMs = this.nowMs();
+                }
+            });
+        };
+        this.surface = surface;
+        this.log = log;
+    }
+}
+
+var booker_intent_tracker_BOOKER_INTENT_MEETING_STAGE = /* unused export */ undefined;
+var booker_intent_tracker_BOOKER_INTENT_OUTCOME = /* unused export */ undefined;
+var booker_intent_tracker_INTENT_TO_BOOKER_SHOWN_MEETING_STAGE = /* unused export */ undefined;
+var booker_intent_tracker_INTENT_TO_QUALIFICATION_RECEIVED_MEETING_STAGE = /* unused export */ undefined;
+export { BookerIntentTracker, booker_intent_tracker_BOOKER_INTENT_MEETING_STAGE as BOOKER_INTENT_MEETING_STAGE, booker_intent_tracker_BOOKER_INTENT_OUTCOME as BOOKER_INTENT_OUTCOME, booker_intent_tracker_INTENT_TO_BOOKER_SHOWN_MEETING_STAGE as INTENT_TO_BOOKER_SHOWN_MEETING_STAGE, booker_intent_tracker_INTENT_TO_QUALIFICATION_RECEIVED_MEETING_STAGE as INTENT_TO_QUALIFICATION_RECEIVED_MEETING_STAGE };