@blotoutio/providers-evo-search-sdk 1.64.2 → 1.65.0

package/index.js

@@ -820,6 +820,95 @@ var ProvidersEvoSearchSdk = (function () {
         notifySubscribers(registry.subscribers, 'resetRegistry');
     };
 
+    // Resilience wrapper for /search requests. A transient network failure or a
+    // hung request must not wedge the UI: add a per-attempt timeout (a hang becomes
+    // a rejection), retry transient failures with backoff, and never retry a
+    // caller-superseded (aborted) request. Shared by the widget and the headless
+    // hook. See callers: search-widget.ts (performAutocomplete) and
+    // hooks/use-evo-search.ts.
+    const DEFAULTS = {
+        timeoutMs: 7000,
+        retries: 2,
+        backoffMs: [400, 1200],
+    };
+    // Deterministic HTTP errors (4xx other than 429) will never succeed on
+    // retry — only retry timeouts, network errors, 429, and 5xx. Errors without
+    // an attached `status` (network/timeout failures) are always retryable.
+    const isRetryable = (error) => {
+        const status = error === null || error === void 0 ? void 0 : error.status;
+        return status == null || status === 429 || status >= 500;
+    };
+    const delay = (ms, signal) => new Promise((resolve, reject) => {
+        if (signal.aborted)
+            return reject(new DOMException('Aborted', 'AbortError'));
+        const t = setTimeout(resolve, ms);
+        signal.addEventListener('abort', () => {
+            clearTimeout(t);
+            reject(new DOMException('Aborted', 'AbortError'));
+        }, { once: true });
+    });
+    /**
+     * Run `attempt` with a timeout, retrying transient failures. `callerSignal`
+     * supersedes everything: if it aborts, we stop immediately without retrying
+     * (the query changed / the widget cleaned up). A timeout or network error is
+     * retried up to `retries` times; anything left over is rethrown.
+     */
+    async function withSearchResilience(attempt, callerSignal, options = {}) {
+        var _a, _b;
+        const { timeoutMs, retries, backoffMs } = { ...DEFAULTS, ...options };
+        let lastError;
+        for (let i = 0; i <= retries; i++) {
+            if (callerSignal.aborted)
+                throw new DOMException('Aborted', 'AbortError');
+            const local = new AbortController();
+            const onCallerAbort = () => local.abort();
+            callerSignal.addEventListener('abort', onCallerAbort, { once: true });
+            // Race the attempt against an explicit timeout that REJECTS. Aborting the
+            // signal alone isn't enough — an attempt that ignores its signal would
+            // otherwise hang forever and never retry. Reject with a TimeoutError (not
+            // an AbortError) so callers surface it instead of treating it as a
+            // caller-cancellation.
+            let timer;
+            const timeout = new Promise((_, reject) => {
+                timer = setTimeout(() => {
+                    local.abort(); // still cancel the in-flight request to free the socket
+                    reject(new DOMException('Search request timed out', 'TimeoutError'));
+                }, timeoutMs);
+            });
+            try {
+                return await Promise.race([attempt(local.signal), timeout]);
+            }
+            catch (error) {
+                lastError = error;
+                // The caller superseded this request — do not retry, propagate the abort.
+                if (callerSignal.aborted)
+                    throw error;
+                // Otherwise it was a timeout or a transient network error: retry if budget remains.
+                if (i < retries && isRetryable(error)) {
+                    const wait = (_b = (_a = backoffMs[i]) !== null && _a !== void 0 ? _a : backoffMs[backoffMs.length - 1]) !== null && _b !== void 0 ? _b : 0;
+                    // Rejects with an AbortError if the caller aborts mid-backoff —
+                    // propagate that cancellation instead of the transient `error` above.
+                    await delay(wait, callerSignal);
+                    continue;
+                }
+                throw error;
+            }
+            finally {
+                clearTimeout(timer);
+                callerSignal.removeEventListener('abort', onCallerAbort);
+            }
+        }
+        throw lastError;
+    }
+
+    // Client-side deadlines for the Ask SSE path. `/search` already gets these via
+    // withSearchResilience; Ask is the streaming counterpart. The request timeout
+    // matches the resilience wrapper's per-attempt budget; the idle timeout catches
+    // a stream that stalls mid-flight without a terminal frame and resets on every
+    // chunk. Both surface a TimeoutError (not an AbortError) so submitAsk routes
+    // them to the search fallback instead of treating them as caller-cancellation.
+    const ASK_REQUEST_TIMEOUT_MS = 7000;
+    const ASK_SSE_IDLE_TIMEOUT_MS = 10000;
     // Always defer to what the storefront itself is rendering — same source
     // shop-gpt reads from. Two widgets on the same page would otherwise drift:
     // shop-gpt picks Shopify, evo-search would pick its own override and show
@@ -847,15 +936,28 @@ var ProvidersEvoSearchSdk = (function () {
         if (!sendTag) {
             throw new Error('sendTag missing');
         }
+        const getChannel = () => { var _a; return (((_a = window[registryKey]) === null || _a === void 0 ? void 0 : _a.ui) ? 'widget' : 'headless'); };
         const getHeaders = () => {
-            var _a;
             const headers = new Headers({ EdgeTagUserId: userId });
             if (sessionId) {
                 headers.set('EdgeTagSessionId', sessionId);
             }
-            headers.set('X-EvoSearch-Channel', ((_a = window[registryKey]) === null || _a === void 0 ? void 0 : _a.ui) ? 'widget' : 'headless');
+            headers.set('X-EvoSearch-Channel', getChannel());
             return headers;
         };
+        // Identity for the public read endpoints travels as query params instead of
+        // headers so the GET stays a CORS-simple request — no OPTIONS preflight,
+        // one connection attempt per keystroke instead of two (a hung transport
+        // path then wedges half as often, and withSearchResilience's retry isn't
+        // preceded by a second preflight). /user/* keeps the header form: the
+        // worker's cookie-HMAC auth binds to it, and those routes preflight anyway.
+        const setIdentityParams = (url) => {
+            url.searchParams.set('uid', userId);
+            if (sessionId) {
+                url.searchParams.set('sid', sessionId);
+            }
+            url.searchParams.set('channel', getChannel());
+        };
         // Parsing `baseURL` once at API construction avoids re-parsing the host on
         // every keystroke when `getURL` runs inside the autocomplete hot path.
         const baseOrigin = new URL(baseURL).origin;
@@ -878,10 +980,14 @@ var ProvidersEvoSearchSdk = (function () {
             for (const [key, value] of Object.entries(params !== null && params !== void 0 ? params : {})) {
                 url.searchParams.set(key, value);
             }
+            const credentialed = needsCredentials(path);
+            if (!credentialed) {
+                setIdentityParams(url);
+            }
             const response = await fetchImpl(url, {
                 method: 'GET',
-                headers: getHeaders(),
-                credentials: needsCredentials(path) ? 'include' : 'omit',
+                ...(credentialed ? { headers: getHeaders() } : {}),
+                credentials: credentialed ? 'include' : 'omit',
                 signal,
             });
             if (!response.ok) {
@@ -901,17 +1007,38 @@ var ProvidersEvoSearchSdk = (function () {
             logger.info('EvoSearch API: Fetching ask config');
             return getJSON('/config', 'Config', undefined, signal);
         };
-        // Fire-and-forget isolate warmer: tells the worker to prime its search
-        // index off the request path so the first keystroke doesn't pay the cold
-        // prime. Errors are irrelevant — autocomplete just falls back to priming
-        // inline like before.
+        // Isolate warmer doubling as connection establisher: primes the worker's
+        // search index off the request path AND opens the h2/h3 connection before
+        // the first real keystroke needs it. Runs under the resilience wrapper so a
+        // black-holed connection attempt (hung QUIC/IPv6 path) is aborted and
+        // retried — the retry is what lets the browser fall back to a working
+        // transport while the shopper is still reaching for the search box. Any
+        // HTTP response counts as success: even an error status proves the
+        // connection is established. Never rejects; concurrent triggers (open,
+        // focus, first keystroke, keep-warm tick) coalesce into one attempt.
+        let warmInFlight = null;
+        let warmAbort = null;
         const warm = () => {
-            fetchImpl(getURL('/warm'), {
-                method: 'GET',
-                headers: getHeaders(),
-                credentials: 'omit',
-            }).catch(() => undefined);
+            if (warmInFlight) {
+                return warmInFlight;
+            }
+            const url = getURL('/warm');
+            setIdentityParams(url);
+            warmAbort = new AbortController();
+            warmInFlight = withSearchResilience((signal) => fetchImpl(url, { method: 'GET', credentials: 'omit', signal }), warmAbort.signal)
+                .then(() => undefined)
+                .catch(() => undefined)
+                .finally(() => {
+                warmInFlight = null;
+                warmAbort = null;
+            });
+            return warmInFlight;
         };
+        // Closing the widget must kill the chain: a black-holed attempt would
+        // otherwise keep re-establishing connections for the wrapper's full budget
+        // (~23s) after the overlay is gone — exactly the churn warm() exists to
+        // avoid. The next warm() mints a fresh controller.
+        const cancelWarm = () => warmAbort === null || warmAbort === void 0 ? void 0 : warmAbort.abort();
         const recents = (signal) => {
             logger.info('EvoSearch API: Fetching recent searches');
             return getJSON('/user/recents', 'Recents', undefined, signal);
@@ -952,50 +1079,107 @@ var ProvidersEvoSearchSdk = (function () {
         // reader, the for-await loop drops out, and the iterator returns.
         async function* askStream(query, signal) {
             const url = getURL('/ask');
-            const response = await fetchImpl(url, {
-                method: 'POST',
-                headers: (() => {
-                    const h = getHeaders();
-                    h.set('Content-Type', 'application/json');
-                    return h;
-                })(),
-                body: JSON.stringify({ query }),
-                credentials: 'omit',
-                signal,
-            });
-            if (!response.ok || !response.body) {
-                throw new Error(`Ask failed - ${response.status}`);
-            }
-            const reader = response.body
-                .pipeThrough(new TextDecoderStream())
-                .getReader();
-            let buffer = '';
+            // One controller drives teardown for the whole stream: the caller's signal,
+            // the initial-request deadline, and the SSE idle timeout all abort through
+            // it, so a stall closes the fetch instead of hanging. `timedOut` lets us
+            // rethrow a TimeoutError rather than the AbortError the abort would raise.
+            const controller = new AbortController();
+            const onCallerAbort = () => controller.abort();
+            signal === null || signal === void 0 ? void 0 : signal.addEventListener('abort', onCallerAbort, { once: true });
+            if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+                controller.abort();
+            }
+            let timedOut = false;
+            const initialTimer = setTimeout(() => {
+                timedOut = true;
+                controller.abort();
+            }, ASK_REQUEST_TIMEOUT_MS);
+            // Outer try guarantees the caller-signal listener is removed on EVERY exit
+            // path. It's `{ once: true }`, so a caller abort auto-removes it — but the
+            // initial-timeout, network-error, and non-ok paths never fire the abort
+            // event, so without this they'd leak a listener on a long-lived shared
+            // signal (one per Ask query).
             try {
-                while (true) {
-                    const { done, value } = await reader.read();
-                    if (done) {
-                        break;
+                let response;
+                try {
+                    response = await fetchImpl(url, {
+                        method: 'POST',
+                        headers: (() => {
+                            const h = getHeaders();
+                            h.set('Content-Type', 'application/json');
+                            return h;
+                        })(),
+                        body: JSON.stringify({ query }),
+                        credentials: 'omit',
+                        signal: controller.signal,
+                    });
+                }
+                catch (error) {
+                    if (timedOut) {
+                        throw new DOMException('Ask request timed out', 'TimeoutError');
                     }
-                    buffer += value;
-                    let boundary = buffer.indexOf('\n\n');
-                    while (boundary !== -1) {
-                        const frame = buffer.slice(0, boundary);
-                        buffer = buffer.slice(boundary + 2);
-                        const event = parseSseFrame(frame);
-                        if (event) {
-                            yield event;
+                    throw error;
+                }
+                finally {
+                    // The idle timeout takes over once the response resolves.
+                    clearTimeout(initialTimer);
+                }
+                if (!response.ok || !response.body) {
+                    throw new Error(`Ask failed - ${response.status}`);
+                }
+                const reader = response.body
+                    .pipeThrough(new TextDecoderStream())
+                    .getReader();
+                let buffer = '';
+                try {
+                    while (true) {
+                        // Idle timeout, reset every chunk: a stream that stalls mid-flight
+                        // (no terminal frame) rejects here instead of freezing the skeleton.
+                        let idleTimer;
+                        const idle = new Promise((_, reject) => {
+                            idleTimer = setTimeout(() => {
+                                timedOut = true;
+                                controller.abort();
+                                reject(new DOMException('Ask stream stalled', 'TimeoutError'));
+                            }, ASK_SSE_IDLE_TIMEOUT_MS);
+                        });
+                        let result;
+                        try {
+                            result = await Promise.race([reader.read(), idle]);
                         }
-                        boundary = buffer.indexOf('\n\n');
+                        finally {
+                            clearTimeout(idleTimer);
+                        }
+                        const { done, value } = result;
+                        if (done) {
+                            break;
+                        }
+                        buffer += value;
+                        let boundary = buffer.indexOf('\n\n');
+                        while (boundary !== -1) {
+                            const frame = buffer.slice(0, boundary);
+                            buffer = buffer.slice(boundary + 2);
+                            const event = parseSseFrame(frame);
+                            if (event) {
+                                yield event;
+                            }
+                            boundary = buffer.indexOf('\n\n');
+                        }
+                    }
+                }
+                finally {
+                    try {
+                        // cancel (not releaseLock) — safe with an outstanding read and tears
+                        // down the upstream fetch on a caller-abort or idle timeout.
+                        await reader.cancel();
+                    }
+                    catch {
+                        // ignore — already closed
                     }
                 }
             }
             finally {
-                try {
-                    reader.releaseLock();
-                }
-                catch {
-                    // ignore
-                }
+                signal === null || signal === void 0 ? void 0 : signal.removeEventListener('abort', onCallerAbort);
             }
         }
         const sendEvent = (action, currency, actionData, clickData, beacon) => {
@@ -1047,6 +1231,7 @@ var ProvidersEvoSearchSdk = (function () {
             trending,
             config,
             warm,
+            cancelWarm,
             user: {
                 recents,
                 deleteRecent,
@@ -8310,88 +8495,13 @@ var ProvidersEvoSearchSdk = (function () {
   }
 `;
 
-    // Resilience wrapper for /search requests. A transient network failure or a
-    // hung request must not wedge the UI: add a per-attempt timeout (a hang becomes
-    // a rejection), retry transient failures with backoff, and never retry a
-    // caller-superseded (aborted) request. Shared by the widget and the headless
-    // hook. See callers: search-widget.ts (performAutocomplete) and
-    // hooks/use-evo-search.ts.
-    const DEFAULTS = {
-        timeoutMs: 7000,
-        retries: 2,
-        backoffMs: [400, 1200],
-    };
-    // Deterministic HTTP errors (4xx other than 429) will never succeed on
-    // retry — only retry timeouts, network errors, 429, and 5xx. Errors without
-    // an attached `status` (network/timeout failures) are always retryable.
-    const isRetryable = (error) => {
-        const status = error === null || error === void 0 ? void 0 : error.status;
-        return status == null || status === 429 || status >= 500;
-    };
-    const delay = (ms, signal) => new Promise((resolve, reject) => {
-        if (signal.aborted)
-            return reject(new DOMException('Aborted', 'AbortError'));
-        const t = setTimeout(resolve, ms);
-        signal.addEventListener('abort', () => {
-            clearTimeout(t);
-            reject(new DOMException('Aborted', 'AbortError'));
-        }, { once: true });
-    });
-    /**
-     * Run `attempt` with a timeout, retrying transient failures. `callerSignal`
-     * supersedes everything: if it aborts, we stop immediately without retrying
-     * (the query changed / the widget cleaned up). A timeout or network error is
-     * retried up to `retries` times; anything left over is rethrown.
-     */
-    async function withSearchResilience(attempt, callerSignal, options = {}) {
-        var _a, _b;
-        const { timeoutMs, retries, backoffMs } = { ...DEFAULTS, ...options };
-        let lastError;
-        for (let i = 0; i <= retries; i++) {
-            if (callerSignal.aborted)
-                throw new DOMException('Aborted', 'AbortError');
-            const local = new AbortController();
-            const onCallerAbort = () => local.abort();
-            callerSignal.addEventListener('abort', onCallerAbort, { once: true });
-            // Race the attempt against an explicit timeout that REJECTS. Aborting the
-            // signal alone isn't enough — an attempt that ignores its signal would
-            // otherwise hang forever and never retry. Reject with a TimeoutError (not
-            // an AbortError) so callers surface it instead of treating it as a
-            // caller-cancellation.
-            let timer;
-            const timeout = new Promise((_, reject) => {
-                timer = setTimeout(() => {
-                    local.abort(); // still cancel the in-flight request to free the socket
-                    reject(new DOMException('Search request timed out', 'TimeoutError'));
-                }, timeoutMs);
-            });
-            try {
-                return await Promise.race([attempt(local.signal), timeout]);
-            }
-            catch (error) {
-                lastError = error;
-                // The caller superseded this request — do not retry, propagate the abort.
-                if (callerSignal.aborted)
-                    throw error;
-                // Otherwise it was a timeout or a transient network error: retry if budget remains.
-                if (i < retries && isRetryable(error)) {
-                    const wait = (_b = (_a = backoffMs[i]) !== null && _a !== void 0 ? _a : backoffMs[backoffMs.length - 1]) !== null && _b !== void 0 ? _b : 0;
-                    // Rejects with an AbortError if the caller aborts mid-backoff —
-                    // propagate that cancellation instead of the transient `error` above.
-                    await delay(wait, callerSignal);
-                    continue;
-                }
-                throw error;
-            }
-            finally {
-                clearTimeout(timer);
-                callerSignal.removeEventListener('abort', onCallerAbort);
-            }
-        }
-        throw lastError;
-    }
-
     const MIN_QUERY_LENGTH = 3;
+    // Keep-warm cadence while the widget is open. Chrome reaps used-idle sockets
+    // after ~5 minutes and the edge sooner than that under load; a ping well
+    // inside those windows keeps the established h2/h3 connection alive so a
+    // keystroke after an idle pause multiplexes onto it instead of paying (and
+    // possibly wedging on) fresh connection establishment.
+    const KEEP_WARM_INTERVAL_MS = 60000;
     // @state fields whose change should be persisted to the session snapshot.
     const SESSION_PERSIST_KEYS = [
         'searchQuery',
@@ -8557,21 +8667,55 @@ var ProvidersEvoSearchSdk = (function () {
             this.isMobile = this.mobileMediaQuery.matches;
             this.mobileMediaQuery.addEventListener('change', this.mobileMediaListener);
             window.addEventListener('online', this.onlineListener);
+            // Restart keep-warm when the same instance re-attaches (a host re-append
+            // moves the subtree and fires disconnected→connected without a fresh
+            // firstUpdated). On the very first connect `api` may not be bound yet —
+            // firstUpdated repeats the call below and the timer guard dedupes.
+            this.startKeepWarm();
         }
         firstUpdated() {
             this.focusSearchBox();
             this.fetchRecents();
+            // Establish the worker connection while the shopper is still reaching for
+            // the keyboard, and re-ping while the widget stays open so it never idles
+            // out. warm() coalesces with the focus/first-keystroke triggers.
+            this.startKeepWarm();
+        }
+        startKeepWarm() {
+            var _a, _b;
+            // The immediate ping stays outside the timer guard: warm() coalesces, so
+            // a duplicate call is free, and skipping it would lose the first-open
+            // preconnect (api binds between connectedCallback and firstUpdated).
+            void ((_b = (_a = this.api) === null || _a === void 0 ? void 0 : _a.warm) === null || _b === void 0 ? void 0 : _b.call(_a));
+            if (this.keepWarmTimer !== undefined) {
+                return;
+            }
+            this.keepWarmTimer = setInterval(() => {
+                var _a, _b;
+                // An overlay left open in a backgrounded tab has no keystroke coming,
+                // and /warm shares the per-IP rate-limit bucket with /search — don't
+                // spend a NAT'd storefront's budget on a shopper who isn't looking.
+                // Focus and the first keystroke both re-warm when they return.
+                if (document.hidden) {
+                    return;
+                }
+                void ((_b = (_a = this.api) === null || _a === void 0 ? void 0 : _a.warm) === null || _b === void 0 ? void 0 : _b.call(_a));
+            }, KEEP_WARM_INTERVAL_MS);
         }
         disconnectedCallback() {
-            var _a, _b, _c;
+            var _a, _b, _c, _d, _e;
             // Closing the widget settles whatever query was on screen.
             this.finalizeSettledQuery();
             clearTimeout(this.autocompleteTimer);
-            (_a = this.askAbort) === null || _a === void 0 ? void 0 : _a.abort();
-            (_b = this.resultsAbort) === null || _b === void 0 ? void 0 : _b.abort();
+            clearInterval(this.keepWarmTimer);
+            this.keepWarmTimer = undefined;
+            // Stops an in-flight warm retry chain from outliving the overlay.
+            (_b = (_a = this.api) === null || _a === void 0 ? void 0 : _a.cancelWarm) === null || _b === void 0 ? void 0 : _b.call(_a);
+            (_c = this.askAbort) === null || _c === void 0 ? void 0 : _c.abort();
+            (_d = this.resultsAbort) === null || _d === void 0 ? void 0 : _d.abort();
             this.resetAnswerBuffer();
             this.removeEventListener('keydown', this.keydownListener);
-            (_c = this.mobileMediaQuery) === null || _c === void 0 ? void 0 : _c.removeEventListener('change', this.mobileMediaListener);
+            (_e = this.mobileMediaQuery) === null || _e === void 0 ? void 0 : _e.removeEventListener('change', this.mobileMediaListener);
             window.removeEventListener('online', this.onlineListener);
             super.disconnectedCallback();
         }
@@ -9037,7 +9181,8 @@ var ProvidersEvoSearchSdk = (function () {
                 if (!this.api) {
                     return;
                 }
-                const response = await this.api.search(query, undefined, this.newResultsSignal());
+                const api = this.api;
+                const response = await withSearchResilience((signal) => api.search(query, undefined, signal), this.newResultsSignal());
                 if (generation !== this.requestGeneration) {
                     return;
                 }