@blotoutio/providers-evo-search-sdk 1.66.2 → 1.67.0

package/core.js

@@ -599,6 +599,19 @@ var ProvidersEvoSearchSdk = (function () {
             return false;
         }
     };
+    // Session-sticky opt-out for internal QA: ?evs=off suppresses the widget even
+    // when the manifest has it enabled, so the merchant's default site can be
+    // previewed. Takes precedence over both `enabled` and the preview flag.
+    const disableKeyName = 'disableEvoSearch';
+    const hasDisableKey = () => {
+        var _a;
+        try {
+            return ((_a = sessionStorage.getItem(disableKeyName)) !== null && _a !== void 0 ? _a : '0') === '1';
+        }
+        catch {
+            return false;
+        }
+    };
 
     var _a;
     const registryKey = Symbol.for('evo-search');
@@ -641,6 +654,10 @@ var ProvidersEvoSearchSdk = (function () {
     // caller-superseded (aborted) request. Shared by the widget and the headless
     // hook. See callers: search-widget.ts (performAutocomplete) and
     // hooks/use-evo-search.ts.
+    // Per-attempt budget for /search/image, shared by the widget and the headless
+    // hook so the two can't drift. Wider than the text search's 7s: the request
+    // carries an upload and waits on a multimodal embedding.
+    const IMAGE_SEARCH_TIMEOUT_MS = 15000;
     const DEFAULTS = {
         timeoutMs: 7000,
         retries: 2,
@@ -744,6 +761,126 @@ var ProvidersEvoSearchSdk = (function () {
         throw lastError;
     }
 
+    // Client-side downscale for image search. The worker caps the decoded upload at
+    // ~1.5MB and every request costs a multimodal embed, so shrinking a phone photo
+    // here (a 12MP JPEG is ~4MB) is what keeps the request inside the cap and the
+    // upload quick on mobile data. Matches the sync-time `imageEmbedWidth` (see
+    // search-tuning.ts) so query and index renditions land in the same Gemini
+    // tiling bracket — a JPEG at this edge is still two orders of magnitude below
+    // the worker's decoded-size cap.
+    const MAX_IMAGE_EDGE = 768;
+    const JPEG_QUALITY = 0.85;
+    // Fallback decode for engines without createImageBitmap. Orientation here is
+    // whatever the UA's `image-orientation` default is — see decodeImage.
+    const loadImage = (source) => new Promise((resolve, reject) => {
+        const objectUrl = URL.createObjectURL(source);
+        const image = new Image();
+        image.onload = () => {
+            URL.revokeObjectURL(objectUrl);
+            resolve(image);
+        };
+        image.onerror = () => {
+            URL.revokeObjectURL(objectUrl);
+            reject(new Error('Image could not be decoded'));
+        };
+        image.src = objectUrl;
+    });
+    // createImageBitmap pins EXIF orientation explicitly, so a portrait phone photo
+    // is embedded upright even on engines that predate the
+    // `image-orientation: from-image` default (older iOS Safari, the embedded
+    // Android WebViews storefront traffic includes) — a sideways embed degrades
+    // retrieval with no error to show for it. It also skips the full-size <img>
+    // decode. So it goes first, and the <img> path catches everything it can't do:
+    // engines that lack the API, and the sources it rejects outright but <img>
+    // renders (an SVG with no intrinsic size is the one that shows up).
+    // A very large source can still yield a blank canvas on old iOS; if blank
+    // embeds are ever observed, add a source pixel-count ceiling here.
+    const decodeImage = async (source) => {
+        if (typeof createImageBitmap === 'function') {
+            try {
+                const bitmap = await createImageBitmap(source, {
+                    imageOrientation: 'from-image',
+                });
+                return {
+                    image: bitmap,
+                    width: bitmap.width,
+                    height: bitmap.height,
+                    // Phone memory doesn't wait for GC to reclaim a decoded bitmap.
+                    release: () => bitmap.close(),
+                };
+            }
+            catch {
+                // Fall through: a rejection here means "this decoder can't", not "this
+                // isn't an image". The legacy path decides, and only its failure is the
+                // shopper's error.
+            }
+        }
+        const image = await loadImage(source);
+        return {
+            image,
+            width: image.naturalWidth,
+            height: image.naturalHeight,
+            release: () => undefined,
+        };
+    };
+    // Draw `image` — or just `region` of it — into a fresh canvas whose longest
+    // edge is at most `maxEdge`, on a white ground. A cropped region is scaled to
+    // the same edge cap as the whole frame, so a selection is embedded at the
+    // resolution the index renditions were built at rather than at whatever
+    // fraction of the frame it happened to occupy.
+    const renderToCanvas = (image, sourceWidth, sourceHeight, maxEdge, region) => {
+        const sx = region ? Math.round(region.x * sourceWidth) : 0;
+        const sy = region ? Math.round(region.y * sourceHeight) : 0;
+        const sw = region
+            ? Math.max(1, Math.round(region.w * sourceWidth))
+            : sourceWidth;
+        const sh = region
+            ? Math.max(1, Math.round(region.h * sourceHeight))
+            : sourceHeight;
+        const longestEdge = Math.max(sw, sh);
+        const scale = longestEdge > maxEdge ? maxEdge / longestEdge : 1;
+        const canvas = document.createElement('canvas');
+        canvas.width = Math.max(1, Math.round(sw * scale));
+        canvas.height = Math.max(1, Math.round(sh * scale));
+        const context = canvas.getContext('2d');
+        if (!context) {
+            throw new Error('Canvas is unavailable');
+        }
+        // JPEG has no alpha, so a transparent source (a PNG/WebP cutout, the common
+        // paste case) would otherwise composite onto the canvas's transparent-black
+        // default and be embedded as a black-backed product. Catalog shots are
+        // typically white-background, so white is the closer prior.
+        context.fillStyle = '#ffffff';
+        context.fillRect(0, 0, canvas.width, canvas.height);
+        if (region) {
+            context.drawImage(image, sx, sy, sw, sh, 0, 0, canvas.width, canvas.height);
+        }
+        else {
+            context.drawImage(image, 0, 0, canvas.width, canvas.height);
+        }
+        return canvas;
+    };
+    /**
+     * Downscale `source` to a JPEG data URI whose longest edge is at most
+     * `MAX_IMAGE_EDGE`, upright regardless of the source's EXIF orientation.
+     * Rejects anything that isn't an image, and anything the browser can't decode
+     * (HEIC off iOS, corrupt files) — every input path (file picker, drop, paste) is
+     * shopper-controlled, so this is the trust boundary that keeps a stray PDF or
+     * text drop off the wire.
+     */
+    const downscaleImage = async (source) => {
+        if (!source.type.startsWith('image/')) {
+            throw new Error('Only image files can be searched');
+        }
+        const { image, width, height, release } = await decodeImage(source);
+        try {
+            return renderToCanvas(image, width, height, MAX_IMAGE_EDGE).toDataURL('image/jpeg', JPEG_QUALITY);
+        }
+        finally {
+            release();
+        }
+    };
+
     // 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.
@@ -927,6 +1064,62 @@ var ProvidersEvoSearchSdk = (function () {
             logger.info(`EvoSearch API: Search success - ${data.llmSuggestions.length} suggestions, ${data.products.length} products`);
             return data;
         };
+        // Image search. Unlike `/search` there is no response cache on the worker
+        // side and every call costs a multimodal embedding, so callers must debounce
+        // and abort rather than fire per keystroke. A 403 `{disabled:true}` means the
+        // merchant turned visual search off — surfaced as `disabled` on the thrown
+        // error so the widget can hide the affordance instead of showing an error.
+        //
+        // A File/Blob (the common case headlessly: straight off an `<input
+        // type="file">`) is downscaled and JPEG-encoded here, which is both the size
+        // cap the worker enforces and the trust boundary that keeps a non-image off
+        // the wire. A string is assumed to be a prepared data URI and passes through.
+        const searchImage = async (image, text, limit, signal) => {
+            var _a;
+            const dataUri = typeof image === 'string' ? image : await downscaleImage(image);
+            logger.info(`EvoSearch API: Image search request - text length: ${(_a = text === null || text === void 0 ? void 0 : text.length) !== null && _a !== void 0 ? _a : 0}`);
+            const headers = getHeaders();
+            headers.set('Content-Type', 'application/json');
+            // The widget and the hook wrap this in a no-retry resilience budget; a raw
+            // consumer that passes no signal gets the same deadline here rather than a
+            // request that can hang indefinitely.
+            const controller = new AbortController();
+            const onCallerAbort = () => controller.abort();
+            signal === null || signal === void 0 ? void 0 : signal.addEventListener('abort', onCallerAbort);
+            if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+                controller.abort();
+            }
+            const timer = setTimeout(() => controller.abort(), IMAGE_SEARCH_TIMEOUT_MS);
+            let response;
+            try {
+                response = await fetchImpl(getURL('/search/image'), {
+                    method: 'POST',
+                    headers,
+                    body: JSON.stringify({
+                        image: dataUri,
+                        ...(text ? { text } : {}),
+                        ...(limit === undefined ? {} : { limit }),
+                    }),
+                    credentials: 'omit',
+                    signal: controller.signal,
+                });
+            }
+            finally {
+                clearTimeout(timer);
+                signal === null || signal === void 0 ? void 0 : signal.removeEventListener('abort', onCallerAbort);
+            }
+            if (!response.ok) {
+                const errorText = await response.text().catch(() => '');
+                logger.error(`EvoSearch API: ImageSearch failed - ${response.status}: ${errorText}`);
+                const error = new Error(`ImageSearch failed - ${response.status}`);
+                error.status = response.status;
+                if (response.status === 403 && isDisabledBody(errorText)) {
+                    error.disabled = true;
+                }
+                throw error;
+            }
+            return (await response.json());
+        };
         // SSE consumer for Ask AI. Decodes `event: <type>\ndata: <json>` frames
         // from the worker stream and yields typed events as they arrive. Caller
         // aborts via the AbortSignal — fetch teardown closes the underlying
@@ -1092,10 +1285,19 @@ var ProvidersEvoSearchSdk = (function () {
                 clearRecents,
             },
             search,
+            searchImage,
             askStream,
             sendEvent,
         };
     };
+    const isDisabledBody = (body) => {
+        try {
+            return JSON.parse(body).disabled === true;
+        }
+        catch {
+            return false;
+        }
+    };
     const parseSseFrame = (frame) => {
         let eventType = '';
         const dataLines = [];
@@ -1162,8 +1364,10 @@ var ProvidersEvoSearchSdk = (function () {
             // 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') {
+            const evsParam = new URLSearchParams(window.location.search).get('evs');
+            if (evsParam === 'preview') {
                 try {
+                    sessionStorage.removeItem(disableKeyName);
                     sessionStorage.setItem(previewKeyName, '1');
                     logger.info('EvoSearch SDK: Preview mode enabled via ?evs=preview URL param');
                 }
@@ -1171,11 +1375,32 @@ var ProvidersEvoSearchSdk = (function () {
                     error('EvoSearch SDK: Failed to set previewEvoSearch sessionStorage');
                 }
             }
+            else if (evsParam === 'off') {
+                try {
+                    sessionStorage.removeItem(previewKeyName);
+                    sessionStorage.setItem(disableKeyName, '1');
+                    logger.info('EvoSearch SDK: Disabled via ?evs=off URL param');
+                }
+                catch {
+                    error('EvoSearch SDK: Failed to set disableEvoSearch sessionStorage');
+                }
+            }
+            else if (evsParam === 'reset') {
+                try {
+                    sessionStorage.removeItem(previewKeyName);
+                    sessionStorage.removeItem(disableKeyName);
+                    logger.info('EvoSearch SDK: Reset to configured state via ?evs=reset URL param');
+                }
+                catch {
+                    error('EvoSearch SDK: Failed to clear evoSearch sessionStorage');
+                }
+            }
             const { enabled, uiPreferences, askAi } = (_c = (_b = params.manifest) === null || _b === void 0 ? void 0 : _b.variables) !== null && _c !== void 0 ? _c : {};
             const mode = uiPreferences === null || uiPreferences === void 0 ? void 0 : uiPreferences.mode;
             const askAiEnabled = (askAi === null || askAi === void 0 ? void 0 : askAi.enabled) === true;
+            const visualSearchEnabled = (uiPreferences === null || uiPreferences === void 0 ? void 0 : uiPreferences.visualSearch) === true;
             const hasPreview = hasPreviewKey();
-            const shouldEnable = enabled || hasPreview;
+            const shouldEnable = !hasDisableKey() && (enabled || hasPreview);
             if (!shouldEnable) {
                 logger.info('EvoSearch SDK: Mode is disabled, skipping initialization');
                 return;
@@ -1223,6 +1448,7 @@ var ProvidersEvoSearchSdk = (function () {
                 api: evoSearchAPI,
                 uiPreferences,
                 askAiEnabled,
+                visualSearchEnabled,
             });
             params.sendTag({
                 eventId: crypto.randomUUID(),
@@ -1245,7 +1471,7 @@ var ProvidersEvoSearchSdk = (function () {
     const tag = ({ data }) => {
         try {
             return {
-                sdkVersion: "1.66.2" || '',
+                sdkVersion: "1.67.0" || '',
                 searchQuery: data['searchQuery'],
                 searchResults: data['searchResults'],
                 timestamp: Date.now(),
@@ -1254,7 +1480,7 @@ var ProvidersEvoSearchSdk = (function () {
         catch (err) {
             console.error(`EvoSearch SDK: Tagging failed - ${err}`);
             return {
-                sdkVersion: "1.66.2" ,
+                sdkVersion: "1.67.0" ,
                 timestamp: Date.now(),
             };
         }

package/core.mjs

@@ -596,6 +596,19 @@ const hasPreviewKey = () => {
         return false;
     }
 };
+// Session-sticky opt-out for internal QA: ?evs=off suppresses the widget even
+// when the manifest has it enabled, so the merchant's default site can be
+// previewed. Takes precedence over both `enabled` and the preview flag.
+const disableKeyName = 'disableEvoSearch';
+const hasDisableKey = () => {
+    var _a;
+    try {
+        return ((_a = sessionStorage.getItem(disableKeyName)) !== null && _a !== void 0 ? _a : '0') === '1';
+    }
+    catch {
+        return false;
+    }
+};
 
 var _a;
 const registryKey = Symbol.for('evo-search');
@@ -638,6 +651,10 @@ const notifyReady = () => {
 // caller-superseded (aborted) request. Shared by the widget and the headless
 // hook. See callers: search-widget.ts (performAutocomplete) and
 // hooks/use-evo-search.ts.
+// Per-attempt budget for /search/image, shared by the widget and the headless
+// hook so the two can't drift. Wider than the text search's 7s: the request
+// carries an upload and waits on a multimodal embedding.
+const IMAGE_SEARCH_TIMEOUT_MS = 15000;
 const DEFAULTS = {
     timeoutMs: 7000,
     retries: 2,
@@ -741,6 +758,126 @@ async function withSearchResilience(attempt, callerSignal, options = {}) {
     throw lastError;
 }
 
+// Client-side downscale for image search. The worker caps the decoded upload at
+// ~1.5MB and every request costs a multimodal embed, so shrinking a phone photo
+// here (a 12MP JPEG is ~4MB) is what keeps the request inside the cap and the
+// upload quick on mobile data. Matches the sync-time `imageEmbedWidth` (see
+// search-tuning.ts) so query and index renditions land in the same Gemini
+// tiling bracket — a JPEG at this edge is still two orders of magnitude below
+// the worker's decoded-size cap.
+const MAX_IMAGE_EDGE = 768;
+const JPEG_QUALITY = 0.85;
+// Fallback decode for engines without createImageBitmap. Orientation here is
+// whatever the UA's `image-orientation` default is — see decodeImage.
+const loadImage = (source) => new Promise((resolve, reject) => {
+    const objectUrl = URL.createObjectURL(source);
+    const image = new Image();
+    image.onload = () => {
+        URL.revokeObjectURL(objectUrl);
+        resolve(image);
+    };
+    image.onerror = () => {
+        URL.revokeObjectURL(objectUrl);
+        reject(new Error('Image could not be decoded'));
+    };
+    image.src = objectUrl;
+});
+// createImageBitmap pins EXIF orientation explicitly, so a portrait phone photo
+// is embedded upright even on engines that predate the
+// `image-orientation: from-image` default (older iOS Safari, the embedded
+// Android WebViews storefront traffic includes) — a sideways embed degrades
+// retrieval with no error to show for it. It also skips the full-size <img>
+// decode. So it goes first, and the <img> path catches everything it can't do:
+// engines that lack the API, and the sources it rejects outright but <img>
+// renders (an SVG with no intrinsic size is the one that shows up).
+// A very large source can still yield a blank canvas on old iOS; if blank
+// embeds are ever observed, add a source pixel-count ceiling here.
+const decodeImage = async (source) => {
+    if (typeof createImageBitmap === 'function') {
+        try {
+            const bitmap = await createImageBitmap(source, {
+                imageOrientation: 'from-image',
+            });
+            return {
+                image: bitmap,
+                width: bitmap.width,
+                height: bitmap.height,
+                // Phone memory doesn't wait for GC to reclaim a decoded bitmap.
+                release: () => bitmap.close(),
+            };
+        }
+        catch {
+            // Fall through: a rejection here means "this decoder can't", not "this
+            // isn't an image". The legacy path decides, and only its failure is the
+            // shopper's error.
+        }
+    }
+    const image = await loadImage(source);
+    return {
+        image,
+        width: image.naturalWidth,
+        height: image.naturalHeight,
+        release: () => undefined,
+    };
+};
+// Draw `image` — or just `region` of it — into a fresh canvas whose longest
+// edge is at most `maxEdge`, on a white ground. A cropped region is scaled to
+// the same edge cap as the whole frame, so a selection is embedded at the
+// resolution the index renditions were built at rather than at whatever
+// fraction of the frame it happened to occupy.
+const renderToCanvas = (image, sourceWidth, sourceHeight, maxEdge, region) => {
+    const sx = region ? Math.round(region.x * sourceWidth) : 0;
+    const sy = region ? Math.round(region.y * sourceHeight) : 0;
+    const sw = region
+        ? Math.max(1, Math.round(region.w * sourceWidth))
+        : sourceWidth;
+    const sh = region
+        ? Math.max(1, Math.round(region.h * sourceHeight))
+        : sourceHeight;
+    const longestEdge = Math.max(sw, sh);
+    const scale = longestEdge > maxEdge ? maxEdge / longestEdge : 1;
+    const canvas = document.createElement('canvas');
+    canvas.width = Math.max(1, Math.round(sw * scale));
+    canvas.height = Math.max(1, Math.round(sh * scale));
+    const context = canvas.getContext('2d');
+    if (!context) {
+        throw new Error('Canvas is unavailable');
+    }
+    // JPEG has no alpha, so a transparent source (a PNG/WebP cutout, the common
+    // paste case) would otherwise composite onto the canvas's transparent-black
+    // default and be embedded as a black-backed product. Catalog shots are
+    // typically white-background, so white is the closer prior.
+    context.fillStyle = '#ffffff';
+    context.fillRect(0, 0, canvas.width, canvas.height);
+    if (region) {
+        context.drawImage(image, sx, sy, sw, sh, 0, 0, canvas.width, canvas.height);
+    }
+    else {
+        context.drawImage(image, 0, 0, canvas.width, canvas.height);
+    }
+    return canvas;
+};
+/**
+ * Downscale `source` to a JPEG data URI whose longest edge is at most
+ * `MAX_IMAGE_EDGE`, upright regardless of the source's EXIF orientation.
+ * Rejects anything that isn't an image, and anything the browser can't decode
+ * (HEIC off iOS, corrupt files) — every input path (file picker, drop, paste) is
+ * shopper-controlled, so this is the trust boundary that keeps a stray PDF or
+ * text drop off the wire.
+ */
+const downscaleImage = async (source) => {
+    if (!source.type.startsWith('image/')) {
+        throw new Error('Only image files can be searched');
+    }
+    const { image, width, height, release } = await decodeImage(source);
+    try {
+        return renderToCanvas(image, width, height, MAX_IMAGE_EDGE).toDataURL('image/jpeg', JPEG_QUALITY);
+    }
+    finally {
+        release();
+    }
+};
+
 // 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.
@@ -924,6 +1061,62 @@ const createEvoSearchAPI = ({ fetch: fetchImpl = window.fetch, baseURL, userId,
         logger.info(`EvoSearch API: Search success - ${data.llmSuggestions.length} suggestions, ${data.products.length} products`);
         return data;
     };
+    // Image search. Unlike `/search` there is no response cache on the worker
+    // side and every call costs a multimodal embedding, so callers must debounce
+    // and abort rather than fire per keystroke. A 403 `{disabled:true}` means the
+    // merchant turned visual search off — surfaced as `disabled` on the thrown
+    // error so the widget can hide the affordance instead of showing an error.
+    //
+    // A File/Blob (the common case headlessly: straight off an `<input
+    // type="file">`) is downscaled and JPEG-encoded here, which is both the size
+    // cap the worker enforces and the trust boundary that keeps a non-image off
+    // the wire. A string is assumed to be a prepared data URI and passes through.
+    const searchImage = async (image, text, limit, signal) => {
+        var _a;
+        const dataUri = typeof image === 'string' ? image : await downscaleImage(image);
+        logger.info(`EvoSearch API: Image search request - text length: ${(_a = text === null || text === void 0 ? void 0 : text.length) !== null && _a !== void 0 ? _a : 0}`);
+        const headers = getHeaders();
+        headers.set('Content-Type', 'application/json');
+        // The widget and the hook wrap this in a no-retry resilience budget; a raw
+        // consumer that passes no signal gets the same deadline here rather than a
+        // request that can hang indefinitely.
+        const controller = new AbortController();
+        const onCallerAbort = () => controller.abort();
+        signal === null || signal === void 0 ? void 0 : signal.addEventListener('abort', onCallerAbort);
+        if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+            controller.abort();
+        }
+        const timer = setTimeout(() => controller.abort(), IMAGE_SEARCH_TIMEOUT_MS);
+        let response;
+        try {
+            response = await fetchImpl(getURL('/search/image'), {
+                method: 'POST',
+                headers,
+                body: JSON.stringify({
+                    image: dataUri,
+                    ...(text ? { text } : {}),
+                    ...(limit === undefined ? {} : { limit }),
+                }),
+                credentials: 'omit',
+                signal: controller.signal,
+            });
+        }
+        finally {
+            clearTimeout(timer);
+            signal === null || signal === void 0 ? void 0 : signal.removeEventListener('abort', onCallerAbort);
+        }
+        if (!response.ok) {
+            const errorText = await response.text().catch(() => '');
+            logger.error(`EvoSearch API: ImageSearch failed - ${response.status}: ${errorText}`);
+            const error = new Error(`ImageSearch failed - ${response.status}`);
+            error.status = response.status;
+            if (response.status === 403 && isDisabledBody(errorText)) {
+                error.disabled = true;
+            }
+            throw error;
+        }
+        return (await response.json());
+    };
     // SSE consumer for Ask AI. Decodes `event: <type>\ndata: <json>` frames
     // from the worker stream and yields typed events as they arrive. Caller
     // aborts via the AbortSignal — fetch teardown closes the underlying
@@ -1089,10 +1282,19 @@ const createEvoSearchAPI = ({ fetch: fetchImpl = window.fetch, baseURL, userId,
             clearRecents,
         },
         search,
+        searchImage,
         askStream,
         sendEvent,
     };
 };
+const isDisabledBody = (body) => {
+    try {
+        return JSON.parse(body).disabled === true;
+    }
+    catch {
+        return false;
+    }
+};
 const parseSseFrame = (frame) => {
     let eventType = '';
     const dataLines = [];
@@ -1159,8 +1361,10 @@ const init = (params) => {
         // 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') {
+        const evsParam = new URLSearchParams(window.location.search).get('evs');
+        if (evsParam === 'preview') {
             try {
+                sessionStorage.removeItem(disableKeyName);
                 sessionStorage.setItem(previewKeyName, '1');
                 logger.info('EvoSearch SDK: Preview mode enabled via ?evs=preview URL param');
             }
@@ -1168,11 +1372,32 @@ const init = (params) => {
                 error('EvoSearch SDK: Failed to set previewEvoSearch sessionStorage');
             }
         }
+        else if (evsParam === 'off') {
+            try {
+                sessionStorage.removeItem(previewKeyName);
+                sessionStorage.setItem(disableKeyName, '1');
+                logger.info('EvoSearch SDK: Disabled via ?evs=off URL param');
+            }
+            catch {
+                error('EvoSearch SDK: Failed to set disableEvoSearch sessionStorage');
+            }
+        }
+        else if (evsParam === 'reset') {
+            try {
+                sessionStorage.removeItem(previewKeyName);
+                sessionStorage.removeItem(disableKeyName);
+                logger.info('EvoSearch SDK: Reset to configured state via ?evs=reset URL param');
+            }
+            catch {
+                error('EvoSearch SDK: Failed to clear evoSearch sessionStorage');
+            }
+        }
         const { enabled, uiPreferences, askAi } = (_c = (_b = params.manifest) === null || _b === void 0 ? void 0 : _b.variables) !== null && _c !== void 0 ? _c : {};
         const mode = uiPreferences === null || uiPreferences === void 0 ? void 0 : uiPreferences.mode;
         const askAiEnabled = (askAi === null || askAi === void 0 ? void 0 : askAi.enabled) === true;
+        const visualSearchEnabled = (uiPreferences === null || uiPreferences === void 0 ? void 0 : uiPreferences.visualSearch) === true;
         const hasPreview = hasPreviewKey();
-        const shouldEnable = enabled || hasPreview;
+        const shouldEnable = !hasDisableKey() && (enabled || hasPreview);
         if (!shouldEnable) {
             logger.info('EvoSearch SDK: Mode is disabled, skipping initialization');
             return;
@@ -1220,6 +1445,7 @@ const init = (params) => {
             api: evoSearchAPI,
             uiPreferences,
             askAiEnabled,
+            visualSearchEnabled,
         });
         params.sendTag({
             eventId: crypto.randomUUID(),
@@ -1242,7 +1468,7 @@ const init = (params) => {
 const tag = ({ data }) => {
     try {
         return {
-            sdkVersion: "1.66.2" || '',
+            sdkVersion: "1.67.0" || '',
             searchQuery: data['searchQuery'],
             searchResults: data['searchResults'],
             timestamp: Date.now(),
@@ -1251,7 +1477,7 @@ const tag = ({ data }) => {
     catch (err) {
         console.error(`EvoSearch SDK: Tagging failed - ${err}`);
         return {
-            sdkVersion: "1.66.2" ,
+            sdkVersion: "1.67.0" ,
             timestamp: Date.now(),
         };
     }