@sharadtech/infralytiqs-sdk 1.0.0 → 1.0.1

package/clients/publicis/ps/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@sharadtech/infralytiqs-client-publicis-ps",
+  "version": "1.0.0-SNAPSHOT",
+  "private": true,
+  "type": "module",
+  "description": "Infralytiqs client-specific bootstrap for Publicis Sapient (psassets.publicissapient.com). Reads window.IL_* configuration injected by the host page, initializes the Infralytiqs SDK loaded from the CDN, and hooks the login-page user journey: anonymous page view, credential sign-in submit, Lion Login SSO click, and Terms & Conditions click.",
+  "main": "dist/infralytiqs-bootstrap.min.js",
+  "files": [
+    "dist",
+    "src",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "rollup -c rollup.config.mjs",
+    "dev": "rollup -c rollup.config.mjs --watch",
+    "clean": "rm -rf dist"
+  },
+  "devDependencies": {
+    "@rollup/plugin-node-resolve": "^16.0.1",
+    "@rollup/plugin-terser": "^0.4.4",
+    "rollup": "^4.34.8"
+  }
+}

package/clients/publicis/ps/rollup.config.mjs

@@ -0,0 +1,28 @@
+import terser from '@rollup/plugin-terser';
+import resolve from '@rollup/plugin-node-resolve';
+import { readFileSync } from 'node:fs';
+
+const pkg = JSON.parse(readFileSync(new URL('./package.json', import.meta.url), 'utf8'));
+const banner = `/*! ${pkg.name} v${pkg.version} | (c) ${new Date().getUTCFullYear()} sharadtech | Built: ${new Date().toISOString()} */`;
+
+export default {
+  input: 'src/index.js',
+  output: [
+    {
+      file: 'dist/infralytiqs-bootstrap.js',
+      format: 'iife',
+      name: 'InfralytiqsBootstrapPublicisPS',
+      sourcemap: false,
+      banner,
+    },
+    {
+      file: 'dist/infralytiqs-bootstrap.min.js',
+      format: 'iife',
+      name: 'InfralytiqsBootstrapPublicisPS',
+      sourcemap: false,
+      banner,
+      plugins: [terser({ format: { comments: /^!/ } })],
+    },
+  ],
+  plugins: [resolve()],
+};

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

