@qualified-salesforce/web 0.0.1-oidc-bootstrap

package/widget/debug_mode_state.js

@@ -0,0 +1,175 @@
+import { __webpack_require__ } from "../js/runtime.js";
+import { default as images_close } from "../images/close.js";
+import { default as logo_logo } from "../images/logo.js";
+import { safeSet, safeGet } from "../src/localstorage.js";
+import "./utils/native_globals.js";
+
+/* provided dependency */ var __nativeWindowAddEventListener = __webpack_require__(68034).zh;
+
+
+
+const MAX_DURATION_THIRTY_MINUTES_MS = 30 * 60 * 1000;
+const LOCAL_KEYS = {
+    DEBUG_STORE: "debug_store",
+    SUBMITTED: "submitted_store"
+};
+const debugLinkId = "debugLink";
+const SAVE_FORM_DATA_NOT_CALLED_MESSAGE = '[Error] "saveFormData" was not called.';
+const SHOW_FORM_EXPERIENCE_NOT_CALLED_MESSAGE = '[Error] "showFormExperience" was not called.';
+const HEADER = "Results from your form submission\n";
+const SUCCESS_FOOTER = "Congratulations! This form is successfully set up. If the Experience is still not appearing, please ask your Qualified admin to make sure that the Experience is enabled and properly configured.";
+const ERROR_FOOTER = "There are problems with this form setup. Please address the issues above and try again.";
+const ELEMENT_PADDING = "16px";
+const centerBannerCalculationStringify = (maxWidth)=>{
+    return "calc(50% - " + maxWidth + "/2 + " + ELEMENT_PADDING + ")";
+};
+const constructDebugMessage = ()=>{
+    var _DebugModeState_getApiMessage, _DebugModeState_getApiMessage1;
+    const debugMessages = [];
+    debugMessages.push(HEADER);
+    const saveFormData = (_DebugModeState_getApiMessage = DebugModeState.getApiMessage("saveFormData")) != null ? _DebugModeState_getApiMessage : SAVE_FORM_DATA_NOT_CALLED_MESSAGE;
+    debugMessages.push(saveFormData);
+    const showFormExperienceLog = (_DebugModeState_getApiMessage1 = DebugModeState.getApiMessage("showFormExperience")) != null ? _DebugModeState_getApiMessage1 : SHOW_FORM_EXPERIENCE_NOT_CALLED_MESSAGE;
+    debugMessages.push(showFormExperienceLog);
+    debugMessages.push("");
+    const errorMessage = saveFormData.includes("[Error]") || showFormExperienceLog.includes("[Error]");
+    errorMessage ? debugMessages.push(ERROR_FOOTER) : debugMessages.push(SUCCESS_FOOTER);
+    return debugMessages;
+};
+const BANNER_STYLE = {
+    padding: ELEMENT_PADDING,
+    position: "fixed",
+    maxWidth: "400px",
+    bottom: "0",
+    fontSize: "16px",
+    backgroundColor: "#6558FF",
+    borderRadius: "8px 8px 0px 0px",
+    left: centerBannerCalculationStringify("400px"),
+    zIndex: 2147483647 // Max z-index value, debug buttons should be at top layer
+};
+const LABEL_STYLE = {
+    paddingLeft: ELEMENT_PADDING,
+    paddingRight: ELEMENT_PADDING,
+    color: "#FFFFFF",
+    fontFamily: "sans-serif",
+    lineHeight: "1.5"
+};
+const EXIT_STYLE = {
+    height: "12px",
+    paddingLeft: ELEMENT_PADDING,
+    alignSelf: "center",
+    width: "30px"
+};
+const LOGO_STYLE = {
+    height: "25px",
+    filter: "invert(1)",
+    width: "21px"
+};
+const updateFormSubmissionLabel = (label)=>{
+    label.innerText = "Form submission detected";
+};
+const updateFormSubmissionBanner = (banner)=>{
+    banner.style.maxWidth = "490px";
+    banner.style.left = centerBannerCalculationStringify("490px");
+};
+const generateDebugLogLink = ()=>{
+    const debugLogLink = document.createElement("div");
+    Object.assign(debugLogLink.style, LABEL_STYLE);
+    debugLogLink.style.textDecoration = "underline";
+    debugLogLink.style.fontWeight = "600";
+    debugLogLink.innerText = "View debug report";
+    debugLogLink.id = debugLinkId;
+    return debugLogLink;
+};
+const createBanner = ()=>{
+    const banner = document.createElement("div");
+    Object.assign(banner.style, BANNER_STYLE);
+    return banner;
+};
+const updateBannerAfterSubmission = (banner, label, exit)=>{
+    updateFormSubmissionBanner(banner);
+    updateFormSubmissionLabel(label);
+    const debugInfoAlreadyExists = document.getElementById(debugLinkId);
+    if (!debugInfoAlreadyExists) {
+        const debugInfo = generateDebugLogLink();
+        debugInfo.addEventListener("click", ()=>{
+            const debugMessages = constructDebugMessage();
+            alert(debugMessages.join("\n"));
+        });
+        label.insertAdjacentElement("afterend", debugInfo);
+    }
+};
+const createLabel = ()=>{
+    const label = document.createElement("div");
+    Object.assign(label.style, LABEL_STYLE);
+    label.innerText = "Submit a form to test your experience";
+    return label;
+};
+const createLogo = (host)=>{
+    const logoImage = document.createElement("img");
+    logoImage.src = "" + host + logo_logo;
+    Object.assign(logoImage.style, LOGO_STYLE);
+    return logoImage;
+};
+const createExit = (host, banner)=>{
+    const exitButton = document.createElement("img");
+    Object.assign(exitButton.style, EXIT_STYLE);
+    exitButton.src = "" + host + images_close;
+    exitButton.addEventListener("click", ()=>{
+        banner.remove();
+        safeSet(LOCAL_KEYS.SUBMITTED, false);
+        DebugModeState.exitDebugMode();
+    });
+    return exitButton;
+};
+const showDebugBanner = (host)=>{
+    const logo = createLogo(host);
+    const banner = createBanner();
+    const exitButton = createExit(host, banner);
+    const label = createLabel();
+    const parentLabel = document.createElement("div");
+    parentLabel.style.display = "flex";
+    parentLabel.append(logo);
+    parentLabel.append(label);
+    parentLabel.append(exitButton);
+    banner.append(parentLabel);
+    // Changes after submission
+    __nativeWindowAddEventListener("submit", ()=>{
+        updateBannerAfterSubmission(banner, label, exitButton);
+        safeSet(LOCAL_KEYS.SUBMITTED, true);
+    });
+    if (safeGet(LOCAL_KEYS.SUBMITTED)) {
+        updateBannerAfterSubmission(banner, label, exitButton);
+    }
+    document.body.appendChild(banner);
+};
+class DebugModeState {
+}
+DebugModeState.initializeDebugMode = ()=>{
+    safeSet(LOCAL_KEYS.DEBUG_STORE, {
+        startTime: Date.now(),
+        apiCalls: {}
+    });
+};
+DebugModeState.exitDebugMode = ()=>{
+    safeSet(LOCAL_KEYS.DEBUG_STORE, undefined);
+};
+DebugModeState.isInDebugMode = ()=>{
+    const debugState = safeGet(LOCAL_KEYS.DEBUG_STORE);
+    return debugState && Date.now() - debugState.startTime < MAX_DURATION_THIRTY_MINUTES_MS;
+};
+DebugModeState.setApiMessage = (api, status, statement)=>{
+    const debugState = safeGet(LOCAL_KEYS.DEBUG_STORE);
+    if (!debugState) return;
+    debugState.apiCalls[api] = "[" + status + "] " + statement;
+    safeSet(LOCAL_KEYS.DEBUG_STORE, debugState);
+};
+DebugModeState.getApiMessage = (api)=>{
+    const debugState = safeGet(LOCAL_KEYS.DEBUG_STORE);
+    if (!debugState) return null;
+    return debugState.apiCalls[api];
+};
+
+
+export { showDebugBanner };
+export default DebugModeState;

