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

package/index.cjs.js

@@ -819,6 +819,95 @@ const resetRegistry = () => {
     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
@@ -846,15 +935,28 @@ const createEvoSearchAPI = ({ fetch: fetchImpl = window.fetch, baseURL, userId,
     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;
@@ -877,10 +979,14 @@ const createEvoSearchAPI = ({ fetch: fetchImpl = window.fetch, baseURL, userId,
         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) {
@@ -900,17 +1006,38 @@ const createEvoSearchAPI = ({ fetch: fetchImpl = window.fetch, baseURL, userId,
         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);
@@ -951,50 +1078,107 @@ const createEvoSearchAPI = ({ fetch: fetchImpl = window.fetch, baseURL, userId,
     // 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) => {
@@ -1046,6 +1230,7 @@ const createEvoSearchAPI = ({ fetch: fetchImpl = window.fetch, baseURL, userId,
         trending,
         config,
         warm,
+        cancelWarm,
         user: {
             recents,
             deleteRecent,
@@ -8309,88 +8494,13 @@ const searchWidgetStyles = i$6 `
   }
 `;
 
-// 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',
@@ -8556,21 +8666,55 @@ class SearchWidget extends ElementWithStylesheet {
         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();
     }
@@ -9036,7 +9180,8 @@ class SearchWidget extends ElementWithStylesheet {
             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;
             }