@@ -0,0 +1,479 @@
+/**
+ * Infralytiqs client-specific bootstrap — Publicis Sapient (psassets.publicissapient.com)
+ *
+ * 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 is loaded after the SDK + config and:
+ *        a. Reads window.IL_* and Infralytiqs.init() with browser-side enrichment.
+ *        b. Tracks the four key login-page events:
+ *            • 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
+ *
+ * Selector strategy
+ * -----------------
+ * The page DOM may evolve, so every selector is overridable via window globals
+ * (set BEFORE this bootstrap runs):
+ *
+ *   window.IL_PS_SELECTORS = {
+ *     loginForm:    '#loginForm',
+ *     signInButton: 'button[type="submit"]',
+ *     userField:    'input[name="username"]',
+ *     ssoButton:    '[data-il-sso-lion]',
+ *     termsLink:    'a[href*="terms"]'
+ *   };
+ *
+ * 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 case.
+ */
+(function () {
+  'use strict';
+
+  if (window.__ilPsBootstrapped) {
+    return;
+  }
+  window.__ilPsBootstrapped = 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_PS_SELECTORS && typeof window.IL_PS_SELECTORS === 'object')
+    ? window.IL_PS_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 Sign-in / Terms / SSO controls don't carry stable IDs.
+  var SELECTORS = {
+    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"]'
+  };
+
+  // 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
+  };
+
+  // ─── 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-PS] 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-PS] init failed', e);
+      return false;
+    }
+    return true;
+  }
+
+  // ─── 6. DOM 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;
+  }
+
+  // ─── 7. Event-specific hooks ─────────────────────────────
+
+  /**
+   * EVENT 1: 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 2: Submit username + password via Sign-in button.
+   *
+   * Captures the typed username (used as a soft identifier) but NEVER the
+   * password. The submit listener on the form also covers Enter-key
+   * submissions; the button click listener covers buttons that intercept
+   * the submit and POST via JS.
+   */
+  function hookSignInSubmit() {
+    var form = $(SELECTORS.loginForm);
+    var btn  = $(SELECTORS.signInButton);
+
+    // Last-resort fallback: walk the page for a button/<a>/role=button
+    // whose visible text matches /sign[- ]?in|log[- ]?in|login/.
+    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 });
+    }
+  }
+
+  /**
+   * EVENT 3: Click on the SSO "Login with Lion Login" button.
+   */
+  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 });
+  }
+
+  /**
+   * EVENT 4: Click on the "Terms and Conditions" link.
+   */
+  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 });
+  }
+
+  // ─── 8. Orchestration ────────────────────────────────────
+
+  /**
+   * The login page on psassets.publicissapient.com is a single-page
+   * application — controls may render after initial DOMContentLoaded. We
+   * try once on ready, then re-attempt via a short MutationObserver to
+   * catch late-mounted buttons / forms. Hooks are idempotent thanks to
+   * per-element flags below.
+   */
+  var HOOK_FLAG = '__il_ps_hooked__';
+
+  function safeHookAll() {
+    function once(el, name, fn) {
+      if (!el || el[HOOK_FLAG + name]) return;
+      el[HOOK_FLAG + name] = true;
+      fn();
+    }
+    // Re-resolve every cycle because the SPA can swap nodes underneath us.
+    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-PS] Infralytiqs SDK not loaded — bootstrap aborted');
+      return;
+    }
+    trackLoginPageView();
+    safeHookAll();
+
+    if (typeof MutationObserver === 'function') {
+      var mo = new MutationObserver(function () { safeHookAll(); });
+      mo.observe(document.documentElement || document.body, {
+        childList: true,
+        subtree:   true
+      });
+      // Stop watching after 20 seconds — 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);
+    }
+  }
+
+  // ─── 9. Entry point ──────────────────────────────────────
+  function waitForSdkAndStart() {
+    var attempts = 0;
+    var max = 50;
+    (function tick() {
+      if (getApi()) {
+        start();
+        return;
+      }
+      if (++attempts >= max) {
+        console.warn('[IL-PS] Infralytiqs SDK never appeared after ' + (max * 100) + 'ms');
+        return;
+      }
+      setTimeout(tick, 100);
+    })();
+  }
+
+  if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', waitForSdkAndStart, { once: true });
+  } else {
+    waitForSdkAndStart();
+  }
+})();

package/dist/infralytiqs.js

