feat(sdk): implement full external SDK

Phase 2: Full External SDK (3h)
- Replace stub with real implementation
- Process queued events on load
- Session management (sessionStorage + UUID)
- send() function (sendBeacon + fetch fallback)
- track() and trackPageview() methods
- Auto-tracking (SPA navigation + outbound links)
- Error handling (silent failures in production)
- Debug mode logging
- Idempotent init (prevent double initialization)

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: rmarsigli

sdk/rush.js

@@ -0,0 +1,202 @@
+(function(window, document) {
+  'use strict';
+
+  // Configuration defaults
+  var defaults = {
+    endpoint: 'https://analytics.example.com/ingest',
+    autoTrack: true,
+    debug: false
+  };
+
+  var config = {};
+  var sessionId = null;
+  var initialized = false;
+
+  // Real Rush implementation (replaces stub)
+  var Rush = {
+    init: function(options) {
+      if (initialized) {
+        if (config.debug) console.warn('[Rush] Already initialized');
+        return;
+      }
+
+      config = Object.assign({}, defaults, options);
+      sessionId = getOrCreateSession();
+      initialized = true;
+
+      if (config.debug) {
+        console.log('[Rush] Initialized', {
+          siteId: config.siteId,
+          endpoint: config.endpoint,
+          sessionId: sessionId
+        });
+      }
+
+      if (config.autoTrack) {
+        trackPageview();
+        setupAutoTracking();
+      }
+    },
+
+    track: function(eventName, data) {
+      if (!initialized) {
+        console.error('[Rush] Not initialized. Call Rush.init() first.');
+        return;
+      }
+
+      var payload = {
+        site_id: config.siteId,
+        session_id: sessionId,
+        event_name: eventName,
+        path: window.location.pathname,
+        referrer: document.referrer || null,
+        timestamp: new Date().toISOString()
+      };
+
+      // Merge custom data
+      if (data) {
+        Object.keys(data).forEach(function(key) {
+          payload[key] = data[key];
+        });
+      }
+
+      send(payload);
+    },
+
+    trackPageview: function() {
+      this.track('pageview', {
+        url: window.location.href,
+        title: document.title
+      });
+    }
+  };
+
+  // Session management
+  function getOrCreateSession() {
+    var key = '_rush_sid';
+    var sid = sessionStorage.getItem(key);
+    if (!sid) {
+      sid = generateUUID();
+      sessionStorage.setItem(key, sid);
+    }
+    return sid;
+  }
+
+  function generateUUID() {
+    // Use native crypto API if available
+    if (crypto.randomUUID) {
+      return crypto.randomUUID();
+    }
+
+    // Fallback for older browsers
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
+      var r = Math.random() * 16 | 0;
+      var v = c === 'x' ? r : (r & 0x3 | 0x8);
+      return v.toString(16);
+    });
+  }
+
+  // Send event to backend
+  function send(payload) {
+    var data = JSON.stringify(payload);
+
+    // Prefer sendBeacon (more reliable for page unload)
+    if (navigator.sendBeacon) {
+      var blob = new Blob([data], { type: 'application/json' });
+      var sent = navigator.sendBeacon(config.endpoint, blob);
+
+      if (config.debug) {
+        console.log('[Rush] Event sent via sendBeacon:', sent, payload);
+      }
+
+      return;
+    }
+
+    // Fallback to fetch
+    fetch(config.endpoint, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: data,
+      keepalive: true
+    })
+    .then(function() {
+      if (config.debug) console.log('[Rush] Event sent via fetch:', payload);
+    })
+    .catch(function(err) {
+      if (config.debug) console.error('[Rush] Send failed:', err);
+      // Fail silently in production
+    });
+  }
+
+  function trackPageview() {
+    Rush.track('pageview', {
+      url: window.location.href,
+      title: document.title
+    });
+  }
+
+  // Auto-tracking setup
+  function setupAutoTracking() {
+    // SPA navigation (pushState, replaceState, popstate)
+    var pushState = history.pushState;
+    history.pushState = function() {
+      pushState.apply(history, arguments);
+      setTimeout(trackPageview, 0); // Async to let framework update
+    };
+
+    var replaceState = history.replaceState;
+    history.replaceState = function() {
+      replaceState.apply(history, arguments);
+      setTimeout(trackPageview, 0);
+    };
+
+    window.addEventListener('popstate', trackPageview);
+
+    // Outbound links tracking
+    document.addEventListener('click', function(e) {
+      var link = e.target.closest('a');
+      if (link && link.href && link.hostname !== window.location.hostname) {
+        Rush.track('outbound_link', {
+          url: link.href,
+          text: link.textContent || link.innerText
+        });
+      }
+    });
+
+    if (config.debug) {
+      console.log('[Rush] Auto-tracking enabled (SPA + outbound links)');
+    }
+  }
+
+  // Process queued events from stub
+  function processQueue() {
+    var queue = window.Rush._queue || [];
+
+    if (config.debug && queue.length > 0) {
+      console.log('[Rush] Processing', queue.length, 'queued events');
+    }
+
+    queue.forEach(function(item) {
+      var method = item[0];
+      var args = item.slice(1);
+
+      if (Rush[method]) {
+        Rush[method].apply(Rush, args);
+      }
+    });
+
+    // Clear queue
+    window.Rush._queue = [];
+  }
+
+  // Replace stub with real implementation
+  window.Rush = Rush;
+
+  // Process queued events
+  if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', processQueue);
+  } else {
+    processQueue();
+  }
+
+})(window, document);