@syntrologie/runtime-sdk 2.8.0-canary.207 → 2.8.0-canary.209

package/dist/bootstrap-init.d.ts

@@ -8,9 +8,16 @@
  * via the __VITE_IMPORT_META_ENV__ define.
  */
 export declare function getEnvVar(name: string): string | undefined;
+export declare function loadCached<T>(key: string, ttlMs?: number): T | null;
+export declare function writeCached(key: string, data: unknown): void;
 /**
  * Load cached segment attributes from localStorage.
  * Returns cached values for instant Phase 1 evaluation.
+ *
+ * Data is stored in the generic { ts, data } envelope. Legacy entries written
+ * without the envelope (bare JSON objects) will fail to parse as an envelope
+ * and return null — `loadCachedSegmentAttributes` returns {} in that case.
+ * The next /decide call repopulates the cache in the new format automatically.
  */
 export declare function loadCachedSegmentAttributes(): Record<string, boolean>;
 /**
@@ -27,9 +34,14 @@ export declare function extractSegmentFlags(allFlags: Record<string, boolean | s
  * Only non-empty values are included.
  */
 export declare function collectBrowserMetadata(): Record<string, string | string[]>;
+type InitialAttrs = Record<string, string>;
+export declare function computeInitialAttrs(fresh: Record<string, string | string[]>, cached: InitialAttrs | null): InitialAttrs;
+export declare function loadInitialAttrs(): InitialAttrs | null;
+export declare function saveInitialAttrs(attrs: InitialAttrs): void;
 export declare const GEO_DEFAULT_HOST = "https://geo.syntrologie.com";
 /**
  * Fetch geo data from the Cloudflare Worker, with localStorage caching.
  * Returns cached data immediately on subsequent visits. Best-effort — never blocks init.
  */
 export declare function fetchGeo(geoHost: string): Promise<Record<string, string>>;
+export {};

package/dist/bootstrap.d.ts

@@ -21,7 +21,7 @@ import type { AppLoader, AppLoadResult } from './apps/AppLoader';
 import type { SmartCanvasRuntime } from './runtime';
 import type { InterventionTracker } from './telemetry/InterventionTracker';
 import { decodeToken, encodeToken } from './token';