@@ -1,4 +1,4 @@
-/*! infralytiqs-sdk v1.0.0 | (c) 2026 sharadtech | License: See LICENSE | Built: 2026-05-24T02:39:05.253Z */
+/*! infralytiqs-sdk v1.0.1 | (c) 2026 sharadtech | License: See LICENSE | Built: 2026-05-27T12:40:33.717Z */
 var Infralytiqs = (function (exports) {
     'use strict';
 
@@ -820,6 +820,95 @@ var Infralytiqs = (function (exports) {
         }
     }
 
+    /**
+     * Client-bootstrap auto-loader.
+     *
+     * When the SDK script first executes on a host page, it looks for a
+     * `window.IL_CLIENT_BOOTSTRAP_LIB` global declared by the host (in AEM this
+     * is injected by the `Infralytiqs.html` Sightly fragment). If present, the
+     * SDK fetches that client-specific bootstrap JavaScript from the CDN and
+     * appends it to <head>. The bootstrap is then responsible for calling
+     * `Infralytiqs.init({...})` with tenant/site configuration and wiring any
+     * site-specific event hooks.
+     *
+     * Path resolution
+     * ---------------
+     * `IL_CLIENT_BOOTSTRAP_LIB` may be either:
+     *   • A fully qualified URL ("https://…/bootstrap.min.js") — used as-is.
+     *   • A path starting with "/" (e.g. "/cl/publicis/ps/bootstrap.min.js") —
+     *     resolved against the SDK's own origin (the CDN host that served this
+     *     script). This lets every client bootstrap live in the same S3 bucket
+     *     as the SDK without the host page needing to know the CDN hostname.
+     *   • A relative path — resolved against the SDK's own URL.
+     *
+     * The SDK script URL is captured at module-evaluation time via
+     * `document.currentScript`, which is only reliable during the SDK's
+     * synchronous IIFE execution. A defensive fallback scans existing <script>
+     * tags for one whose src matches the SDK bundle naming convention.
+     */
+    const SDK_SCRIPT_URL = (() => {
+        try {
+            if (typeof document === 'undefined')
+                return '';
+            const current = document.currentScript;
+            if (current && current.src)
+                return current.src;
+            const scripts = document.getElementsByTagName('script');
+            for (let i = scripts.length - 1; i >= 0; i--) {
+                const src = scripts[i].src;
+                if (src && /infralytiqs(\.min)?\.js(\?.*)?$/.test(src))
+                    return src;
+            }
+        }
+        catch (_a) {
+            /* noop — fall through to empty */
+        }
+        return '';
+    })();
+    const BOOTSTRAP_FLAG = '__il_bootstrap_loaded__';
+    function resolveBootstrapUrl(rawPath) {
+        if (/^https?:\/\//i.test(rawPath))
+            return rawPath;
+        if (!SDK_SCRIPT_URL)
+            return rawPath;
+        try {
+            return new URL(rawPath, SDK_SCRIPT_URL).href;
+        }
+        catch (_a) {
+            return rawPath;
+        }
+    }
+    /**
+     * Injects a <script src="…"> tag for the client bootstrap declared on the
+     * host page. Idempotent — a window sentinel guards against double injection
+     * if the SDK is somehow evaluated twice.
+     */
+    function loadClientBootstrap() {
+        if (typeof window === 'undefined' || typeof document === 'undefined')
+            return;
+        const w = window;
+        if (w[BOOTSTRAP_FLAG])
+            return;
+        const lib = w.IL_CLIENT_BOOTSTRAP_LIB;
+        if (!lib || typeof lib !== 'string')
+            return;
+        const absoluteUrl = resolveBootstrapUrl(lib);
+        w[BOOTSTRAP_FLAG] = true;
+        const s = document.createElement('script');
+        s.src = absoluteUrl;
+        s.async = true;
+        s.setAttribute('data-il-bootstrap', 'client');
+        s.onerror = () => {
+            if (typeof console !== 'undefined') {
+                console.error('[Infralytiqs] failed to load client bootstrap from', absoluteUrl);
+            }
+        };
+        const parent = document.head || document.documentElement;
+        if (parent) {
+            parent.appendChild(s);
+        }
+    }
+
     /**
      * st-ck-server license module id for Infralytiqs (Companies.productPlans[].module,
      * Users.moduleAndRole[].module). Kept here for documentation and optional host-app use.
@@ -897,6 +986,20 @@ var Infralytiqs = (function (exports) {
             tracker.destroy();
         },
     };
+    // ─── Auto-load the client-specific bootstrap ────────────────────────────
+    // When the SDK script tag executes, look for `window.IL_CLIENT_BOOTSTRAP_LIB`
+    // declared by the host page (e.g. by the AEM Infralytiqs.html Sightly
+    // fragment) and inject a <script> tag for it. The bootstrap is then
+    // responsible for calling `Infralytiqs.init({...})` and wiring up any
+    // site-specific event hooks. Resolution against the SDK's own CDN origin
+    // is handled inside the loader, so host pages can use absolute-path
+    // shortcuts like "/cl/publicis/ps/infralytiqs-bootstrap.min.js".
+    try {
+        loadClientBootstrap();
+    }
+    catch (_a) {
+        /* never throw out of SDK script-tag evaluation */
+    }
 
     exports.LICENSE_MODULE_ID = LICENSE_MODULE_ID;
     exports.default = Infralytiqs;