package/widget/dummy_module.js

@@ -0,0 +1,9 @@
+class DummyModule {
+    init() {
+    // No-op: dummy module for testing code splitting
+    }
+}
+/* export default */ const dummy_module = (DummyModule);
+
+export { DummyModule };
+export default dummy_module;

package/widget/eloqua_visitor.js

@@ -0,0 +1,17 @@
+import { api } from "../js/4101.js";
+
+
+class EloquaVisitor {
+    getToken() {
+        const cookie = api.get("ELOQUA");
+        let token = cookie == null ? void 0 : cookie.split("GUID=")[1];
+        if (token) {
+            // e.g. FEF813779AC54D40868E60219D780B39&FPCVISITED=1, we ignore extra params
+            token = token.split("&")[0];
+        }
+        return token;
+    }
+}
+/* export default */ const eloqua_visitor = (EloquaVisitor);
+
+export default eloqua_visitor;

package/widget/form_cta_booker_intent.js

@@ -0,0 +1,246 @@
+import { BookerIntentTracker } from "./booker_intent_tracker.js";
+import { BOOKER_PATHWAY_ORIGIN } from "./booker_outcome_tracker.js";
+import { serverLogger } from "./server-logger.js";
+
+
+
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Form/CTA pre-offer booker SLI (host realm).
+//
+// A visitor submits a smart form or clicks a CTA, watches a spinner, and either
+// gets a booker or doesn't. `booker_outcome` can't see any of that — it arms only
+// once an offer exists — so an abandoned spinner produced no signal at all.
+//
+// Everything here lives in the HOST realm, which turns out to be where the
+// answers are: the trigger fires host-side (`tracker.ts`), and `channel.ts`
+// receives the trigger's response before handing it to either renderer, so the
+// same realm sees whether that response carried an offer, qualification
+// questions, or a dead end. The one thing it cannot see is the booker *painting*
+// — the legacy booker renders inside the messenger iframe — which arrives via the
+// `serverLog` bridge instead (see `observeBookerOutcome`).
+//
+// Deliberately NOT built on ButtonsFormsTriggeringTracer, which already collects
+// similar data and discards it two ways: its root span finishes only when a
+// response arrives (so an abandoning visitor never flushes), and its transport is
+// the sampled OTLP/APM path rather than unsampled flex logs.
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * One tracker for the host page. `surface` is omitted: at trigger time nothing has
+ * decided whether the booker will render in the legacy iframe or the multimodal
+ * lightbox, and guessing would put a wrong value on a failure-localization facet.
+ */ const tracker = new BookerIntentTracker({
+    log: (params)=>serverLogger.serverLog(params)
+});
+// A form/CTA trigger always produces an `element` conversation, which the server
+// classifies as `pathway_origin: form`. Passed as literals rather than derived:
+// the usual derivation reads the offer's `source`, and at trigger time there is
+// no offer — it would classify every form/CTA intent as `chat`.
+const FORM_CTA_CONVERSATION_TYPE = "element";
+/**
+ * The only events whose payload holds messages belonging to the armed trigger.
+ *
+ * Mirrors the two message-carrying cases in
+ * `ButtonsFormsTriggeringTracer.extractAttributesIfFormsOrButtonsResponse`
+ * (`fullscreenMBOrQQ` and `asyncFullscreenMBOrQQ`); its other two cases are
+ * message-less and handled by `isTerminalNonMeeting`.
+ */ const TRIGGER_MESSAGE_EVENTS = [
+    "initElementConversation",
+    // The same initial response, for a `qualified_form?` bot: the server picks the
+    // event name off the bot type (`broadcasting.rb:309`), and that payload's
+    // allowed messages include `calendar_event_offer`
+    // (`qualified_form/constants.ts`). Omitting it dropped those offers entirely,
+    // leaving the trigger armed to report `abandoned_pre_offer` for a form that
+    // succeeded.
+    "initQualifiedFormElementConversation",
+    "elementMessage"
+];
+/**
+ * The broadcast carries messages in two shapes, and the difference is invisible
+ * from the client. `initElementConversation` sends `payload.messages`, but
+ * `Message#broadcast_to_visitor` serializes a *single* message and broadcasts it
+ * as `elementMessage` with the message itself as the payload — which is the
+ * async-after-routing path, and therefore the common one for a routed form.
+ * Reading only `payload.messages` missed those offers entirely and let them fall
+ * through to `abandoned_pre_offer`.
+ */ function messagesIn(message) {
+    // Scoped to the two events that carry a trigger's own messages, the same way
+    // `isTerminalNonMeeting` scopes the other two. Without this the bare-payload
+    // branch below also matches chat traffic: `Message#broadcast_to_visitor` sends
+    // element conversations as `elementMessage` and *everything else* as `message`,
+    // with an identically shaped payload — so a rep's offer, or an AI `auto_respond`
+    // one, would close a form/CTA intent that never produced it, while the trigger's
+    // real offer was still in flight.
+    if (!TRIGGER_MESSAGE_EVENTS.includes(message == null ? void 0 : message.event)) return [];
+    const payload = message == null ? void 0 : message.payload;
+    if (!payload) return [];
+    if (Array.isArray(payload.messages)) return payload.messages;
+    // A bare serialized message: recognised by carrying its own `type`.
+    return payload.type ? [
+        payload
+    ] : [];
+}
+/**
+ * Arms the SLI at a form submit or CTA click.
+ *
+ * **Last write wins.** This is the only meeting pathway where two intents can
+ * overlap on one page — a visitor can submit a form, wait, then click a CTA — and
+ * a second trigger replaces the first, which is then dropped without an outcome.
+ * Deliberate: a superseded trigger has no honest outcome to report. Calling it
+ * `abandoned_pre_offer` would be wrong, because a CTA click that opens a form the
+ * visitor then submits is *one* journey with two triggers, and that reading would
+ * report a failure for a journey that succeeded. Dropping it undercounts the
+ * denominator slightly; inventing an outcome would corrupt the numerator.
+ */ function armFormCtaBookerIntent(intentId, botApiName) {
+    tracker.arm({
+        intentId,
+        pathwayOrigin: BOOKER_PATHWAY_ORIGIN.FORM,
+        conversationType: FORM_CTA_CONVERSATION_TYPE,
+        botApiName
+    });
+}
+/**
+ * Classifies a trigger response, mirroring the conditions
+ * `ButtonsFormsTriggeringTracer.extractAttributesIfFormsOrButtonsResponse` uses
+ * for `app.experience_result_type` (kept independent of that module rather than
+ * widening its private API — see the file header).
+ *
+ * Called for every inbound channel message and no-ops unless a trigger is armed,
+ * so unrelated traffic costs one boolean.
+ */ function resolveFormCtaBookerIntent(message) {
+    // Checked before the guard, not inside it: this runs on every inbound message,
+    // and nothing is armed for the vast majority of them. `isArmed` reads one field
+    // and cannot throw, so the common path costs a comparison rather than a closure
+    // plus a try block. Everything that *can* throw — reading the untyped payload —
+    // stays inside.
+    if (!tracker.isArmed) return;
+    safely(()=>{
+        // Socket payloads are not typed at runtime, and this runs inside the widget's
+        // inbound message loop — a shape we didn't anticipate must cost a datapoint,
+        // not the conversation.
+        const messages = messagesIn(message);
+        const offer = messages.find((entry)=>(entry == null ? void 0 : entry.type) === "calendar_event_offer");
+        if (offer) {
+            // Branch on the offer's *presence*, not on it having an id. An offer message
+            // proves this trigger was not a dead end, so falling through to the terminal
+            // check would report `no_offer` for a delivered offer — corrupting the
+            // numerator and the denominator at once.
+            if (offer.id) {
+                var _offer_calendarEventTypeId;
+                tracker.markOffered(offer.id, {
+                    calendarEventTypeId: (_offer_calendarEventTypeId = offer.calendarEventTypeId) == null ? void 0 : _offer_calendarEventTypeId.toString()
+                });
+            } else {
+                // No id means no join key, so there is no datapoint worth keeping — but
+                // simply returning would leave the intent armed, and a later `pagehide`
+                // would then report `abandoned_pre_offer` for a trigger that demonstrably
+                // produced an offer. Dropping it has to be explicit: losing one datapoint
+                // beats inventing a failure.
+                disposeFormCtaBookerIntent();
+            }
+            return;
+        }
+        // Questions are a waypoint, not an outcome — the booker can still arrive in a
+        // later broadcast. Record how fast they reached the client and stay armed.
+        // This runs from `channel.ts`'s inbound handler, before the payload is emitted
+        // to a renderer, so it measures arrival rather than paint — hence `received`.
+        if (messages.some((entry)=>(entry == null ? void 0 : entry.type) === "lightbox_gather")) {
+            tracker.markQualificationReceived();
+            return;
+        }
+        if (isTerminalNonMeeting(message)) tracker.markNoOffer();
+    });
+}
+/**
+ * Resolves the visitor-experienced total by observing `booker_outcome` as it
+ * transits the host `serverLog` passthrough.
+ *
+ * The booker renders in the messenger iframe, and the iframe->host event channel
+ * cannot carry an offer id: `MESSENGER_EVENTS` is a closed allowlist and
+ * `clientEvent` passes a name with no payload. The `serverLog` bridge already
+ * forwards the full payload, so the SLI it emits doubles as the cross-realm
+ * signal — no new bridge, no allowlist change. The same call also covers the
+ * same-realm multimodal lightbox, whose SLI takes the identical path.
+ */ function observeBookerOutcome(params) {
+    // Same reasoning as above: this sits on every `serverLog` call.
+    if (!tracker.isArmed) return;
+    safely(()=>{
+        var _params_extra, _params_extra1;
+        // `widget.serverLog` is a public passthrough the iframe bridge forwards
+        // arbitrary payloads into, so nothing here can assume a shape.
+        if ((params == null ? void 0 : params.message) !== "booker_outcome") return;
+        if (((_params_extra = params.extra) == null ? void 0 : _params_extra.outcome) !== "shown") return;
+        const offerMessageId = (_params_extra1 = params.extra) == null ? void 0 : _params_extra1.offer_message_id;
+        if (typeof offerMessageId === "string") tracker.markShown(offerMessageId);
+    });
+}
+/**
+ * Drops any armed intent and releases its `pagehide` / `visibilitychange`
+ * listeners.
+ *
+ * Needed in production, not just tests. This tracker is a module singleton, so
+ * unlike the multimodal one — which `RootStore#dispose` tears down — nothing
+ * otherwise unhooks it when the widget is destroyed. `Widget#onTeardown` and
+ * `onRefresh` both dispose and then restart, so an intent left armed across that
+ * boundary would keep its listeners and, on a later `pagehide`, report
+ * `abandoned_pre_offer` for a trigger belonging to the previous instance. The log
+ * is stamped with whatever session is current at POST time, so that outcome would
+ * land on a session that never produced it.
+ *
+ * Also used as the test seam, since "drop everything" is the same operation.
+ */ function disposeFormCtaBookerIntent() {
+    tracker.dispose();
+}
+/**
+ * Terminal results that mean "this trigger will never become a meeting": the
+ * widget opened instead (`initState` for a smart_cta/form conversation), or the
+ * script dead-ended and fell back to default website behaviour.
+ *
+ * Deliberately NOT "the response carried content we don't recognise". Broadcasts
+ * with unrecognised message types demonstrably occur mid-journey — that is the
+ * whole subject of the `triggered_to_no_content` / `no_renderable_content` work —
+ * and one arriving between the questions and the offer would resolve `no_offer`
+ * and disarm, so the real offer that followed would never be counted. An
+ * unrecognised broadcast leaves the tracker armed; if nothing follows, `pagehide`
+ * reports it as abandonment. That also matches the ticket's instruction to scope
+ * `no_offer` to the unambiguous client-terminal types and treat
+ * `abandoned_pre_offer` as an upper bound.
+ */ /**
+ * Both exported entry points run in hot shared paths — the widget's inbound
+ * message loop and the `serverLog` passthrough — so each is wrapped rather than
+ * relying on the tracker's internal guards, which only cover what happens *after*
+ * these functions have already read the payload.
+ */ function safely(fn) {
+    try {
+        fn();
+    } catch (unused) {
+    // Losing a datapoint is strictly preferable to breaking the conversation.
+    }
+}
+function isTerminalNonMeeting(message) {
+    var _ref;
+    var _message_payload;
+    const conversations = Array.isArray(message == null ? void 0 : (_message_payload = message.payload) == null ? void 0 : _message_payload.conversations) ? message.payload.conversations : [];
+    const lastConversation = conversations[conversations.length - 1];
+    if (message.event === "initState" && [
+        "smart_cta",
+        "form"
+    ].includes((_ref = lastConversation == null ? void 0 : lastConversation.triggeredByBotType) != null ? _ref : "")) {
+        return true;
+    }
+    // Any `closeLightbox` ends the journey, not just the `fallbackToDefault` one.
+    // The server broadcasts it from eight places and only one sets that flag
+    // (`visitor_types_processing.rb:354`); the other seven are equally dead ends —
+    // the experience produced no element conversation (`:350`), a rebroadcast found
+    // no element conversation to restore (`:369`, `conversation_task.rb:117`), a
+    // non-lightbox bot was triggered on a lightbox team (`:232`), a form or
+    // `bot_api_name` matched no bot (`conversation_task.rb:136`, `:145`), or the
+    // widget changed page views and closed the lightbox to unblock the page
+    // (`widget/lifecycle.rb:280`). Keying on the flag left the intent armed through
+    // all of those, so a later `pagehide` reported `abandoned_pre_offer` for a
+    // trigger that never had a chance — inverting the metric rather than just
+    // missing a datapoint.
+    return message.event === "closeLightbox";
+}
+
+export { armFormCtaBookerIntent, disposeFormCtaBookerIntent, observeBookerOutcome, resolveFormCtaBookerIntent };