-export { collectBrowserMetadata, fetchGeo } from './bootstrap-init';
+export { collectBrowserMetadata, computeInitialAttrs, fetchGeo, loadCached, writeCached, } from './bootstrap-init';
 export type { SyntroInitOptions, SyntroInitResult } from './bootstrap-types';
 /**
  * Initialize the Syntro SDK with a single token.

package/dist/index.js

@@ -9935,7 +9935,7 @@ function bindWebVitals(reporter, options) {
 }
 
 // src/version.ts
-var SDK_VERSION = "2.8.0-canary.207";
+var SDK_VERSION = "2.8.0-canary.209";
 
 // src/types.ts
 var SDK_SCHEMA_VERSION = "2.0";
@@ -14120,30 +14120,40 @@ function getEnvVar(name) {
   }
   return void 0;
 }
-var SEGMENT_CACHE_KEY = "syntro_segment_attributes";
-function loadCachedSegmentAttributes() {
-  if (typeof window === "undefined") return {};
+function loadCached(key, ttlMs) {
+  if (typeof window === "undefined") return null;
   try {
-    const cached = localStorage.getItem(SEGMENT_CACHE_KEY);
-    if (cached) {
-      const attrs = JSON.parse(cached);
-      debug("Syntro Bootstrap", "Loaded cached segment attributes:", attrs);
-      return attrs;
-    }
-  } catch (err) {
-    warn("Syntro Bootstrap", "Failed to load cached segment attributes:", err);
+    const raw = localStorage.getItem(key);
+    if (!raw) return null;
+    const envelope = JSON.parse(raw);
+    if (!envelope || typeof envelope.ts !== "number" || !("data" in envelope)) return null;
+    if (ttlMs != null && Date.now() - envelope.ts > ttlMs) return null;
+    return envelope.data;
+  } catch {
+    return null;
   }
-  return {};
 }
-function cacheSegmentAttributes(attrs) {
+function writeCached(key, data) {
   if (typeof window === "undefined") return;
   try {
-    localStorage.setItem(SEGMENT_CACHE_KEY, JSON.stringify(attrs));
-    debug("Syntro Bootstrap", "Cached segment attributes:", attrs);
-  } catch (err) {
-    warn("Syntro Bootstrap", "Failed to cache segment attributes:", err);
+    const envelope = { ts: Date.now(), data };
+    localStorage.setItem(key, JSON.stringify(envelope));
+  } catch {
   }
 }
+var SEGMENT_CACHE_KEY = "syntro_segment_attributes";
+function loadCachedSegmentAttributes() {
+  const cached = loadCached(SEGMENT_CACHE_KEY);
+  if (cached) {
+    debug("Syntro Bootstrap", "Loaded cached segment attributes:", cached);
+    return cached;
+  }
+  return {};
+}
+function cacheSegmentAttributes(attrs) {
+  writeCached(SEGMENT_CACHE_KEY, attrs);
+  debug("Syntro Bootstrap", "Cached segment attributes:", attrs);
+}
 function extractSegmentFlags(allFlags) {
   if (!allFlags) return {};
   const segmentFlags = {};
@@ -14234,6 +14244,51 @@ function collectBrowserMetadata() {
   }
   return attrs;
 }
+var INITIAL_ATTRS_KEY = "syntro_initial_attrs";
+var INITIAL_ATTRS_TTL = 30 * 60 * 1e3;
+var UTM_KEYS = ["utm_source", "utm_medium", "utm_campaign", "utm_content", "utm_term"];
+function isInternalReferrer(referrerHostname) {
+  if (typeof window === "undefined") return false;
+  try {
+    return referrerHostname === window.location.hostname;
+  } catch {
+    return false;
+  }
+}
+function computeInitialAttrs(fresh, cached) {
+  const result = {};
+  const hasFreshUtms = UTM_KEYS.some((k2) => typeof fresh[k2] === "string");
+  for (const key of UTM_KEYS) {
+    const value = hasFreshUtms ? fresh[key] : cached == null ? void 0 : cached[key];
+    if (value) result[key] = value;
+  }
+  const freshReferrerHostname = typeof fresh.referrer_hostname === "string" ? fresh.referrer_hostname : void 0;
+  const isInternal = freshReferrerHostname ? isInternalReferrer(freshReferrerHostname) : true;
+  if (!isInternal && typeof fresh.referrer === "string") {
+    result.referrer = fresh.referrer;
+    if (freshReferrerHostname) result.referrer_hostname = freshReferrerHostname;
+  } else if (cached == null ? void 0 : cached.referrer) {
+    result.referrer = cached.referrer;
+    if (cached.referrer_hostname) result.referrer_hostname = cached.referrer_hostname;
+  }
+  if (cached == null ? void 0 : cached.initial_page_url) {
+    result.initial_page_url = cached.initial_page_url;
+    if (cached.initial_page_path) result.initial_page_path = cached.initial_page_path;
+    if (cached.initial_page_query) result.initial_page_query = cached.initial_page_query;
+  } else {
+    if (typeof fresh.page_url === "string") result.initial_page_url = fresh.page_url;
+    if (typeof fresh.page_path === "string") result.initial_page_path = fresh.page_path;
+    if (typeof fresh.page_query === "string") result.initial_page_query = fresh.page_query;
+  }
+  return result;
+}
+function loadInitialAttrs() {
+  return loadCached(INITIAL_ATTRS_KEY, INITIAL_ATTRS_TTL);
+}
+function saveInitialAttrs(attrs) {
+  writeCached(INITIAL_ATTRS_KEY, attrs);
+  debug("Syntro Bootstrap", "Cached initial attrs:", attrs);
+}
 var GEO_CACHE_KEY = "syntro_geo";
 var GEO_DEFAULT_HOST = "https://geo.syntrologie.com";
 async function fetchGeo(geoHost) {
@@ -14462,7 +14517,7 @@ function identifyFromUrlParam(telemetry, consentGate) {
 }
 
 // src/defaults/initialProperties.ts
-var UTM_KEYS = ["utm_source", "utm_medium", "utm_campaign", "utm_content", "utm_term"];
+var UTM_KEYS2 = ["utm_source", "utm_medium", "utm_campaign", "utm_content", "utm_term"];
 function isStrictRegion(geo) {
   if (geo.is_eu === "true") return true;
   if (geo.country_code === "GB" || geo.country_code === "CH") return true;
@@ -14491,7 +14546,7 @@ function captureInitialProperties(telemetry, geoPromise) {
     $initial_referrer: referrer,
     $initial_referring_domain: safeReferringDomain(referrer)
   };
-  for (const key of UTM_KEYS) {
+  for (const key of UTM_KEYS2) {
     const value = params.get(key);
     if (value) {
       props[`$initial_${key}`] = value;
@@ -18423,8 +18478,17 @@ async function _initCore(options) {
   const cachedSegmentAttrs = loadCachedSegmentAttributes();
   const browserMetadata = collectBrowserMetadata();
   const appSignalsInit = (_e2 = options.appSignalsInit) != null ? _e2 : {};
-  const phaseOneAttrs = { ...browserMetadata, ...cachedSegmentAttrs, ...appSignalsInit };
+  const cachedInitialAttrs = loadInitialAttrs();
+  const initialAttrs = computeInitialAttrs(browserMetadata, cachedInitialAttrs);
+  saveInitialAttrs(initialAttrs);
+  const phaseOneAttrs = {
+    ...browserMetadata,
+    ...initialAttrs,
+    ...cachedSegmentAttrs,
+    ...appSignalsInit
+  };
   debug("Syntro Bootstrap", "Phase 1: Browser metadata:", browserMetadata);
+  debug("Syntro Bootstrap", "Phase 1: Initial attrs:", initialAttrs);
   debug("Syntro Bootstrap", "Phase 1: Cached segment attributes:", cachedSegmentAttrs);
   if (Object.keys(appSignalsInit).length > 0) {
     debug("Syntro Bootstrap", "Phase 1: App signals:", appSignalsInit);
@@ -18520,6 +18584,7 @@ async function _initCore(options) {
       const sessionAttrs = (_b2 = (_a4 = sessionMetrics == null ? void 0 : sessionMetrics.getAll) == null ? void 0 : _a4.call(sessionMetrics)) != null ? _b2 : {};
       const updatedAttrs = {
         ...browserMetadata,
+        ...initialAttrs,
         ...sessionAttrs,
         ...segmentFlags,
         ...appSignalsInit
@@ -18741,7 +18806,7 @@ async function _initCore(options) {
   }
   const geoData = await geoPromise;
   if (experiments && Object.keys(geoData).length > 0) {
-    const mergedAttrs = { ...browserMetadata, ...geoData, ...appSignalsInit };
+    const mergedAttrs = { ...browserMetadata, ...initialAttrs, ...geoData, ...appSignalsInit };
     debug("Syntro Bootstrap", "Merging geo data into GrowthBook attributes:", geoData);
     (_l = experiments.setAttributes) == null ? void 0 : _l.call(experiments, mergedAttrs);
   }
@@ -18749,7 +18814,7 @@ async function _initCore(options) {
   if (mcpHost && experiments) {
     browserMetadata.surface_type = "mcp-app";
     browserMetadata.surface_host = mcpHost.name;
-    (_m = experiments.setAttributes) == null ? void 0 : _m.call(experiments, { ...browserMetadata, ...geoData });
+    (_m = experiments.setAttributes) == null ? void 0 : _m.call(experiments, { ...browserMetadata, ...initialAttrs, ...geoData });
     runtime5.context.setSurfaceType("mcp-app");
     runtime5.context.setSurfaceHost(mcpHost.name);
     debug("Syntro Bootstrap", "MCP App detected:", mcpHost.name);