@gemboss/gem-framework 0.4.0

package/dist/gem-runtime.js

@@ -0,0 +1,880 @@
+(() => {
+  const config = {"planId":"gem-framework-package","base":"gem-native","dawnAdapter":false,"plugins":[{"key":"cart-drawer","loadStrategy":"interaction","dependsOn":[]},{"key":"mobile-menu","loadStrategy":"interaction","dependsOn":[]},{"key":"quantity-input","loadStrategy":"interaction","dependsOn":[]},{"key":"variant-selects","loadStrategy":"interaction","dependsOn":[]},{"key":"predictive-search","loadStrategy":"critical","dependsOn":[]},{"key":"localization","loadStrategy":"interaction","dependsOn":[]},{"key":"disclosure","loadStrategy":"interaction","dependsOn":[]},{"key":"tabs","loadStrategy":"interaction","dependsOn":[]},{"key":"media-gallery","loadStrategy":"viewport","dependsOn":[]},{"key":"carousel","loadStrategy":"viewport","dependsOn":[]},{"key":"hero-slideshow","loadStrategy":"idle","dependsOn":[]},{"key":"quick-view","loadStrategy":"interaction","dependsOn":[]},{"key":"promo-popup","loadStrategy":"idle","dependsOn":[]},{"key":"before_after","loadStrategy":"viewport","dependsOn":[]},{"key":"runtime-slot-loader","loadStrategy":"idle","dependsOn":[]},{"key":"sticky-atc","loadStrategy":"viewport","dependsOn":[]},{"key":"recently-viewed","loadStrategy":"idle","dependsOn":[]},{"key":"countdown","loadStrategy":"viewport","dependsOn":[]},{"key":"reveal-on-scroll","loadStrategy":"viewport","dependsOn":[]},{"key":"seasonal-effects","loadStrategy":"idle","dependsOn":[]},{"key":"context-adapter","loadStrategy":"idle","dependsOn":[]},{"key":"offer-engine","loadStrategy":"interaction","dependsOn":[]}]};
+  const target = window;
+  const existing = target.GemTheme || {};
+  const listeners = existing.listeners || {};
+  const api = {
+    ...existing,
+    config,
+    listeners,
+    on(event, callback) {
+      (listeners[event] ||= []).push(callback);
+      return () => { listeners[event] = (listeners[event] || []).filter((item) => item !== callback); };
+    },
+    emit(event, detail = {}) {
+      document.dispatchEvent(new CustomEvent(event, { detail }));
+      for (const callback of listeners[event] || []) callback(detail);
+    },
+  };
+  target.GemTheme = api;
+  const pluginRegistry = {};
+  const loadedPlugins = {};
+  const hasPlugin = (key) => config.plugins.some((plugin) => plugin.key === key);
+  const pluginConfig = (key) => config.plugins.find((plugin) => plugin.key === key);
+  const registerPlugin = (key, setup) => { pluginRegistry[key] = setup; };
+  const loadPlugin = (key, reason = 'direct') => {
+    const spec = pluginConfig(key);
+    if (!spec || loadedPlugins[key]) return false;
+    for (const dependency of spec.dependsOn || []) loadPlugin(dependency, 'dependency');
+    const setup = pluginRegistry[key];
+    if (typeof setup === 'function') setup({ api, config, reason });
+    loadedPlugins[key] = true;
+    api.emit('gem:plugin:loaded', { key, reason, loadStrategy: spec.loadStrategy });
+    return true;
+  };
+  const onInteraction = (callback) => {
+    const events = ['click', 'focusin', 'submit', 'input', 'change'];
+    const handler = (event) => {
+      events.forEach((name) => document.removeEventListener && document.removeEventListener(name, handler, true));
+      callback(event);
+    };
+    events.forEach((name) => canListen(document) && document.addEventListener(name, handler, true));
+  };
+  const onIdle = (callback) => {
+    if (target.requestIdleCallback) target.requestIdleCallback(callback);
+    else setTimeout(callback, 0);
+  };
+  const onViewport = (callback) => {
+    if (!target.IntersectionObserver) { setTimeout(callback, 0); return; }
+    const sentinel = document.querySelector('[data-gem-plugin], [data-gem-component], .gem-section') || document.documentElement;
+    const observer = new target.IntersectionObserver((entries) => {
+      if (!entries.some((entry) => entry.isIntersecting)) return;
+      observer.disconnect();
+      callback();
+    }, { rootMargin: '160px' });
+    observer.observe(sentinel);
+  };
+  const schedulePlugin = (plugin) => {
+    if (!plugin || loadedPlugins[plugin.key]) return;
+    api.emit('gem:plugin:scheduled', { key: plugin.key, loadStrategy: plugin.loadStrategy });
+    if (plugin.loadStrategy === 'critical') loadPlugin(plugin.key, 'critical');
+    else if (plugin.loadStrategy === 'idle') onIdle(() => loadPlugin(plugin.key, 'idle'));
+    else if (plugin.loadStrategy === 'viewport') onViewport(() => loadPlugin(plugin.key, 'viewport'));
+    else onInteraction(() => loadPlugin(plugin.key, 'interaction'));
+  };
+  const canListen = (element) => Boolean(element && typeof element.addEventListener === 'function');
+  const registerNoopPlugin = (key, readyEvent) => {
+    registerPlugin(key, ({ api }) => {
+      if (readyEvent) api.emit(readyEvent, { source: 'gem-runtime' });
+    });
+  };
+  registerPlugin('cart-drawer', ({ api }) => {
+    const drawers = document.querySelectorAll('[data-gem-cart-drawer], [data-gem-cart-canvas], .gem-cart-drawer');
+    const cartLinks = document.querySelectorAll('[data-gem-cart-drawer-trigger], [data-gem-cart-toggle], a[href*="/cart"]');
+    const cartForms = document.querySelectorAll('form[action*="/cart/add"], form[action*="/cart"]');
+    const drawer = drawers[0];
+    const setDrawerA11y = (isOpen) => {
+      if (!drawer) return;
+      drawer.setAttribute && drawer.setAttribute('aria-expanded', isOpen ? 'true' : 'false');
+      const panel = drawer.querySelector && drawer.querySelector('[data-gem-cart-canvas-panel], .gem-cart-drawer__panel');
+      if (panel && panel.setAttribute) panel.setAttribute('aria-hidden', isOpen ? 'false' : 'true');
+    };
+    const openDrawer = (reason, href) => {
+      if (drawer && drawer.tagName === 'DETAILS') drawer.open = true;
+      if (drawer && drawer.dataset) drawer.dataset.gemCartDrawerState = 'open';
+      setDrawerA11y(true);
+      api.emit('gem:cart:open', { source: 'gem-runtime', reason, href });
+    };
+    const closeDrawer = (reason) => {
+      if (drawer && drawer.tagName === 'DETAILS') drawer.open = false;
+      if (drawer && drawer.dataset) drawer.dataset.gemCartDrawerState = 'closed';
+      setDrawerA11y(false);
+      api.emit('gem:cart:close', { source: 'gem-runtime', reason });
+    };
+    let bound = 0;
+    drawers.forEach((drawer) => {
+      if (!mark(drawer, 'cart-drawer')) return;
+      drawer.dataset.gemCartDrawerState = drawer.hasAttribute('open') ? 'open' : 'ready';
+      setDrawerA11y(drawer.hasAttribute('open'));
+      drawer.querySelectorAll('[data-gem-cart-drawer-close], [data-gem-cart-canvas-close]').forEach((control) => { if (!canListen(control)) return; control.addEventListener('click', (event) => {
+        event.preventDefault && event.preventDefault();
+        closeDrawer('close-control');
+      }); });
+      if (canListen(drawer)) drawer.addEventListener('toggle', () => { drawer.dataset.gemCartDrawerState = drawer.hasAttribute('open') ? 'open' : 'closed'; });
+      bound += 1;
+    });
+    cartLinks.forEach((link) => {
+      if (!mark(link, 'cart-link')) return;
+      if (!canListen(link)) return;
+      link.addEventListener('click', (event) => {
+        if (drawer && (link.hasAttribute('data-gem-cart-drawer-trigger') || link.hasAttribute('data-gem-cart-toggle'))) event.preventDefault && event.preventDefault();
+        openDrawer('cart-link', link.href || undefined);
+      });
+      bound += 1;
+    });
+    if (canListen(document)) document.addEventListener('keydown', (event) => { if (event.key === 'Escape' && drawer && drawer.hasAttribute('open')) closeDrawer('escape'); });
+    cartForms.forEach((form) => {
+      if (!mark(form, 'cart-form')) return;
+      if (!canListen(form)) return;
+      form.addEventListener('submit', () => api.emit('gem:cart:submit', { source: 'gem-runtime', action: form.getAttribute('action') || undefined }));
+      bound += 1;
+    });
+    api.emit('gem:cart:ready', { source: 'gem-runtime', count: bound });
+  });
+  registerPlugin('mobile-menu', ({ api }) => {
+    const menus = document.querySelectorAll('[data-gem-mobile-menu], details.gem-shell-header__drawer');
+    let bound = 0;
+    menus.forEach((menu) => {
+      if (!mark(menu, 'mobile-menu')) return;
+      const setMenuA11y = () => {
+        menu.setAttribute && menu.setAttribute('aria-expanded', menu.open ? 'true' : 'false');
+        const panel = menu.querySelector && menu.querySelector('[data-gem-mobile-menu-panel], .gem-shell-header__drawer-panel');
+        if (panel && panel.setAttribute) panel.setAttribute('aria-hidden', menu.open ? 'false' : 'true');
+      };
+      menu.dataset.gemMenuState = menu.open ? 'open' : 'closed';
+      setMenuA11y();
+      if (!canListen(menu)) return;
+      menu.addEventListener('toggle', () => {
+        menu.dataset.gemMenuState = menu.open ? 'open' : 'closed';
+        setMenuA11y();
+        if (menu.open) {
+          const panel = menu.querySelector && menu.querySelector('[data-gem-mobile-menu-panel], .gem-shell-header__drawer-panel');
+          const firstFocusable = panel && panel.querySelector && panel.querySelector('a[href], button, select, input, textarea, summary, [tabindex]:not([tabindex="-1"])');
+          if (firstFocusable && firstFocusable.focus) firstFocusable.focus();
+        }
+        api.emit(menu.open ? 'gem:menu:open' : 'gem:menu:close', { source: 'gem-runtime', id: menu.id || undefined });
+      });
+      menu.addEventListener('keydown', (event) => {
+        if (event.key !== 'Escape' || !menu.open) return;
+        menu.open = false;
+        menu.dataset.gemMenuState = 'closed';
+        setMenuA11y();
+        const summary = menu.querySelector && menu.querySelector('summary');
+        if (summary && summary.focus) summary.focus();
+      });
+      bound += 1;
+    });
+    api.emit('gem:menu:ready', { source: 'gem-runtime', count: bound });
+  });
+  registerPlugin('quantity-input', ({ api }) => {
+    const controls = document.querySelectorAll('[data-gem-quantity-input], .gem-quantity-input');
+    let bound = 0;
+    const clamp = (value, min, max) => Math.max(min, Math.min(max, value));
+    controls.forEach((control) => {
+      if (!mark(control, 'quantity-input')) return;
+      const input = control.querySelector && control.querySelector('input[type="number"]');
+      if (!input) return;
+      const setValue = (nextValue, reason) => {
+        const min = Number.isFinite(Number(input.min)) ? Number(input.min) : 0;
+        const max = Number.isFinite(Number(input.max)) && input.max !== '' ? Number(input.max) : Number.MAX_SAFE_INTEGER;
+        const value = clamp(Number(nextValue) || min, min, max);
+        input.value = String(value);
+        api.emit('gem:quantity:change', { source: 'gem-runtime', value, reason, name: input.name || undefined });
+      };
+      if (!canListen(control) || !canListen(input)) return;
+      control.addEventListener('click', (event) => {
+        const button = event.target && event.target.closest ? event.target.closest('[data-gem-quantity-change]') : null;
+        if (!button) return;
+        event.preventDefault && event.preventDefault();
+        const delta = Number(button.getAttribute('data-gem-quantity-change') || '0');
+        setValue(Number(input.value || 0) + delta, delta > 0 ? 'increase' : 'decrease');
+      });
+      input.addEventListener('change', () => setValue(input.value, 'input'));
+      bound += 1;
+    });
+    api.emit('gem:quantity:ready', { source: 'gem-runtime', count: bound });
+  });
+  registerPlugin('variant-selects', ({ api }) => {
+    const selects = document.querySelectorAll('[data-gem-variant-select], select[name="id"]');
+    let bound = 0;
+    selects.forEach((select) => {
+      if (!mark(select, 'variant-selects')) return;
+      let hasInitialized = false;
+      const update = () => {
+        const option = select.options && select.options[select.selectedIndex];
+        const available = !option || option.getAttribute('data-gem-variant-available') !== 'false';
+        const price = option && option.getAttribute('data-gem-variant-price');
+        const mediaId = option && option.getAttribute('data-gem-variant-media-id');
+        const form = select.closest && select.closest('form');
+        const scope = (form && form.closest && form.closest('[data-gem-section-id], .gem-section, [data-qa-surface]')) || (select.closest && select.closest('[data-gem-section-id], .gem-section, [data-qa-surface]')) || document;
+        const submit = form && form.querySelector && form.querySelector('[type="submit"]');
+        const status = form && form.querySelector && form.querySelector('[data-gem-variant-status]');
+        const priceOutput = scope && scope.querySelector && scope.querySelector('[data-gem-variant-price-output]');
+        const availabilityOutput = scope && scope.querySelector && scope.querySelector('[data-gem-variant-availability]');
+        if (form && form.dataset) form.dataset.gemSelectedVariantId = String(select.value || '');
+        if (form && form.dataset && price) form.dataset.gemSelectedVariantPrice = price;
+        if (form && form.dataset && mediaId) form.dataset.gemSelectedMediaId = mediaId;
+        if (submit) submit.disabled = !available;
+        if (submit) submit.setAttribute('aria-disabled', available ? 'false' : 'true');
+        if (status) status.textContent = available ? 'Selected variant available' : 'Selected variant unavailable';
+        if (hasInitialized && price && priceOutput) priceOutput.textContent = price;
+        if (availabilityOutput) {
+          availabilityOutput.textContent = available ? 'In stock' : 'Sold out';
+          availabilityOutput.classList && availabilityOutput.classList.toggle('gem-product-main__availability--in-stock', available);
+          availabilityOutput.classList && availabilityOutput.classList.toggle('gem-product-main__availability--sold-out', !available);
+        }
+        if (mediaId) {
+          const escapedMediaId = String(mediaId).replace(/["\\]/g, '\\$&');
+          const gallery = (scope && scope.querySelector && scope.querySelector('[data-gem-media-gallery], .gem-product-media-gallery')) || document.querySelector('[data-gem-media-gallery], .gem-product-media-gallery');
+          const thumb = gallery && gallery.querySelector && gallery.querySelector('[data-gem-media-id="' + escapedMediaId + '"]');
+          const mediaIndex = thumb && thumb.getAttribute && thumb.getAttribute('data-gem-media-index');
+          if (thumb && typeof thumb.click === 'function') thumb.click();
+          if (gallery && mediaIndex !== null && mediaIndex !== undefined) {
+            gallery.dataset && (gallery.dataset.gemMediaActiveIndex = String(mediaIndex));
+            gallery.querySelectorAll && gallery.querySelectorAll('[data-gem-media-thumb]').forEach((control) => {
+              const isActive = control.getAttribute && control.getAttribute('data-gem-media-index') === String(mediaIndex);
+              if (isActive) control.setAttribute('aria-current', 'true'); else control.removeAttribute('aria-current');
+              if (control.dataset) control.dataset.gemMediaActive = isActive ? 'true' : 'false';
+            });
+          }
+        }
+        api.emit('gem:variant:change', { source: 'gem-runtime', variantId: select.value || undefined, available, price, mediaId });
+        hasInitialized = true;
+      };
+      if (!canListen(select)) return;
+      select.addEventListener('change', update);
+      update();
+      bound += 1;
+    });
+    api.emit('gem:variant:ready', { source: 'gem-runtime', count: bound });
+  });
+  registerPlugin('predictive-search', ({ api }) => {
+    const forms = document.querySelectorAll('[data-gem-predictive-search], [data-gem-search-canvas], form[action*="/search"], form[role="search"]');
+    const toggles = document.querySelectorAll('[data-gem-search-toggle]');
+    const canvas = document.querySelector('[data-gem-search-canvas]');
+    let bound = 0;
+    const setCanvasState = (state, reason = 'api') => {
+      if (!canvas || !canvas.dataset) return false;
+      canvas.dataset.gemSearchCanvasState = state;
+      canvas.setAttribute && canvas.setAttribute('aria-hidden', state === 'open' ? 'false' : 'true');
+      if (state === 'open') {
+        const input = canvas.querySelector && canvas.querySelector('input[type="search"], input[name="q"]');
+        if (input && input.focus) input.focus();
+      }
+      api.emit(state === 'open' ? 'gem:search:open' : 'gem:search:close', { source: 'gem-runtime', reason });
+      return true;
+    };
+    forms.forEach((form) => {
+      if (!mark(form, 'predictive-search')) return;
+      const input = form.querySelector && form.querySelector('input[type="search"], input[name="q"]');
+      const results = form.querySelector && form.querySelector('[data-gem-predictive-search-results]');
+      const setState = (state, value = '') => {
+        if (form.dataset) form.dataset.gemPredictiveSearchState = state;
+        if (results) {
+          results.hidden = state === 'closed';
+          if (results.dataset) results.dataset.gemPredictiveSearchState = state;
+          results.setAttribute && results.setAttribute('aria-hidden', state === 'closed' ? 'true' : 'false');
+          if (state === 'typing') results.textContent = value ? 'Search suggestions for ' + value : 'Start typing to search';
+          if (state === 'empty') results.textContent = 'Start typing to search';
+        }
+      };
+      if (results) {
+        results.hidden = true;
+        results.setAttribute && results.setAttribute('role', 'status');
+        results.setAttribute && results.setAttribute('aria-live', 'polite');
+      }
+      setState('closed');
+      if (canListen(input)) input.addEventListener('focus', () => { setState(input.value ? 'typing' : 'empty', input.value || ''); api.emit('gem:search:open', { source: 'gem-runtime', value: input.value || '' }); });
+      const closeOnEscape = (event) => { if (event.key === 'Escape') { event.preventDefault && event.preventDefault(); event.stopPropagation && event.stopPropagation(); setState('closed'); api.emit('gem:search:close', { source: 'gem-runtime', reason: 'escape' }); } };
+      if (canListen(input)) input.addEventListener('input', () => { setState(input.value ? 'typing' : 'empty', input.value || ''); api.emit('gem:search:input', { source: 'gem-runtime', value: input.value || '' }); });
+      if (canListen(input)) input.addEventListener('keydown', closeOnEscape);
+      if (canListen(form)) form.addEventListener('keydown', closeOnEscape);
+      if (canListen(form)) form.addEventListener('submit', () => { setState('submit', input && input.value || ''); api.emit('gem:search:submit', { source: 'gem-runtime', value: input && input.value || '' }); });
+      bound += 1;
+    });
+    if (canvas) {
+      canvas.dataset && (canvas.dataset.gemSearchCanvasState = 'closed');
+      canvas.setAttribute && canvas.setAttribute('aria-hidden', 'true');
+      if (mark(canvas, 'search-canvas')) bound += 1;
+      if (canListen(canvas)) canvas.addEventListener('keydown', (event) => { if (event.key === 'Escape') setCanvasState('closed', 'escape'); });
+    }
+    toggles.forEach((toggle) => {
+      if (!mark(toggle, 'search-toggle')) return;
+      if (!canListen(toggle)) return;
+      toggle.addEventListener('click', (event) => {
+        if (canvas) event.preventDefault && event.preventDefault();
+        setCanvasState('open', 'toggle');
+      });
+      bound += 1;
+    });
+    api.emit('gem:search:ready', { source: 'gem-runtime', count: bound });
+  });
+  registerPlugin('localization', ({ api }) => {
+    const forms = document.querySelectorAll('form[action*="/localization"], form[action*="localization"], [data-gem-footer-localization], [data-gem-header-localization], .gem-navigation-shell__localization, .gem-shell-footer__localization, .gem-shell-header__localization-form');
+    let bound = 0;
+    forms.forEach((form) => {
+      if (!mark(form, 'localization')) return;
+      form.dataset && (form.dataset.gemLocalizationState = 'ready');
+      form.querySelectorAll && form.querySelectorAll('select[name="country_code"], select[name="locale_code"]').forEach((select) => {
+        if (!canListen(select)) return;
+        select.addEventListener('change', () => {
+          form.dataset && (form.dataset.gemLocalizationState = 'changed');
+          api.emit('gem:localization:change', { source: 'gem-runtime', name: select.name || undefined, value: select.value || undefined });
+        });
+      });
+      canListen(form) && form.addEventListener('submit', () => {
+        form.dataset && (form.dataset.gemLocalizationState = 'submit');
+        api.emit('gem:localization:submit', { source: 'gem-runtime' });
+      });
+      bound += 1;
+    });
+    api.emit('gem:localization:ready', { source: 'gem-runtime', count: bound });
+  });
+  registerPlugin('disclosure', ({ api }) => {
+    const items = document.querySelectorAll('details[data-gem-disclosure], .gem-accordion details, .gem-tabs details, .gem-footer-shell details, [data-gem-footer-shell] details');
+    let bound = 0;
+    items.forEach((item) => {
+      if (!mark(item, 'disclosure')) return;
+      item.dataset.gemDisclosureState = item.open ? 'open' : 'closed';
+      if (!canListen(item)) return;
+      item.addEventListener('toggle', () => {
+        item.dataset.gemDisclosureState = item.open ? 'open' : 'closed';
+        api.emit(item.open ? 'gem:disclosure:open' : 'gem:disclosure:close', { source: 'gem-runtime', id: item.id || undefined });
+      });
+      item.addEventListener('keydown', (event) => {
+        if (event.key !== 'Escape' || !item.open) return;
+        event.preventDefault && event.preventDefault();
+        item.open = false;
+        item.dataset.gemDisclosureState = 'closed';
+        const summary = item.querySelector && item.querySelector('summary');
+        if (summary && summary.focus) summary.focus();
+        api.emit('gem:disclosure:close', { source: 'gem-runtime', id: item.id || undefined, reason: 'escape' });
+      });
+      bound += 1;
+    });
+    api.emit('gem:disclosure:ready', { source: 'gem-runtime', count: bound });
+  });
+  registerPlugin('tabs', ({ api }) => {
+    const roots = document.querySelectorAll('[data-gem-tabs]');
+    let bound = 0;
+    roots.forEach((root) => {
+      if (!mark(root, 'tabs')) return;
+      const tabs = Array.prototype.slice.call(root.querySelectorAll('[data-gem-tab]'));
+      const panels = Array.prototype.slice.call(root.querySelectorAll('[data-gem-panel]'));
+      if (!tabs.length || !panels.length) return;
+      const select = (key, userInitiated) => {
+        tabs.forEach((t) => t.setAttribute('aria-selected', String(t.getAttribute('data-gem-tab') === key)));
+        let active = null;
+        panels.forEach((p) => {
+          if (p.getAttribute('data-gem-panel') === key) { p.removeAttribute('hidden'); active = p; }
+          else p.setAttribute('hidden', '');
+        });
+        if (userInitiated && active && active.getBoundingClientRect) {
+          const r = active.getBoundingClientRect();
+          const vh = window.innerHeight || document.documentElement.clientHeight;
+          if (!(r.top < vh * 0.85 && r.bottom > vh * 0.15) && active.scrollIntoView) {
+            active.scrollIntoView({ behavior: 'smooth', block: 'nearest' });
+          }
+        }
+        api.emit('gem:tabs:change', { source: 'gem-runtime', key: key });
+      };
+      tabs.forEach((t) => {
+        if (!canListen(t)) return;
+        t.addEventListener('click', () => select(t.getAttribute('data-gem-tab'), true));
+      });
+      const initial = tabs.filter((t) => t.getAttribute('aria-selected') === 'true')[0] || tabs[0];
+      select(initial.getAttribute('data-gem-tab'), false);
+      bound += 1;
+    });
+    api.emit('gem:tabs:ready', { source: 'gem-runtime', count: bound });
+  });
+  registerPlugin('media-gallery', ({ api }) => {
+    const galleries = document.querySelectorAll('[data-gem-media-gallery], .gem-media-gallery, .gem-product-media-gallery');
+    let bound = 0;
+    galleries.forEach((gallery) => {
+      if (!mark(gallery, 'media-gallery')) return;
+      const items = gallery.querySelectorAll('[data-gem-media-item], img, video, model-viewer');
+      const thumbControls = gallery.querySelectorAll('[data-gem-media-thumb]');
+      const controls = thumbControls.length ? thumbControls : items;
+      gallery.dataset.gemMediaState = 'ready';
+      items.forEach((item, index) => {
+        if (!item.dataset) return;
+        item.dataset.gemMediaIndex = String(index);
+      });
+      const activate = (target, reason = 'click') => {
+        if (!target) return;
+        const index = target.dataset && target.dataset.gemMediaIndex ? Number(target.dataset.gemMediaIndex) : undefined;
+        if (!Number.isFinite(index)) return;
+        controls.forEach((control) => {
+          const isActive = control.dataset && Number(control.dataset.gemMediaIndex) === index;
+          if (isActive) control.setAttribute('aria-current', 'true'); else control.removeAttribute('aria-current');
+          if (control.dataset) control.dataset.gemMediaActive = isActive ? 'true' : 'false';
+        });
+        gallery.dataset.gemMediaActiveIndex = String(index);
+        api.emit('gem:media:change', { source: 'gem-runtime', index, galleryId: gallery.id || undefined, reason });
+      };
+      const firstActive = gallery.querySelector('[aria-current="true"], [data-gem-media-thumb]');
+      if (firstActive) activate(firstActive, 'init');
+      if (canListen(gallery)) gallery.addEventListener('click', (event) => {
+        const target = event.target && event.target.closest ? event.target.closest('[data-gem-media-item], img, video, model-viewer') : null;
+        if (!target) return;
+        activate(target, 'click');
+      });
+      controls.forEach((control) => { if (!canListen(control)) return; control.addEventListener('keydown', (event) => {
+        if (!['Enter', ' '].includes(event.key)) return;
+        event.preventDefault && event.preventDefault();
+        activate(control, 'keyboard');
+      }); });
+      bound += 1;
+    });
+    api.emit('gem:media:ready', { source: 'gem-runtime', count: bound });
+  });
+  registerPlugin('carousel', ({ api }) => {
+    const carousels = document.querySelectorAll('[data-gem-carousel], .gem-carousel');
+    let bound = 0;
+    carousels.forEach((carousel) => {
+      if (!mark(carousel, 'carousel')) return;
+      const viewport = carousel.querySelector && (carousel.querySelector('[data-gem-carousel-viewport]') || carousel.querySelector('.gem-carousel__viewport'));
+      const slides = carousel.querySelectorAll('[data-gem-carousel-slide], .gem-carousel__slide');
+      const previous = carousel.querySelector && carousel.querySelector('[data-gem-carousel-prev]');
+      const next = carousel.querySelector && carousel.querySelector('[data-gem-carousel-next]');
+      const slideCount = slides.length || 0;
+      const currentIndex = () => {
+        if (!viewport || !slideCount) return 0;
+        const width = Number(viewport.clientWidth || viewport.offsetWidth || 1);
+        return Math.max(0, Math.min(slideCount - 1, Math.round(Number(viewport.scrollLeft || 0) / width)));
+      };
+      const setIndex = (index, reason = 'api') => {
+        const nextIndex = Math.max(0, Math.min(slideCount - 1, Number.isFinite(index) ? index : 0));
+        carousel.dataset.gemCarouselIndex = String(nextIndex);
+        carousel.dataset.gemCarouselCount = String(slideCount);
+        if (viewport && viewport.scrollTo) viewport.scrollTo({ left: Number(viewport.clientWidth || viewport.offsetWidth || 0) * nextIndex, behavior: 'smooth' });
+        api.emit('gem:carousel:change', { source: 'gem-runtime', id: carousel.id || undefined, index: nextIndex, count: slideCount, reason });
+      };
+      slides.forEach((slide, index) => { if (slide.dataset) slide.dataset.gemCarouselIndex = String(index); });
+      carousel.dataset.gemCarouselState = slideCount > 1 ? 'ready' : 'single';
+      carousel.dataset.gemCarouselCount = String(slideCount);
+      carousel.dataset.gemCarouselIndex = String(currentIndex());
+      if (canListen(previous)) previous.addEventListener('click', (event) => { event.preventDefault && event.preventDefault(); setIndex(currentIndex() - 1, 'previous'); });
+      if (canListen(next)) next.addEventListener('click', (event) => { event.preventDefault && event.preventDefault(); setIndex(currentIndex() + 1, 'next'); });
+      if (canListen(viewport)) viewport.addEventListener('scroll', () => { carousel.dataset.gemCarouselIndex = String(currentIndex()); }, { passive: true });
+      bound += 1;
+    });
+    api.emit('gem:carousel:ready', { source: 'gem-runtime', count: bound });
+  });
+  registerPlugin('hero-slideshow', ({ api }) => {
+    const roots = document.querySelectorAll('[data-gem-hero-slideshow]');
+    let bound = 0;
+    roots.forEach((root) => {
+      if (!mark(root, 'hero-slideshow')) return;
+      const slides = Array.prototype.slice.call(root.querySelectorAll('[data-gem-hero-slide]'));
+      if (slides.length < 2) return;
+      const dots = Array.prototype.slice.call(root.querySelectorAll('[data-gem-hero-dot]'));
+      const previous = root.querySelector && root.querySelector('[data-gem-hero-prev]');
+      const next = root.querySelector && root.querySelector('[data-gem-hero-next]');
+      const pause = root.querySelector && root.querySelector('[data-gem-hero-pause]');
+      const reduce = window.matchMedia && window.matchMedia('(prefers-reduced-motion: reduce)').matches;
+      const autoplay = !!(root.dataset && root.dataset.autoplay === 'true') && !reduce;
+      const interval = Math.max(Number((root.dataset && root.dataset.autoplayInterval) || 6000), 4000);
+      let active = 0;
+      for (let i = 0; i < slides.length; i += 1) { if ((slides[i].className || '').indexOf('gem-hero-slideshow__slide--active') > -1) { active = i; break; } }
+      let timer = null; let paused = false;
+      const show = (index) => {
+        active = (index + slides.length) % slides.length;
+        slides.forEach((s, i) => { const on = i === active; if (s.classList) s.classList.toggle('gem-hero-slideshow__slide--active', on); s.hidden = !on; });
+        dots.forEach((d, i) => { const on = i === active; if (d.classList) d.classList.toggle('gem-hero-slideshow__dot--active', on); if (d.setAttribute) { d.setAttribute('aria-selected', String(on)); d.setAttribute('tabindex', on ? '0' : '-1'); } });
+        api.emit('gem:hero-slideshow:change', { source: 'gem-runtime', id: root.id || undefined, index: active, count: slides.length });
+      };
+      const stop = () => { if (timer) { window.clearInterval(timer); timer = null; } };
+      const start = () => { stop(); if (autoplay && !paused) timer = window.setInterval(() => { show(active + 1); }, interval); };
+      if (canListen(previous)) previous.addEventListener('click', (e) => { if (e.preventDefault) e.preventDefault(); show(active - 1); start(); });
+      if (canListen(next)) next.addEventListener('click', (e) => { if (e.preventDefault) e.preventDefault(); show(active + 1); start(); });
+      dots.forEach((d, i) => { if (canListen(d)) d.addEventListener('click', () => { show(Number((d.dataset && d.dataset.slideIndex) || i)); start(); }); });
+      const focusDot = (i) => { const n = dots.length; if (!n) return; const k = ((i % n) + n) % n; show(k); start(); if (dots[k].focus) dots[k].focus(); };
+      dots.forEach((d, i) => { if (canListen(d)) d.addEventListener('keydown', (e) => {
+        const k = e.key;
+        if (k === 'ArrowRight' || k === 'ArrowDown') { if (e.preventDefault) e.preventDefault(); focusDot(i + 1); }
+        else if (k === 'ArrowLeft' || k === 'ArrowUp') { if (e.preventDefault) e.preventDefault(); focusDot(i - 1); }
+        else if (k === 'Home') { if (e.preventDefault) e.preventDefault(); focusDot(0); }
+        else if (k === 'End') { if (e.preventDefault) e.preventDefault(); focusDot(dots.length - 1); }
+      }); });
+      if (canListen(pause)) pause.addEventListener('click', () => { paused = !paused; if (pause.setAttribute) pause.setAttribute('aria-pressed', String(paused)); start(); });
+      show(active); start(); bound += 1;
+    });
+    api.emit('gem:hero-slideshow:ready', { source: 'gem-runtime', count: bound });
+  });
+  registerPlugin('quick-view', ({ api }) => {
+    const triggers = document.querySelectorAll('[data-gem-quick-view], [data-gem-action="quick-view"]');
+    const surface = document.querySelector('[data-gem-quick-view-surface], .gem-quick-view, .gem-modal[data-gem-component="quick-view"]');
+    let bound = 0;
+    const close = (reason = 'close-control') => {
+      if (surface) {
+        surface.dataset.gemQuickViewState = 'closed';
+        surface.removeAttribute && surface.removeAttribute('open');
+        surface.setAttribute && surface.setAttribute('aria-hidden', 'true');
+      }
+      api.emit('gem:quick-view:close', { source: 'gem-runtime', reason });
+    };
+    const openSurface = (detail) => {
+      if (surface) {
+        surface.dataset.gemQuickViewState = 'open';
+        surface.dataset.gemProductHandle = detail.productHandle || '';
+        surface.dataset.gemProductUrl = detail.productUrl || '';
+        surface.setAttribute && surface.setAttribute('open', '');
+        surface.setAttribute && surface.setAttribute('aria-hidden', 'false');
+        surface.setAttribute && surface.setAttribute('role', 'dialog');
+        surface.setAttribute && surface.setAttribute('aria-modal', 'true');
+        const content = surface.querySelector && surface.querySelector('[data-gem-quick-view-content]');
+        if (content && content.textContent !== undefined) content.textContent = 'Quick view for ' + (detail.productHandle || 'product');
+        else if (surface.textContent !== undefined) surface.textContent = 'Quick view for ' + (detail.productHandle || 'product');
+        const closeButton = surface.querySelector && surface.querySelector('[data-gem-quick-view-close]');
+        if (closeButton && closeButton.focus) closeButton.focus();
+      }
+      api.emit('gem:quick-view:open', { source: 'gem-runtime', ...detail, hasSurface: Boolean(surface) });
+    };
+    triggers.forEach((trigger) => {
+      if (!mark(trigger, 'quick-view')) return;
+      if (!canListen(trigger)) return;
+      trigger.addEventListener('click', (event) => {
+        const productUrl = trigger.getAttribute && (trigger.getAttribute('data-gem-product-url') || trigger.getAttribute('href'));
+        const productHandle = trigger.getAttribute && trigger.getAttribute('data-gem-product-handle');
+        if (!productUrl && !productHandle) return;
+        event.preventDefault && event.preventDefault();
+        openSurface({ productUrl, productHandle });
+      });
+      bound += 1;
+    });
+    if (surface && mark(surface, 'quick-view-surface')) {
+      surface.dataset.gemQuickViewState = 'closed';
+      surface.setAttribute && surface.setAttribute('aria-hidden', 'true');
+      if (canListen(surface)) surface.addEventListener('click', (event) => {
+        const target = event.target;
+        if (target && target.closest && target.closest('[data-gem-quick-view-close]')) close('close-control');
+      });
+      if (canListen(surface)) surface.addEventListener('keydown', (event) => { if (event.key === 'Escape') close('escape'); });
+    }
+    api.quickView = { open: (detail = {}) => openSurface({ ...detail }), close };
+    api.emit('gem:quick-view:ready', { source: 'gem-runtime', count: bound, hasSurface: Boolean(surface) });
+  });
+  registerPlugin('promo-popup', ({ api }) => {
+    const popups = document.querySelectorAll('[data-gem-promo-popup], .gem-promo-popup');
+    let bound = 0;
+    const storagePrefix = 'gem:promo-popup-dismissed:';
+    const now = () => Date.now ? Date.now() : new Date().getTime();
+    const readDismissedUntil = (key) => {
+      try { return Number(target.localStorage && target.localStorage.getItem(storagePrefix + key) || '0'); }
+      catch { return 0; }
+    };
+    const writeDismissedUntil = (key, timestamp) => {
+      try { if (target.localStorage) target.localStorage.setItem(storagePrefix + key, String(timestamp)); }
+      catch { /* storage can be unavailable in private contexts */ }
+    };
+    popups.forEach((popup, index) => {
+      if (!mark(popup, 'promo-popup')) return;
+      const key = popup.id || popup.getAttribute && popup.getAttribute('data-gem-section-library-id') || String(index);
+      const delaySeconds = Number(popup.getAttribute && (popup.getAttribute('data-gem-promo-delay') || '0'));
+      const frequencyDays = Number(popup.getAttribute && (popup.getAttribute('data-gem-promo-frequency-days') || '7'));
+      const dialog = popup.querySelector && popup.querySelector('[data-gem-promo-popup-dialog]');
+      const overlay = popup.querySelector && popup.querySelector('[data-gem-promo-popup-overlay]');
+      const open = (reason = 'timer') => {
+        if (readDismissedUntil(key) > now()) { popup.dataset.gemPromoPopupState = 'dismissed'; return false; }
+        popup.hidden = false;
+        if (dialog) dialog.hidden = false;
+        if (overlay) overlay.hidden = false;
+        popup.dataset.gemPromoPopupState = 'open';
+        api.emit('gem:promo-popup:open', { source: 'gem-runtime', id: popup.id || undefined, reason });
+        return true;
+      };
+      const close = (reason = 'dismiss') => {
+        const days = Number.isFinite(frequencyDays) ? Math.max(1, frequencyDays) : 7;
+        writeDismissedUntil(key, now() + days * 86400000);
+        if (dialog) dialog.hidden = true;
+        if (overlay) overlay.hidden = true;
+        popup.dataset.gemPromoPopupState = 'closed';
+        api.emit('gem:promo-popup:close', { source: 'gem-runtime', id: popup.id || undefined, reason });
+      };
+      popup.querySelectorAll && popup.querySelectorAll('[data-gem-promo-popup-dismiss]').forEach((button) => {
+        if (!canListen(button)) return;
+        button.addEventListener('click', (event) => { event.preventDefault && event.preventDefault(); close('dismiss'); });
+      });
+      if (canListen(overlay)) overlay.addEventListener('click', () => close('overlay'));
+      popup.dataset.gemPromoPopupState = 'ready';
+      const delay = Math.max(0, Number.isFinite(delaySeconds) ? delaySeconds : 0) * 1000;
+      target.setTimeout ? target.setTimeout(() => open('timer'), delay) : open('timer');
+      bound += 1;
+    });
+    api.promoPopup = { open: () => popups.forEach((popup) => { popup.hidden = false; popup.dataset.gemPromoPopupState = 'open'; }) };
+    api.emit('gem:promo-popup:ready', { source: 'gem-runtime', count: bound });
+  });
+  registerPlugin('sticky-atc', ({ api }) => {
+    const bars = document.querySelectorAll('[data-gem-sticky-atc], .gem-sticky-atc');
+    let bound = 0;
+    const setState = (bar, state) => {
+      if (!bar || !bar.dataset) return;
+      if (bar.dataset.gemStickyAtcState === state) return;
+      bar.dataset.gemStickyAtcState = state;
+      api.emit(state === 'visible' ? 'gem:sticky-atc:show' : 'gem:sticky-atc:hide', { source: 'gem-runtime', id: bar.id || undefined });
+    };
+    bars.forEach((bar) => {
+      if (!mark(bar, 'sticky-atc')) return;
+      const threshold = Number(bar.getAttribute && (bar.getAttribute('data-gem-sticky-threshold') || '240'));
+      const update = () => {
+        const scrollY = Number(target.scrollY || target.pageYOffset || 0);
+        setState(bar, scrollY >= threshold ? 'visible' : 'hidden');
+      };
+      update();
+      if (canListen(target)) target.addEventListener('scroll', update, { passive: true });
+      const form = bar.querySelector && bar.querySelector('form');
+      if (canListen(form)) form.addEventListener('submit', () => api.emit('gem:sticky-atc:submit', { source: 'gem-runtime', id: bar.id || undefined }));
+      bound += 1;
+    });
+    api.emit('gem:sticky-atc:ready', { source: 'gem-runtime', count: bound });
+  });
+  registerPlugin('before_after', ({ api }) => {
+    const frames = document.querySelectorAll('[data-gem-before-after-frame], .gem-before-after__frame');
+    let bound = 0;
+    const clamp = (value) => Math.max(0, Math.min(100, Number.isFinite(value) ? value : 50));
+    frames.forEach((frame) => {
+      if (!mark(frame, 'before_after')) return;
+      const range = frame.querySelector && frame.querySelector('[data-gem-before-after-range], input[type="range"]');
+      const setPosition = (value, reason = 'init') => {
+        const position = clamp(Number(value));
+        if (frame.style && frame.style.setProperty) frame.style.setProperty('--gem-before-after-position', position + '%');
+        frame.dataset.gemBeforeAfterPosition = String(position);
+        if (range && range.value !== undefined) range.value = String(position);
+        api.emit('gem:before-after:change', { source: 'gem-runtime', position, reason, id: frame.id || undefined });
+      };
+      const initial = range && range.value !== undefined ? range.value : frame.getAttribute && frame.getAttribute('data-gem-before-after-position');
+      setPosition(initial || 50);
+      if (canListen(range)) range.addEventListener('input', () => setPosition(range.value, 'input'));
+      bound += 1;
+    });
+    api.emit('gem:before-after:ready', { source: 'gem-runtime', count: bound });
+  });
+  registerPlugin('countdown', ({ api }) => {
+    const timers = document.querySelectorAll('[data-gem-countdown], .gem-countdown');
+    let bound = 0;
+    const pad = (value) => String(Math.max(0, value)).padStart(2, '0');
+    const write = (timer, selector, value) => {
+      const targetNode = timer.querySelector && timer.querySelector(selector);
+      if (targetNode) targetNode.textContent = pad(value);
+    };
+    timers.forEach((timer) => {
+      if (!mark(timer, 'countdown')) return;
+      const targetIso = timer.getAttribute && timer.getAttribute('data-gem-countdown-target');
+      const targetTime = targetIso ? Date.parse(targetIso) : NaN;
+      const update = () => {
+        if (!Number.isFinite(targetTime)) {
+          timer.dataset.gemCountdownState = 'invalid';
+          return;
+        }
+        const remainingSeconds = Math.max(0, Math.floor((targetTime - Date.now()) / 1000));
+        const days = Math.floor(remainingSeconds / 86400);
+        const hours = Math.floor((remainingSeconds % 86400) / 3600);
+        const minutes = Math.floor((remainingSeconds % 3600) / 60);
+        timer.dataset.gemCountdownState = remainingSeconds > 0 ? 'running' : 'complete';
+        timer.dataset.gemCountdownRemainingSeconds = String(remainingSeconds);
+        write(timer, '[data-gem-countdown-days]', days);
+        write(timer, '[data-gem-countdown-hours]', hours);
+        write(timer, '[data-gem-countdown-minutes]', minutes);
+        api.emit(remainingSeconds > 0 ? 'gem:countdown:start' : 'gem:countdown:complete', { source: 'gem-runtime', id: timer.id || undefined, remainingSeconds });
+      };
+      update();
+      if (target.setInterval && Number.isFinite(targetTime)) target.setInterval(update, 60000);
+      bound += 1;
+    });
+    api.emit('gem:countdown:ready', { source: 'gem-runtime', count: bound });
+  });
+  registerPlugin('reveal-on-scroll', ({ api }) => {
+    const nodes = document.querySelectorAll('[data-gem-reveal], .gem-reveal');
+    let bound = 0;
+    const reveal = (node) => { node.dataset.gemRevealState = 'in'; };
+    if (!target.IntersectionObserver) { nodes.forEach(reveal); api.emit('gem:reveal:ready', { source: 'gem-runtime', count: 0 }); return; }
+    const observer = new target.IntersectionObserver((entries, obs) => {
+      entries.forEach((entry) => {
+        if (!entry.isIntersecting) return;
+        reveal(entry.target);
+        obs.unobserve(entry.target);
+        api.emit('gem:reveal:in', { source: 'gem-runtime', id: entry.target.id || undefined });
+      });
+    }, { threshold: 0.12, rootMargin: '0px 0px -40px 0px' });
+    nodes.forEach((node) => {
+      if (!mark(node, 'reveal-on-scroll')) return;
+      if (!node.dataset.gemRevealState) node.dataset.gemRevealState = 'ready';
+      observer.observe(node);
+      bound += 1;
+    });
+    api.emit('gem:reveal:ready', { source: 'gem-runtime', count: bound });
+  });
+  registerPlugin('recently-viewed', ({ api }) => {
+    const storageKey = 'gem:recently-viewed-products';
+    const readItems = () => {
+      try { return JSON.parse(target.localStorage && target.localStorage.getItem(storageKey) || '[]'); }
+      catch { return []; }
+    };
+    const writeItems = (items) => {
+      try { if (target.localStorage) target.localStorage.setItem(storageKey, JSON.stringify(items.slice(0, 12))); }
+      catch { /* storage can be unavailable in private contexts */ }
+    };
+    const escapeHtml = (value) => String(value || '').replace(/[&<>'"]/g, (char) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', "'": '&#39;', '"': '&quot;' }[char]));
+    const renderItem = (item) => {
+      const url = item && item.url ? String(item.url) : '#';
+      const label = item && (item.title || item.handle || item.url) ? String(item.title || item.handle || item.url) : 'Recently viewed product';
+      return '<a class="gem-card gem-recently-viewed__item" href="' + escapeHtml(url) + '"><strong>' + escapeHtml(label) + '</strong></a>';
+    };
+    const current = document.querySelector('[data-gem-current-product], [data-gem-product-handle]');
+    if (current) {
+      const handle = current.getAttribute && current.getAttribute('data-gem-product-handle');
+      const url = current.getAttribute && (current.getAttribute('data-gem-product-url') || current.getAttribute('href'));
+      const title = current.getAttribute && current.getAttribute('data-gem-product-title');
+      if (handle || url) {
+        const nextItem = { handle, url, title, recordedAt: new Date().toISOString() };
+        const items = [nextItem, ...readItems().filter((item) => item && item.handle !== handle && item.url !== url)];
+        writeItems(items);
+        api.emit('gem:recently-viewed:record', { source: 'gem-runtime', handle, url });
+      }
+    }
+    const rails = document.querySelectorAll('[data-gem-recently-viewed], .gem-recently-viewed');
+    let bound = 0;
+    rails.forEach((rail) => {
+      if (!mark(rail, 'recently-viewed')) return;
+      const limit = Number(rail.getAttribute && (rail.getAttribute('data-gem-recently-viewed-limit') || '4'));
+      const items = readItems().slice(0, Number.isFinite(limit) ? limit : 4);
+      const list = rail.querySelector && (rail.querySelector('[data-gem-recently-viewed-list]') || rail);
+      const empty = rail.querySelector && rail.querySelector('[data-gem-recently-viewed-empty]');
+      rail.dataset.gemRecentlyViewedCount = String(items.length);
+      if (items.length > 0) {
+        rail.dataset.gemRecentlyViewedState = 'ready';
+        if (list) {
+          list.hidden = false;
+          if (list.dataset) list.dataset.gemRecentlyViewedCount = String(items.length);
+          if ('innerHTML' in list) list.innerHTML = items.map(renderItem).join('');
+          else if ('textContent' in list) list.textContent = items.map((item) => item && (item.title || item.handle || item.url) || 'Recently viewed product').join(', ');
+        }
+        if (empty) empty.hidden = true;
+      } else {
+        rail.dataset.gemRecentlyViewedState = 'empty';
+        if (empty) empty.hidden = false;
+      }
+      bound += 1;
+    });
+    api.recentlyViewed = { list: readItems };
+    api.emit('gem:recently-viewed:ready', { source: 'gem-runtime', count: bound });
+  });
+  registerPlugin('runtime-slot-loader', ({ api }) => {
+    const slots = document.querySelectorAll('[data-gem-runtime-slot], [data-gem-footer-block-builder], .gem-navigation-shell__layout');
+    let bound = 0;
+    slots.forEach((slot, index) => {
+      if (!mark(slot, 'runtime-slot-loader')) return;
+      if (slot.dataset) {
+        slot.dataset.gemRuntimeSlotState = 'ready';
+        if (!slot.dataset.gemRuntimeSlotIndex) slot.dataset.gemRuntimeSlotIndex = String(index);
+      }
+      bound += 1;
+    });
+    api.emit('gem:slot:ready', { source: 'gem-runtime', count: bound });
+  });
+  registerPlugin('offer-engine', ({ api }) => {
+    (function(){
+  document.querySelectorAll('[data-gem-offer-engine]').forEach(function(root){
+    if(root.__gemOffer)return; root.__gemOffer=1;
+    var el=root.querySelector('[data-gem-offer-model]'); if(!el)return;
+    var model; try{model=JSON.parse(el.textContent);}catch(e){return;}
+    var dims=model.dimensions||{}, sel={};
+    Object.keys(dims).forEach(function(d){var o=(dims[d].options||[]),def=o.filter(function(x){return x.default;})[0]||o[0];sel[d]=(model.default_selection&&model.default_selection[d])||(def&&def.id);});
+    function m(w){return Object.keys(w).every(function(k){return sel[k]===w[k];});}
+    function sp(w){return Object.keys(w).length;}
+    function pick(list){return (list||[]).filter(function(r){return m(r.when);}).sort(function(a,b){return sp(b.when)-sp(a.when);})[0];}
+    function gift(g,t){if(!g||t==null)return null;var sym=g.currency_symbol||'$';var rem=Math.max(0,Math.round((g.threshold-t)*100)/100);var unl=rem<=0;var rs=sym+rem.toFixed(2);var pct=g.threshold>0?Math.max(0,Math.min(100,Math.round((t/g.threshold)*100))):100;var tpl=unl?(g.unlocked_text||'\uD83C\uDF81 {label} unlocked!'):(g.locked_text||'Add {remaining} more to unlock {label}');return {unlocked:unl,remaining:rs,remaining_amount:rem,percent:pct,text:tpl.replace('{remaining}',rs).replace('{label}',g.label)};}
+    function render(){
+      var row=pick(model.price_matrix)||{}, plan=pick(model.selling_plan_map);
+      var vis={}; Object.keys(dims).forEach(function(d){vis[d]=true;});
+      (model.conditions||[]).forEach(function(c){vis[c.show]=(sel[c.when_dim]===c.equals);});
+      (model.panels||[]).forEach(function(p){if(p.when)vis[p.id]=(sel[p.when.when_dim]===p.when.equals);});
+      var headline=row.total||row.price||'';
+      var gf=gift(model.gift,row.total_amount);
+      root.querySelectorAll('[data-gem-offer-out]').forEach(function(o){var k=o.getAttribute('data-gem-offer-out');
+        if(k==='price')o.textContent=row.price||'';
+        else if(k==='compare'){o.textContent=row.compare_at||'';o.style.display=row.compare_at?'':'none';}
+        else if(k==='save'){o.textContent=row.save_label||'';o.style.display=row.save_label?'':'none';}
+        else if(k==='gift'){o.textContent=gf?gf.text:'';if(o.classList)o.classList.toggle('unlocked',!!(gf&&gf.unlocked));}
+        else if(k==='cta')o.textContent=(model.cta_template||'Add to cart').replace('{price}',headline).replace('{total}',headline);});
+      root.querySelectorAll('[data-gem-offer-gift]').forEach(function(w){w.style.display=gf?'':'none';if(w.classList)w.classList.toggle('unlocked',!!(gf&&gf.unlocked));});
+      root.querySelectorAll('[data-gem-offer-gift-bar]').forEach(function(b){b.style.width=(gf?gf.percent:0)+'%';});
+      root.querySelectorAll('[data-gem-offer-group]').forEach(function(g){g.style.display=(vis[g.getAttribute('data-gem-offer-group')]===false)?'none':'';});
+      root.querySelectorAll('[data-gem-offer-dim]').forEach(function(b){var d=b.getAttribute('data-gem-offer-dim'),v=b.getAttribute('data-gem-offer-value');if(b.tagName==='OPTION'){b.selected=(sel[d]===v);}else{b.classList.toggle('sel',sel[d]===v);}});
+      var s=root.querySelector('[data-gem-offer-selling-plan]'); if(s)s.value=(plan&&plan.selling_plan_id)||'';
+      var ca=(plan&&plan.cart_attributes)||{};
+      root.querySelectorAll('[data-gem-offer-cart-field]').forEach(function(f){var n=f.getAttribute('data-gem-offer-cart-field');f.value=ca[n]||'';f.disabled=!(n in ca);});
+      root.dispatchEvent(new CustomEvent('gem:offer:change',{bubbles:true,detail:{selection:sel,row:row,selling_plan_id:(plan&&plan.selling_plan_id)||null,cart_attributes:ca,gift:gf}}));
+    }
+    root.addEventListener('click',function(e){var b=e.target.closest('[data-gem-offer-dim]');if(!b||b.tagName==='OPTION')return;sel[b.getAttribute('data-gem-offer-dim')]=b.getAttribute('data-gem-offer-value');render();});
+    root.addEventListener('change',function(e){var s=e.target.closest('select[data-gem-offer-select]');if(!s)return;var o=s.options[s.selectedIndex];sel[s.getAttribute('data-gem-offer-select')]=o.getAttribute('data-gem-offer-value');render();});
+    render();
+  });
+})();
+    api.emit('gem:offer:ready', { source: 'gem-runtime' });
+  });
+  registerNoopPlugin("seasonal-effects", "gem:seasonal:ready");
+  registerNoopPlugin("context-adapter", "gem:context:ready");
+  const mark = (element, key) => {
+    const attr = 'data-gem-bound-' + key;
+    if (!element || element.hasAttribute(attr)) return false;
+    element.setAttribute(attr, 'true');
+    return true;
+  };
+  const wrapMethod = (element, method, event, detail = {}) => {
+    if (!element || typeof element[method] !== 'function') return false;
+    const attr = 'data-gem-wrap-' + method;
+    if (element.hasAttribute(attr)) return true;
+    const original = element[method].bind(element);
+    element[method] = (...args) => {
+      const result = original(...args);
+      api.emit(event, typeof detail === 'function' ? detail(...args) : detail);
+      return result;
+    };
+    element.setAttribute(attr, 'true');
+    return true;
+  };
+  const whenElementDefined = (name, callback) => {
+    if (!target.customElements || !target.customElements.whenDefined) { callback(); return; }
+    target.customElements.whenDefined(name).then(callback).catch(callback);
+  };
+  const wireDawnCartDrawer = () => {
+    if (!hasPlugin('cart-drawer')) return false;
+    const drawer = document.querySelector('cart-drawer');
+    if (!drawer || !mark(drawer, 'cart-drawer')) return false;
+    wrapMethod(drawer, 'open', 'gem:cart:open', { source: 'dawn' });
+    wrapMethod(drawer, 'close', 'gem:cart:close', { source: 'dawn' });
+    wrapMethod(drawer, 'renderContents', 'gem:cart:update', (state) => ({
+      source: 'dawn',
+      productId: state && state.id ? state.id : undefined,
+    }));
+    return true;
+  };
+  const wireDawnMenuDrawer = () => {
+    if (!hasPlugin('mobile-menu')) return false;
+    const drawers = document.querySelectorAll('menu-drawer, header-drawer');
+    let wired = false;
+    drawers.forEach((drawer) => {
+      if (!mark(drawer, 'mobile-menu')) return;
+      wrapMethod(drawer, 'openMenuDrawer', 'gem:menu:open', { source: 'dawn' });
+      wrapMethod(drawer, 'closeMenuDrawer', 'gem:menu:close', { source: 'dawn' });
+      wired = true;
+    });
+    return wired;
+  };
+  const wireDawnPredictiveSearch = () => {
+    if (!hasPlugin('predictive-search')) return false;
+    const search = document.querySelector('predictive-search');
+    if (!search || !mark(search, 'predictive-search')) return false;
+    const input = search.querySelector('input[type="search"], input[name="q"]');
+    const form = search.querySelector('form');
+    if (canListen(input)) input.addEventListener('focus', () => api.emit('gem:search:open', { source: 'dawn' }), { once: false });
+    if (canListen(form)) form.addEventListener('submit', () => api.emit('gem:search:submit', { source: 'dawn' }), { once: false });
+    return true;
+  };
+  const wireDawnAdapter = () => {
+    if (!config.dawnAdapter || config.base !== 'dawn') return;
+    const detected = [];
+    whenElementDefined('cart-drawer', () => { if (wireDawnCartDrawer()) detected.push('cart-drawer'); });
+    whenElementDefined('menu-drawer', () => { if (wireDawnMenuDrawer()) detected.push('mobile-menu'); });
+    whenElementDefined('header-drawer', () => { if (wireDawnMenuDrawer()) detected.push('mobile-menu'); });
+    whenElementDefined('predictive-search', () => { if (wireDawnPredictiveSearch()) detected.push('predictive-search'); });
+    setTimeout(() => api.emit('gem:dawn-adapter:ready', { detected: [...new Set(detected)] }), 0);
+  };
+  wireDawnAdapter();
+  config.plugins.forEach(schedulePlugin);
+  document.documentElement.dataset.gemRuntime = 'ready';
+  api.emit('gem:runtime:ready', { plugins: config.plugins.map((plugin) => plugin.key), loadedPlugins: Object.keys(loadedPlugins) });
+})();