package/widget/hubspot_visitor.js

@@ -0,0 +1,39 @@
+import { __webpack_require__ } from "../js/runtime.js";
+import { api } from "../js/4101.js";
+import "../constants.generated.js";
+import "./utils/native_globals.js";
+
+/* provided dependency */ var hubspot_visitor_setInterval = __webpack_require__(68034).LK;
+/* provided dependency */ var hubspot_visitor_clearInterval = __webpack_require__(68034).wm;
+
+
+class HubSpotVisitor {
+    async getToken(timeout) {
+        if (timeout === void 0) timeout = (/* inlined export .DEFAULT_HUBSPOT_TOKEN_RETRIEVAL_TIMEOUT */1000);
+        return new Promise((resolve)=>{
+            const getCookiedToken = ()=>api.get("__hstc");
+            if (getCookiedToken()) {
+                // cookie exists already
+                resolve(getCookiedToken());
+            } else if (window._hsq) {
+                // hubspot tracking exists but cookie isn't set yet
+                const startTime = Date.now();
+                const intervalId = hubspot_visitor_setInterval(()=>{
+                    if (getCookiedToken()) {
+                        hubspot_visitor_clearInterval(intervalId);
+                        resolve(getCookiedToken());
+                    } else if (Date.now() - startTime > timeout) {
+                        hubspot_visitor_clearInterval(intervalId);
+                        resolve(undefined);
+                    }
+                }, 200);
+            } else {
+                // no cookie or tracking
+                resolve(undefined);
+            }
+        });
+    }
+}
+/* export default */ const hubspot_visitor = (HubSpotVisitor);
+
+export default hubspot_visitor;

