@blotoutio/providers-evo-search-sdk 1.65.1 → 1.65.2

package/hooks.cjs.js

@@ -695,87 +695,6 @@ const processAutocompleteResponse = (response) => {
     };
 };
 
-// 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 isDevEnv$1 = () => typeof process != 'undefined' && process.env['NODE_ENV'] != 'production';
 const emptyReturn = (query, setQuery, trackClick) => ({
     query,
@@ -847,7 +766,9 @@ const useEvoSearch = (options = {}) => {
         const controller = new AbortController();
         const timer = setTimeout(async () => {
             try {
-                const res = await withSearchResilience((signal) => api.search(query, undefined, signal), controller.signal);
+                // Resilience is inside api.search() now — wrapping again would
+                // double-wrap to 9 attempts.
+                const res = await api.search(query, undefined, controller.signal);
                 setResults(processAutocompleteResponse(res).products);
                 if (wantsSuggestions) {
                     setSuggestions((prev) => {

package/hooks.mjs

@@ -693,87 +693,6 @@ const processAutocompleteResponse = (response) => {
     };
 };
 
-// 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 isDevEnv$1 = () => typeof process != 'undefined' && process.env['NODE_ENV'] != 'production';
 const emptyReturn = (query, setQuery, trackClick) => ({
     query,
@@ -845,7 +764,9 @@ const useEvoSearch = (options = {}) => {
         const controller = new AbortController();
         const timer = setTimeout(async () => {
             try {
-                const res = await withSearchResilience((signal) => api.search(query, undefined, signal), controller.signal);
+                // Resilience is inside api.search() now — wrapping again would
+                // double-wrap to 9 attempts.
+                const res = await api.search(query, undefined, controller.signal);
                 setResults(processAutocompleteResponse(res).products);
                 if (wantsSuggestions) {
                     setSuggestions((prev) => {

package/index.cjs.js

@@ -837,24 +837,48 @@ 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 });
-});
+// `navigator.onLine` is only informative when false; wait for the network rather
+// than spending retries on a route that doesn't exist.
+const isOffline = () => typeof navigator != 'undefined' && navigator.onLine === false;
+// Waits `ms`, or until the network returns, whichever is first.
+const delay = (ms, signal) => {
+    // Whichever of timer/online/abort settles first tears down the other two.
+    let cleanup = () => undefined;
+    const waiting = new Promise((resolve, reject) => {
+        var _a;
+        if (signal.aborted)
+            return reject(new DOMException('Aborted', 'AbortError'));
+        const timer = setTimeout(resolve, ms);
+        const onOnline = () => resolve();
+        const onAbort = () => reject(new DOMException('Aborted', 'AbortError'));
+        (_a = globalThis.addEventListener) === null || _a === void 0 ? void 0 : _a.call(globalThis, 'online', onOnline);
+        signal.addEventListener('abort', onAbort, { once: true });
+        cleanup = () => {
+            var _a;
+            clearTimeout(timer);
+            (_a = globalThis.removeEventListener) === null || _a === void 0 ? void 0 : _a.call(globalThis, 'online', onOnline);
+            signal.removeEventListener('abort', onAbort);
+        };
+    });
+    return waiting.finally(() => cleanup());
+};
 /**
  * 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.
+ *
+ * Every phase draws from one shared deadline — the nominal schedule of all
+ * attempts plus all backoffs — so waiting out an offline route borrows from the
+ * budget instead of widening it, and the whole call still ends within it.
  */
 async function withSearchResilience(attempt, callerSignal, options = {}) {
     var _a, _b;
     const { timeoutMs, retries, backoffMs } = { ...DEFAULTS, ...options };
+    const deadline = Date.now() +
+        (retries + 1) * timeoutMs +
+        backoffMs.reduce((sum, ms) => sum + ms, 0);
+    const remaining = () => deadline - Date.now();
     let lastError;
     for (let i = 0; i <= retries; i++) {
         if (callerSignal.aborted)
@@ -872,7 +896,7 @@ async function withSearchResilience(attempt, callerSignal, options = {}) {
             timer = setTimeout(() => {
                 local.abort(); // still cancel the in-flight request to free the socket
                 reject(new DOMException('Search request timed out', 'TimeoutError'));
-            }, timeoutMs);
+            }, Math.min(timeoutMs, remaining()));
         });
         try {
             return await Promise.race([attempt(local.signal), timeout]);
@@ -884,7 +908,11 @@ async function withSearchResilience(attempt, callerSignal, options = {}) {
                 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;
+                // Offline: hold for the network instead of burning the retry on a route
+                // that doesn't exist — but only with time the call already had.
+                const wait = isOffline()
+                    ? remaining()
+                    : (_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);
@@ -900,14 +928,21 @@ async function withSearchResilience(attempt, callerSignal, options = {}) {
     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.
+// Ask can't reuse withSearchResilience: a half-consumed stream isn't retryable.
+// Idle timeout resets per chunk; both reject with TimeoutError so submitAsk
+// routes them to the search fallback rather than treating them as cancellation.
 const ASK_REQUEST_TIMEOUT_MS = 7000;
 const ASK_SSE_IDLE_TIMEOUT_MS = 10000;
+// Keep-warm cadence for `warm()`. 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. Lives here rather than in either caller so
+// the widget's open-scoped timer and init's headless timer can't drift apart.
+const KEEP_WARM_INTERVAL_MS = 60000;
+// Stand-in caller signal for `search()` calls that don't pass one. Module-level
+// and never aborted, so it carries no state between calls.
+const NEVER_ABORTED = new AbortController().signal;
 // 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
@@ -1066,9 +1101,13 @@ const createEvoSearchAPI = ({ fetch: fetchImpl = window.fetch, baseURL, userId,
     };
     const deleteRecent = (value) => sendMutation('/user/recents', 'DeleteRecent', 'DELETE', { value });
     const clearRecents = () => sendMutation('/user/recents', 'ClearRecents', 'DELETE');
+    // Resilience lives here, not at each call site, so no consumer can opt out —
+    // the headless channel previously had no deadline and no retry.
     const search = async (query, limit = 8, signal) => {
         logger.info(`EvoSearch API: Search request - query length: ${query.length}, limit: ${limit}`);
-        const data = await getJSON('/search', 'Search', { q: query, limit: String(limit) }, signal);
+        const data = await withSearchResilience((attemptSignal) => getJSON('/search', 'Search', { q: query, limit: String(limit) }, attemptSignal), 
+        // Shared stand-in is safe: the wrapper removes its abort listener per attempt.
+        signal !== null && signal !== void 0 ? signal : NEVER_ABORTED);
         logger.info(`EvoSearch API: Search success - ${data.llmSuggestions.length} suggestions, ${data.products.length} products`);
         return data;
     };
@@ -1266,6 +1305,36 @@ const parseSseFrame = (frame) => {
 };
 
 const error = (message) => console.error(message);
+// Headless hosts render their own UI, so nothing else pings /warm for them.
+let disposeKeepWarm;
+// A ping on load, on the interval, and on the two events that mean the shopper
+// is back — tab return, and the network returning after a sleep suspended the
+// timer. Skipped while hidden: no keystroke is coming and /warm shares its
+// per-IP bucket with /search.
+const startHeadlessKeepWarm = (api) => {
+    // Repeated init() would otherwise leave earlier timers and listeners warming
+    // a replaced API forever.
+    disposeKeepWarm === null || disposeKeepWarm === void 0 ? void 0 : disposeKeepWarm();
+    const ping = () => {
+        if (!document.hidden) {
+            void api.warm();
+        }
+    };
+    ping();
+    const timer = setInterval(ping, KEEP_WARM_INTERVAL_MS);
+    document.addEventListener('visibilitychange', ping);
+    window.addEventListener('online', ping);
+    disposeKeepWarm = () => {
+        clearInterval(timer);
+        document.removeEventListener('visibilitychange', ping);
+        window.removeEventListener('online', ping);
+        // Stopping the cadence must also kill an in-flight retry chain: a
+        // black-holed /warm would otherwise keep re-establishing connections for
+        // the wrapper's full budget against a replaced API.
+        api.cancelWarm();
+        disposeKeepWarm = undefined;
+    };
+};
 const init = (params) => {
     var _a, _b, _c, _d, _e, _f, _g, _h;
     if (typeof window == 'undefined' || typeof document == 'undefined') {
@@ -1274,6 +1343,9 @@ const init = (params) => {
     try {
         (_a = window[registryKey]) !== null && _a !== void 0 ? _a : (window[registryKey] = {});
         logger.info('EvoSearch SDK: Initializing');
+        // A re-init can land on a different channel, or bail out entirely, so drop
+        // any previous cadence before deciding which one this run owns.
+        disposeKeepWarm === null || disposeKeepWarm === void 0 ? void 0 : disposeKeepWarm();
         if (new URLSearchParams(window.location.search).get('evs') === 'preview') {
             try {
                 sessionStorage.setItem(previewKeyName, '1');
@@ -1313,8 +1385,12 @@ const init = (params) => {
             options: { destination: params.baseUrl },
         });
         if (!uiImplementation) {
-            if ((_f = (_e = params.manifest) === null || _e === void 0 ? void 0 : _e.variables) === null || _f === void 0 ? void 0 : _f.disableDefaultUI) {
+            if (((_f = (_e = params.manifest) === null || _e === void 0 ? void 0 : _e.variables) === null || _f === void 0 ? void 0 : _f.disableDefaultUI) === true) {
                 logger.info('EvoSearch SDK: Running in headless mode, no default UI will render');
+                // Deliberately keyed on `disableDefaultUI` rather than bare `headless`:
+                // in the else branch the UI is missing by mistake, so search isn't
+                // usable and there's no connection worth holding open.
+                startHeadlessKeepWarm(evoSearchAPI);
             }
             else {
                 error('UI implementation is missing');
@@ -8495,12 +8571,6 @@ const searchWidgetStyles = i$6 `
 `;
 
 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',
@@ -8590,7 +8660,27 @@ class SearchWidget extends ElementWithStylesheet {
         // autocomplete can't overwrite a fresh search's results.
         this.requestGeneration = 0;
         this.keydownListener = (event) => this.handleKeydown(event);
-        this.onlineListener = () => this.handleReconnect();
+        // The keep-warm interval below is skipped while hidden, so the next tick can
+        // be a minute after the shopper returns — re-establish on both signals that
+        // mean they're back: tab return, and the network returning after a sleep
+        // suspended the timer. Bails out while hidden: no keystroke is coming, and
+        // both /warm and the self-heal /search share the per-IP bucket. A tab that
+        // errored while hidden heals on the visibilitychange leg instead.
+        // Warm before re-querying: re-querying first would pay connection setup on
+        // the query itself, which is what wedges. warm() never rejects.
+        this.rewarmListener = async () => {
+            var _a, _b;
+            if (document.hidden) {
+                return;
+            }
+            await ((_b = (_a = this.api) === null || _a === void 0 ? void 0 : _a.warm) === null || _b === void 0 ? void 0 : _b.call(_a));
+            // The overlay can close during the await; handleReconnect would otherwise
+            // issue a query and mutate state on a detached widget.
+            if (!this.isConnected) {
+                return;
+            }
+            this.handleReconnect();
+        };
         // Streaming tokens are coalesced into one per-frame state update rather than
         // reassigning `askAnswer` on every token — a ~220-token answer would
         // otherwise trigger ~220 full widget renders.
@@ -8665,7 +8755,8 @@ class SearchWidget extends ElementWithStylesheet {
         this.mobileMediaQuery = window.matchMedia('(max-width: 768px)');
         this.isMobile = this.mobileMediaQuery.matches;
         this.mobileMediaQuery.addEventListener('change', this.mobileMediaListener);
-        window.addEventListener('online', this.onlineListener);
+        window.addEventListener('online', this.rewarmListener);
+        document.addEventListener('visibilitychange', this.rewarmListener);
         // 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 —
@@ -8715,7 +8806,8 @@ class SearchWidget extends ElementWithStylesheet {
         this.resetAnswerBuffer();
         this.removeEventListener('keydown', this.keydownListener);
         (_e = this.mobileMediaQuery) === null || _e === void 0 ? void 0 : _e.removeEventListener('change', this.mobileMediaListener);
-        window.removeEventListener('online', this.onlineListener);
+        window.removeEventListener('online', this.rewarmListener);
+        document.removeEventListener('visibilitychange', this.rewarmListener);
         super.disconnectedCallback();
     }
     willUpdate(changed) {
@@ -9135,7 +9227,9 @@ class SearchWidget extends ElementWithStylesheet {
                 return;
             }
             const api = this.api;
-            const response = await withSearchResilience((signal) => api.search(query, undefined, signal), this.newResultsSignal());
+            // api.search() now owns the per-attempt timeout and retry, so wrapping
+            // here would double-wrap to 9 attempts.
+            const response = await api.search(query, undefined, this.newResultsSignal());
             if (generation !== this.requestGeneration) {
                 return;
             }
@@ -9181,7 +9275,9 @@ class SearchWidget extends ElementWithStylesheet {
                 return;
             }
             const api = this.api;
-            const response = await withSearchResilience((signal) => api.search(query, undefined, signal), this.newResultsSignal());
+            // api.search() now owns the per-attempt timeout and retry, so wrapping
+            // here would double-wrap to 9 attempts.
+            const response = await api.search(query, undefined, this.newResultsSignal());
             if (generation !== this.requestGeneration) {
                 return;
             }