@sharadtech/infralytiqs-sdk 1.0.1 → 1.0.3

package/clients/publicis/colab/src/index.js

@@ -0,0 +1,2901 @@
+/**
+ * Infralytiqs client-specific bootstrap — Publicis Colab
+ * (aem-sit.publiciscolab.com, ...)
+ *
+ * This is the "colab" sibling of the "publicis/ps" bootstrap. Both target
+ * the same Adobe DAM Asset Share Commons platform (groupe-dam tenant), so
+ * the event taxonomy, selectors, and DOM heuristics are identical; only
+ * the host domain, the client-override global namespace (IL_COLAB_*), and
+ * the internal de-dupe flag prefixes (__ilColab*) differ. The per-tenant
+ * server/tenant/site/db values are still read from window.IL_* injected
+ * server-side by the AEM Sightly `Infralytiqs.html` fragment (colab runs
+ * on site_id = SIT), so this file hard-codes none of them.
+ *
+ * Colab serves its ASC pages under a /colab/us/en/ locale prefix
+ * (login at `/colab/us/en/login.html`, home/search at
+ * `/colab/us/en/home.html`, asset explorer at
+ * `/colab/us/en/home/asset-explorer.html`, details at
+ * `/.../details/<type>.html/<assetPath>`) and its DAM content lives under
+ * `/content/dam/px/colab`. The page-type heuristics below match
+ * `login` / `asset-explorer` / `details` anywhere in the path and accept
+ * any `/content/dam/...` asset path, so neither the locale prefix nor the
+ * nested DAM root needs special handling.
+ *
+ * Pipeline:
+ *   1. The host page embeds the Infralytiqs SDK from the CDN:
+ *        <script src="https://assets.infralytiqs.com/cdn/infralytiqs.min.js"></script>
+ *   2. The host page injects per-tenant configuration as `window.IL_*` globals
+ *      (server-side rendered via the Sightly `Infralytiqs.html` fragment).
+ *   3. This bootstrap loads after the SDK + config and:
+ *        a. Reads window.IL_* and Infralytiqs.init() with browser-side enrichment.
+ *        b. Resolves the logged-in AEM user via /libs/granite/security/currentuser.json
+ *           and calls Infralytiqs.identify() so subsequent events carry user_id.
+ *        c. Tracks two families of events:
+ *
+ *   ──────────────────────────────────────────────────────────────
+ *   LOGIN PAGE (auth_state = anonymous)
+ *   ──────────────────────────────────────────────────────────────
+ *     login_page_view  — anonymous landing on the login page
+ *     login_attempt    — Sign-in button submit (captures typed username,
+ *                        NEVER the password)
+ *     sso_click        — "Login with Lion Login" SSO button click
+ *     terms_click      — "Terms and Conditions" link click
+ *
+ *   ──────────────────────────────────────────────────────────────
+ *   ASSET SHARE COMMONS (auth_state = authenticated)
+ *   (search_context = "asc"   — URL-driven, pushState SPA)
+ *   ──────────────────────────────────────────────────────────────
+ *     search_executed   — fired on every page whose URL carries `?fulltext=…`.
+ *                         Captures search term, semantic / fuzzy toggles,
+ *                         active filters (group, human label, property,
+ *                         operation, values) cross-referenced against the
+ *                         right-rail predicate sections so reports can
+ *                         render `ASSET TYPE = Image` instead of
+ *                         `jcr:content/metadata/ps:assettype = Image`,
+ *                         order-by, sort direction, layout (card | list),
+ *                         offset / limit, plus the search-statistics widget
+ *                         (`search_time_ms`, `result_total`, `result_pages`)
+ *                         once ASC finishes rendering the result count and
+ *                         response time in the right rail. The bootstrap
+ *                         briefly observes the statistics block before
+ *                         firing so the timing reflects the search the
+ *                         user actually just executed (not a stale value
+ *                         left over from the previous in-page navigation).
+ *
+ *     asset_preview     — fired on every page whose URL matches
+ *                         /details/<type>.html/<assetPath>. Captures the
+ *                         /content/dam/... path, the asset-share asset type
+ *                         (image / video / document / 3d / …), file name
+ *                         and extension.
+ *
+ *     asset_download    — fired when the browser POSTs to the ASC download
+ *                         endpoint (network interception, NOT button click,
+ *                         so it captures bulk-download from card menus,
+ *                         detail-page button, and the dropdown rendition
+ *                         picker uniformly).
+ *                         Captures asset_path + rendition_name from the
+ *                         form-encoded POST body.
+ *
+ *     asset_add_to_cart — fired on click of any element matched by the
+ *                         `addToCart` selector list, the `[data-il-cart-add]`
+ *                         opt-in attribute, or visible text /add to cart/i.
+ *                         Captures the asset_path from data-attrs on the
+ *                         button or its nearest card ancestor.
+ *
+ *     asset_share       — fired on click of any element matched by the
+ *                         `shareButton` selector list or visible text
+ *                         /share/i. Placeholder until the share workflow
+ *                         is finalized.
+ *
+ *   ──────────────────────────────────────────────────────────────
+ *   ASSET EXPLORER  (search_context = "asset_explorer")
+ *   /asset-explorer.html#/content/dam/...  (React SPA, hash routing)
+ *   ──────────────────────────────────────────────────────────────
+ *     search_executed   — fired when the user runs a search inside the
+ *                         explorer. Listens to every plausible trigger
+ *                         (Enter on the input, native form submit,
+ *                         Search Options modal close, right-rail filter
+ *                         click, debounced typing) and carries the
+ *                         original `search_trigger` on each event so we
+ *                         can prune redundant hooks once production
+ *                         tells us which path actually fires. Captures
+ *                         search_term, semantic_search, fuzzy_search
+ *                         (read from the toggles in the open Search
+ *                         Options modal — see readAssetExplorerToggleState
+ *                         for the four heuristics tried), `folder_path`
+ *                         (the `#/content/dam/...` hash), and the stats
+ *                         widget (`search_time_ms`, `result_total`,
+ *                         `result_displayed`, `result_pages` when shown)
+ *                         once it settles. Subtype is `asset_search` —
+ *                         same as ASC — so a single ClickHouse query can
+ *                         report cross-context search volume.
+ *
+ *     folder_navigation — fired whenever the hash route changes (user
+ *                         clicked into another DAM folder). Carries
+ *                         `folder_path` + the standard browser-side
+ *                         enrichment dimensions. Subtype is `asset_browse`.
+ *
+ *     asset_preview     — reuses the ASC details-page detector when the
+ *                         explorer hands off to a /details/<type>.html URL,
+ *                         plus the body-level click delegation so a
+ *                         right-side preview panel that exposes a
+ *                         `data-asset-path` attribute is also captured.
+ *
+ *     asset_download    — same network-interception path as ASC, since the
+ *                         download endpoint is shared at the AEM backend
+ *                         layer.
+ *
+ *     asset_add_to_cart, asset_share — same click delegation as ASC.
+ *
+ * Selector strategy
+ * -----------------
+ * The DOM may evolve, so every selector is overridable via window globals
+ * (set BEFORE this bootstrap runs):
+ *
+ *   window.IL_COLAB_SELECTORS = {
+ *     // Login page
+ *     loginForm:    '#loginForm',
+ *     signInButton: 'button[type="submit"]',
+ *     userField:    'input[name="username"]',
+ *     ssoButton:    '[data-il-sso-lion]',
+ *     termsLink:    'a[href*="terms"]',
+ *     // ASC
+ *     searchInput:  'input[name="fulltext"]',
+ *     filterRail:   '#rail',
+ *     addToCart:    '[data-il-cart-add]',
+ *     shareButton:  '[data-il-share]'
+ *   };
+ *
+ * If none are provided we fall back to a robust default set that matches
+ * by id, name, role, data-attribute, and visible text — so the bootstrap
+ * is essentially zero-config for the common ASC layout.
+ *
+ * The host page can also override how the logged-in user is resolved:
+ *
+ *   window.IL_COLAB_USER_RESOLVER = function () {
+ *     return 'qa-ps-asc-global';   // sync
+ *     // or: return Promise.resolve('qa-ps-asc-global');
+ *   };
+ */
+(function () {
+  'use strict';
+
+  if (window.__ilColabBootstrapped) {
+    return;
+  }
+  window.__ilColabBootstrapped = true;
+
+  // ─── 1. Read host-page configuration ──────────────────────
+  var SERVER_URL = window.IL_SERVER_URL;
+  var TENANT_ID  = window.IL_TENANT_ID;
+  var SITE_ID    = window.IL_SITE_ID;
+  var DB_NAME    = window.IL_DB_NAME;
+
+  if (!SERVER_URL || !TENANT_ID || !SITE_ID) {
+    return;
+  }
+
+  var USER_OVERRIDES = (window.IL_COLAB_SELECTORS && typeof window.IL_COLAB_SELECTORS === 'object')
+    ? window.IL_COLAB_SELECTORS
+    : {};
+
+  // ─── 2. Default selectors ────────────────────────────────
+  // Each is a comma-separated list of CSS selectors tried in order. The first
+  // element that matches the page wins. Text-based fallback below handles
+  // pages whose controls don't carry stable IDs.
+  var SELECTORS = {
+    // ── Login page ─────────────────────────────────────────
+    loginForm: USER_OVERRIDES.loginForm
+      || 'form#loginForm, form[name="loginForm"], form[action*="login"], form[action*="signin"]',
+    signInButton: USER_OVERRIDES.signInButton
+      || '#signInButton, #signin, #signInBtn, #loginButton, button[name="signin"], button[data-action="signin"], button[type="submit"]',
+    userField: USER_OVERRIDES.userField
+      || '#username, #userId, #email, input[name="username"], input[name="userId"], input[name="email"], input[type="email"]',
+    ssoButton: USER_OVERRIDES.ssoButton
+      || '#lionLogin, [data-il-sso-lion], [data-sso="lion-login"], button[name="lion-login"], a[href*="lion-login"], a[href*="lionlogin"]',
+    termsLink: USER_OVERRIDES.termsLink
+      || 'a[data-il-terms], a#termsLink, a[href*="terms-and-conditions"], a[href*="terms_and_conditions"], a[href*="/terms"], a[href*="terms.html"]',
+
+    // ── Asset Share Commons ───────────────────────────────
+    // The search input on aem-sit.publiciscolab.com has `name="fulltext"` and the
+    // `data-search-input` attribute set by the ASC search-bar component
+    // (id includes a per-render numeric suffix, so we don't depend on it).
+    searchInput: USER_OVERRIDES.searchInput
+      || 'input[name="fulltext"], [data-search-input], input.cmp-fulltext, input[type="search"][data-cmp-hook-search-input]',
+    // The ASC right-rail container that holds the filter/predicate panel.
+    // On aem-sit.publiciscolab.com this is `#rail` inside the asset-share-commons
+    // root; we keep a comma-separated fallback list so the bootstrap also
+    // covers older / themed deployments that use a `.sidebar` wrapper.
+    filterRail: USER_OVERRIDES.filterRail
+      || '#rail, .search-rail, [data-cmp-is="search-rail"], #asset-share-commons .ui.wide.sidebar.right, .ui.wide.sidebar.right',
+    // Search-statistics widget (right-rail, "X assets / 54 ms / Y pages").
+    // On aem-sit.publiciscolab.com this is `.cmp.cmp-search-statistics` containing
+    // a Semantic-UI `.ui.mini.three.statistics` block with three `.statistic`
+    // tiles. We keep alternative selectors for themed / re-skinned variants.
+    searchStatistics: USER_OVERRIDES.searchStatistics
+      || '.cmp.cmp-search-statistics, [class*="cmp-search-statistics"], [data-cmp-is="search-statistics"], .search-statistics, .cmp-searchstatistics',
+    // Asset-level Add-to-Cart button (per-tile / per-card / details
+    // page). The Asset Share Commons convention puts the asset path on
+    // `data-asset-share-asset` and the button-id on `data-asset-share-id`.
+    // We prioritise the data attributes so the button can be detected
+    // even when rendered as an icon-only variant with no visible label.
+    addToCart: USER_OVERRIDES.addToCart
+      || '[data-asset-share-id="add-to-cart"], [data-asset-share-id="addToCart"], [data-il-cart-add], [data-cmp-cart-action="add"], [data-asset-cart-action="add"], button.cart-add, a.cart-add, button[data-action="cart-add"]',
+    // Asset-level Share button. Distinct from the cart-level share
+    // (`data-asset-share-id="share-all"`) which the click delegation
+    // checks BEFORE this so they never overlap.
+    shareButton: USER_OVERRIDES.shareButton
+      || '[data-asset-share-id="share-asset"], [data-asset-share-id="share"], [data-il-share], [data-cmp-share-action], button.share, a.share, button[data-action="share"]',
+    // ── Cart & downloads (ASC modal flow, used on the asset-explorer too) ──
+    // Top-bar cart icon — opens the cart modal. The Asset Share
+    // Commons template renders this as a Semantic UI `<i class="big
+    // cart icon">` inside an `<a class="item">` link. We keep a
+    // data-attribute path in front for installations that follow
+    // newer ASC conventions.
+    cartOpenButton: USER_OVERRIDES.cartOpenButton
+      || '[data-asset-share-id="cart"], [data-asset-share-id="open-cart"], a[data-il-cart-open], a.item > i.cart.icon, a.item > i.big.cart.icon, .cmp-structure-user-menu i.cart.icon, .cmp-structure-user-menu i.big.cart.icon',
+    // Cart-modal "Share Cart" button — applies to the WHOLE cart.
+    // The DOM uses `data-asset-share-id="share-all"`.
+    cartShareButton: USER_OVERRIDES.cartShareButton
+      || '[data-asset-share-id="share-all"], [data-asset-share-id="shareCart"]',
+    // Cart-modal "Download Cart" button — initiates the cart-download
+    // flow (a second confirmation modal opens afterwards, then the
+    // actual binaries are produced and listed in the downloads modal).
+    cartDownloadButton: USER_OVERRIDES.cartDownloadButton
+      || '[data-asset-share-id="download-all"], [data-asset-share-id="downloadCart"]',
+    // Cart modal itself — used to scrape the cart contents at the
+    // moment Share Cart / Download Cart is clicked.
+    cartModal: USER_OVERRIDES.cartModal
+      || 'form.cmp-modal-cart, .cmp-modal-cart, [class*="cmp-modal-cart"]',
+    // Top-bar downloads icon — opens the downloads-list modal.
+    downloadsOpenButton: USER_OVERRIDES.downloadsOpenButton
+      || '[data-asset-share-id="downloads"], [data-asset-share-id="open-downloads"], a[data-il-downloads-open], a.item > i.download.icon, a.item > i.big.download.icon, .cmp-structure-user-menu i.download.icon, .cmp-structure-user-menu i.big.download.icon',
+    // Per-artifact download link inside the downloads modal. Anchors
+    // pointing at the AEM download-binaries endpoint with a
+    // `downloadId` query string. We deliberately accept ANY scheme /
+    // host the href might carry — the path is the stable identifier.
+    downloadBinaryLink: USER_OVERRIDES.downloadBinaryLink
+      || 'a[href*="downloadbinaries.json"], a[href*="downloadbinaries"][href*="downloadId="]',
+    // Per-download "remove from downloads" button. Carries the
+    // download UUID on `data-asset-share-download-id`.
+    downloadRemoveButton: USER_OVERRIDES.downloadRemoveButton
+      || '[data-asset-share-id="remove-from-downloads"], [data-asset-share-id="removeFromDownloads"]',
+    // ── Cart-Share modal (cmp-modal-share) ─────────────────
+    // The "Share Cart" button opens a SECOND modal that collects the
+    // recipient e-mails, the "Share Publicly" flag, and the optional
+    // start/expiry dates. The class anchor `cmp-modal-share` is
+    // stable across themes and the variant suffix
+    // `__wrapper--initial` covers the "fresh" state; we accept all
+    // wrapper variants because some themes also produce
+    // `__wrapper--success` / `__wrapper--error` after submission.
+    shareModal: USER_OVERRIDES.shareModal
+      || 'form.cmp-modal-share, form[class*="cmp-modal-share"], [class*="cmp-modal-share__wrapper"]',
+    // Comma-delimited e-mail recipients. The DOM uses
+    // <input type="email" multiple name="email">; the type+name
+    // pairing is the most stable anchor.
+    shareEmailInput: USER_OVERRIDES.shareEmailInput
+      || 'form.cmp-modal-share input[name="email"], form[class*="cmp-modal-share"] input[name="email"], [class*="cmp-modal-share"] input[type="email"][name="email"]',
+    // "Share Publicly" checkbox. ASC renders this without a data
+    // attribute, so we use the Semantic UI wrapper + child input
+    // pattern. The reader (below) also accepts a label-text match
+    // so a future template tweak that renames the wrapper won't
+    // silently dark-launch.
+    sharePublicCheckbox: USER_OVERRIDES.sharePublicCheckbox
+      || 'form.cmp-modal-share .ui.checkbox input[type="checkbox"], form[class*="cmp-modal-share"] .ui.checkbox input[type="checkbox"]',
+    // External-share date range. Only required when the public
+    // checkbox is ticked; the inputs use plain HTML id anchors that
+    // the ASC template controls.
+    shareStartDateInput: USER_OVERRIDES.shareStartDateInput
+      || 'form.cmp-modal-share #startDate, form[class*="cmp-modal-share"] #startDate, form.cmp-modal-share input[name="startDate"], form[class*="cmp-modal-share"] input[name="startDate"]',
+    shareExpiryDateInput: USER_OVERRIDES.shareExpiryDateInput
+      || 'form.cmp-modal-share #expiryDate, form[class*="cmp-modal-share"] #expiryDate, form.cmp-modal-share input[name="expiryDate"], form[class*="cmp-modal-share"] input[name="expiryDate"]',
+
+    // ── Asset Explorer (React) ─────────────────────────────
+    // /asset-explorer.html is a React SPA whose CSS Modules generate class
+    // names with a build-hash suffix that changes on every deploy
+    // (`_input_x72oj_15` → `_input_a1b2c_42` on the next build). Every
+    // selector below uses [class*="_<stable-prefix>_"] so it survives the
+    // hash refresh; we anchor on the human-stable prefix from the source
+    // CSS Module file name (`*.module.css`) which is reused across deploys.
+    assetExplorerRoot: USER_OVERRIDES.assetExplorerRoot
+      || '[class*="_directoryExplorer_"], .directory-explorer',
+    assetExplorerForm: USER_OVERRIDES.assetExplorerForm
+      || '[class*="_directoryExplorer_"] form, [class*="_form_"]',
+    assetExplorerSearchInput: USER_OVERRIDES.assetExplorerSearchInput
+      || '[class*="_directoryExplorer_"] input[type="text"], [class*="_inputWrapper_"] input, [class*="_input_"][type="text"]',
+    // Each row in the open Search Options modal. We identify "Semantic
+    // Search" vs "Fuzzy Search" by visible text, not by row index, in case
+    // the modal grows additional rows in a future release.
+    assetExplorerSearchOptionRow: USER_OVERRIDES.assetExplorerSearchOptionRow
+      || '[class*="_searchOptionRow_"], [class*="_searchOption_Row_"]',
+    // The right-side filter rail. Contains both the facet sections and
+    // the search-statistics tiles (`N DISPLAYED / N TOTAL / N MILLISECONDS`)
+    // at the bottom on aem-sit.publiciscolab.com.
+    assetExplorerFilterRail: USER_OVERRIDES.assetExplorerFilterRail
+      || '[class*="_filterWrapper_"], [class*="_wrapper_tqpgs"], [class*="_filtersPanel_"]',
+    // Stats container. Live builds use `_statContainer_<hash>` (note the
+    // CamelCase — `_stat_` with a trailing underscore would not match) so
+    // we look for that prefix first, then progressively widen to other
+    // common React naming patterns. The reader pairs `_value_` children
+    // with `_label_` siblings inside whichever container matches, and
+    // falls back to a regex parse over the filter rail's text content
+    // when no structured tiles can be located.
+    assetExplorerSearchStatistics: USER_OVERRIDES.assetExplorerSearchStatistics
+      || '[class*="_statContainer_"], [class*="_statsContainer_"], [class*="_statisticsContainer_"], [class*="_statistics_"], [class*="_searchStats_"], [class*="_resultStats_"], [class*="_filterWrapper_"]',
+    // Filter sections inside the rail. Each section has a heading
+    // ("ASSET TYPE", "MARKETING FUNCTION / INDUSTRY", ...) plus its
+    // selectable options. We anchor on `_filterSection_`, `_facet_`,
+    // `_filterGroup_` and similar React naming conventions, and fall
+    // through to `<section>` / `<fieldset>` for un-prefixed builds.
+    assetExplorerFilterSection: USER_OVERRIDES.assetExplorerFilterSection
+      || '[class*="_filterSection_"], [class*="_filterGroup_"], [class*="_facet_"], [class*="_category_"], [class*="_section_"], section, fieldset',
+    // Left-side folder tree inside the explorer's content panel.
+    // `_directoryTree_<hash>` wraps the entire tree, `_directoryTreeContent_`
+    // is the scrollable inner container. Inner items also carry the
+    // `_directoryTree_<another-hash>` prefix from a nested CSS Module so
+    // the selector is intentionally permissive.
+    assetExplorerFolderTree: USER_OVERRIDES.assetExplorerFolderTree
+      || '[class*="_directoryTreeContent_"], [class*="_directoryTreeWrapper_"], [class*="_directoryTree_"]'
+  };
+
+  // Visible-text regexes used as a last-resort fallback when none of the CSS
+  // selectors above match. Intentionally case-insensitive and tolerant of
+  // surrounding whitespace / punctuation.
+  var TEXT_PATTERNS = {
+    signIn:   /\b(sign[- ]?in|log[- ]?in|login)\b/i,
+    lionSso:  /\blion\s*login\b/i,
+    terms:    /\bterms?\s*(?:&|and)\s*conditions?\b/i,
+    cart:     /\badd\s*to\s*(?:cart|collection)\b/i,
+    share:    /\bshare\b/i,
+    semantic: /\bsemantic\s*search\b/i,
+    fuzzy:    /\bfuzzy\s*search\b/i,
+    // "What are you looking for?" placeholder anchors the search input on
+    // /asset-explorer.html when the CSS-Module prefix has not yet been
+    // covered by the [class*="_input_"] selectors (themed builds, etc.).
+    aeSearchPlaceholder: /\b(looking for|search assets?|find assets?)\b/i
+  };
+
+  // ASC network endpoints — matched against the request URL. Patterns are
+  // intentionally tolerant so they survive moves in the AEM content tree
+  // (the `/content/<tenant>/<region>/.../actions/...` prefix varies but the
+  // suffix `/actions/download/.../download.download-asset-renditions.zip`
+  // is the ASC convention).
+  var ENDPOINTS = {
+    // POST /content/.../actions/download/.../download.download-asset-renditions.zip
+    // body: timezone=…&path=<assetPath>&renditionName=<name>&:cq_csrf_token=…
+    download:    /\/actions\/download(?:\/[^?\s]*)?\/download\.download-asset-renditions\.zip(?:[?#]|$)/,
+    // Best-effort cart/share — used to OPPORTUNISTICALLY capture network calls
+    // if the click hook missed them. Not authoritative.
+    addToCart:   /\/(?:cart|asset-collection|asset-collections)(?:\/[^?\s]*)?\.(?:add|json|html)(?:[?#]|$)|\/bin\/asset-share-commons\/cart/i,
+    share:       /\/(?:share|email-asset|send)(?:\/[^?\s]*)?\.(?:send|json|html)(?:[?#]|$)/i
+  };
+
+  // Granite endpoint that returns { authorizableId, id, ... } for the
+  // currently logged-in AEM user. Public; requires the session cookie.
+  var CURRENT_USER_ENDPOINT = '/libs/granite/security/currentuser.json';
+
+  // localStorage cache key for the resolved user. Bypasses the Granite
+  // fetch on subsequent page loads so user_id is attached to events
+  // synchronously (avoids the "first event after navigation lacks user_id"
+  // race during a roundtrip to /libs/granite/...).
+  var CACHE_KEY_USER = 'IL_COLAB_USER_ID';
+
+  // ─── 3. SDK access + safe wrappers ───────────────────────
+  function getApi() {
+    var raw = window.Infralytiqs;
+    if (!raw) return null;
+    return raw && raw.default && typeof raw.default.init === 'function' ? raw.default : raw;
+  }
+
+  function track(eventType, dims, metrics, subtype) {
+    var api = getApi();
+    if (!api) return;
+    try {
+      api.track(eventType, dims || {}, metrics || {}, subtype);
+    } catch (e) {
+      console.error('[IL-COLAB] track failed', eventType, e);
+    }
+  }
+
+  function identify(userId) {
+    var api = getApi();
+    if (!api) return;
+    try { api.identify(userId); } catch (e) { /* noop */ }
+  }
+
+  function flush() {
+    var api = getApi();
+    if (!api) return Promise.resolve();
+    try { return api.flush(); } catch (e) { return Promise.resolve(); }
+  }
+
+  // ─── 4. Browser-side enrichment ──────────────────────────
+  // Each event picks up these as `custom_dimensions` so reports can break
+  // traffic down by browser, screen, timezone, etc. without per-event work.
+  function detectBrowser() {
+    var ua = (navigator && navigator.userAgent) || '';
+    var rules = [
+      { name: 'Edge',    re: /\bEdg(?:e|A|iOS)?\/([\d\.]+)/i },
+      { name: 'Opera',   re: /\bOPR\/([\d\.]+)/i },
+      { name: 'Samsung', re: /\bSamsungBrowser\/([\d\.]+)/i },
+      { name: 'Firefox', re: /\bFirefox\/([\d\.]+)/i },
+      { name: 'Chrome',  re: /\bChrom(?:e|ium)\/([\d\.]+)/i },
+      { name: 'Safari',  re: /\bVersion\/([\d\.]+).*Safari\b/i },
+      { name: 'IE',      re: /\bMSIE\s([\d\.]+)|\bTrident\/.*\brv:([\d\.]+)/i }
+    ];
+    for (var i = 0; i < rules.length; i++) {
+      var m = ua.match(rules[i].re);
+      if (m) {
+        return { name: rules[i].name, version: (m[1] || m[2] || '').split('.')[0] };
+      }
+    }
+    return { name: 'Other', version: '' };
+  }
+
+  function safeStr(v) {
+    return (v === undefined || v === null) ? '' : String(v);
+  }
+
+  function getViewportSize() {
+    try {
+      var w = window.innerWidth  || (document.documentElement && document.documentElement.clientWidth)  || 0;
+      var h = window.innerHeight || (document.documentElement && document.documentElement.clientHeight) || 0;
+      return w && h ? (w + 'x' + h) : '';
+    } catch (e) { return ''; }
+  }
+
+  function getScreenResolution() {
+    try {
+      var s = window.screen || {};
+      var w = s.width || 0;
+      var h = s.height || 0;
+      return w && h ? (w + 'x' + h) : '';
+    } catch (e) { return ''; }
+  }
+
+  function getIanaTimezone() {
+    try {
+      if (typeof Intl !== 'undefined' && Intl.DateTimeFormat) {
+        return Intl.DateTimeFormat().resolvedOptions().timeZone || '';
+      }
+    } catch (e) { /* noop */ }
+    return '';
+  }
+
+  function getColorScheme() {
+    try {
+      if (window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches) return 'dark';
+      if (window.matchMedia && window.matchMedia('(prefers-color-scheme: light)').matches) return 'light';
+    } catch (e) { /* noop */ }
+    return '';
+  }
+
+  function buildEnrichmentDims() {
+    var browser = detectBrowser();
+    var dims = {
+      client_app:        'publicis-ps',
+      client_origin:     location.origin,
+      client_tenant:     TENANT_ID,
+      client_site:       SITE_ID,
+      browser_name:      browser.name,
+      browser_version:   browser.version,
+      viewport_size:     getViewportSize(),
+      screen_resolution: getScreenResolution(),
+      timezone_iana:     getIanaTimezone(),
+      language_full:     safeStr(navigator && navigator.language),
+      color_scheme:      getColorScheme()
+    };
+    var clean = {};
+    for (var k in dims) {
+      if (dims.hasOwnProperty(k) && dims[k] !== '' && dims[k] !== undefined) {
+        clean[k] = dims[k];
+      }
+    }
+    return clean;
+  }
+
+  // ─── 5. SDK initialization ───────────────────────────────
+  function initSdk() {
+    var api = getApi();
+    if (!api) return false;
+    try {
+      api.init({
+        serverUrl:        SERVER_URL,
+        tenantId:         TENANT_ID,
+        siteId:           SITE_ID,
+        dbName:           DB_NAME,
+        debug:            !!window.IL_DEBUG,
+        captureLocation:  window.IL_CAPTURE_LOCATION === true,
+        globalDimensions: buildEnrichmentDims()
+      });
+    } catch (e) {
+      console.error('[IL-COLAB] init failed', e);
+      return false;
+    }
+    return true;
+  }
+
+  // ─── 6. DOM + URL helpers ────────────────────────────────
+  function $(selectorList) {
+    if (!selectorList) return null;
+    try {
+      return document.querySelector(selectorList);
+    } catch (e) {
+      return null;
+    }
+  }
+
+  function visibleText(el) {
+    if (!el) return '';
+    var t = el.textContent || el.value || el.getAttribute('aria-label') || '';
+    return t.replace(/\s+/g, ' ').trim();
+  }
+
+  function closestMatchByText(root, tag, pattern) {
+    var nodes = root.querySelectorAll(tag);
+    for (var i = 0; i < nodes.length; i++) {
+      if (pattern.test(visibleText(nodes[i]))) {
+        return nodes[i];
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Login-page heuristic: explicit URL hint, or DOM signals (password input
+   * inside a form). Anything that matches counts — false positives are
+   * harmless (just adds a `login_page` subtype to the page-view).
+   */
+  function isLoginPage() {
+    var href = (location.pathname + location.search + location.hash).toLowerCase();
+    if (/(^|\/)login(\.|\/|$|\?)/.test(href)) return true;
+    if (/signin/.test(href)) return true;
+    if (document.querySelector('input[type="password"]')) return true;
+    return false;
+  }
+
+  /**
+   * Parses `location.search` into a flat key→value (or key→string[]) map,
+   * URL-decoding both keys and values and tolerating duplicate keys.
+   */
+  function parseQuery() {
+    var out = {};
+    var qs = (location.search || '').replace(/^\?/, '');
+    if (!qs) return out;
+    var parts = qs.split('&');
+    for (var i = 0; i < parts.length; i++) {
+      if (!parts[i]) continue;
+      var eqIdx = parts[i].indexOf('=');
+      var k = eqIdx >= 0 ? parts[i].slice(0, eqIdx) : parts[i];
+      var v = eqIdx >= 0 ? parts[i].slice(eqIdx + 1) : '';
+      try { k = decodeURIComponent(k.replace(/\+/g, ' ')); } catch (e) { /* keep raw */ }
+      try { v = decodeURIComponent(v.replace(/\+/g, ' ')); } catch (e) { /* keep raw */ }
+      if (out[k] === undefined) out[k] = v;
+      else if (Array.isArray(out[k])) out[k].push(v);
+      else out[k] = [out[k], v];
+    }
+    return out;
+  }
+
+  /**
+   * Parses a form-encoded body (POST request) into a flat map. Accepts a
+   * raw string, a FormData, or a URLSearchParams. Returns {} on any error.
+   */
+  function parseFormBody(body) {
+    var out = {};
+    if (!body) return out;
+    try {
+      if (typeof FormData !== 'undefined' && body instanceof FormData) {
+        body.forEach(function (v, k) { if (!(k in out)) out[k] = String(v); });
+        return out;
+      }
+      if (typeof URLSearchParams !== 'undefined' && body instanceof URLSearchParams) {
+        body.forEach(function (v, k) { if (!(k in out)) out[k] = String(v); });
+        return out;
+      }
+    } catch (e) { /* fall through to string parse */ }
+
+    var s = typeof body === 'string' ? body : '';
+    if (!s) return out;
+    var parts = s.split('&');
+    for (var i = 0; i < parts.length; i++) {
+      var p = parts[i];
+      if (!p) continue;
+      var eqIdx = p.indexOf('=');
+      var k = eqIdx >= 0 ? p.slice(0, eqIdx) : p;
+      var v = eqIdx >= 0 ? p.slice(eqIdx + 1) : '';
+      try { k = decodeURIComponent(k.replace(/\+/g, ' ')); } catch (e) { /* keep raw */ }
+      try { v = decodeURIComponent(v.replace(/\+/g, ' ')); } catch (e) { /* keep raw */ }
+      if (!(k in out)) out[k] = v;
+    }
+    return out;
+  }
+
+  /**
+   * ASC encodes search-rail filters into the URL using indexed groups, e.g.:
+   *   0_group.propertyvalues.property   = jcr:content/metadata/ps:assettype
+   *   0_group.propertyvalues.operation  = equals
+   *   0_group.propertyvalues.0_values   = Image
+   *   1_group.propertyvalues.property   = ...
+   *
+   * This helper walks the parsed query string, buckets params by their
+   * `<idx>_group.` prefix, and returns a normalized array of
+   *   { group, property, operation, values: [...] }
+   * suitable for JSON-serializing into a single dimension.
+   */
+  function extractFilters(q) {
+    var groups = {};
+    for (var k in q) {
+      if (!q.hasOwnProperty(k)) continue;
+      var m = k.match(/^(\d+)_group\.(.+)$/);
+      if (!m) continue;
+      var idx = m[1];
+      var rest = m[2];
+      if (!groups[idx]) groups[idx] = {};
+      groups[idx][rest] = q[k];
+    }
+    var list = [];
+    var keys = Object.keys(groups).sort(function (a, b) { return parseInt(a, 10) - parseInt(b, 10); });
+    for (var i = 0; i < keys.length; i++) {
+      var g = groups[keys[i]];
+      var prop = g['propertyvalues.property'] || g['property.property'] || '';
+      var op   = g['propertyvalues.operation'] || g['property.operation'] || 'equals';
+      var values = [];
+      for (var p in g) {
+        if (!g.hasOwnProperty(p)) continue;
+        // `propertyvalues.0_values`, `propertyvalues.1_values`, ...
+        // or `property.0_value`, or singular `value` / `values`.
+        if (/^propertyvalues\.\d+_values$|^property\.\d+_value$|^propertyvalues\.values?$|^property\.values?$/.test(p)) {
+          var raw = g[p];
+          if (Array.isArray(raw)) {
+            for (var j = 0; j < raw.length; j++) values.push(raw[j]);
+          } else {
+            values.push(raw);
+          }
+        }
+      }
+      if (prop || values.length) {
+        list.push({ group: keys[i], property: prop, operation: op, values: values });
+      }
+    }
+    return list;
+  }
+
+  /**
+   * Locates the ASC right-rail filter container.
+   *
+   * The visible filter sections (ASSET TYPE, MARKETING FUNCTION / INDUSTRY,
+   * APPLICATION & USE, ORIGIN, ASSET USAGE RIGHTS, LANGUAGE / REGION, YEAR,
+   * LAST MODIFIED, CREATED, …) live inside this container along with the
+   * hidden inputs that ASC's predicate components use to encode the
+   * `<idx>_group.propertyvalues.property` URL params.
+   */
+  function findFilterRail() {
+    return $(SELECTORS.filterRail);
+  }
+
+  function cleanText(s) {
+    return (s == null ? '' : String(s)).replace(/\s+/g, ' ').trim();
+  }
+
+  /**
+   * Builds a property → human-readable label map by scanning the rail for
+   * predicate blocks. Each ASC predicate (`cmp-predicate`) carries a hidden
+   * `…propertyvalues.property` input and a visible heading. We walk up from
+   * the hidden input until we find the predicate block, then take its
+   * heading text as the label.
+   *
+   * Returns e.g.
+   *   { 'jcr:content/metadata/ps:assettype': 'ASSET TYPE',
+   *     'jcr:content/metadata/cq:tags':     'MARKETING FUNCTION / INDUSTRY',
+   *     ... }
+   */
+  function buildPropertyLabelMap(rail) {
+    var map = {};
+    if (!rail || !rail.querySelectorAll) return map;
+    var propInputs;
+    try {
+      // Hidden inputs whose name ends with `.property` or `.propertyvalues.property`.
+      propInputs = rail.querySelectorAll(
+        'input[name$=".property"], ' +
+        'input[name$=".propertyvalues.property"], ' +
+        '[data-cmp-predicate-property]'
+      );
+    } catch (e) { return map; }
+
+    for (var i = 0; i < propInputs.length; i++) {
+      var node = propInputs[i];
+      var prop = (node.tagName === 'INPUT' ? node.value : node.getAttribute('data-cmp-predicate-property')) || '';
+      prop = String(prop);
+      if (!prop || map[prop]) continue;
+
+      var section = (node.closest && node.closest(
+        '.cmp-predicate, [data-cmp-is="predicate"], .predicate, ' +
+        '.cmp-search-predicate, .filter-section, section, fieldset'
+      )) || node.parentNode;
+
+      // Walk up looking for a section heading. Stop at the rail boundary
+      // so we don't accidentally pick up the entire panel's outer label.
+      while (section && section !== rail && section.nodeType === 1) {
+        var heading = section.querySelector(
+          '.cmp-predicate__title, [data-cmp-hook-predicate-title], ' +
+          '[data-predicate-title], legend, h2, h3, h4, h5, ' +
+          '.predicate-title, .filter-title'
+        );
+        if (heading && cleanText(heading.textContent)) {
+          map[prop] = cleanText(heading.textContent);
+          break;
+        }
+        section = section.parentNode;
+      }
+    }
+    return map;
+  }
+
+  /**
+   * Scans the rail for currently-selected filter inputs and groups them by
+   * the visible section heading they live under. This is a belt-and-braces
+   * capture: it picks up predicates whose state lives only in the DOM (and
+   * isn't visible in the URL) — and it lets us emit a clean
+   *   [{ name: "ASSET TYPE", values: ["Image"] }, ...]
+   * even when the property→label map didn't resolve.
+   */
+  function scanRailSelectedFilters(rail) {
+    if (!rail || !rail.querySelectorAll) return [];
+    var groupsByLabel = {};
+
+    var selected;
+    try {
+      selected = rail.querySelectorAll(
+        'input[type="checkbox"]:checked, ' +
+        'input[type="radio"]:checked, ' +
+        '[aria-checked="true"], ' +
+        '[data-selected="true"], ' +
+        '.is-selected:not(.disabled), ' +
+        '.cmp-predicate__option--selected'
+      );
+    } catch (e) { return []; }
+
+    for (var i = 0; i < selected.length; i++) {
+      var n = selected[i];
+      // Hidden, submit, and button inputs are infrastructure, not selections.
+      if (n.type === 'hidden' || n.type === 'submit' || n.type === 'button') continue;
+
+      // Prefer the visible label associated with the input.
+      var value = '';
+      try {
+        if (n.labels && n.labels.length) value = cleanText(n.labels[0].textContent);
+      } catch (e) { /* `labels` not supported */ }
+      if (!value) {
+        var labelEl = (n.closest && n.closest('label')) || null;
+        if (labelEl) value = cleanText(labelEl.textContent);
+      }
+      if (!value) value = cleanText(n.value);
+      if (!value || value.toLowerCase() === 'on') continue;
+
+      // Walk up to the predicate section + its heading.
+      var label = '';
+      var section = (n.closest && n.closest(
+        '.cmp-predicate, [data-cmp-is="predicate"], .predicate, ' +
+        '.cmp-search-predicate, .filter-section, section, fieldset'
+      )) || null;
+      var cur = section;
+      while (cur && cur !== rail && cur.nodeType === 1) {
+        var heading = cur.querySelector(
+          '.cmp-predicate__title, [data-cmp-hook-predicate-title], ' +
+          '[data-predicate-title], legend, h2, h3, h4, h5, ' +
+          '.predicate-title, .filter-title'
+        );
+        if (heading && cleanText(heading.textContent)) {
+          label = cleanText(heading.textContent);
+          break;
+        }
+        cur = cur.parentNode;
+      }
+      if (!label) label = 'filter';
+
+      if (!groupsByLabel[label]) groupsByLabel[label] = [];
+      if (groupsByLabel[label].indexOf(value) === -1) groupsByLabel[label].push(value);
+    }
+
+    var out = [];
+    for (var k in groupsByLabel) {
+      if (groupsByLabel.hasOwnProperty(k)) out.push({ name: k, values: groupsByLabel[k] });
+    }
+    return out;
+  }
+
+  /**
+   * Parses a stat value text into a Float64. Tolerates thousand separators,
+   * whitespace, and trailing unit suffixes like "ms", "s", "seconds".
+   * Returns null when the text doesn't contain a usable number.
+   */
+  function parseStatNumber(txt) {
+    if (txt == null) return null;
+    var s = String(txt).replace(/[\s,]/g, '');
+    var m = s.match(/-?\d+(?:\.\d+)?/);
+    if (!m) return null;
+    var n = parseFloat(m[0]);
+    return isFinite(n) ? n : null;
+  }
+
+  /**
+   * Classifies a stat-widget label to one of the metrics we surface.
+   *
+   * Observed ASC label variants (verified against `aem-sit.publiciscolab.com`
+   * search-stats raw_json captured 2026-05-28):
+   *   "Displayed"      → result_displayed   (count shown on current page)
+   *   "Total"          → result_total       (total assets matched)
+   *   "Milliseconds"   → search_time_ms     (server-side query latency)
+   * And the wider OOTB ASC family:
+   *   "Time", "Time (ms)", "Search Time", "Elapsed", "Duration",
+   *   "Latency", "Response" → search_time_ms
+   *   "Seconds"        → search_time_ms (×1000 → ms)
+   *   "Assets", "Results", "Hits", "Matches", "Found", "Count"
+   *                    → result_total
+   *   "Pages"          → result_pages
+   *   "Showing", "Shown" → result_displayed (alternate displayed labels)
+   *
+   * Returns null for unrecognized labels — the caller must not invent an
+   * attribution from position alone unless EVERY label in the widget came
+   * back null (see readSearchStatistics() pass 2).
+   */
+  function classifyStatLabel(label) {
+    var s = String(label || '').toLowerCase();
+    if (!s) return null;
+    if (/\b(millisecond|msec|\bms\b)/.test(s))   return { key: 'time_ms',   unit: 'ms' };
+    if (/\b(second|\bs\b)\b/.test(s))             return { key: 'time_ms',   unit: 's'  };
+    if (/\b(time|elapsed|duration|latency|response)\b/.test(s))
+                                                  return { key: 'time_ms',   unit: 'ms' };
+    if (/\b(displayed|showing|shown|visible)\b/.test(s))
+                                                  return { key: 'displayed', unit: ''   };
+    if (/\b(asset|result|hit|match|found|total|count)\b/.test(s))
+                                                  return { key: 'total',     unit: ''   };
+    if (/\bpages?\b/.test(s))                     return { key: 'pages',     unit: ''   };
+    return null;
+  }
+
+  /**
+   * Reads the ASC `cmp-search-statistics` widget into a normalized shape:
+   *   { container,
+   *     stats: {
+   *       time_ms, total, pages,
+   *       raw,       // [{ idx, label, value }] in DOM order — diagnostic
+   *       claimed    // Set<idx> of blocks already attributed to a metric
+   *     }
+   *   }
+   * `time_ms`, `total`, `pages` are Float64s (or null when not displayed);
+   * `raw` is an ordered list so we can inspect classifier mistakes from
+   * the back-end (we JSON-serialize it onto every search_executed event
+   * as `custom_dimensions.search_stats_raw_json`). Returns
+   * `{ container: <el|null>, stats: null }` when the widget hasn't been
+   * mounted yet OR has no populated `.value` cells.
+   *
+   * Positional fallback (1st=total, 2nd=time_ms, 3rd=pages) only fires
+   * for blocks NOT already claimed by the label classifier — so a single
+   * cell can never be attributed to two metrics at once.
+   */
+  function readSearchStatistics() {
+    var container = $(SELECTORS.searchStatistics);
+    if (!container || !container.querySelectorAll) {
+      return { container: null, stats: null };
+    }
+
+    // First-pass: gather (index, label, value) tuples from every leaf
+    // `.statistic` block. We deliberately exclude the outer `.statistics`
+    // wrapper that `[class*="statistic"]` would otherwise match.
+    var statBlocks = container.querySelectorAll(
+      '.statistic, [class*="statistic"]:not(.statistics)'
+    );
+    var rows = [];
+    for (var i = 0; i < statBlocks.length; i++) {
+      var block = statBlocks[i];
+      if (block.querySelector && block.querySelector('.statistic')) continue;
+
+      var labelEl = block.querySelector('.label, [class*="label"]');
+      var valueEl = block.querySelector('.value, [class*="value"]');
+      if (!valueEl) continue;
+
+      var labelText = labelEl ? cleanText(labelEl.textContent) : '';
+      var rawText   = cleanText(valueEl.textContent);
+      var n         = parseStatNumber(rawText);
+      rows.push({ idx: rows.length, label: labelText, valueText: rawText, value: n });
+    }
+    if (!rows.length || !rows.some(function (r) { return r.value !== null; })) {
+      return { container: container, stats: null };
+    }
+
+    var stats = {
+      time_ms:   null,
+      total:     null,
+      pages:     null,
+      displayed: null,
+      raw:       rows.map(function (r) { return { idx: r.idx, label: r.label, value: r.valueText }; })
+    };
+    var claimed       = {};
+    var anyClassified = false;
+
+    // Pass 1: label-driven classification — authoritative whenever the
+    // label is recognized. Skips blocks whose `.value` was empty.
+    for (var k = 0; k < rows.length; k++) {
+      var r = rows[k];
+      if (r.value === null) continue;
+      var c = classifyStatLabel(r.label);
+      if (!c) continue;
+      anyClassified = true;
+      // First match wins for each metric, so a duplicate label (rare) on
+      // a later block doesn't clobber an earlier one.
+      if (c.key === 'time_ms' && stats.time_ms === null) {
+        // Convert seconds → ms when label explicitly says seconds, so
+        // the metric column is always milliseconds regardless of label.
+        stats.time_ms = c.unit === 's' ? r.value * 1000 : r.value;
+        claimed[r.idx] = true;
+      } else if (c.key === 'total' && stats.total === null) {
+        stats.total = r.value;
+        claimed[r.idx] = true;
+      } else if (c.key === 'pages' && stats.pages === null) {
+        stats.pages = r.value;
+        claimed[r.idx] = true;
+      } else if (c.key === 'displayed' && stats.displayed === null) {
+        stats.displayed = r.value;
+        claimed[r.idx] = true;
+      }
+    }
+
+    // Pass 2: positional fallback. We deliberately keep this STRICT — it
+    // only fires when *no* label in the widget was recognized at all (a
+    // re-themed deployment with non-English / custom labels). Otherwise we
+    // trust the labels we DID recognize and leave any unclassified blocks
+    // out of the event, so an unrelated tile (e.g. "Displayed") can never
+    // bleed into `result_pages` or `search_time_ms`.
+    if (!anyClassified) {
+      // Stock ASC OOTB column order: 1) total assets, 2) time (ms), 3) pages.
+      if (rows[0] && rows[0].value !== null) {
+        stats.total = rows[0].value;
+        claimed[rows[0].idx] = true;
+      }
+      if (rows[1] && rows[1].value !== null) {
+        stats.time_ms = rows[1].value;
+        claimed[rows[1].idx] = true;
+      }
+      if (rows[2] && rows[2].value !== null) {
+        stats.pages = rows[2].value;
+        claimed[rows[2].idx] = true;
+      }
+    }
+
+    return { container: container, stats: stats };
+  }
+
+  /**
+   * Waits for a search-statistics widget to be populated for the CURRENT
+   * search and then invokes `cb(stats)`. Falls back to `cb(stats|null)`
+   * after `timeoutMs` (default 3000) so the search_executed event is never
+   * silenced indefinitely just because the widget didn't show up.
+   *
+   * `reader` is the page-specific stats-reader function returning the
+   * shared `{ container, stats: { time_ms, total, pages, displayed, raw } }`
+   * shape — `readSearchStatistics` for ASC, `readAssetExplorerSearchStatistics`
+   * for the React-based explorer. This way the wait/observe/baseline logic
+   * is written once and both contexts get the same race-safety guarantees.
+   *
+   * On the first invocation per page load the currently-displayed value is
+   * trusted (server-side rendered for the URL we just loaded). On every
+   * subsequent invocation — i.e. a pushState navigation — we cache the
+   * pre-call snapshot and require a MutationObserver hit AND a value
+   * difference vs the snapshot before resolving. That avoids attributing
+   * the previous search's "Time" reading to the new search.
+   *
+   * Returns a `cancel()` function so a fresh search that fires before the
+   * previous wait completes can abort the previous wait without leaving
+   * dangling observers.
+   */
+  function waitForSearchStats(reader, timeoutMs, cb) {
+    var read = typeof reader === 'function' ? reader : readSearchStatistics;
+    var done = false;
+    var mo = null;
+    var timer = null;
+
+    function teardown() {
+      if (mo)    { try { mo.disconnect(); } catch (e) {} mo = null; }
+      if (timer) { clearTimeout(timer); timer = null; }
+    }
+
+    function finish(stats) {
+      if (done) return;
+      done = true;
+      teardown();
+      try { cb(stats); } catch (e) { /* swallow */ }
+    }
+
+    var initial      = read();
+    var baselineTime = initial.stats ? initial.stats.time_ms : null;
+    var baselineTot  = initial.stats ? initial.stats.total   : null;
+
+    // First search of the page: the widget's current value WAS rendered for
+    // this URL (either SSR or by the SDK's earlier auto-init pass), so we
+    // can fire immediately.
+    if (__searchFireCount === 0 && initial.stats && baselineTime !== null) {
+      finish(initial.stats);
+      return function noopCancel() {};
+    }
+
+    var observeRoot = initial.container || document.body || document.documentElement;
+
+    timer = setTimeout(function () {
+      // Hard timeout: fire with whatever the widget is showing right now,
+      // even if it didn't change from the baseline. Better to record the
+      // search with no time than to drop it.
+      var late = read();
+      finish(late.stats || null);
+    }, timeoutMs || 3000);
+
+    if (typeof MutationObserver === 'function' && observeRoot) {
+      try {
+        mo = new MutationObserver(function () {
+          var probe = read();
+          if (!probe.stats || probe.stats.time_ms === null) return;
+          // Require at least one of the two key cells to have changed vs
+          // baseline. Cards, pagination, and skeleton loaders also mutate
+          // the DOM while the search XHR is in flight — we don't want any
+          // of those to count as "stats ready".
+          if (probe.stats.time_ms !== baselineTime || probe.stats.total !== baselineTot) {
+            finish(probe.stats);
+          }
+        });
+        mo.observe(observeRoot, {
+          childList:     true,
+          subtree:       true,
+          characterData: true
+        });
+      } catch (e) { /* fall back to timer-only path */ }
+    }
+
+    return function cancel() {
+      if (done) return;
+      done = true;
+      teardown();
+    };
+  }
+
+  /**
+   * Pretty-fallback when the property→label map didn't have an entry. Picks
+   * the most meaningful trailing token of a JCR-style path so reports don't
+   * have to render `jcr:content/metadata/ps:assettype` unaltered.
+   *
+   *   jcr:content/metadata/ps:assettype  →  ps:assettype
+   *   jcr:content/metadata/cq:tags       →  cq:tags
+   *   jcr:content/jcr:lastModified       →  jcr:lastModified
+   */
+  function deriveFallbackName(prop) {
+    if (!prop) return '';
+    var s = String(prop);
+    var slash = s.lastIndexOf('/');
+    return slash >= 0 ? s.slice(slash + 1) : s;
+  }
+
+  /**
+   * Detects an asset-preview / details URL anywhere in the path. Matches
+   * both layouts we've observed on aem-sit.publiciscolab.com:
+   *
+   *   ASC (root-level):
+   *     /details/image.html/content/dam/ps/branded-assets/Rolex-1.jpeg
+   *
+   *   Asset Explorer (nested under the AEM page path):
+   *     /content/ps/global/us/en/home/asset-explorer/details/image.html/content/dam/ps/brand-toolkit/bmwi4_029.jpg
+   *
+   * We deliberately require the captured `assetPath` to start with
+   * `/content/`, so a page accidentally named `details.html` somewhere else
+   * in the tree can't match. Returns null when the URL isn't a details
+   * page in either layout.
+   */
+  function detectDetailsAssetPath() {
+    var m = location.pathname.match(/\/details\/([^/]+)\.html(\/content\/.+)$/);
+    if (!m) return null;
+    return { assetType: m[1], assetPath: m[2] };
+  }
+
+  /**
+   * Walks up from a clicked element looking for a DAM asset path:
+   *   1. `data-asset-path`, `data-asset`, `data-cmp-asset`, or
+   *      `data-foundation-collection-item-id` carrying `/content/dam/…`.
+   *   2. An ancestor `<a href="/details/…">` from which we extract the path.
+   * Returns '' if nothing matches.
+   */
+  function extractAssetPathFromEl(el) {
+    var cur = el;
+    while (cur && cur !== document.body && cur.nodeType === 1) {
+      // `data-asset-share-asset` is the ASC convention used by the
+      // explorer tiles (`<button data-asset-share-id="add-to-cart"
+      // data-asset-share-asset="/content/dam/...">`). Check it first so
+      // we don't accidentally walk up to a card-level fallback when the
+      // button itself already carries the precise asset.
+      var dataAttrs = [
+        'data-asset-share-asset',
+        'data-asset-path',
+        'data-asset',
+        'data-cmp-asset',
+        'data-foundation-collection-item-id',
+        'data-path'
+      ];
+      for (var i = 0; i < dataAttrs.length; i++) {
+        var v = cur.getAttribute && cur.getAttribute(dataAttrs[i]);
+        if (v && /^\/content\/dam\//.test(v)) return v;
+      }
+      var href = (cur.getAttribute && (cur.getAttribute('data-href') || cur.getAttribute('href'))) || '';
+      if (href) {
+        var mm = href.match(/\/details\/[^/]+\.html(\/content\/dam\/[^\s?#]+)/);
+        if (mm) return mm[1];
+      }
+      cur = cur.parentNode;
+    }
+    return '';
+  }
+
+  /**
+   * Parses a URL or query-string fragment into a plain object. Trivial
+   * shim around `URLSearchParams` that survives IE / older Safari where
+   * the constructor isn't available. Used to pull `downloadId` and
+   * `artifactId` from the asset-download anchor href.
+   */
+  function parseUrlParams(href) {
+    var out = {};
+    if (!href) return out;
+    var q = String(href);
+    var hashIdx = q.indexOf('#');
+    if (hashIdx >= 0) q = q.slice(0, hashIdx);
+    var qIdx = q.indexOf('?');
+    if (qIdx < 0) return out;
+    var pairs = q.slice(qIdx + 1).split('&');
+    for (var i = 0; i < pairs.length; i++) {
+      var kv = pairs[i].split('=');
+      if (!kv[0]) continue;
+      var k, v;
+      try { k = decodeURIComponent(kv[0].replace(/\+/g, ' ')); } catch (e) { k = kv[0]; }
+      try { v = kv.length > 1 ? decodeURIComponent(kv[1].replace(/\+/g, ' ')) : ''; } catch (e) { v = kv[1] || ''; }
+      out[k] = v;
+    }
+    return out;
+  }
+
+  /**
+   * Reads the current contents of the ASC cart modal (if open). Returns
+   * an array of unique `/content/dam/...` paths discovered via, in
+   * order:
+   *
+   *   1. `data-asset-share-asset` attributes (preferred — the cart
+   *      template renders these on each row),
+   *   2. `data-asset-path` / `data-asset` / `data-cmp-asset` as
+   *      fallbacks for older / themed ASC builds,
+   *   3. `<a href="/.../details/<type>.html/content/dam/...">` links,
+   *   4. hidden `<input name="path">` form fields (legacy ASC).
+   *
+   * Returns `[]` when the modal isn't currently in the DOM — the
+   * caller can attach an empty `cart_asset_paths_json=""` and a
+   * `cart_item_count=0` so reports can distinguish "no cart open" from
+   * "cart open but empty".
+   */
+  function readCartContents() {
+    var modal = document.querySelector(SELECTORS.cartModal);
+    if (!modal) return [];
+    var paths = [];
+    var seen  = {};
+    function add(p) {
+      if (!p) return;
+      if (!/^\/content\/dam\//.test(p)) return;
+      if (seen[p]) return;
+      seen[p] = true;
+      paths.push(p);
+    }
+    var attrAttempts = ['data-asset-share-asset', 'data-asset-path', 'data-asset', 'data-cmp-asset'];
+    for (var a = 0; a < attrAttempts.length; a++) {
+      var els = modal.querySelectorAll('[' + attrAttempts[a] + ']');
+      for (var i = 0; i < els.length; i++) {
+        add(els[i].getAttribute(attrAttempts[a]));
+      }
+    }
+    var anchors = modal.querySelectorAll('a[href*="/details/"]');
+    for (var j = 0; j < anchors.length; j++) {
+      var href = anchors[j].getAttribute('href') || '';
+      var m = href.match(/\/details\/[^/]+\.html(\/content\/dam\/[^\s?#]+)/);
+      if (m) add(m[1]);
+    }
+    var inputs = modal.querySelectorAll('input[name="path"], input[name="paths"]');
+    for (var k = 0; k < inputs.length; k++) {
+      add(inputs[k].value);
+    }
+    return paths;
+  }
+
+  // ─── 7. User identity resolution ─────────────────────────
+  function readCachedUserId() {
+    try { return localStorage.getItem(CACHE_KEY_USER) || ''; } catch (e) { return ''; }
+  }
+  function writeCachedUserId(u) {
+    try { localStorage.setItem(CACHE_KEY_USER, String(u || '')); } catch (e) { /* private mode etc. */ }
+  }
+
+  /**
+   * Resolves the AEM authorizable id of the currently logged-in user.
+   * Resolution order:
+   *   1. host-page-provided `window.IL_COLAB_USER_RESOLVER` (sync string or Promise)
+   *   2. `<meta name="cq:user" | "user" | "user-id">`
+   *   3. `/libs/granite/security/currentuser.json` (Granite endpoint)
+   *
+   * Calls `cb('')` for anonymous sessions; never throws.
+   *
+   * We deliberately use the unwrapped (pre-install) `fetch` so that our
+   * own identity probe doesn't echo through the network interception
+   * installed below for asset_download.
+   */
+  var ORIG_FETCH = (typeof window.fetch === 'function') ? window.fetch.bind(window) : null;
+
+  function resolveCurrentUser(cb) {
+    try {
+      if (typeof window.IL_COLAB_USER_RESOLVER === 'function') {
+        var v = window.IL_COLAB_USER_RESOLVER();
+        if (typeof v === 'string') { cb(v || ''); return; }
+        if (v && typeof v.then === 'function') {
+          v.then(function (s) { cb(typeof s === 'string' ? s : ''); }, function () { cb(''); });
+          return;
+        }
+      }
+    } catch (e) { /* fall through */ }
+
+    var meta = document.querySelector('meta[name="cq:user"], meta[name="user"], meta[name="user-id"]');
+    if (meta && meta.getAttribute('content')) { cb(meta.getAttribute('content')); return; }
+
+    if (ORIG_FETCH) {
+      ORIG_FETCH(CURRENT_USER_ENDPOINT, {
+        credentials: 'same-origin',
+        headers: { 'Accept': 'application/json' }
+      })
+        .then(function (r) { return r && r.ok ? r.json() : null; })
+        .then(function (j) {
+          if (!j) { cb(''); return; }
+          cb(j.authorizableId || j.id || j.userId || j.name || '');
+        })
+        .catch(function () { cb(''); });
+      return;
+    }
+    cb('');
+  }
+
+  function resolveAndIdentifyUser() {
+    var cached = readCachedUserId();
+    if (cached) identify(cached);
+    resolveCurrentUser(function (u) {
+      if (u && u !== cached) {
+        writeCachedUserId(u);
+        identify(u);
+      }
+    });
+  }
+
+  // ─── 8. URL-driven events ────────────────────────────────
+
+  // Cross-call state for trackSearchExecuted ↔ waitForSearchStats. Kept at
+  // the bootstrap scope (not per-call) so we can flush an in-flight wait
+  // when the user navigates to a new search before the previous one's
+  // statistics widget finished updating — otherwise the old call's
+  // MutationObserver would pick up the NEW search's stats.
+  var __searchFireCount         = 0;
+  var __cancelInflightStatsWait = null;
+  var __flushInflightSearchNow  = null;
+
+  /**
+   * EVENT (login page only): Anonymous landing on the Login page.
+   *
+   * The SDK already auto-fires a `page_view` on every load (including this
+   * one), but we add an explicit `login_page_view` event so the Reports
+   * "login funnel" panel can distinguish login-page traffic from generic
+   * site traffic and segment anonymous visitors before identify() fires.
+   */
+  function trackLoginPageView() {
+    if (!isLoginPage()) return;
+    track('login_page_view', {
+      page_type:   'login',
+      auth_state:  'anonymous',
+      page_url:    location.href,
+      referrer:    document.referrer || ''
+    }, {}, 'anonymous');
+  }
+
+  /**
+   * EVENT 1 (search): fires when the current URL is a search-results page.
+   *
+   * ASC submits the search form via GET, so every search materializes as
+   * a navigation. The new page-load runs this bootstrap fresh; if the URL
+   * carries `?fulltext=…` we have a verified search execution AND all the
+   * inputs the user supplied (term, semantic toggle, fuzzy toggle, rail
+   * filters, ordering, layout, pagination) right there in the query string.
+   *
+   * This is more reliable than hooking the submit handler because it also
+   * captures bookmarked searches, browser-back navigations, and shareable
+   * search URLs — every one of which counts as a "search executed" event.
+   */
+  function trackSearchExecuted(q) {
+    if (!q.hasOwnProperty('fulltext')) return;
+
+    // A new search arrived before the previous wait completed. Fire the
+    // previous event NOW with whatever it has — we cannot let its
+    // MutationObserver pick up THIS search's stats and mis-attribute them.
+    if (__flushInflightSearchNow) {
+      try { __flushInflightSearchNow(); } catch (e) {}
+      __flushInflightSearchNow = null;
+    }
+    if (__cancelInflightStatsWait) {
+      try { __cancelInflightStatsWait(); } catch (e) {}
+      __cancelInflightStatsWait = null;
+    }
+
+    // 1. URL is the canonical source of WHICH filters were applied — group,
+    //    property, operation, values are all encoded there.
+    var urlFilters = extractFilters(q);
+
+    // 2. Enrich each URL filter with the human-readable section heading
+    //    from the right rail (ASSET TYPE, MARKETING FUNCTION / INDUSTRY,
+    //    APPLICATION & USE, ORIGIN, ASSET USAGE RIGHTS, LANGUAGE / REGION,
+    //    YEAR, LAST MODIFIED, CREATED, …). Falls back to the property's
+    //    trailing JCR segment if the rail isn't present (e.g. event fired
+    //    from a shared URL on a page without the rail).
+    var rail = findFilterRail();
+    var labelMap = buildPropertyLabelMap(rail);
+    for (var i = 0; i < urlFilters.length; i++) {
+      var f = urlFilters[i];
+      f.name = labelMap[f.property] || deriveFallbackName(f.property);
+    }
+
+    // 3. DOM-only sweep as a safety net — captures any predicate that is
+    //    selected in the rail but didn't appear in the URL (e.g. local UI
+    //    state that hadn't been submitted yet, or predicates encoded by a
+    //    non-standard component). Indexed by visible section heading so
+    //    reports can render it without per-filter mapping.
+    var domFilters = scanRailSelectedFilters(rail);
+
+    var dims = {
+      search_term:      safeStr(q.fulltext),
+      semantic_search:  String(safeStr(q.semanticSearchEnabled).toLowerCase() === 'true'),
+      fuzzy_search:     String(safeStr(q.fuzzySearchEnabled).toLowerCase() === 'true'),
+      filters_json:     urlFilters.length ? JSON.stringify(urlFilters) : '',
+      filters_dom_json: domFilters.length ? JSON.stringify(domFilters) : '',
+      orderby:          safeStr(q.orderby),
+      order_dir:        safeStr(q['orderby.sort']),
+      layout:           safeStr(q.layout),
+      search_context:   'asc',
+      page_url:         location.href,
+      page_referrer:    document.referrer || ''
+    };
+    var metrics = {
+      filter_count:     urlFilters.length,
+      filter_dom_count: domFilters.length,
+      result_offset:    parseInt(safeStr(q['p.offset']) || '0', 10) || 0,
+      result_limit:     parseInt(safeStr(q['p.limit'])  || '0', 10) || 0
+    };
+
+    var fired = false;
+    function fireWithStats(stats) {
+      if (fired) return;
+      fired = true;
+      __cancelInflightStatsWait = null;
+      __flushInflightSearchNow  = null;
+
+      if (stats) {
+        if (stats.time_ms   !== null) metrics.search_time_ms   = stats.time_ms;
+        if (stats.total     !== null) metrics.result_total     = stats.total;
+        if (stats.pages     !== null) metrics.result_pages     = stats.pages;
+        if (stats.displayed !== null) metrics.result_displayed = stats.displayed;
+        dims.search_stats_ready = 'true';
+        // Persist the raw label→value pairs in DOM order so any classifier
+        // misattribution can be diagnosed from the back-end (e.g. ASC
+        // re-labels "Time (ms)" → "Search Speed" in a future release).
+        // Truncated to 240 chars to stay well under any ClickHouse Map
+        // value size limit and avoid bloating event payloads.
+        try {
+          if (stats.raw && stats.raw.length) {
+            var rawJson = JSON.stringify(stats.raw);
+            dims.search_stats_raw_json = rawJson.length > 240
+              ? rawJson.slice(0, 240)
+              : rawJson;
+          }
+        } catch (e) { /* swallow */ }
+      } else {
+        dims.search_stats_ready = 'false';
+      }
+
+      // Fourth arg is the event subtype — surfaces in ClickHouse's
+      // event_subtype column. ASC fires our bootstrap once per full page
+      // load, but also navigates via history.pushState when the user
+      // tweaks a filter / pagination / layout / sort. We re-fire search
+      // events on those pushState transitions too (see installSpaNavHooks
+      // below), and tag both initial + SPA fires with the SAME subtype so
+      // reports don't have to special-case how the URL was reached.
+      track('search_executed', dims, metrics, 'asset_search');
+      __searchFireCount++;
+    }
+
+    // Stash a synchronous flush hook so the next trackSearchExecuted call
+    // can force this one to fire (without stats) before starting its own
+    // wait — see the early-return block at the top of this function.
+    __flushInflightSearchNow  = function () { fireWithStats(null); };
+    __cancelInflightStatsWait = waitForSearchStats(readSearchStatistics, 3000, fireWithStats);
+  }
+
+  /**
+   * EVENT 2 (asset preview): fires when the current URL is an ASC details
+   * page — i.e. a thumbnail click in the results grid navigated here.
+   *
+   * The asset path (`/content/dam/…`) is the suffix of `location.pathname`
+   * after `/details/<type>.html`; the asset type is the segment in front
+   * of `.html` (image, video, document, 3d, audio, …).
+   */
+  function trackAssetPreview() {
+    var info = detectDetailsAssetPath();
+    if (!info) return;
+    var assetName = (info.assetPath.split('/').pop() || '');
+    var dotIdx = assetName.lastIndexOf('.');
+    var assetExt = dotIdx > 0 ? assetName.slice(dotIdx + 1).toLowerCase() : '';
+    track('asset_preview', {
+      asset_path:      info.assetPath,
+      asset_type:      info.assetType,
+      asset_name:      assetName,
+      asset_extension: assetExt,
+      page_url:        location.href,
+      page_referrer:   document.referrer || ''
+    }, {}, 'asset_detail');
+  }
+
+  /**
+   * Wraps `history.pushState` / `history.replaceState` (and listens for
+   * `popstate`) so we re-evaluate the URL on every SPA navigation and
+   * re-fire `search_executed` / `asset_preview` if appropriate.
+   *
+   * Why this matters: Asset Share Commons rewires its in-page filter /
+   * sort / layout / pagination controls to call `history.pushState`
+   * rather than doing a full page reload. Without this hook the SDK's
+   * own pushState wrapper still fires a `page_view` with
+   * `event_subtype = "spa_navigation"`, but our search_executed event
+   * (with `search_term`, `semantic_search`, `fuzzy_search`,
+   * `filters_json`, etc. on the `custom_dimensions` map) would never
+   * fire on those in-page transitions.
+   *
+   * Dedup: we keep the previous URL in a closure variable and skip
+   * re-firing when the URL hasn't actually changed (e.g. some libraries
+   * call replaceState with the current state on hash-only updates).
+   */
+  function installSpaNavHooks() {
+    if (window.__ilColabSpaHooked) return;
+    window.__ilColabSpaHooked = true;
+
+    var lastUrl = location.href;
+
+    function reevaluate() {
+      try {
+        var nowUrl = location.href;
+        if (nowUrl === lastUrl) return;
+        lastUrl = nowUrl;
+        var q = parseQuery();
+        trackSearchExecuted(q);
+        trackAssetPreview();
+      } catch (e) { /* swallow — never break the host page */ }
+    }
+
+    // Defer slightly so the URL change has actually settled in the address
+    // bar by the time we read `location.href` (some routers call pushState
+    // synchronously inside an event handler that hasn't yet committed).
+    function scheduleReevaluate() {
+      try { (window.requestAnimationFrame || setTimeout)(reevaluate, 0); }
+      catch (e) { setTimeout(reevaluate, 0); }
+    }
+
+    window.addEventListener('popstate',     scheduleReevaluate);
+    window.addEventListener('hashchange',   scheduleReevaluate);
+
+    if (window.history && typeof history.pushState === 'function') {
+      var origPush = history.pushState;
+      history.pushState = function () {
+        var ret = origPush.apply(this, arguments);
+        scheduleReevaluate();
+        return ret;
+      };
+    }
+    if (window.history && typeof history.replaceState === 'function') {
+      var origReplace = history.replaceState;
+      history.replaceState = function () {
+        var ret = origReplace.apply(this, arguments);
+        scheduleReevaluate();
+        return ret;
+      };
+    }
+  }
+
+  // ─── 8b. Asset Explorer (React) ──────────────────────────
+
+  /**
+   * Returns true when the current URL is the React-based Asset Explorer
+   * (e.g. /asset-explorer.html#/content/dam/ps). We accept the URL signal
+   * first because it doesn't require the DOM to have settled, and fall
+   * back to a DOM probe for themed deployments that mount the explorer
+   * under a different path.
+   */
+  function isAssetExplorerPage() {
+    var p = location.pathname;
+    // Asset-preview / details URLs are a *child* of the explorer page
+    // (`.../asset-explorer/details/<type>.html/<asset-path>`) and we want
+    // those to fall into the ASC-style branch so trackAssetPreview() fires.
+    // The details-detector above is the authoritative match for that.
+    if (detectDetailsAssetPath()) return false;
+    // URL path heuristic: matches both `/asset-explorer.html` (vanity URL)
+    // and `/content/.../asset-explorer.html` (resolved page path).
+    if (/\/asset[-_]?explorer(\.html|\/|$)/i.test(p)) return true;
+    if (document.querySelector('[class*="_directoryExplorer_"], .directory-explorer')) return true;
+    return false;
+  }
+
+  function findAssetExplorerRoot() {
+    return $(SELECTORS.assetExplorerRoot);
+  }
+
+  /**
+   * Locates the visible search input. Falls back to placeholder-text match
+   * if the [class*="_input_"] selectors haven't been baked into a themed
+   * deployment yet.
+   */
+  function findAssetExplorerSearchInput() {
+    var byClass = $(SELECTORS.assetExplorerSearchInput);
+    if (byClass) return byClass;
+    var inputs = document.querySelectorAll('input[type="text"], input:not([type])');
+    for (var i = 0; i < inputs.length; i++) {
+      var p = inputs[i].getAttribute('placeholder') || '';
+      if (TEXT_PATTERNS.aeSearchPlaceholder.test(p)) return inputs[i];
+    }
+    return null;
+  }
+
+  /**
+   * Returns the current `#/content/dam/...` folder path the explorer is
+   * showing. Strips the leading `#` and any embedded query suffix so the
+   * value is directly comparable to AEM JCR paths.
+   */
+  function readAssetExplorerFolderPath() {
+    var h = String(location.hash || '');
+    h = h.replace(/^#/, '');
+    var qIdx = h.indexOf('?');
+    if (qIdx >= 0) h = h.slice(0, qIdx);
+    return h;
+  }
+
+  /**
+   * Reads the on/off state of a labelled toggle inside the Search Options
+   * modal. Toggle markup varies across React component libraries so we
+   * walk several known patterns before giving up:
+   *
+   *   1. native checkbox / radio (`checked`)
+   *   2. `aria-checked` / `aria-pressed` / `aria-selected`
+   *   3. class names containing "checked", "active", "enabled", "on"
+   *   4. `data-state="on"` (Radix UI) / `data-selected="true"`
+   *
+   * Returns `'true'` / `'false'` strings so the value drops directly into
+   * the ClickHouse `custom_dimensions` map without further serialization,
+   * and `''` when the labelled row isn't present (modal not open). The
+   * caller treats `''` as "unknown" and won't emit a misleading default.
+   */
+  function readAssetExplorerToggleState(labelRe) {
+    var rows = document.querySelectorAll(SELECTORS.assetExplorerSearchOptionRow);
+    for (var i = 0; i < rows.length; i++) {
+      var row = rows[i];
+      var text = cleanText(row.textContent || '');
+      if (!labelRe.test(text)) continue;
+
+      // 1. native form control
+      var checkbox = row.querySelector('input[type="checkbox"], input[type="radio"]');
+      if (checkbox && checkbox.checked !== undefined) {
+        return String(!!checkbox.checked);
+      }
+
+      // 2. ARIA
+      var ariaChecked = row.querySelector('[aria-checked], [aria-pressed], [aria-selected]');
+      if (ariaChecked) {
+        var v = ariaChecked.getAttribute('aria-checked')
+             || ariaChecked.getAttribute('aria-pressed')
+             || ariaChecked.getAttribute('aria-selected');
+        if (v === 'true' || v === 'false') return v;
+      }
+
+      // 3. data-state / data-selected
+      var dataStated = row.querySelector('[data-state], [data-selected]');
+      if (dataStated) {
+        var ds = (dataStated.getAttribute('data-state') || '').toLowerCase();
+        if (ds === 'on' || ds === 'checked' || ds === 'true')  return 'true';
+        if (ds === 'off' || ds === 'unchecked' || ds === 'false') return 'false';
+        var sel = (dataStated.getAttribute('data-selected') || '').toLowerCase();
+        if (sel === 'true')  return 'true';
+        if (sel === 'false') return 'false';
+      }
+
+      // 4. class-name heuristic on the row OR its toggle child
+      var classRoot = row.querySelector('[class*="toggle"], [class*="switch"], [role="switch"]') || row;
+      var cls = (classRoot.className && classRoot.className.baseVal !== undefined)
+        ? classRoot.className.baseVal  // SVG element
+        : String(classRoot.className || '');
+      if (/(^|[\s_-])(active|checked|enabled|on|selected)([\s_-]|$)/i.test(cls)) return 'true';
+      if (/(^|[\s_-])(inactive|unchecked|disabled|off)([\s_-]|$)/i.test(cls))    return 'false';
+
+      // Row matched but we couldn't determine state — return empty so the
+      // caller emits "" rather than a misleading default.
+      return '';
+    }
+    return '';
+  }
+
+  /**
+   * Reads the Asset Explorer search-statistics tiles.
+   *
+   * The live aem-sit.publiciscolab.com build renders three tiles inside a
+   * `<div class="_statContainer_1qyta_1">` (camelCase suffix → not
+   * matched by `[class*="_stat_"]`!) where each tile is a sibling
+   * `<div>` containing a `<div class="_value_1qyta_9">N</div>` and a
+   * sibling `<div class="_label_*">LABEL</div>`. We try in order:
+   *
+   *   1. find the stats container (or fall back to the filter rail),
+   *   2. for every `[class*="_value_"]` descendant, pair it with a
+   *      `[class*="_label_"]` peer found by climbing the closest tile
+   *      wrapper (`<div>` parent) — covers both
+   *      "value-then-label" and "label-then-value" tile layouts,
+   *   3. as a last resort, regex-parse the container's textContent for
+   *      `<number><whitespace?><LABEL>` so a stripped-down themed build
+   *      with no _value_/_label_ class hints still resolves.
+   *
+   * Returns the same `{ container, stats: { time_ms, total, pages,
+   *   displayed, raw } }` shape as readSearchStatistics() so the shared
+   * waitForSearchStats() works unchanged.
+   */
+  function readAssetExplorerSearchStatistics() {
+    var container = $(SELECTORS.assetExplorerSearchStatistics);
+    if (!container) return { container: null, stats: null };
+
+    var rows = [];
+    var seen = {};
+
+    function pushRow(label, valueText, value) {
+      var key = (label || '').toLowerCase() + ':' + valueText;
+      if (seen[key]) return;
+      seen[key] = true;
+      rows.push({ idx: rows.length, label: label, valueText: valueText, value: value });
+    }
+
+    // ── Strategy 1: _value_ / _label_ pairing ───────────────
+    // Walk every `[class*="_value_"]` in the container, then look for a
+    // sibling/uncle/parent text that's the label. This handles the
+    // `_statContainer_ > div[i] > {_value_, _label_}` shape and the
+    // common variant where value and label are wrapped together in
+    // a `<div>` tile.
+    var valueEls = container.querySelectorAll('[class*="_value_"]');
+    for (var i = 0; i < valueEls.length; i++) {
+      var vEl       = valueEls[i];
+      var valueText = cleanText(vEl.textContent);
+      var n         = parseStatNumber(valueText);
+      if (n === null) continue;
+
+      // Skip $value$ blocks that aren't direct text values (e.g., a
+      // nested wrapper). Only first-level numeric content qualifies.
+      if (!/^[-+]?\d/.test(valueText)) continue;
+
+      var labelText = '';
+
+      // a) Sibling [class*="_label_"]
+      if (vEl.parentElement) {
+        var sibLabel = vEl.parentElement.querySelector('[class*="_label_"]');
+        if (sibLabel && sibLabel !== vEl) labelText = cleanText(sibLabel.textContent);
+      }
+
+      // b) Walk up one level — tile may wrap value+label in a div whose
+      //    parent has a separate [class*="_label_"] child.
+      if (!labelText && vEl.parentElement && vEl.parentElement.parentElement) {
+        var unc = vEl.parentElement.parentElement.querySelector('[class*="_label_"]');
+        if (unc && unc !== vEl) labelText = cleanText(unc.textContent);
+      }
+
+      // c) Adjacent textContent — parent's text minus the value
+      if (!labelText && vEl.parentElement) {
+        var parentText = cleanText(vEl.parentElement.textContent);
+        if (parentText && parentText.indexOf(valueText) >= 0) {
+          var residual = parentText.replace(valueText, '').trim();
+          // Only keep if residual is short (a label) not a paragraph.
+          if (residual && residual.length <= 80) labelText = residual;
+        }
+      }
+
+      pushRow(labelText, valueText, n);
+    }
+
+    // ── Strategy 2: regex over container text ───────────────
+    // Pattern: `<number><whitespace?><LABEL>` repeated (e.g.
+    // "4 DISPLAYED 4 TOTAL 11 MILLISECONDS" or "4DISPLAYED…").
+    if (!rows.length) {
+      var fullText = cleanText(container.textContent || '');
+      var re = /(\d+(?:[.,]\d+)?)\s*(displayed|showing|shown|visible|total|results?|assets?|hits?|matches?|found|count|milliseconds?|seconds?|elapsed|duration|time|pages?)\b/gi;
+      var m;
+      while ((m = re.exec(fullText)) !== null) {
+        var rv = parseStatNumber(m[1]);
+        if (rv === null) continue;
+        pushRow(m[2], m[1], rv);
+      }
+    }
+
+    if (!rows.length || !rows.some(function (r) { return r.value !== null; })) {
+      return { container: container, stats: null };
+    }
+
+    var stats = {
+      time_ms:   null,
+      total:     null,
+      pages:     null,
+      displayed: null,
+      raw:       rows.map(function (r) { return { idx: r.idx, label: r.label, value: r.valueText }; })
+    };
+
+    // Label-driven classification. We deliberately DO NOT carry the
+    // positional fallback over from the ASC reader — React layouts
+    // have no stable left-to-right ordering convention and a silent
+    // no-op is safer than a confident mis-attribution.
+    for (var k = 0; k < rows.length; k++) {
+      var r = rows[k];
+      if (r.value === null) continue;
+      var c = classifyStatLabel(r.label);
+      if (!c) continue;
+      if (c.key === 'time_ms' && stats.time_ms === null) {
+        stats.time_ms = c.unit === 's' ? r.value * 1000 : r.value;
+      } else if (c.key === 'total' && stats.total === null) {
+        stats.total = r.value;
+      } else if (c.key === 'pages' && stats.pages === null) {
+        stats.pages = r.value;
+      } else if (c.key === 'displayed' && stats.displayed === null) {
+        stats.displayed = r.value;
+      }
+    }
+
+    return { container: container, stats: stats };
+  }
+
+  /**
+   * Reads the currently-selected filters from the right-rail facet panel.
+   * Returns an array of `{ name, values[] }` blocks keyed by section
+   * heading text — same shape `filters_dom_json` carries on the ASC
+   * search_executed event so dashboards can pivot on either context
+   * uniformly. An empty array (no selections) is the normal default;
+   * the caller emits `filters_dom_json=""` in that case.
+   *
+   * Detection strategies, applied in order until something is found:
+   *   1. Native form controls (`input[type="checkbox"]:checked`,
+   *      `input[type="radio"]:checked`).
+   *   2. ARIA: `[aria-checked="true"]`, `[aria-selected="true"]`,
+   *      `[aria-pressed="true"]`.
+   *   3. data-state: `[data-state="checked" | "on" | "selected"]`,
+   *      `[data-selected="true"]`.
+   *   4. Class-name heuristic — any element under the rail with a class
+   *      containing "_selected", "_checked", "_active", or "_on" that
+   *      ISN'T paired with an "un-" prefix on the same chip.
+   *
+   * Each match is grouped under its enclosing section heading; the
+   * heading is resolved by walking up to the closest filter-section
+   * container and reading its first heading-class child.
+   */
+  function readAssetExplorerFilters() {
+    var rail = $(SELECTORS.assetExplorerFilterRail);
+    if (!rail) return [];
+
+    // Live aem-sit.publiciscolab.com filter rail captures show section
+    // headings landing on classes the original `_filterSection_`-anchored
+    // logic never saw. Climb up to 8 ancestor levels and, at each step,
+    // look for either a previous-sibling or first-child element whose
+    // class matches the heading patterns OR whose textContent is a
+    // short ALL-CAPS label. The ALL-CAPS fallback handles builds
+    // where the heading element has no recognisable class (just a plain
+    // <div>FACET NAME</div>).
+    //
+    // We deliberately keep `[class*="_label_"]` / `[class*="_name_"]` /
+    // `[class*="_header_"]` OUT of the heading selector — in this React
+    // build the CHIP itself wraps its visible text in `_label_<hash>`,
+    // and the chip's label appears in DOM order BEFORE its input, so
+    // matching `_label_` would walk straight into the chip's own text
+    // and return it as the section heading (v1.1.3 bug: "2026" / "Image"
+    // ended up as section names). The ALL-CAPS visibility test below
+    // is the more reliable signal for actual section names.
+    var HEADING_SELECTOR =
+      '[class*="_heading_"], [class*="_title_"], [class*="_sectionTitle_"], ' +
+      '[class*="_categoryName_"], [class*="_facetTitle_"], [class*="_groupName_"], ' +
+      '[class*="_groupTitle_"], [class*="_sectionHeader_"], [class*="_facetHeader_"], ' +
+      '[class*="_categoryHeader_"], [class*="_filterHeader_"], [class*="_filterTitle_"], ' +
+      'h1, h2, h3, h4, h5, h6, legend, summary';
+
+    function looksLikeFacetHeading(txt) {
+      if (!txt) return false;
+      if (txt.length < 3 || txt.length > 80) return false;
+      // Reject stat tiles ("4 DISPLAYED") and pure numbers ("2026").
+      if (/^\d/.test(txt)) return false;
+      // Must contain at least one A-Z letter and NO lowercase letters
+      // — observed facets on this build are 100% uppercase with optional
+      // punctuation: ASSET TYPE, MARKETING FUNCTION / INDUSTRY,
+      // APPLICATION & USE, ORIGIN, ASSET USAGE RIGHTS,
+      // LANGUAGE / REGION, YEAR.
+      if (!/[A-Z]/.test(txt)) return false;
+      if (/[a-z]/.test(txt))   return false;
+      // Allowed character set — uppercase letters, digits (rare),
+      // whitespace, and a handful of punctuation marks seen in facet
+      // names. Anything else is probably a chip with weird casing.
+      if (!/^[A-Z0-9 &/().,\-]+$/.test(txt)) return false;
+      // Reject pure punctuation / pure whitespace.
+      if (!/[A-Z]{2,}/.test(txt) && txt.length < 4) return false;
+      return true;
+    }
+
+    function sectionHeadingFor(el) {
+      var ancestor = el;
+      for (var depth = 0; depth < 8 && ancestor && ancestor !== rail; depth++) {
+        // a) Heading-class previous sibling at this depth
+        var prev = ancestor.previousElementSibling;
+        while (prev) {
+          if (prev.matches && prev.matches(HEADING_SELECTOR)) {
+            var t1 = cleanText(prev.textContent || '');
+            if (t1) return t1.slice(0, 80);
+          }
+          // ALL-CAPS plain element with short text counts too
+          var pt = cleanText(prev.textContent || '');
+          if (looksLikeFacetHeading(pt)) return pt.slice(0, 80);
+          prev = prev.previousElementSibling;
+        }
+        // b) Heading-class first child of THIS ancestor (before the chip)
+        var children = ancestor.children;
+        for (var i = 0; i < children.length; i++) {
+          var c = children[i];
+          if (c === el) break;
+          if (c.contains && c.contains(el)) continue;     // skip the chip's branch
+          if (c.matches && c.matches(HEADING_SELECTOR)) {
+            var t2 = cleanText(c.textContent || '');
+            if (t2) return t2.slice(0, 80);
+          }
+          // ALL-CAPS plain element
+          var ct = cleanText(c.textContent || '');
+          if (looksLikeFacetHeading(ct)) return ct.slice(0, 80);
+        }
+        ancestor = ancestor.parentElement;
+      }
+      return '';
+    }
+
+    function chipLabel(el) {
+      var inp;
+      if (el.tagName === 'INPUT' || el.tagName === 'SELECT' || el.tagName === 'OPTION') {
+        inp = el;
+      }
+      // Prefer an associated <label>, then aria-label, then visible text.
+      if (inp && inp.id) {
+        var lab = document.querySelector('label[for="' + CSS.escape(inp.id) + '"]');
+        if (lab) return cleanText(lab.textContent || '');
+      }
+      var aria = el.getAttribute && el.getAttribute('aria-label');
+      if (aria) return aria;
+      // Climb to the nearest row/chip wrapper for the visible text — the
+      // raw element itself might be an inner input/svg with no text.
+      var wrapper = el.closest('label, li, [role="option"], [role="treeitem"], [role="menuitem"], [class*="_option_"], [class*="_chip_"], [class*="_item_"], [class*="_row_"]') || el;
+      return cleanText(wrapper.textContent || '').slice(0, 120);
+    }
+
+    var bySection = {};
+    function record(el) {
+      var section = sectionHeadingFor(el) || 'unknown';
+      var label   = chipLabel(el);
+      if (!label) return;
+      if (!bySection[section]) bySection[section] = [];
+      // Dedup within the same section (a checkbox + its <label> wrapper
+      // can both match the class-name heuristic).
+      if (bySection[section].indexOf(label) < 0) bySection[section].push(label);
+    }
+
+    // 1. native form controls
+    var natives = rail.querySelectorAll('input[type="checkbox"]:checked, input[type="radio"]:checked');
+    for (var n = 0; n < natives.length; n++) record(natives[n]);
+
+    // 2. ARIA / data-state
+    var ariaSel = rail.querySelectorAll(
+      '[aria-checked="true"], [aria-selected="true"], [aria-pressed="true"], ' +
+      '[data-state="checked"], [data-state="on"], [data-state="selected"], ' +
+      '[data-selected="true"]'
+    );
+    for (var a = 0; a < ariaSel.length; a++) record(ariaSel[a]);
+
+    // 3. class-name heuristic — narrow to elements whose className is
+    //    SHORT (likely a chip) and contains a positive state marker.
+    var clsCandidates = rail.querySelectorAll(
+      '[class*="_selected_"], [class*="_checked_"], [class*="_active_"], [class*="_on_"], [class*="_isSelected"]'
+    );
+    for (var c = 0; c < clsCandidates.length; c++) {
+      var el  = clsCandidates[c];
+      var cls = (el.className && el.className.baseVal !== undefined) ? el.className.baseVal : String(el.className || '');
+      if (cls.length > 240) continue;          // skip container-level matches
+      if (/_unselected|_unchecked|_inactive|_off/i.test(cls)) continue;
+      // Skip elements that are descendants of an already-matched native
+      // input — record() already handled them.
+      if (el.querySelector('input[type="checkbox"]:checked, input[type="radio"]:checked')) continue;
+      record(el);
+    }
+
+    var out = [];
+    for (var s in bySection) {
+      if (bySection.hasOwnProperty(s)) {
+        out.push({ name: s, values: bySection[s] });
+      }
+    }
+    return out;
+  }
+
+  // Cross-call state for trackAssetExplorerSearch (mirrors the ASC pair).
+  var __aeCancelInflightStatsWait = null;
+  var __aeFlushInflightSearchNow  = null;
+  // Dedup: avoid re-firing the same {term, semantic, fuzzy, folder} combo
+  // when several triggers (Enter + form submit + click) overlap on a
+  // single user action. Compared by string equality with the LAST fired
+  // signature; cleared on hashchange.
+  var __aeLastFiredSig = '';
+
+  /**
+   * Emits `search_executed` (subtype `asset_search`) for the React Asset
+   * Explorer page. Captures search term + semantic/fuzzy toggles + the
+   * current folder + the stats widget once it settles. The `trigger`
+   * argument records HOW the search was initiated (enter, submit, click,
+   * options_close, filter_click, input_debounced) so we can prune the
+   * hooks later once we see which paths actually fire in production.
+   */
+  function trackAssetExplorerSearch(searchTerm, opts) {
+    opts = opts || {};
+    searchTerm = safeStr(searchTerm).trim();
+    if (!searchTerm) return;
+
+    var semantic = (typeof opts.semantic === 'string')
+      ? opts.semantic
+      : readAssetExplorerToggleState(TEXT_PATTERNS.semantic);
+    var fuzzy = (typeof opts.fuzzy === 'string')
+      ? opts.fuzzy
+      : readAssetExplorerToggleState(TEXT_PATTERNS.fuzzy);
+    var folder  = readAssetExplorerFolderPath();
+    var trigger = safeStr(opts.trigger);
+    var filters = readAssetExplorerFilters();
+    var filtersJson = filters.length ? JSON.stringify(filters) : '';
+
+    // Dedup signature includes the filter selection — flipping a single
+    // facet on/off should re-fire even if the search term is unchanged,
+    // since the result set itself changes.
+    var sig = [searchTerm, semantic, fuzzy, folder, filtersJson].join('|');
+    if (sig === __aeLastFiredSig && !opts.forceDedupBypass) return;
+    __aeLastFiredSig = sig;
+
+    if (__aeFlushInflightSearchNow) {
+      try { __aeFlushInflightSearchNow(); } catch (e) {}
+      __aeFlushInflightSearchNow = null;
+    }
+    if (__aeCancelInflightStatsWait) {
+      try { __aeCancelInflightStatsWait(); } catch (e) {}
+      __aeCancelInflightStatsWait = null;
+    }
+
+    var dims = {
+      search_term:      searchTerm,
+      semantic_search:  semantic,
+      fuzzy_search:     fuzzy,
+      search_context:   'asset_explorer',
+      search_trigger:   trigger,
+      folder_path:      folder,
+      filters_dom_json: filtersJson,
+      page_url:         location.href,
+      page_referrer:    document.referrer || ''
+    };
+    var metrics = {
+      filter_dom_count: filters.reduce(function (acc, g) { return acc + (g.values ? g.values.length : 0); }, 0)
+    };
+
+    var fired = false;
+    function fireWithStats(stats) {
+      if (fired) return;
+      fired = true;
+      __aeCancelInflightStatsWait = null;
+      __aeFlushInflightSearchNow  = null;
+
+      if (stats) {
+        if (stats.time_ms   !== null) metrics.search_time_ms   = stats.time_ms;
+        if (stats.total     !== null) metrics.result_total     = stats.total;
+        if (stats.pages     !== null) metrics.result_pages     = stats.pages;
+        if (stats.displayed !== null) metrics.result_displayed = stats.displayed;
+        dims.search_stats_ready = 'true';
+        try {
+          if (stats.raw && stats.raw.length) {
+            var rawJson = JSON.stringify(stats.raw);
+            dims.search_stats_raw_json = rawJson.length > 240 ? rawJson.slice(0, 240) : rawJson;
+          }
+        } catch (e) { /* swallow */ }
+      } else {
+        dims.search_stats_ready = 'false';
+      }
+
+      track('search_executed', dims, metrics, 'asset_search');
+      __searchFireCount++;
+    }
+
+    __aeFlushInflightSearchNow  = function () { fireWithStats(null); };
+    __aeCancelInflightStatsWait = waitForSearchStats(readAssetExplorerSearchStatistics, 3000, fireWithStats);
+  }
+
+  /**
+   * Emits a `folder_navigation` event with subtype `asset_browse`. The
+   * `tree_action` dim distinguishes how the navigation was triggered so
+   * a single event type can describe every kind of folder interaction:
+   *
+   *   - "hash_change" — the URL hash route changed (true navigation)
+   *   - "click"       — user clicked a folder label in the side tree
+   *   - "expand"      — user expanded a tree node
+   *   - "collapse"    — user collapsed a tree node
+   *
+   * The tree-action variants also carry `tree_target_label` (the visible
+   * text of the clicked node) and `tree_target_class_hint` (the first
+   * 240 chars of the target's className) so we can refine the action
+   * detection later without re-instrumenting the page.
+   */
+  function trackAssetExplorerFolderNavigation(opts) {
+    opts = opts || {};
+    var folder = readAssetExplorerFolderPath();
+    var action = safeStr(opts.tree_action) || 'hash_change';
+    // Skip the initial page_load / hash_change variants when the React
+    // app hasn't set its default route yet — the next real hashchange
+    // will fire a clean event. We still fire on click/expand/collapse
+    // even with an empty folder so a no-op gesture is observable.
+    if (!folder && (action === 'hash_change' || action === 'page_load')) return;
+    var dims = {
+      folder_path:    folder,
+      search_context: 'asset_explorer',
+      tree_action:    action,
+      page_url:       location.href,
+      page_referrer:  document.referrer || ''
+    };
+    if (opts.tree_target_label) {
+      dims.tree_target_label = safeStr(opts.tree_target_label).slice(0, 120);
+    }
+    if (opts.tree_target_class_hint) {
+      dims.tree_target_class_hint = safeStr(opts.tree_target_class_hint).slice(0, 240);
+    }
+    track('folder_navigation', dims, {}, 'asset_browse');
+  }
+
+  // ─── 9. DOM-driven hooks (clicks) ────────────────────────
+
+  // ── Login page hooks (preserved from earlier login-only bootstrap) ──
+
+  function hookSignInSubmit() {
+    var form = $(SELECTORS.loginForm);
+    var btn  = $(SELECTORS.signInButton);
+    if (!btn) {
+      btn = closestMatchByText(document, 'button, a, [role="button"], input[type="submit"]', TEXT_PATTERNS.signIn);
+    }
+    function fire(reason) {
+      var userInput = $(SELECTORS.userField);
+      var typedUser = (userInput && (userInput.value || '').trim()) || '';
+      if (typedUser) identify(typedUser);
+      track('login_attempt', {
+        method:        'credentials',
+        attempt_user:  typedUser,
+        submit_reason: reason || 'click',
+        page_url:      location.href
+      });
+      flush();
+    }
+    if (btn)  btn.addEventListener('click',  function () { fire('click'); }, { capture: true });
+    if (form) form.addEventListener('submit', function () { fire('submit'); }, { capture: true });
+  }
+
+  function hookSsoClick() {
+    var btn = $(SELECTORS.ssoButton);
+    if (!btn) {
+      btn = closestMatchByText(document, 'button, a, [role="button"]', TEXT_PATTERNS.lionSso);
+    }
+    if (!btn) return;
+    btn.addEventListener('click', function () {
+      track('sso_click', {
+        method:       'lion_login',
+        sso_provider: 'lion',
+        button_text:  visibleText(btn).substring(0, 120),
+        page_url:     location.href
+      });
+      flush();
+    }, { capture: true });
+  }
+
+  function hookTermsClick() {
+    var link = $(SELECTORS.termsLink);
+    if (!link) {
+      link = closestMatchByText(document, 'a, button, [role="link"]', TEXT_PATTERNS.terms);
+    }
+    if (!link) return;
+    link.addEventListener('click', function () {
+      track('terms_click', {
+        link_url:  (link.getAttribute && link.getAttribute('href')) || '',
+        link_text: visibleText(link).substring(0, 120),
+        page_url:  location.href
+      });
+      flush();
+    }, { capture: true });
+  }
+
+  // ── ASC click delegation (one body-level listener, survives SPA mutations) ──
+
+  /**
+   * Body-level click listener that matches Add-to-Cart and Share buttons
+   * across both the search-results grid (tile + table) and the asset detail
+   * page. Uses `closest()` so it works whether the user clicks the icon,
+   * the label, or any descendant of the button.
+   */
+  function installAscClickDelegation() {
+    if (window.__ilColabClickDelegated) return;
+    window.__ilColabClickDelegated = true;
+
+    function tryClosest(target, selector) {
+      try { return target.closest(selector); } catch (e) { return null; }
+    }
+
+    document.addEventListener('click', function (e) {
+      var target = e.target;
+      if (!target || target.nodeType !== 1 || !target.closest) return;
+
+      // The dispatch ordering matters — match the MOST SPECIFIC
+      // data-asset-share-id first so cart-level controls don't fall
+      // through to asset-level handlers. Each branch returns to
+      // prevent a single user click from emitting multiple events.
+
+      // ── 1. Cart-level "Download Cart" (data-asset-share-id="download-all") ──
+      // The user-confirmed intent to start downloading the entire
+      // cart. A second confirmation modal appears AFTER this click;
+      // the actual binaries are produced asynchronously and surface
+      // in the downloads modal as individual downloadbinaries.json
+      // anchors (covered by branch 3 below).
+      var dlAllBtn = tryClosest(target, SELECTORS.cartDownloadButton);
+      if (dlAllBtn) {
+        var dlContents = readCartContents();
+        var dlContentsJson = dlContents.length ? JSON.stringify(dlContents) : '';
+        if (dlContentsJson.length > 480) dlContentsJson = dlContentsJson.slice(0, 480);
+        track('cart_download', {
+          cart_asset_paths_json: dlContentsJson,
+          page_url:              location.href,
+          page_referrer:         document.referrer || ''
+        }, {
+          cart_item_count: dlContents.length
+        }, 'cart_action');
+        return;
+      }
+
+      // ── 2. Cart-level "Share Cart" (data-asset-share-id="share-all") ──
+      // Clicking this OPENS a second modal where the user enters
+      // recipient emails + public flag + optional date range. The
+      // real share doesn't happen until that form is submitted,
+      // which we capture in `installShareFormHook()`. To survive the
+      // cart-modal closing before the share form is filled in, we
+      // stash the cart snapshot module-globally so the submit
+      // handler can attach it to the cart_share event.
+      var shareAllBtn = tryClosest(target, SELECTORS.cartShareButton);
+      if (shareAllBtn) {
+        var shContents = readCartContents();
+        var shContentsJson = shContents.length ? JSON.stringify(shContents) : '';
+        if (shContentsJson.length > 480) shContentsJson = shContentsJson.slice(0, 480);
+        // Stash for the submit handler.
+        window.__ilColabPendingCartShare = {
+          paths: shContents,
+          paths_json: shContentsJson,
+          captured_at: Date.now()
+        };
+        // "Intent to share" event — useful for the funnel
+        // (clicked → completed) and fires regardless of whether
+        // the user actually submits the form.
+        track('cart_share_initiated', {
+          cart_asset_paths_json: shContentsJson,
+          page_url:              location.href,
+          page_referrer:         document.referrer || ''
+        }, {
+          cart_item_count: shContents.length
+        }, 'cart_action');
+        return;
+      }
+
+      // ── 3. Per-artifact download link (downloadbinaries.json) ──
+      // Fired when a user clicks any individual download anchor in
+      // the downloads modal. This is the REAL "asset_download" event
+      // — the binary leaves the server on this click, unlike the
+      // cart-download button above which is just the user's intent
+      // to start the download pipeline.
+      var dlLink = tryClosest(target, SELECTORS.downloadBinaryLink);
+      if (dlLink) {
+        var href      = dlLink.getAttribute('href') || '';
+        var params    = parseUrlParams(href);
+        var endpoint  = href.split('?')[0];
+        track('asset_download', {
+          download_id:        params.downloadId  || '',
+          artifact_id:        params.artifactId  || '',
+          download_endpoint:  endpoint,
+          download_source:    'downloads_modal',
+          download_method:    'binary_link_click',
+          page_url:           location.href,
+          page_referrer:      document.referrer || ''
+        });
+        return;
+      }
+
+      // ── 4. Per-artifact "remove from downloads" button ──
+      var dlRemoveBtn = tryClosest(target, SELECTORS.downloadRemoveButton);
+      if (dlRemoveBtn) {
+        track('download_removed', {
+          download_id: dlRemoveBtn.getAttribute('data-asset-share-download-id') || '',
+          page_url:    location.href
+        }, {}, 'cart_action');
+        return;
+      }
+
+      // ── 5. Asset-level "Add to Cart" tile button ──
+      // Now that the cart-level controls are handled above, anything
+      // remaining with `data-asset-share-id="add-to-cart"` is the
+      // per-asset variant. We DO NOT rely on the button's visible
+      // text — the icon-only variant has none — and pull the asset
+      // path straight off `data-asset-share-asset` via the extractor.
+      var cartBtn = tryClosest(target, SELECTORS.addToCart);
+      if (!cartBtn) {
+        // Visible-text fallback for installations that haven't been
+        // migrated to the data-asset-share-id convention yet.
+        var cartCandidate = tryClosest(target, 'button, a, [role="button"], [role="menuitem"]');
+        if (cartCandidate && TEXT_PATTERNS.cart.test(visibleText(cartCandidate))) {
+          cartBtn = cartCandidate;
+        }
+      }
+      if (cartBtn) {
+        track('asset_add_to_cart', {
+          asset_path: extractAssetPathFromEl(cartBtn),
+          page_url:   location.href
+        });
+        return;
+      }
+
+      // ── 6. Header cart-icon click (opens cart modal) ──
+      var cartOpen = tryClosest(target, SELECTORS.cartOpenButton);
+      if (cartOpen) {
+        track('cart_open', { page_url: location.href }, {}, 'cart_action');
+        return;
+      }
+
+      // ── 7. Header download-icon click (opens downloads modal) ──
+      var dlOpen = tryClosest(target, SELECTORS.downloadsOpenButton);
+      if (dlOpen) {
+        track('downloads_open', { page_url: location.href }, {}, 'cart_action');
+        return;
+      }
+
+      // ── 8. Asset-level Share button ──
+      var shareBtn = tryClosest(target, SELECTORS.shareButton);
+      if (!shareBtn) {
+        var shareCandidate = tryClosest(target, 'button, a, [role="button"], [role="menuitem"]');
+        // Visible-text fallback — explicitly reject anything that sits
+        // under the cart-modal or matches the cart-share selector, so
+        // a generic /share/i click on Share Cart can't fall through
+        // to asset_share here.
+        if (shareCandidate &&
+            TEXT_PATTERNS.share.test(visibleText(shareCandidate)) &&
+            !TEXT_PATTERNS.cart.test(visibleText(shareCandidate)) &&
+            !tryClosest(shareCandidate, SELECTORS.cartShareButton) &&
+            !tryClosest(shareCandidate, SELECTORS.cartModal)) {
+          shareBtn = shareCandidate;
+        }
+      }
+      if (shareBtn) {
+        track('asset_share', {
+          asset_path: extractAssetPathFromEl(shareBtn),
+          page_url:   location.href
+        });
+      }
+    }, { capture: true });
+  }
+
+  /**
+   * Parses the recipient e-mail field. The input is `<input
+   * type="email" multiple name="email">` and the user typically types
+   * `a@b.com, c@d.com, e@f.com` (the placeholder advertises a
+   * comma-delimited list). We accept commas, semicolons, and
+   * whitespace as separators, trim and de-dupe (case-insensitive),
+   * and drop anything that doesn't look vaguely like an e-mail. The
+   * returned array preserves the user's typed order for the first
+   * occurrence of each address.
+   */
+  function parseRecipientEmails(raw) {
+    if (!raw) return [];
+    var parts = String(raw).split(/[,;\s]+/);
+    var out = [];
+    var seen = {};
+    for (var i = 0; i < parts.length; i++) {
+      var t = (parts[i] || '').trim();
+      if (!t) continue;
+      // Loose validation — we only want to drop obvious garbage
+      // like trailing punctuation; the server will do real
+      // validation downstream. We DO require an `@` plus a `.`
+      // somewhere after it.
+      if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(t)) continue;
+      var key = t.toLowerCase();
+      if (seen[key]) continue;
+      seen[key] = true;
+      out.push(t);
+    }
+    return out;
+  }
+
+  /**
+   * Captures the share-modal form submission. The cart-level "Share
+   * Cart" button (handled in installAscClickDelegation, branch 2)
+   * fires a `cart_share_initiated` intent event AND stashes the cart
+   * contents in `window.__ilColabPendingCartShare` because the cart
+   * modal usually closes before the share form is filled in. When
+   * the user actually submits the share form, this hook fires the
+   * REAL `cart_share` event with:
+   *
+   *   - share_emails               – comma-joined list (480-char cap)
+   *   - share_emails_count         – metric, distinct after dedupe
+   *   - share_is_public            – "true" / "false"
+   *   - share_start_date           – yyyy-mm-dd (public-only)
+   *   - share_end_date             – yyyy-mm-dd (public-only)
+   *   - share_date_range_days      – metric, end-start in days (>=0)
+   *   - cart_asset_paths_json      – snapshot from button-click stash,
+   *                                  falls back to a fresh
+   *                                  readCartContents() if the stash
+   *                                  expired (e.g. the user reloaded
+   *                                  between clicking and submitting)
+   *
+   * Capture phase + non-passive so we get the submit BEFORE ASC's
+   * own jQuery validator can call preventDefault on an invalid form;
+   * we still fire the event so the funnel sees the attempt. The
+   * stash is cleared after a successful read so a subsequent
+   * unrelated form submission can't accidentally inherit it.
+   */
+  function installShareFormHook() {
+    if (window.__ilColabShareFormHooked) return;
+    window.__ilColabShareFormHooked = true;
+
+    document.addEventListener('submit', function (e) {
+      var form = e.target;
+      if (!form || form.nodeType !== 1) return;
+      var matchSelf = false;
+      try { matchSelf = form.matches && form.matches(SELECTORS.shareModal); } catch (err) { /* ignore */ }
+      // The event target IS the form, but be defensive in case the
+      // template ever wraps the submission in a parent element.
+      if (!matchSelf) {
+        var ancestor = null;
+        try { ancestor = form.closest && form.closest(SELECTORS.shareModal); } catch (err) { /* ignore */ }
+        if (!ancestor) return;
+        form = ancestor;
+      }
+
+      var emailInput = form.querySelector(SELECTORS.shareEmailInput);
+      var emails     = parseRecipientEmails(emailInput && emailInput.value);
+      var emailsJoined = emails.join(',');
+      if (emailsJoined.length > 480) emailsJoined = emailsJoined.slice(0, 480);
+
+      // "Share Publicly" — the explicit checkbox match comes first.
+      // If multiple checkboxes exist in the form (some themes add a
+      // T&C tickbox), we look for the one paired with the "Share
+      // Publicly" label by walking up to the .ui.checkbox wrapper.
+      var publicChecked = false;
+      var cbCandidates = form.querySelectorAll(SELECTORS.sharePublicCheckbox);
+      for (var i = 0; i < cbCandidates.length; i++) {
+        var cb = cbCandidates[i];
+        var wrap = cb.closest('.ui.checkbox, .field');
+        var lbl  = wrap && (wrap.querySelector('label') || wrap);
+        var txt  = lbl ? (lbl.textContent || '').trim() : '';
+        if (cbCandidates.length === 1 || /share\s*publicly/i.test(txt)) {
+          publicChecked = !!cb.checked;
+          break;
+        }
+      }
+
+      var startEl = form.querySelector(SELECTORS.shareStartDateInput);
+      var expiryEl = form.querySelector(SELECTORS.shareExpiryDateInput);
+      var startDate  = (startEl  && startEl.value)  || '';
+      var expiryDate = (expiryEl && expiryEl.value) || '';
+      // Heuristic — if the dates are populated but the checkbox
+      // matcher missed (e.g. the theme rebrands the label), treat
+      // the share as public anyway. Better to over-tag than miss
+      // the public-share population entirely.
+      if (!publicChecked && (startDate || expiryDate)) publicChecked = true;
+
+      var rangeDays = 0;
+      if (startDate && expiryDate) {
+        var s = Date.parse(startDate);
+        var e2 = Date.parse(expiryDate);
+        if (!isNaN(s) && !isNaN(e2)) rangeDays = Math.max(0, Math.round((e2 - s) / 86400000));
+      }
+
+      var stash = window.__ilColabPendingCartShare;
+      var stashFresh = stash && (Date.now() - stash.captured_at < 10 * 60 * 1000);
+      var pathsJson, pathsCount;
+      if (stashFresh) {
+        pathsJson  = stash.paths_json || '';
+        pathsCount = (stash.paths && stash.paths.length) || 0;
+      } else {
+        var fresh = readCartContents();
+        pathsJson  = fresh.length ? JSON.stringify(fresh) : '';
+        if (pathsJson.length > 480) pathsJson = pathsJson.slice(0, 480);
+        pathsCount = fresh.length;
+      }
+      window.__ilColabPendingCartShare = null;
+
+      track('cart_share', {
+        share_emails:          emailsJoined,
+        share_is_public:       publicChecked ? 'true' : 'false',
+        share_start_date:      publicChecked ? startDate  : '',
+        share_end_date:        publicChecked ? expiryDate : '',
+        cart_asset_paths_json: pathsJson,
+        page_url:              location.href,
+        page_referrer:         document.referrer || ''
+      }, {
+        share_emails_count:    emails.length,
+        share_date_range_days: rangeDays,
+        cart_item_count:       pathsCount
+      }, 'cart_action');
+    }, { capture: true });
+  }
+
+  // ─── 9b. Asset Explorer (React) hooks ────────────────────
+
+  /**
+   * Wires every plausible search trigger on /asset-explorer.html. The
+   * page is a React SPA that doesn't expose a single canonical "search
+   * submit" event, so we listen at the document level (capture phase)
+   * for the four observed user intents:
+   *
+   *   - Enter pressed inside the search input
+   *   - Native form submit (Enter or a button reachable via submit())
+   *   - The Search Options modal closing (treated as "user accepted
+   *     semantic/fuzzy choice and the search will now run")
+   *   - A click on any element inside the right-rail filter wrapper
+   *     (treated as "user changed a facet and a new search will run")
+   *
+   * Plus a debounced `input` listener so live-typing scenarios — if any —
+   * still record the eventual term. Every fire carries a `search_trigger`
+   * dimension so we can drop the redundant hooks once we see what the
+   * page actually emits in ClickHouse.
+   *
+   * Dedup is centralized inside trackAssetExplorerSearch() via
+   * __aeLastFiredSig so overlapping triggers (Enter + form submit) on the
+   * same user action collapse into a single event.
+   */
+  function installAssetExplorerHooks() {
+    if (window.__ilColabAEHooked) return;
+    window.__ilColabAEHooked = true;
+
+    function currentTerm() {
+      var inp = findAssetExplorerSearchInput();
+      return inp ? (inp.value || '').trim() : '';
+    }
+
+    function fireWithTrigger(trigger) {
+      var term = currentTerm();
+      if (!term) return;
+      trackAssetExplorerSearch(term, { trigger: trigger });
+    }
+
+    // ── 1. Enter inside the search input ─────────────────────
+    document.addEventListener('keydown', function (e) {
+      if (e.key !== 'Enter' && e.keyCode !== 13) return;
+      var t = e.target;
+      if (!t || t.nodeType !== 1) return;
+      // Match either the explorer's React input OR any text input that
+      // sits under the explorer root (themed deployments may swap the
+      // CSS-Module class).
+      var inExplorer = t.closest && t.closest(SELECTORS.assetExplorerRoot);
+      if (!inExplorer) return;
+      if (t.tagName !== 'INPUT' && t.tagName !== 'TEXTAREA') return;
+      setTimeout(function () { fireWithTrigger('enter'); }, 0);
+    }, { capture: true });
+
+    // ── 2. Native form submit ────────────────────────────────
+    document.addEventListener('submit', function (e) {
+      var f = e.target;
+      if (!f || !f.closest) return;
+      if (!f.closest(SELECTORS.assetExplorerRoot)) return;
+      setTimeout(function () { fireWithTrigger('submit'); }, 0);
+    }, { capture: true });
+
+    // ── 3. Search Options modal close ───────────────────────
+    // We can't always observe the modal-close gesture directly (escape
+    // key, clicking the backdrop, clicking a confirm button). Instead,
+    // watch for the modal element being REMOVED from the DOM and treat
+    // that as "user finished tweaking semantic/fuzzy".
+    if (typeof MutationObserver === 'function') {
+      var modalState = { open: false };
+      try {
+        var mo = new MutationObserver(function () {
+          var modal = document.querySelector(
+            '[class*="_searchOptionModal_"], [class*="_searchOption_Modal_"], [class*="_searchOptionsModal_"]'
+          );
+          var nowOpen = !!modal;
+          if (modalState.open && !nowOpen) {
+            setTimeout(function () { fireWithTrigger('options_close'); }, 0);
+          }
+          modalState.open = nowOpen;
+        });
+        mo.observe(document.body || document.documentElement, {
+          childList: true,
+          subtree:   true
+        });
+      } catch (e) { /* fall through */ }
+    }
+
+    // ── 4. Filter-rail clicks ───────────────────────────────
+    document.addEventListener('click', function (e) {
+      var t = e.target;
+      if (!t || !t.closest) return;
+      var rail = t.closest(SELECTORS.assetExplorerFilterRail);
+      if (!rail) return;
+      // Defer past React's re-render so the term + stats reflect the
+      // new filter state when we read them.
+      setTimeout(function () {
+        // We bypass the term-empty check via forceDedupBypass=false so
+        // a filter-only narrow over an empty search isn't tracked here;
+        // it falls into folder_navigation territory.
+        fireWithTrigger('filter_click');
+      }, 30);
+    }, { capture: true });
+
+    // ── 5. Debounced typing (catch-all for auto-search builds) ──
+    var debounceTimer = null;
+    document.addEventListener('input', function (e) {
+      var t = e.target;
+      if (!t || t.nodeType !== 1) return;
+      if (t.tagName !== 'INPUT') return;
+      if (!t.closest || !t.closest(SELECTORS.assetExplorerRoot)) return;
+      var inp = findAssetExplorerSearchInput();
+      if (!inp || t !== inp) return;
+      if (debounceTimer) clearTimeout(debounceTimer);
+      debounceTimer = setTimeout(function () {
+        fireWithTrigger('input_debounced');
+      }, 800);
+    }, { capture: true });
+
+    // ── 6. Hash-route folder navigation ─────────────────────
+    window.addEventListener('hashchange', function () {
+      // Reset the search-event dedup signature so the new folder's first
+      // search records cleanly even if its (term, toggles) happen to
+      // match the previous folder's.
+      __aeLastFiredSig = '';
+      trackAssetExplorerFolderNavigation({ tree_action: 'hash_change' });
+    });
+
+    // ── 7. Folder-tree click delegation ─────────────────────
+    // Every click anywhere inside the side directory tree fires
+    // folder_navigation(subtype=asset_browse) so we observe folder
+    // selections (which usually also trigger hashchange) AND
+    // expand/collapse gestures (which do not). We best-effort classify
+    // the action via aria-expanded mutation, fall back to "click" if
+    // we can't tell, and tag the event with diagnostic dims so the
+    // refinement is data-driven from ClickHouse.
+    document.addEventListener('click', function (e) {
+      var target = e.target;
+      if (!target || target.nodeType !== 1 || !target.closest) return;
+      var tree = target.closest(SELECTORS.assetExplorerFolderTree);
+      if (!tree) return;
+      // Skip clicks that landed in the rail's facet panel — that's the
+      // right side (search_executed/filter_click territory), not the
+      // left tree. The selectors *can* overlap on extremely permissive
+      // builds where both panels share `_wrapper_` ancestors.
+      if (target.closest(SELECTORS.assetExplorerFilterRail)) return;
+
+      // Find the closest folder-row element so we can capture the
+      // folder label (visible text) and the aria-expanded state.
+      // Tree-row markup we expect (best-effort):
+      //   [role="treeitem"] | [class*="_treeNode_"] | [class*="_node_"]
+      //   | the immediate clickable wrapper (`<li>` / `<button>`).
+      var node = target.closest(
+        '[role="treeitem"], [class*="_treeNode_"], [class*="_node_"], [class*="_folder_"], [class*="_item_"], li, button, a'
+      ) || target;
+
+      var labelEl = node.querySelector('[class*="_label_"], [class*="_name_"], [class*="_title_"]') || node;
+      var label   = cleanText(labelEl.textContent || '').slice(0, 120);
+
+      var preExpanded = node.getAttribute && node.getAttribute('aria-expanded');
+
+      // Sample the className for diagnostic use — strip whitespace and
+      // cap aggressively to avoid blowing the custom_dimensions column.
+      var cls = (target.className && target.className.baseVal !== undefined)
+        ? target.className.baseVal
+        : String(target.className || '');
+
+      // Snapshot the node's current className too — some React tree
+      // libs put the expanded/collapsed state directly on the row
+      // (`_isOpen`, `_expanded`, `_collapsed`, `_open`) rather than on
+      // an aria-expanded attribute, so we'll need both pre- and post-
+      // click className samples to classify the gesture.
+      var preNodeCls = (node.className && node.className.baseVal !== undefined)
+        ? node.className.baseVal
+        : String(node.className || '');
+
+      // Live React Asset Explorer uses classes like `_toggleIcon_<hash>`
+      // on the expand/collapse chevron. Anything matching one of these
+      // unambiguous "this is a toggle gesture" prefixes is treated as
+      // an expand/collapse even when aria-expanded never shows up.
+      var TOGGLE_CLS_RE = /(?:^|[\s_-])(?:_?toggleIcon|_?toggle|_?chevron|_?arrow|_?caret|_?expand(?:er|Icon)?|_?collapse(?:r|Icon)?)(?:[\s_-]|$)/i;
+      var isToggle = TOGGLE_CLS_RE.test(cls);
+
+      // Defer to the next tick so the React state has had time to apply
+      // the click (aria-expanded flips, classNames toggled, hash routes
+      // pushed, etc.) before we classify. The hashchange listener above
+      // is independent and will fire its own event if the URL changes.
+      setTimeout(function () {
+        var postExpanded = node.getAttribute && node.getAttribute('aria-expanded');
+        var postNodeCls  = (node.className && node.className.baseVal !== undefined)
+          ? node.className.baseVal
+          : String(node.className || '');
+
+        // ── Strategy 1: aria-expanded mutation ───────────────
+        var action = null;
+        if (preExpanded !== null && postExpanded !== null && preExpanded !== postExpanded) {
+          action = (postExpanded === 'true') ? 'expand' : 'collapse';
+        } else if (postExpanded === 'true' && preExpanded === null) {
+          action = 'expand';
+        } else if (postExpanded === 'false' && preExpanded === null) {
+          action = 'collapse';
+        }
+
+        // ── Strategy 2: className state on the row ───────────
+        // React tree libs commonly emit `_isOpen_<hash>` / `_expanded_<hash>`
+        // / `_isCollapsed_<hash>` / `_collapsed_<hash>` on the row when
+        // the open state changes. Compare pre vs post — if either flag
+        // appeared / disappeared, that's our action.
+        if (!action) {
+          var EXP_RE   = /_(?:isOpen|expanded|open(?![A-Za-z]))/i;
+          var COLL_RE  = /_(?:isClosed|collapsed|closed)/i;
+          var preExp   = EXP_RE.test(preNodeCls);
+          var postExp  = EXP_RE.test(postNodeCls);
+          var preColl  = COLL_RE.test(preNodeCls);
+          var postColl = COLL_RE.test(postNodeCls);
+          if (!preExp && postExp)       action = 'expand';
+          else if (preExp && !postExp)  action = 'collapse';
+          else if (!preColl && postColl) action = 'collapse';
+          else if (preColl && !postColl) action = 'expand';
+        }
+
+        // ── Strategy 3: toggle-class hint without direction ──
+        // Click landed on an unambiguous toggle icon but we couldn't
+        // determine direction from the row state. Record the gesture
+        // as a generic `toggle` — still strictly more useful than
+        // `click` because dashboards can split tree-navigation events
+        // from open/close gestures.
+        if (!action) {
+          action = isToggle ? 'toggle' : 'click';
+        }
+
+        // The handler also fires for clicks that ALSO trigger a hash
+        // change. We DO NOT dedup against the hashchange-fired event
+        // here — the user explicitly asked for every click / expand /
+        // collapse gesture to be tracked, so emitting both a click
+        // event AND a hash_change event for the same gesture is the
+        // desired behaviour. Differentiate via the `tree_action` dim
+        // in reports.
+        trackAssetExplorerFolderNavigation({
+          tree_action:            action,
+          tree_target_label:      label,
+          tree_target_class_hint: cls
+        });
+      }, 0);
+    }, { capture: true });
+  }
+
+  // ─── 10. Network interception for downloads ──────────────
+
+  /**
+   * Emits `asset_download` if a request matches the ASC download endpoint.
+   * Extracts `asset_path` (`path`) and `rendition_name` (`renditionName`)
+   * directly from the form-encoded POST body so the event reflects exactly
+   * what the user requested (single-asset, ZIP of renditions, etc.).
+   */
+  function emitDownloadIfMatch(method, url, body) {
+    if (!url) return;
+    if (method && String(method).toUpperCase() !== 'POST') return;
+    if (!ENDPOINTS.download.test(url)) return;
+    var info = parseFormBody(body);
+    track('asset_download', {
+      asset_path:        safeStr(info.path),
+      rendition_name:    safeStr(info.renditionName),
+      download_endpoint: url,
+      page_url:          location.href
+    });
+  }
+
+  /**
+   * Wraps `window.fetch` and `XMLHttpRequest.prototype.{open,send}` once
+   * per page. Idempotent across hot-reloads of the bootstrap. Always calls
+   * the original implementation so site behavior is unchanged.
+   */
+  function installNetworkHooks() {
+    if (typeof window.fetch === 'function' && !window.__ilColabFetchPatched) {
+      window.__ilColabFetchPatched = true;
+      var origFetch = window.fetch;
+      window.fetch = function (input, init) {
+        try {
+          var url    = typeof input === 'string' ? input : (input && input.url) || '';
+          var method = (init && init.method) || (input && input.method) || 'GET';
+          var body   = init && init.body;
+          emitDownloadIfMatch(method, url, body);
+        } catch (e) { /* swallow — never break the page */ }
+        return origFetch.apply(this, arguments);
+      };
+    }
+
+    if (typeof window.XMLHttpRequest === 'function' && !window.__ilColabXhrPatched) {
+      window.__ilColabXhrPatched = true;
+      var XHRProto = window.XMLHttpRequest.prototype;
+      var origOpen = XHRProto.open;
+      var origSend = XHRProto.send;
+      XHRProto.open = function (method, url) {
+        this.__ilColabMethod = method;
+        this.__ilColabUrl    = url;
+        return origOpen.apply(this, arguments);
+      };
+      XHRProto.send = function (body) {
+        try { emitDownloadIfMatch(this.__ilColabMethod, this.__ilColabUrl, body); } catch (e) {}
+        return origSend.apply(this, arguments);
+      };
+    }
+  }
+
+  // ─── 11. Orchestration ───────────────────────────────────
+
+  var HOOK_FLAG = '__il_colab_hooked__';
+
+  /**
+   * Login-page hook installer. Idempotent thanks to per-element flags so the
+   * MutationObserver can re-run safely as the SPA mounts late controls.
+   */
+  function safeHookLoginAll() {
+    function once(el, name, fn) {
+      if (!el || el[HOOK_FLAG + name]) return;
+      el[HOOK_FLAG + name] = true;
+      fn();
+    }
+    var form    = $(SELECTORS.loginForm);
+    var signBtn = $(SELECTORS.signInButton)
+      || closestMatchByText(document, 'button, a, [role="button"], input[type="submit"]', TEXT_PATTERNS.signIn);
+    var ssoBtn  = $(SELECTORS.ssoButton)
+      || closestMatchByText(document, 'button, a, [role="button"]', TEXT_PATTERNS.lionSso);
+    var terms   = $(SELECTORS.termsLink)
+      || closestMatchByText(document, 'a, button, [role="link"]', TEXT_PATTERNS.terms);
+
+    once(form, 'form', function () {
+      form.addEventListener('submit', function () {
+        var userInput = $(SELECTORS.userField);
+        var typedUser = (userInput && (userInput.value || '').trim()) || '';
+        if (typedUser) identify(typedUser);
+        track('login_attempt', {
+          method:        'credentials',
+          attempt_user:  typedUser,
+          submit_reason: 'submit',
+          page_url:      location.href
+        });
+        flush();
+      }, { capture: true });
+    });
+
+    once(signBtn, 'sign', function () {
+      signBtn.addEventListener('click', function () {
+        var userInput = $(SELECTORS.userField);
+        var typedUser = (userInput && (userInput.value || '').trim()) || '';
+        if (typedUser) identify(typedUser);
+        track('login_attempt', {
+          method:        'credentials',
+          attempt_user:  typedUser,
+          submit_reason: 'click',
+          page_url:      location.href
+        });
+        flush();
+      }, { capture: true });
+    });
+
+    once(ssoBtn, 'sso', function () {
+      ssoBtn.addEventListener('click', function () {
+        track('sso_click', {
+          method:       'lion_login',
+          sso_provider: 'lion',
+          button_text:  visibleText(ssoBtn).substring(0, 120),
+          page_url:     location.href
+        });
+        flush();
+      }, { capture: true });
+    });
+
+    once(terms, 'terms', function () {
+      terms.addEventListener('click', function () {
+        track('terms_click', {
+          link_url:  (terms.getAttribute && terms.getAttribute('href')) || '',
+          link_text: visibleText(terms).substring(0, 120),
+          page_url:  location.href
+        });
+        flush();
+      }, { capture: true });
+    });
+  }
+
+  function start() {
+    if (!initSdk()) {
+      console.warn('[IL-COLAB] Infralytiqs SDK not loaded — bootstrap aborted');
+      return;
+    }
+
+    // Identity FIRST so subsequent events carry user_id.
+    // (Cache-hit path is sync; Granite-fetch path updates identity for the
+    // next event batch — pre-flush events are already correctly tagged via
+    // the SDK's identify-then-flush ordering.)
+    resolveAndIdentifyUser();
+
+    // URL-driven events (fire once on page load), dispatched by context.
+    if (isLoginPage()) {
+      trackLoginPageView();
+      safeHookLoginAll();
+
+      if (typeof MutationObserver === 'function') {
+        var mo = new MutationObserver(function () { safeHookLoginAll(); });
+        mo.observe(document.documentElement || document.body, {
+          childList: true,
+          subtree:   true
+        });
+        // Stop watching after 20s — by then the SPA has settled and anything
+        // we missed isn't going to appear from a page-load mutation.
+        setTimeout(function () { mo.disconnect(); }, 20000);
+      }
+    } else if (isAssetExplorerPage()) {
+      // React-based Asset Explorer (/asset-explorer.html#/content/dam/...)
+      // — search and folder browsing live entirely in client-side state,
+      // so we rely on DOM event hooks rather than URL parsing.
+      installAssetExplorerHooks();
+      // Asset preview / download / cart / share interactions piggy-back on
+      // the same delegated listeners as ASC. They're a no-op if the page
+      // doesn't render those affordances.
+      installAscClickDelegation();
+      installShareFormHook();
+      installNetworkHooks();
+      // Initial folder-view ping so reports see the user landed.
+      // tagged "page_load" to distinguish from later interactions.
+      trackAssetExplorerFolderNavigation({ tree_action: 'page_load' });
+    } else {
+      var q = parseQuery();
+      trackSearchExecuted(q);
+      trackAssetPreview();
+      installAscClickDelegation();
+      installShareFormHook();
+      installNetworkHooks();
+      // ASC drives in-page filter / sort / layout / pagination changes
+      // through history.pushState — without this our URL-driven events
+      // would only fire on hard reloads.
+      installSpaNavHooks();
+    }
+  }
+
+  // ─── 12. Entry point ─────────────────────────────────────
+  function waitForSdkAndStart() {
+    var attempts = 0;
+    var max = 50;
+    (function tick() {
+      if (getApi()) {
+        start();
+        return;
+      }
+      if (++attempts >= max) {
+        console.warn('[IL-COLAB] Infralytiqs SDK never appeared after ' + (max * 100) + 'ms');
+        return;
+      }
+      setTimeout(tick, 100);
+    })();
+  }
+
+  if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', waitForSdkAndStart, { once: true });
+  } else {
+    waitForSdkAndStart();
+  }
+})();