package/widget/inline_meeting_booker_page.js

@@ -0,0 +1,90 @@
+/**
+ * Page-container attributes that opt a page into the inline meeting booker.
+ *
+ * A tagged container looks like:
+ *   <div data-qualified-meeting-booker-container
+ *        data-qualified-manual-experience-id="<bot api_name>"></div>
+ *
+ * The experience id is the manual bot's `api_name`, the same value passed to
+ * `tracker.showExperience(...)` when a manual/smart-CTA selector is clicked.
+ */ const MEETING_BOOKER_CONTAINER_ATTR = "data-qualified-meeting-booker-container";
+const MANUAL_EXPERIENCE_ID_ATTR = "data-qualified-manual-experience-id";
+/**
+ * Finds the page's tagged inline-meeting-booker container that carries a
+ * non-empty manual-experience id, returning the container and its trimmed id (or
+ * null when none exists: no tagged container, or only ones with a blank id).
+ *
+ * Shared by {@link pageOwnsInlineMeetingBooker} and the inline booker's mount
+ * path so both agree on what counts as a valid container: a blank/whitespace id
+ * must NOT be treated as an owner, otherwise the classic lightbox would be
+ * withheld while nothing mounts to render the booker.
+ */ function findInlineMeetingBookerContainer() {
+    const containers = document.querySelectorAll("[" + MEETING_BOOKER_CONTAINER_ATTR + "][" + MANUAL_EXPERIENCE_ID_ATTR + "]");
+    for (const container of containers){
+        var _container_getAttribute;
+        const experienceId = (_container_getAttribute = container.getAttribute(MANUAL_EXPERIENCE_ID_ATTR)) == null ? void 0 : _container_getAttribute.trim();
+        if (experienceId) return {
+            container,
+            experienceId
+        };
+    }
+    return null;
+}
+/**
+ * True when this page opts into the multimodal_v2 inline meeting booker: the
+ * account has the `inline_meeting_booker` flag on, the flags that load
+ * multimodal_v2 are on (`widget_allow_messenger_v2_styling` plus
+ * `widget_use_code_split_snippet`), and the page has a tagged container.
+ *
+ * On such a page the inline booker owns meeting-booker rendering, so the classic
+ * messenger iframe must never show its full-screen lightbox (loading spinner or
+ * booker). It would render a duplicate over the inline booker, and on a page
+ * rebroadcast (reload / SPA nav with an existing conversation) the offer that
+ * resolves the spinner is withheld from the iframe, leaving it stuck forever.
+ *
+ * Every input is known at first paint (the container is static page HTML and the
+ * flags come from config), so this is race-free. `rootStore.inlineMeetingBookerActive`
+ * cannot be used here: it only flips true once multimodal_v2 mounts, which is too
+ * late for a rebroadcast `showLightboxLoading` that fires before the chunk loads.
+ *
+ * Requiring the multimodal-load flags means we only suppress the classic lightbox
+ * when multimodal_v2 will actually load to render the inline booker in its place,
+ * so a page that cannot load multimodal_v2 keeps its normal lightbox behavior.
+ */ function pageOwnsInlineMeetingBooker(featureFlags) {
+    if (!featureFlags.inlineMeetingBooker || !featureFlags.widgetAllowMessengerV2Styling || !featureFlags.widgetUseCodeSplitSnippet) {
+        return false;
+    }
+    return findInlineMeetingBookerContainer() !== null;
+}
+/**
+ * Backend `received` events the classic messenger iframe uses to open a
+ * full-screen lightbox meeting booker. On a page that owns the inline booker
+ * these must be withheld from the iframe (see {@link shouldWithholdFromClassicIframe}):
+ *
+ *   - `showLightboxLoading` opens the full-screen loading overlay. The server
+ *     broadcasts it for manual bookers on both live creation and page-reload
+ *     rebroadcast, and it arrives through the generic received relay (not the
+ *     client-side IframeManager.showLightboxLoading method). Withholding it is
+ *     what prevents the stuck full-screen spinner: the resolving offer below is
+ *     also withheld, so an opened overlay would never clear.
+ *   - the element-conversation events carry the booker's loading state and offer
+ *     data; relaying them would render a duplicate booker over the inline one.
+ */ const WITHHELD_IFRAME_EVENTS = new Set([
+    "showLightboxLoading",
+    "startElementConversationLoadingState",
+    "initElementConversation",
+    "initQualifiedFormElementConversation"
+]);
+/**
+ * True when a backend `received` event must NOT be relayed to the classic
+ * messenger iframe because this page owns the inline meeting booker. Keeps the
+ * classic iframe from opening a duplicate full-screen booker or a stuck loading
+ * spinner over the inline one. Any other event relays normally.
+ */ function shouldWithholdFromClassicIframe(event, featureFlags) {
+    return WITHHELD_IFRAME_EVENTS.has(event) && pageOwnsInlineMeetingBooker(featureFlags);
+}
+
+var inline_meeting_booker_page_MANUAL_EXPERIENCE_ID_ATTR = /* unused export */ undefined;
+var inline_meeting_booker_page_MEETING_BOOKER_CONTAINER_ATTR = /* unused export */ undefined;
+var inline_meeting_booker_page_shouldWithholdFromClassicIframe = /* unused export */ undefined;
+export { findInlineMeetingBookerContainer, inline_meeting_booker_page_MANUAL_EXPERIENCE_ID_ATTR as MANUAL_EXPERIENCE_ID_ATTR, inline_meeting_booker_page_MEETING_BOOKER_CONTAINER_ATTR as MEETING_BOOKER_CONTAINER_ATTR, inline_meeting_booker_page_shouldWithholdFromClassicIframe as shouldWithholdFromClassicIframe, pageOwnsInlineMeetingBooker };

