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

package/widget/api_handler/base_api_handler.js

@@ -2,6 +2,7 @@ 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 { isCapabilityAllowed, commandCapability } from "../capabilities.js";
 import { default as WidgetObject } from "../widget_object.js";
 
 __webpack_require__("67353");
@@ -14,6 +15,7 @@ var isFunction_default = /*#__PURE__*/__webpack_require__.n(isFunction);
 
 
 
+
 const API_VERBS = (/* unused pure expression or super */ null && ([
     "initialize",
     "open",
@@ -124,11 +126,29 @@ class BaseApiHandler extends WidgetObject {
             this.queue = [];
         }
     }
+    /**
+   * Capability boundary (QAI-5862): whether `fn` routes to a denied capability and so must be
+   * dropped before its handler runs or queues. Warns once so the drop is visible. No-op for the
+   * hosted widget (allow-all); `initialize` and neutral verbs map to no capability and are never
+   * gated. Shared (QAI-5896) so an `execute()` override — the iframe handler's early-verb fast
+   * path — enforces the same gate instead of side-stepping it.
+   */ isCommandDenied(fn) {
+        const capability = commandCapability(fn);
+        if (capability && !isCapabilityAllowed(capability)) {
+            // eslint-disable-next-line no-console
+            console.warn("Qualified: '" + fn + "' was ignored — the '" + capability + "' capability was not allowed at setup().");
+            return true;
+        }
+        return false;
+    }
     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]) {
+            // Capability boundary (QAI-5862): drop a command routed to a denied capability before it
+            // runs or queues. No-op for the hosted widget (allow-all); `initialize` is never gated.
+            if (this.isCommandDenied(fn)) return;
             if (this.ready || fn === "initialize") {
                 // Should execute immediately?
                 this.handlers[fn].apply(undefined, args);
@@ -225,6 +245,10 @@ class BaseApiHandler extends WidgetObject {
         this.handlers = handlers;
         this.queue = [];
         _class_private_field_loose_base(this, _initDeclarativeApi)[_initDeclarativeApi]();
+        // Host-page form capture (QAI-5864): this arms the smart-form listeners unconditionally, but
+        // egress is gated at the command layer — the submit handler routes through `execute()`, which
+        // drops `sendSmartFormData`/`saveSmartFormData` when the `formCapture` capability is denied. So
+        // there is no separate capability check here by design.
         _class_private_field_loose_base(this, _initSmartForms)[_initSmartForms]();
     }
 }

package/widget/booker_outcome_tracker.js

@@ -1,6 +1,6 @@
 import { __webpack_require__ } from "../js/runtime.js";
-import "./utils/native_globals.js";
 import { _extends } from "../js/4101.js";
+import "./utils/native_globals.js";
 
 /* provided dependency */ var booker_outcome_tracker_setTimeout = __webpack_require__(68034).pS;
 /* provided dependency */ var __nativeWindowAddEventListener = __webpack_require__(68034).zh;
@@ -112,6 +112,44 @@ const emittedOfferIds = new Set();
 /** Test-only: clears the cross-instance dedupe set between cases. */ function resetEmittedBookerOutcomes() {
     emittedOfferIds.clear();
 }
+function emitBookerOutcome(param) {
+    let { log, surface, outcome, pathwayOrigin, conversationType, offerMessageId, timing } = param;
+    if (emittedOfferIds.has(offerMessageId)) return;
+    emittedOfferIds.add(offerMessageId);
+    log(_extends({
+        type: "log",
+        message: "booker_outcome",
+        extra: _extends({
+            meeting_stage: BOOKER_SHOWN_MEETING_STAGE,
+            outcome,
+            surface,
+            pathway_origin: pathwayOrigin,
+            conversation_type: conversationType,
+            offer_message_id: offerMessageId
+        }, timing === undefined ? {} : {
+            timing
+        })
+    }, outcome === BOOKER_OUTCOME.ABANDONED ? {
+        fireAndForget: true
+    } : {}));
+}
+/**
+ * Reports an offer whose booker never loaded, for callers with no tracker to
+ * resolve — on the multimodal surface the tracker lives in the store inside the
+ * chunk that failed, so nothing is armed to time out.
+ *
+ * Shares the once-per-offer dedupe, which is first-write-wins: an offer the
+ * visitor later recovers by retrying still reads as `failed`. Sends no timing,
+ * having no baseline to measure from.
+ */ function reportBookerLoadFailed(params) {
+    try {
+        emitBookerOutcome(_extends({}, params, {
+            outcome: BOOKER_OUTCOME.FAILED
+        }));
+    } catch (unused) {
+    // Same bargain as `safely()`: a lost datapoint beats breaking the booker.
+    }
+}
 class BookerOutcomeTracker {
     arm(offerMessageId, pathwayOrigin, conversationType) {
         this.safely(()=>{
@@ -144,8 +182,16 @@ class BookerOutcomeTracker {
             }
         });
     }
-    markShown() {
-        this.safely(()=>this.resolve(BOOKER_OUTCOME.SHOWN));
+    /**
+   * @param offerMessageId The offer the caller rendered. A mark for any other is
+   *   ignored: callers resolve after paint, so a newer offer can have re-armed
+   *   in between, and crediting it would invent a `shown` and then suppress its
+   *   real outcome. Omit when only one offer is in flight per tracker.
+   */ markShown(offerMessageId) {
+        this.safely(()=>{
+            if (offerMessageId && offerMessageId !== this.offerMessageId) return;
+            this.resolve(BOOKER_OUTCOME.SHOWN);
+        });
     }
     dispose() {
         this.safely(()=>{
@@ -182,22 +228,14 @@ class BookerOutcomeTracker {
     }
     emit(outcome) {
         if (!this.offerMessageId) return;
-        if (emittedOfferIds.has(this.offerMessageId)) return;
-        emittedOfferIds.add(this.offerMessageId);
-        this.log(_extends({
-            type: "log",
-            message: "booker_outcome",
-            extra: _extends({
-                meeting_stage: BOOKER_SHOWN_MEETING_STAGE,
-                outcome,
-                surface: this.surface,
-                pathway_origin: this.pathwayOrigin,
-                conversation_type: this.conversationType,
-                offer_message_id: this.offerMessageId
-            }, this.timing(outcome))
-        }, outcome === BOOKER_OUTCOME.ABANDONED ? {
-            fireAndForget: true
-        } : {}));
+        emitBookerOutcome(_extends({
+            log: this.log,
+            surface: this.surface,
+            outcome,
+            pathwayOrigin: this.pathwayOrigin,
+            conversationType: this.conversationType,
+            offerMessageId: this.offerMessageId
+        }, this.timing(outcome)));
     }
     /**
    * Elapsed time from arm, or nothing when it cannot be trusted.
@@ -326,4 +364,4 @@ var booker_outcome_tracker_BOOKER_LOAD_TIMEOUT_MS = /* unused export */ undefine
 var booker_outcome_tracker_BOOKER_OUTCOME = /* unused export */ undefined;
 var booker_outcome_tracker_BOOKER_SHOWN_MEETING_STAGE = /* unused export */ undefined;
 var booker_outcome_tracker_resetEmittedBookerOutcomes = /* unused export */ undefined;
-export { BOOKER_PATHWAY_ORIGIN, BOOKER_SURFACE, BookerOutcomeTracker, bookerPathwayOrigin, booker_outcome_tracker_BOOKER_LOAD_TIMEOUT_MS as BOOKER_LOAD_TIMEOUT_MS, booker_outcome_tracker_BOOKER_OUTCOME as BOOKER_OUTCOME, booker_outcome_tracker_BOOKER_SHOWN_MEETING_STAGE as BOOKER_SHOWN_MEETING_STAGE, booker_outcome_tracker_resetEmittedBookerOutcomes as resetEmittedBookerOutcomes };
+export { BOOKER_PATHWAY_ORIGIN, BOOKER_SURFACE, BookerOutcomeTracker, bookerPathwayOrigin, booker_outcome_tracker_BOOKER_LOAD_TIMEOUT_MS as BOOKER_LOAD_TIMEOUT_MS, booker_outcome_tracker_BOOKER_OUTCOME as BOOKER_OUTCOME, booker_outcome_tracker_BOOKER_SHOWN_MEETING_STAGE as BOOKER_SHOWN_MEETING_STAGE, booker_outcome_tracker_resetEmittedBookerOutcomes as resetEmittedBookerOutcomes, reportBookerLoadFailed };

package/widget/capabilities.js

@@ -0,0 +1,190 @@
+import { _extends } from "../js/4101.js";
+
+
+/**
+ * Capability boundary for the self-hosted `@qualified/web` npm package (QAI-5862): a consumer-set,
+ * default-deny allowlist that Qualified cannot override. Dependency-free with no import-time side
+ * effects. Not enrolled (hosted CDN widget, never calls `setup()`) = allow-all; enrolled (npm,
+ * `setup()` installs a list) = default-deny and immutable.
+ *
+ * Enforced in three places: `setup()` installs it (`packs/widget/esm/index.ts`),
+ * `filterRuntimeConfig` narrows the fetched config, and the command/message dispatchers drop denied
+ * verbs/messages via `commandCapability` / `messageCapability`. This ticket is the mechanism only;
+ * per-feature client-side skips are QAI-5863 / QAI-5864, which also extend the tables below.
+ */ /**
+ * The gated features. Default-deny: a key not in the allowlist is off. Voice is intentionally
+ * absent — this build ships text-only and can't activate voice; a voice build adds `"voice"` here.
+ *
+ * QAI-5864 deferred the voice/Daily gate for exactly this reason: in the text-only package the
+ * Daily call object is never created (a build-constant throw in `call_store.ts` fires first), so
+ * `c.daily.co` is unreachable and a `"voice"` capability would strip flags with no reachable
+ * effect. When the voice build lands, add `"voice"` here + a `CAPABILITY_CONFIG_ENABLERS.voice`
+ * entry (`featureFlags: ["piperXAgentVoice", "piperXAgentAvatar"]`) and the guard flagged in
+ * `call_store.ts` `getOrCreateCallObject`.
+ */ const CAPABILITY_KEYS = [
+    "pardot",
+    "liveView",
+    "agentNavigation",
+    "analytics",
+    "slidePerception",
+    "formCapture",
+    "marketingIdentity"
+];
+const CAPABILITY_KEY_SET = new Set(CAPABILITY_KEYS);
+/** Narrows an arbitrary string to a known `Capability`, so consumer typos grant nothing. */ function isKnownCapability(key) {
+    return CAPABILITY_KEY_SET.has(key);
+}
+// The installed allowlist, or `null` when not enrolled (allow-all). Module-private and only
+// mutated by `installCapabilityBoundary` (once), which is what makes the boundary immutable.
+let allowed = null;
+function normalize(keys) {
+    const set = new Set();
+    for (const key of keys){
+        if (isKnownCapability(key)) {
+            set.add(key);
+        } else {
+            // Ignored (not thrown) so a typo can't brick boot — but warned so it's visible. The valid
+            // keys are named inline (QAI-5919) so the warning is self-correcting: the consumer sees what
+            // they should have passed without hunting for the reference.
+            // eslint-disable-next-line no-console
+            console.warn('Qualified: ignoring unknown capability "' + key + '" passed to setup(). ' + ("Valid capabilities: " + CAPABILITY_KEYS.join(", ") + "."));
+        }
+    }
+    return set;
+}
+function sameMembers(a, b) {
+    if (a.size !== b.size) return false;
+    for (const key of a){
+        if (!b.has(key)) return false;
+    }
+    return true;
+}
+/**
+ * Installs the consumer's allowlist (once, from `setup()`). Unknown keys are ignored, not thrown.
+ * Re-installing the identical list is a no-op (retry-safe); a different list throws — so nothing
+ * can widen what the consumer allowed.
+ */ function installCapabilityBoundary(capabilities) {
+    const requested = normalize(capabilities);
+    if (allowed !== null) {
+        if (!sameMembers(allowed, requested)) {
+            throw new Error("Qualified: the capability boundary is already installed and cannot be changed after " + "setup(). The allowlist is fixed for the lifetime of the page.");
+        }
+        return;
+    }
+    allowed = requested;
+}
+/** The one check every enforcement point calls: default-deny once enrolled, allow-all when not. */ function isCapabilityAllowed(capability) {
+    if (allowed === null) return true;
+    return allowed.has(capability);
+}
+/** Whether a consumer allowlist has been installed (i.e. this is the enrolled npm package). */ function isCapabilityBoundaryInstalled() {
+    return allowed !== null;
+}
+/**
+ * Config flags/keys whose truthiness turns a capability ON. Denying a capability deletes these —
+ * deletion is the filter's only write. Seeded with today's known enablers; capabilities gated by a
+ * flag's *absence* (liveView) or by inbound messages only (agentNavigation) have none here and are
+ * enforced elsewhere. Feature tickets grow this table.
+ */ const CAPABILITY_CONFIG_ENABLERS = {
+    analytics: {
+        featureFlags: [
+            "piperWebTrackingEvents"
+        ],
+        configKeys: [
+            "analytics"
+        ]
+    },
+    slidePerception: {
+        featureFlags: [
+            "piperPerceptionSlides"
+        ]
+    },
+    pardot: {
+        configKeys: [
+            "pardotConfig"
+        ]
+    },
+    formCapture: {
+        featureFlags: [
+            "smartForms",
+            "websiteEmbeddedForms"
+        ],
+        configKeys: [
+            "hasSmartForms",
+            "hasWebsiteEmbeddedForms"
+        ]
+    },
+    // QAI-5896: marketing-automation visitor identity (Marketo/HubSpot/Data360/Eloqua). Each `has*`
+    // flag makes `tracker.ts` `init()` read a local marketing cookie/global and forward the token to
+    // Qualified; stripping the flags is the primary skip, and `init()` carries a client-side backstop.
+    marketingIdentity: {
+        configKeys: [
+            "hasMarketo",
+            "hasHubSpot",
+            "hasData360",
+            "hasEloqua"
+        ]
+    },
+    liveView: {},
+    agentNavigation: {}
+};
+/**
+ * Returns a shallow clone of `config` with every denied capability's enablers deleted. Only ever
+ * deletes, so it cannot turn a capability ON. Doesn't mutate the input; strips nothing when not
+ * enrolled.
+ */ function filterRuntimeConfig(config) {
+    const cloned = _extends({}, config);
+    if (config.featureFlags) {
+        cloned.featureFlags = _extends({}, config.featureFlags);
+    }
+    for (const capability of CAPABILITY_KEYS){
+        if (!isCapabilityAllowed(capability)) {
+            const { featureFlags = [], configKeys = [] } = CAPABILITY_CONFIG_ENABLERS[capability];
+            for (const flag of featureFlags){
+                if (cloned.featureFlags) delete cloned.featureFlags[flag];
+            }
+            for (const key of configKeys){
+                delete cloned[key];
+            }
+        }
+    }
+    return cloned;
+}
+/**
+ * The capability a backend websocket message belongs to, or `undefined`. `handleIncomingMessage`
+ * drops denied ones upstream of the stores — catching the second `navigate_content` path too.
+ */ const MESSAGE_CAPABILITIES = Object.freeze({
+    navigate_content: "agentNavigation",
+    point_cursor: "agentNavigation"
+});
+function messageCapability(messageType) {
+    return MESSAGE_CAPABILITIES[messageType];
+}
+/**
+ * The capability a public command (`q(verb, ...)`) belongs to, or `undefined`. `execute()` drops a
+ * denied verb before its handler runs; `initialize` and neutral verbs are never gated.
+ */ const COMMAND_CAPABILITIES = Object.freeze({
+    initPardotForm: "pardot",
+    initPardotFormThankYou: "pardot",
+    parsePardotForm: "pardot",
+    parsePardotFormForLandingPage: "pardot",
+    pardotFormSubmitted: "pardot",
+    registerForm: "formCapture",
+    showForm: "formCapture",
+    showFormExperience: "formCapture",
+    showExperienceForForm: "formCapture",
+    saveFormData: "formCapture",
+    saveSmartFormData: "formCapture",
+    sendSmartFormData: "formCapture",
+    emitFormFill: "formCapture",
+    submitEmbeddedForm: "formCapture"
+});
+function commandCapability(verb) {
+    return COMMAND_CAPABILITIES[verb];
+}
+
+var capabilities_COMMAND_CAPABILITIES = /* unused export */ undefined;
+var capabilities_MESSAGE_CAPABILITIES = /* unused export */ undefined;
+var capabilities_isCapabilityBoundaryInstalled = /* unused export */ undefined;
+var capabilities_isKnownCapability = /* unused export */ undefined;
+export { CAPABILITY_KEYS, capabilities_COMMAND_CAPABILITIES as COMMAND_CAPABILITIES, capabilities_MESSAGE_CAPABILITIES as MESSAGE_CAPABILITIES, capabilities_isCapabilityBoundaryInstalled as isCapabilityBoundaryInstalled, capabilities_isKnownCapability as isKnownCapability, commandCapability, filterRuntimeConfig, installCapabilityBoundary, isCapabilityAllowed, messageCapability };

package/widget/channel.js

@@ -58,7 +58,17 @@ class Channel extends WidgetObject {
         // allow for missed pings (ANYCABLE_PING_INTERVAL=4s in manhattan, so 2x = 8s, not 6s).
         connection_monitor.staleThreshold = (_this_config_staleThresholdSeconds = this.config.staleThresholdSeconds) != null ? _this_config_staleThresholdSeconds : 6;
         const params = this.widget.connectionParams, url = this.config.wsHost + "?" + new URLSearchParams(omitBy_default()(params, (isNil_default()))).toString();
-        this._cable = createConsumer(url);
+        this._cable = createConsumer(url, {
+            // Permits the cable to retry itself over SSE + HTTP if the WebSocket turns out to be blocked.
+            // Only the upstream half needs an address, because it goes to Rails rather than to
+            // anycable-go; the downstream stream is served by the same host as the socket. @see SseSocket
+            fallback: {
+                upstreamUrl: this.widget.resourceUrl("cable/command", {
+                    uuid: this.widget.visitor.uuid,
+                    wu: this.widget.widgetId
+                })
+            }
+        });
         this.subscription = this._cable.subscriptions.create({
             channel: "Visitors::WidgetChannel"
         }, {
@@ -164,10 +174,18 @@ class Channel extends WidgetObject {
         } else {
             // @ts-expect-error TS does not realize you can concat a non-array to an array and it will be inserted
             [].concat(message).forEach((message)=>{
-                ButtonsFormsTriggeringTracer.finishFormOrButtonSpan(message);
-                // Same message, unsampled: resolves the pre-offer SLI for an armed
-                // form/CTA trigger. No-ops when nothing is armed.
-                resolveFormCtaBookerIntent(message);
+                // A closeLightbox that IframeManager's outstanding-request gate will
+                // withhold isn't the final answer for this journey -- resolving the
+                // pre-offer SLI / tracing spans for it would record "no offer" moments
+                // before the real offer arrives on the request that's still outstanding
+                // (CORE-3488). Skip both for that message; they still run on whichever
+                // teardown IS the final one.
+                if (message.event !== "closeLightbox" || !this.wouldWithholdTeardown(message.payload)) {
+                    ButtonsFormsTriggeringTracer.finishFormOrButtonSpan(message);
+                    // Same message, unsampled: resolves the pre-offer SLI for an armed
+                    // form/CTA trigger. No-ops when nothing is armed.
+                    resolveFormCtaBookerIntent(message);
+                }
                 if (message.event === "redirect" && message.payload.url) {
                     var _this_offerScript;
                     if (message.payload.isQualifiedForm && ((_this_offerScript = this.offerScript) == null ? void 0 : _this_offerScript.hasActiveForm)) {
@@ -177,7 +195,11 @@ class Channel extends WidgetObject {
                         window.location.href = message.payload.url;
                     }
                 } else if (message.event === "endLoadingState") {
-                    this._emitter.emit(message.event);
+                    // Forward the payload so a formTransactionId can gate a stray teardown
+                    // against an outstanding request (CORE-3488). The other subscriber
+                    // (multimodal.ts's onExperienceEnd) takes a zero-arg callback, so the
+                    // extra argument is harmless there.
+                    this._emitter.emit(message.event, message.payload);
                 } else if (message.event === "personalizeWebsite") {
                     this._emitter.emit(message.event, message.payload);
                 } else if (message.event === "initOffers") {
@@ -230,6 +252,16 @@ class Channel extends WidgetObject {
             });
         }
     }
+    // Non-mutating: whether IframeManager's outstanding-request gate would
+    // withhold a closeLightbox carrying this payload (CORE-3488). False (never
+    // withhold) on v2, where IframeManager isn't registered.
+    wouldWithholdTeardown(payload) {
+        try {
+            return this.widget.iframeManager.wouldWithholdTeardown(payload.formTransactionId);
+        } catch (unused) {
+            return false;
+        }
+    }
     constructor(injectionProps){
         super(injectionProps), // Private - Subscription events
         this.onConnected = ()=>{

package/widget/constants.generated.js

@@ -342,7 +342,8 @@ const SNIPPET_FEATURE_FLAGS = (/* unused pure expression or super */ null && ([
     "widgetDebounceIframeResizes",
     "widgetFullScreenWithScrollDisabler",
     "widgetUseCodeSplitSnippet",
-    "widgetUseShadowDynamicImport"
+    "widgetUseShadowDynamicImport",
+    "widgetVisitorEventsBatching"
 ]));
 
 var constants_generated_SNIPPET_FEATURE_FLAGS = /* unused export */ undefined;

package/widget/multimodal_v2/components/AppLayout.js

@@ -50,7 +50,7 @@ const AppLayout = (param)=>{
                 when: rootStore.layout.root.visible,
                 children: /*#__PURE__*/ jsxRuntime_module_u(FocusTrapDialog, {
                     active: rootStore.layout.additionalState.isDialogActive,
-                    onClose: rootStore.clearMaximizedState,
+                    onClose: rootStore.endPresentationAndClearMaximizedState,
                     ariaLabel: dialogLabel,
                     children: [
                         /*#__PURE__*/ jsxRuntime_module_u(Background, {

package/widget/multimodal_v2/components/app/Foreground.js

@@ -26,15 +26,16 @@ const Foreground = (param)=>{
                 })
             }),
             /*#__PURE__*/ jsxRuntime_module_u(utils_module_u, {
-                when: rootStore.displayMode.docked,
-                children: /*#__PURE__*/ jsxRuntime_module_u(PointerRectOverlay, {
-                    rootStore: rootStore
-                })
-            }),
-            /*#__PURE__*/ jsxRuntime_module_u(utils_module_u, {
-                when: rootStore.displayMode.docked,
-                children: /*#__PURE__*/ jsxRuntime_module_u(CursorOverlay, {
-                    rootStore: rootStore
+                when: rootStore.displayMode.opened,
+                children: /*#__PURE__*/ jsxRuntime_module_u(preact_module_k, {
+                    children: [
+                        /*#__PURE__*/ jsxRuntime_module_u(PointerRectOverlay, {
+                            rootStore: rootStore
+                        }),
+                        /*#__PURE__*/ jsxRuntime_module_u(CursorOverlay, {
+                            rootStore: rootStore
+                        })
+                    ]
                 })
             }),
             /*#__PURE__*/ jsxRuntime_module_u(utils_module_u, {

package/widget/multimodal_v2/components/app/Input.js

@@ -17,11 +17,16 @@ import { styled } from "../../styled-system/jsx/factory.js";
 
 const Input = (param)=>{
     let { rootStore } = param;
-    const { state, isAnchored } = rootStore.input;
+    var _message_value, _message_value1;
+    const { state, isAnchored, message } = rootStore.input;
     const heading = useLocalization(t("main.messageInputHeading"));
     // When a picklist/multi_picklist field request is anchored in the timeline,
-    // keep the text input visible so the visitor can still type or speak.
-    if (state.value === types_InputState.FIELD_REQUEST && isAnchored.value) {
+    // keep the text input visible so the visitor can still type or speak. Do the
+    // same after an engaged visitor collapses the messenger so stale picklist
+    // options do not replace the compact chat input.
+    const isPicklist = ((_message_value = message.value) == null ? void 0 : _message_value.fieldType) === "picklist" || ((_message_value1 = message.value) == null ? void 0 : _message_value1.fieldType) === "multi_picklist";
+    const showChatComposerForFieldRequest = state.value === types_InputState.FIELD_REQUEST && (isAnchored.value || isPicklist && rootStore.displayMode.collapsed.value && rootStore.messages.hasVisitorEngaged.value);
+    if (showChatComposerForFieldRequest) {
         return /*#__PURE__*/ jsxRuntime_module_u(Container, {
             "data-component-name": "Input.Container",
             children: [

package/widget/multimodal_v2/components/app/LightboxExperience.js

@@ -2,6 +2,8 @@ import { __webpack_require__ } from "../../../../js/runtime.js";
 import { compat_module_P, compat_module_z, hooks_module_y, signals_core_module_d, useComputed, hooks_module_d, jsxRuntime_module_u, signals_core_module_E, hooks_module_A } from "../../../../js/multimodal_v2.js";
 import { CrossIcon, ClockIcon, CheckCircleIcon, GlobeIcon } from "../../images/icons.js";
 import "../../styled-system/css/index.js";
+import { getSentryClient } from "../../../widget/sentry.js";
+import { importWithRetry } from "../../utils/signals.js";
 import { MeetingRepHeader } from "../meetings/MeetingRepHeader.js";
 import { formatTimeShort, formatDate } from "../meetings/utils.js";
 import { CalendarLoadingContent, loadingContentStyle } from "./CalendarLoadingContent.js";
@@ -22,6 +24,8 @@ import { css as css_css } from "../../styled-system/css/css.js";
 
 
 
+
+
 const LightboxGather = compat_module_z(()=>import("../lightbox_gather/index.js"));
 const LOCAL_TIMEZONE = Intl.DateTimeFormat().resolvedOptions().timeZone.replace(/_/g, " ");
 function maskEmail(visitorEmail) {
@@ -167,9 +171,19 @@ const MeetingBooker = compat_module_z(()=>import("../meetings/index.js"));
     // instantly on repeat calls once the chunk is cached.
     hooks_module_y(()=>{
         if (isLoadingPhase) {
-            rootStore.meetingStore.load();
-            void import("../meetings/index.js").then(()=>{
+            rootStore.meetingStore.load().catch((error)=>{
+                var _getSentryClient;
+                (_getSentryClient = getSentryClient({
+                    project: "multimodal"
+                })) == null ? void 0 : _getSentryClient.captureException(error);
+            });
+            void importWithRetry(()=>import("../meetings/index.js")).then(()=>{
                 meetingChunkReadySignal.value = true;
+            }).catch((error)=>{
+                var _getSentryClient;
+                (_getSentryClient = getSentryClient({
+                    project: "multimodal"
+                })) == null ? void 0 : _getSentryClient.captureException(error);
             });
         }
     // meetingChunkReadySignal is a stable ref (useRef), never changes identity.
@@ -298,7 +312,7 @@ const MeetingBooker = compat_module_z(()=>import("../meetings/index.js"));
                                             email: (_ref2 = (_rootStore_meetingStore_value1 = rootStore.meetingStore.value) == null ? void 0 : _rootStore_meetingStore_value1.bookedEmail.value) != null ? _ref2 : null,
                                             timeSlot: (_ref3 = (_rootStore_meetingStore_value2 = rootStore.meetingStore.value) == null ? void 0 : _rootStore_meetingStore_value2.bookedTimeSlot.value) != null ? _ref3 : null,
                                             timeZone: (_ref4 = (_rootStore_meetingStore_value3 = rootStore.meetingStore.value) == null ? void 0 : _rootStore_meetingStore_value3.timeZone.value) != null ? _ref4 : LOCAL_TIMEZONE,
-                                            locale: rootStore.translationStore.effectiveLocale.value,
+                                            locale: rootStore.translationStore.effectiveIntlLocale.value,
                                             title: (_ref5 = (_elementConversationTextMessage_value3 = elementConversationTextMessage.value) == null ? void 0 : _elementConversationTextMessage_value3.title) != null ? _ref5 : "Your meeting has been scheduled",
                                             text: (_ref6 = (_elementConversationTextMessage_value4 = elementConversationTextMessage.value) == null ? void 0 : _elementConversationTextMessage_value4.text) != null ? _ref6 : null,
                                             container: isContainer