package/widget/local_state/abstract_local_state.js

@@ -0,0 +1,38 @@
+import { localStorageGet, localStorageRemove, localStorageSet } from "../../src/localstorage.js";
+import { _extends } from "../../js/4101.js";
+
+
+
+class AbstractLocalState {
+    // Returns persisted state if it exists and is not expired
+    get persistedState() {
+        // TODO: Technically there's no guarantee that localStorageGet returns a BasePersistedData<T>
+        const data = localStorageGet(this.KEY);
+        if (data && data.state && Number.isInteger(data.expiresAt) && data.expiresAt > Date.now()) {
+            return data.state;
+        } else {
+            this.clearPersistedState();
+            return null;
+        }
+    }
+    setPersistedState(state) {
+        localStorageSet(this.KEY, {
+            expiresAt: Date.now() + this.TTL,
+            state
+        });
+    }
+    updateStateAtKey(key, value) {
+        var _this_persistedState;
+        this.setPersistedState(_extends({}, (_this_persistedState = this.persistedState) != null ? _this_persistedState : {}, {
+            [key]: value
+        }));
+    }
+    clearPersistedState() {
+        localStorageRemove(this.KEY);
+    }
+    constructor(){
+        this.TTL = 10 * 365 * 24 * 60 * 60 * 1000; // milliseconds, default 10 years
+    }
+}
+
+export { AbstractLocalState };

package/widget/local_state/debug_state/abstract_debug_flow.js

@@ -0,0 +1,29 @@
+import { getDefaultDebugMessage } from "../debug_state.js";
+
+
+const STATUS_TAGS = {
+    missing: "[❓ Not Detected]",
+    success: "[✅ Success]",
+    error: "[❌ Error]"
+};
+class AbstractDebugFlow {
+    get textOutput() {
+        const lines = [
+            this.name
+        ];
+        this.steps.forEach((step)=>{
+            const event = this.eventsMap[step];
+            if (!event) {
+                lines.push(STATUS_TAGS.missing + " " + getDefaultDebugMessage(step, "missing"));
+            } else {
+                lines.push(STATUS_TAGS[event.status] + " " + (event.message || getDefaultDebugMessage(step, event.status)));
+            }
+        });
+        return lines.join("\n");
+    }
+    constructor(eventsMap){
+        this.eventsMap = eventsMap;
+    }
+}
+
+export { AbstractDebugFlow };

package/widget/local_state/debug_state/custom_form_flow.js

@@ -0,0 +1,14 @@
+import { AbstractDebugFlow } from "./abstract_debug_flow.js";
+
+
+class CustomFormFlow extends AbstractDebugFlow {
+    constructor(...args){
+        super(...args), this.name = "Custom Form Experience", this.steps = [
+            "debug:formSubmitCapture",
+            "api:saveFormData",
+            "api:showFormExperience"
+        ];
+    }
+}
+
+export { CustomFormFlow };