@coframe/sdk 1.1.14 → 1.1.21

package/README.md

@@ -40,13 +40,40 @@ await init({
 
 `init()` accepts `config` and optional `projectData`, so npm consumers do not need to manually populate `window.CFQ` first.
 
+### Runtime endpoint overrides
+
+Private-CDN integrations can override the browser SDK's project and ingest
+endpoints:
+
+```ts
+await init({
+  config: {
+    projectId: 'your-project-id',
+    projectUrl: 'https://cdn.example.com/coframe/project.json',
+    ingestUrl: 'https://www.example.com/ingest/v2',
+    enableDebug: false,
+  },
+})
+```
+
+`projectUrl` must return a raw, complete `Project` JSON object. `ingestUrl`
+replaces the ingest base URL (`https://ingest.app.coframe.com/ingest/v2`); the
+SDK still appends the category and project path, so beacons go to
+`<ingestUrl>/batched_events/<projectId>/`, `<ingestUrl>/batched_monitoring/<projectId>/`,
+`<ingestUrl>/session_result/`, and `<ingestUrl>/identify/<projectId>/`. A proxy
+only has to forward `<ingestUrl>/*` to `https://ingest.app.coframe.com/ingest/v2/*`
+with the path unchanged. Both overrides are optional and retain the compiled
+Coframe endpoints when omitted.
+
 ### URL controls
 
 The npm entry uses the same browser URL controls as the script-tag and Edge
 installations:
 
 - `cf_disable` skips initialization and reveals any antiflicker state.
-- `coframe_variant_id` previews one or more comma-separated variant IDs.
+- `coframe_variant_id` previews one or more comma-separated variant IDs. Add
+  `rollouts` to the list to apply them on top of the rolled-out winners a
+  production visitor would get.
 - `coframe_should_send_events=true` allows events during preview for testing.
 
 Debug tools are allowed by default. Open the Launcher with `cf_preview=true` and

package/dist/pkg/cf.cjs.js

@@ -24,6 +24,19 @@ if (!Array.prototype.find) {
         enumerable: false,
     });
 }
+if (!Array.prototype.includes) {
+    Object.defineProperty(Array.prototype, 'includes', {
+        value: function (searchElement) {
+            if (this == null) {
+                throw new TypeError('Array.prototype.includes called on null or undefined');
+            }
+            return Array.prototype.indexOf.call(this, searchElement) !== -1;
+        },
+        writable: true,
+        configurable: true,
+        enumerable: false,
+    });
+}
 if (!Array.prototype.flatMap) {
     Object.defineProperty(Array.prototype, 'flatMap', {
         value: function (callback, thisArg) {
@@ -1066,10 +1079,41 @@ function warnEventsNotSent() {
     }
 }
 
-const SDK_VERSION = '2.6.0';
+const SDK_VERSION = '2.7.0';
 const queuedEvents = [];
 const queuedMonitoringEvents = [];
 const queuedSessions = [];
+let ingestUrl;
+const COMPILED_INGEST_BASE = "https://ingest.app.coframe.com/ingest/v2";
+function configureIngestUrl(url) {
+    const trimmed = url === null || url === void 0 ? void 0 : url.trim().replace(/\/+$/, '');
+    ingestUrl = trimmed || undefined;
+}
+function resolveIngestUrl(defaultUrl) {
+    if (!ingestUrl || !defaultUrl.startsWith(COMPILED_INGEST_BASE))
+        return defaultUrl;
+    return ingestUrl + defaultUrl.slice(COMPILED_INGEST_BASE.length);
+}
+const MAX_BEACON_BATCH_BYTES = 48 * 1024;
+function getBeaconPayloadBytes(data) {
+    return new Blob([JSON.stringify(data)]).size;
+}
+function chunkEventsByByteLimit(events) {
+    const chunks = [];
+    let current = [];
+    for (const event of events) {
+        if (current.length > 0 &&
+            getBeaconPayloadBytes([...current, event]) > MAX_BEACON_BATCH_BYTES) {
+            chunks.push(current);
+            current = [];
+        }
+        current.push(event);
+    }
+    if (current.length > 0) {
+        chunks.push(current);
+    }
+    return chunks;
+}
 function queueMonitoringEvent(coframe, data) {
     queuedMonitoringEvents.push(data);
     if (queuedMonitoringEvents.length >= coframe.batchSize) {
@@ -1122,11 +1166,15 @@ function flushQueuedEvents(projectId) {
         return;
     }
     if (queuedEvents.length > 0) {
-        sendEventToBackend(projectId, queuedEvents, 'batched_events');
+        for (const chunk of chunkEventsByByteLimit(queuedEvents)) {
+            sendEventToBackend(projectId, chunk, 'batched_events');
+        }
         queuedEvents.length = 0;
     }
     if (queuedMonitoringEvents.length > 0) {
-        sendEventToBackend(projectId, queuedMonitoringEvents, 'batched_monitoring');
+        for (const chunk of chunkEventsByByteLimit(queuedMonitoringEvents)) {
+            sendEventToBackend(projectId, chunk, 'batched_monitoring');
+        }
         queuedMonitoringEvents.length = 0;
     }
     if (queuedSessions.length > 0) {
@@ -1228,7 +1276,7 @@ function sendPageEngagementEvent(coframe, eventType, event, { projectId, session
     }
 }
 function sendEventToBackend(projectId, data, eventCategory = 'events') {
-    const eventsEndpoint = `${"https://ingest.app.coframe.com/ingest/v2"}/${eventCategory}/${projectId}/`;
+    const eventsEndpoint = resolveIngestUrl(`${"https://ingest.app.coframe.com/ingest/v2"}/${eventCategory}/${projectId}/`);
     if (navigator.sendBeacon) {
         const textData = JSON.stringify(data);
         const blob = new Blob([textData], { type: 'text/plain' });
@@ -1241,7 +1289,7 @@ function sendEventToBackend(projectId, data, eventCategory = 'events') {
     }
 }
 function createSession(data) {
-    const sessionApiUrl = `${"https://ingest.app.coframe.com/ingest/v2"}/session_result/`;
+    const sessionApiUrl = resolveIngestUrl(`${"https://ingest.app.coframe.com/ingest/v2"}/session_result/`);
     if (navigator.sendBeacon) {
         const textData = JSON.stringify(data);
         const blob = new Blob([textData], { type: 'text/plain' });
@@ -1253,11 +1301,14 @@ function createSession(data) {
         console.warn('[Coframe] cannot send event beacon, feature unavailable');
     }
 }
-async function fetchProjectFromEdge(projectId, currentUrl, signal, userContext, previewVariantId, headers) {
+async function fetchProjectFromEdge(projectId, currentUrl, signal, userContext, previewVariantId, headers, referrer) {
     const payload = { projectId, currentUrl };
     if (previewVariantId) {
         payload.previewVariantId = previewVariantId;
     }
+    if (referrer !== undefined) {
+        payload.referrer = referrer;
+    }
     const safe = sanitizeUserContext(userContext);
     if (safe) {
         payload.userContext = safe;
@@ -1278,6 +1329,26 @@ async function fetchProjectFromEdge(projectId, currentUrl, signal, userContext,
         return null;
     }
 }
+async function fetchProject(projectUrl, projectId, currentUrl, signal, userContext, previewVariantId, headers, referrer) {
+    if (!projectUrl) {
+        return fetchProjectFromEdge(projectId, currentUrl, signal, userContext, previewVariantId, headers, referrer);
+    }
+    try {
+        const response = await fetch(projectUrl, { headers, signal });
+        if (!response.ok)
+            return null;
+        return {
+            project: (await response.json()),
+            personalizationHeaders: {},
+        };
+    }
+    catch (error) {
+        if (error instanceof DOMException && error.name === 'AbortError') {
+            return null;
+        }
+        return null;
+    }
+}
 
 const isPageElement = (element) => {
     return (element === document.body ||
@@ -2129,6 +2200,78 @@ function resolveLaneWinners(claims, reachableByLane, lanes, userToken) {
     return excluded;
 }
 
+var CoInspectorMessageType;
+(function (CoInspectorMessageType) {
+    CoInspectorMessageType["onReady"] = "onReady";
+    CoInspectorMessageType["onHoverElement"] = "onHoverElement";
+    CoInspectorMessageType["onClickElement"] = "onClickElement";
+    CoInspectorMessageType["onPageUrlChange"] = "onPageUrlChange";
+    CoInspectorMessageType["onCreateNewElement"] = "onCreateNewElement";
+    CoInspectorMessageType["onCancelNewElement"] = "onCancelNewElement";
+    CoInspectorMessageType["onCopy"] = "onCopy";
+    CoInspectorMessageType["onCloseDomInspectorPanel"] = "onCloseDomInspectorPanel";
+    CoInspectorMessageType["onEditElement"] = "onEditElement";
+    CoInspectorMessageType["onDeleteElement"] = "onDeleteElement";
+    CoInspectorMessageType["onScroll"] = "onScroll";
+    CoInspectorMessageType["setAllRects"] = "setAllRects";
+    CoInspectorMessageType["onUpdateRects"] = "onUpdateRects";
+    CoInspectorMessageType["DisableMouseTracking"] = "DisableMouseTracking";
+    CoInspectorMessageType["EnableMouseTracking"] = "EnableMouseTracking";
+    CoInspectorMessageType["onLeaveElement"] = "onLeaveElement";
+})(CoInspectorMessageType || (CoInspectorMessageType = {}));
+var CoMainSiteMessageType;
+(function (CoMainSiteMessageType) {
+    CoMainSiteMessageType["ActiveInspect"] = "ActiveInspect";
+    CoMainSiteMessageType["FreezeInspect"] = "FreezeInspect";
+    CoMainSiteMessageType["SetElementChanges"] = "SetElementChanges";
+    CoMainSiteMessageType["ShowDomInspector"] = "ShowDomInspector";
+    CoMainSiteMessageType["RestoreOriginal"] = "RestoreOriginal";
+    CoMainSiteMessageType["CreateNewElement"] = "CreateNewElement";
+    CoMainSiteMessageType["ClickHoverElement"] = "ClickHoverElement";
+    CoMainSiteMessageType["ReloadIframe"] = "ReloadIframe";
+})(CoMainSiteMessageType || (CoMainSiteMessageType = {}));
+
+const COFRAME_PREVIEW_SESSION_STORAGE_KEY = 'coframe.preview_variant';
+const COFRAME_PREVIEW_VARIANT_QUERY_PARAM = 'coframe_variant_id';
+const ROLLOUTS_PREVIEW_ID = 'rollouts';
+function splitPreviewVariantIds(raw) {
+    var _a;
+    return ((_a = raw === null || raw === void 0 ? void 0 : raw.split(',').map((id) => id.trim()).filter(Boolean)) !== null && _a !== void 0 ? _a : []);
+}
+function isPreviewSentinel(id) {
+    return id === GLOBAL_HOLDOUT || id === ROLLOUTS_PREVIEW_ID;
+}
+function normalizePreviewVariantId(raw) {
+    const ids = splitPreviewVariantIds(raw);
+    return ids.length > 0 ? ids.join(',') : null;
+}
+function readPreviewVariantIdFromUrl(url = window.location.href) {
+    try {
+        return normalizePreviewVariantId(getUrlSearchParams(url).get(COFRAME_PREVIEW_VARIANT_QUERY_PARAM));
+    }
+    catch (_a) {
+        return null;
+    }
+}
+function readStoredPreviewVariantId() {
+    try {
+        return normalizePreviewVariantId(window.sessionStorage.getItem(COFRAME_PREVIEW_SESSION_STORAGE_KEY));
+    }
+    catch (_a) {
+        return null;
+    }
+}
+function resolvePreviewSource(url = window.location.href) {
+    const urlVariantId = readPreviewVariantIdFromUrl(url);
+    const storedVariantId = readStoredPreviewVariantId();
+    return {
+        effectiveVariantId: urlVariantId || storedVariantId,
+        isKeptForSession: Boolean(storedVariantId && storedVariantId === (urlVariantId || storedVariantId)),
+        storedVariantId,
+        urlVariantId,
+    };
+}
+
 function isElementVisible(el) {
     const rect = el.getBoundingClientRect();
     return rect.top >= 0 && rect.bottom <= window.innerHeight;
@@ -2168,11 +2311,11 @@ function checkActivationCondition(condition, personalizationHeaders, currentUrl,
     }
     if (condition.url &&
         condition.url !== '*' &&
-        !urlsMatch(condition.url, currentUrl)) {
+        !urlConditionMatches(condition.url, currentUrl, false, logger)) {
         return false;
     }
     if (condition.base_url_matches &&
-        !urlsMatch(condition.base_url_matches, currentUrl, true)) {
+        !urlConditionMatches(condition.base_url_matches, currentUrl, true, logger)) {
         return false;
     }
     if (condition.url_regex) {
@@ -2286,6 +2429,18 @@ const normalizeUrl = (url, baseUrlMatch) => {
     }
     return `${hostname}${pathname}${parsedUrl.search}${parsedUrl.hash}`;
 };
+function urlConditionMatches(conditionUrl, currentUrl, baseUrlMatch, logger) {
+    try {
+        return urlsMatch(conditionUrl, currentUrl, baseUrlMatch);
+    }
+    catch (_a) {
+        logger.error('Error parsing URL condition', 'url_condition_error', {
+            conditionUrl,
+            currentUrl,
+        });
+        return false;
+    }
+}
 function urlsMatch(conditionUrl, currentUrl, baseUrlMatch) {
     if (currentUrl.includes('localhost') || currentUrl.includes('0.0.0.0')) {
         const conditionUrlObj = new URL(conditionUrl);
@@ -2396,15 +2551,15 @@ const inRange = (bins, scale, seed, uid) => {
     }
     return false;
 };
-function checkAllAudiences(metadata, project, personalizationHeaders, currentPageUrl, languages, browserPlatform, userToken, userVisitCount, nonce, logger) {
+function checkAllAudiences(metadata, ctx) {
     var _a;
     const audienceIds = (_a = metadata.activation_condition.audience_ids) !== null && _a !== void 0 ? _a : [];
     let result = true;
     for (const audienceId of audienceIds) {
-        const audience = project.audiences[audienceId];
+        const audience = ctx.project.audiences[audienceId];
         if (!audience)
             continue;
-        const activated = checkActivationCondition(audience.selector, personalizationHeaders, currentPageUrl, languages, browserPlatform, userToken, userVisitCount, (js, args) => executeJs(js, args, { isExpression: true, nonce }), logger);
+        const activated = checkActivationCondition(audience.selector, ctx.personalizationHeaders, ctx.currentPageUrl, ctx.languages, ctx.browserPlatform, ctx.userToken, ctx.userVisitCount, (js, args) => executeJs(js, args, { isExpression: true, nonce: ctx.nonce }), ctx.logger);
         if (activated === false)
             return false;
         if (activated !== true)
@@ -2413,9 +2568,8 @@ function checkAllAudiences(metadata, project, personalizationHeaders, currentPag
     return result;
 }
 async function getVariantsAndElements(personalizationHeaders, project, previewVariantId, userToken, currentPageUrl, languages, browserPlatform, logger, nonce, laneClaims = {}, silentFallback = false) {
-    var _a, _b;
+    var _a;
     const experimentsInfo = [];
-    const variantsAndElements = [];
     const cloakBot = !!((_a = project.settings) === null || _a === void 0 ? void 0 : _a.bot_cloaking_enabled) &&
         personalizationHeaders['x-is-bot'] === 'true';
     const buildResponse = ({ variantsAndElements, experimentsInfo, hasActivatedFrames: frameActivated = false, laneClaims: meClaims = laneClaims, }) => {
@@ -2426,39 +2580,30 @@ async function getVariantsAndElements(personalizationHeaders, project, previewVa
             laneClaims: meClaims,
         };
     };
-    const previewVariantIds = (_b = previewVariantId === null || previewVariantId === void 0 ? void 0 : previewVariantId.split(',').map((id) => id.trim()).filter(Boolean)) !== null && _b !== void 0 ? _b : [];
+    const userVisitCount = Number.parseInt(getCookie(VISIT_COUNT_COOKIE_KEY) || '0', 10);
+    const ctx = {
+        project,
+        personalizationHeaders,
+        userToken,
+        currentPageUrl,
+        languages,
+        browserPlatform,
+        userVisitCount,
+        nonce,
+        logger,
+    };
+    const validatedClaims = validateClaims(laneClaims, project.lanes);
+    const previewVariantIds = splitPreviewVariantIds(previewVariantId);
     if (previewVariantIds.length > 0) {
-        const filteredVariantsAndElements = project.frames
-            .flatMap((frame) => frame.experiments.flatMap((experiment) => experiment.variants.map((variant) => ({
-            variant,
-            elements: frame.elements,
-        }))))
-            .filter((item) => previewVariantIds.includes(item.variant.id));
-        const skipAlert = previewVariantIds.some((id) => id === project.holdout_info.holdout_variant_id || id === GLOBAL_HOLDOUT);
-        if (filteredVariantsAndElements.length > 0) {
+        const variantsAndElements = previewVariants(previewVariantIds, validatedClaims, ctx, silentFallback);
+        if (variantsAndElements) {
             return buildResponse({
-                variantsAndElements: filteredVariantsAndElements,
-                hasActivatedFrames: true,
+                variantsAndElements,
+                hasActivatedFrames: variantsAndElements.length > 0,
             });
         }
-        if (!skipAlert && !silentFallback) {
-            window.alert(`[Coframe] Variant preview unavailable: ${previewVariantId}.`);
-        }
-        if (silentFallback) ;
-        else {
-            return buildResponse({});
-        }
     }
-    const userVisitCount = Number.parseInt(getCookie(VISIT_COUNT_COOKIE_KEY) || '0', 10);
-    const validatedClaims = validateClaims(laneClaims, project.lanes);
-    const activeFrames = project.frames.filter((frame) => {
-        if (!frame.experiments)
-            return false;
-        const frameActivated = checkActivationCondition(frame.activation_condition, personalizationHeaders, currentPageUrl, languages, browserPlatform, userToken, userVisitCount, (js, args) => executeJs(js, args, { isExpression: true, nonce }), logger);
-        if (!frameActivated)
-            return false;
-        return true;
-    });
+    const activeFrames = activateFrames(ctx);
     if (activeFrames.length === 0) {
         return buildResponse({ laneClaims: validatedClaims });
     }
@@ -2476,7 +2621,6 @@ async function getVariantsAndElements(personalizationHeaders, project, previewVa
             level: GLOBAL_HOLDOUT,
         });
         return buildResponse({
-            variantsAndElements,
             experimentsInfo,
             hasActivatedFrames: true,
             laneClaims: validatedClaims,
@@ -2491,7 +2635,27 @@ async function getVariantsAndElements(personalizationHeaders, project, previewVa
         final_state: false,
         level: GLOBAL_HOLDOUT,
     });
-    const evalAudiences = (metadata) => checkAllAudiences(metadata, project, personalizationHeaders, currentPageUrl, languages, browserPlatform, userToken, userVisitCount, nonce, logger) !== false;
+    const assignment = assignFrames(activeFrames, validatedClaims, ctx);
+    return buildResponse({
+        ...assignment,
+        experimentsInfo: [...experimentsInfo, ...assignment.experimentsInfo],
+    });
+}
+function activateFrames(ctx) {
+    return ctx.project.frames.filter((frame) => {
+        if (!frame.experiments)
+            return false;
+        const frameActivated = checkActivationCondition(frame.activation_condition, ctx.personalizationHeaders, ctx.currentPageUrl, ctx.languages, ctx.browserPlatform, ctx.userToken, ctx.userVisitCount, (js, args) => executeJs(js, args, { isExpression: true, nonce: ctx.nonce }), ctx.logger);
+        if (!frameActivated)
+            return false;
+        return true;
+    });
+}
+function assignFrames(activeFrames, validatedClaims, ctx) {
+    const { project, userToken, logger } = ctx;
+    const experimentsInfo = [];
+    const variantsAndElements = [];
+    const evalAudiences = (metadata) => checkAllAudiences(metadata, ctx) !== false;
     const audiencePass = new Map();
     const reachableByLane = {};
     for (const frame of activeFrames) {
@@ -2584,50 +2748,49 @@ async function getVariantsAndElements(personalizationHeaders, project, previewVa
             variantsAndElements.push({ variant, elements });
         }
     }
-    return buildResponse({
+    return {
         variantsAndElements,
         experimentsInfo,
         hasActivatedFrames,
         laneClaims: updatedClaims,
-    });
+    };
 }
-
-const COFRAME_PREVIEW_SESSION_STORAGE_KEY = 'coframe.preview_variant';
-const COFRAME_PREVIEW_VARIANT_QUERY_PARAM = 'coframe_variant_id';
-function normalizePreviewVariantId(raw) {
-    if (!raw)
+function previewVariants(previewVariantIds, validatedClaims, ctx, silentFallback) {
+    const previewRollouts = previewVariantIds.includes(ROLLOUTS_PREVIEW_ID);
+    const requestedVariantIds = previewVariantIds.filter((id) => !isPreviewSentinel(id));
+    const requestedVariants = findVariants(ctx.project.frames, requestedVariantIds);
+    const requestedVariantsMissing = requestedVariantIds.length > 0 && requestedVariants.length === 0;
+    if (requestedVariantsMissing && !previewRollouts && silentFallback) {
         return null;
-    const ids = raw
-        .split(',')
-        .map((id) => id.trim())
-        .filter(Boolean);
-    return ids.length > 0 ? ids.join(',') : null;
-}
-function readPreviewVariantIdFromUrl(url = window.location.href) {
-    try {
-        return normalizePreviewVariantId(getUrlSearchParams(url).get(COFRAME_PREVIEW_VARIANT_QUERY_PARAM));
     }
-    catch (_a) {
-        return null;
+    const requestedHoldout = requestedVariantIds.includes(ctx.project.holdout_info.holdout_variant_id);
+    if (requestedVariantsMissing && !requestedHoldout && !silentFallback) {
+        window.alert(`[Coframe] Variant preview unavailable: ${previewVariantIds.join(',')}.`);
     }
+    const rolledOutVariants = previewRollouts && !previewVariantIds.includes(GLOBAL_HOLDOUT)
+        ? assignFrames(keepRolledOutExperiments(activateFrames(ctx)), validatedClaims, ctx).variantsAndElements
+        : [];
+    return uniqueByVariantId([...rolledOutVariants, ...requestedVariants]);
 }
-function readStoredPreviewVariantId() {
-    try {
-        return normalizePreviewVariantId(window.sessionStorage.getItem(COFRAME_PREVIEW_SESSION_STORAGE_KEY));
-    }
-    catch (_a) {
-        return null;
-    }
+function findVariants(frames, variantIds) {
+    return frames.flatMap((frame) => frame.experiments.flatMap((experiment) => experiment.variants
+        .filter((variant) => variantIds.includes(variant.id))
+        .map((variant) => ({ variant, elements: frame.elements }))));
 }
-function resolvePreviewSource(url = window.location.href) {
-    const urlVariantId = readPreviewVariantIdFromUrl(url);
-    const storedVariantId = readStoredPreviewVariantId();
-    return {
-        effectiveVariantId: urlVariantId || storedVariantId,
-        isKeptForSession: Boolean(storedVariantId && storedVariantId === (urlVariantId || storedVariantId)),
-        storedVariantId,
-        urlVariantId,
-    };
+function uniqueByVariantId(items) {
+    const seen = {};
+    return items.filter(({ variant }) => {
+        if (seen[variant.id])
+            return false;
+        seen[variant.id] = true;
+        return true;
+    });
+}
+function keepRolledOutExperiments(frames) {
+    return frames.map((frame) => ({
+        ...frame,
+        experiments: frame.experiments.filter((experiment) => experiment.metadata.serving_mode === 'winner'),
+    }));
 }
 
 function buildSessionContext(isInitialApply) {
@@ -2913,29 +3076,27 @@ function createTreatmentAnalytics(Coframe, previewVariantId) {
                 });
             }
         }
-        if (previewVariantId) {
-            const previewIds = previewVariantId.split(',');
-            for (const id of previewIds) {
-                treatmentsData.push({
-                    impressionId: sessionId,
-                    userToken,
-                    experimentId: `preview_id_${id}`,
-                    holdoutExperimentId: `preview_holdout_id_${id}`,
-                    variantId: id,
-                    inGlobalHoldout: false,
-                    isBaseline: false,
-                });
-                treatmentsDataV2.push({
-                    coframe_experiment_id: `preview_id_${id}`,
-                    coframe_experiment_slug: `preview_id_${id}`,
-                    coframe_variant_id: id,
-                    coframe_variant_slug: id,
-                    coframe_user_token: userToken,
-                    coframe_impression_id: sessionId,
-                    coframe_in_global_holdout: false,
-                    coframe_in_exp_baseline: false,
-                });
-            }
+        const previewIds = splitPreviewVariantIds(previewVariantId).filter((id) => !isPreviewSentinel(id));
+        for (const id of previewIds) {
+            treatmentsData.push({
+                impressionId: sessionId,
+                userToken,
+                experimentId: `preview_id_${id}`,
+                holdoutExperimentId: `preview_holdout_id_${id}`,
+                variantId: id,
+                inGlobalHoldout: false,
+                isBaseline: false,
+            });
+            treatmentsDataV2.push({
+                coframe_experiment_id: `preview_id_${id}`,
+                coframe_experiment_slug: `preview_id_${id}`,
+                coframe_variant_id: id,
+                coframe_variant_slug: id,
+                coframe_user_token: userToken,
+                coframe_impression_id: sessionId,
+                coframe_in_global_holdout: false,
+                coframe_in_exp_baseline: false,
+            });
         }
         Coframe.treatmentsData = treatmentsData;
         Coframe.treatmentsDataV2 = treatmentsDataV2;
@@ -3180,12 +3341,12 @@ async function ensureBody(Coframe, cdnProject, timeoutMs, nonce) {
 }
 const FLUSH_EVENTS_TIME = 1000 * 3;
 let flushInterval = null;
-function setupFlushInterval(projectId) {
-    flushQueuedEvents(projectId);
+function setupFlushInterval(Coframe) {
+    flushQueuedEvents(Coframe.projectId);
     if (flushInterval !== null) {
         clearInterval(flushInterval);
     }
-    flushInterval = setInterval(() => flushQueuedEvents(projectId), FLUSH_EVENTS_TIME);
+    flushInterval = setInterval(() => flushQueuedEvents(Coframe.projectId), FLUSH_EVENTS_TIME);
 }
 function setupSPANavigation(Coframe, project, config, previewVariantId, isSessionVariant, applyVariants) {
     var _a;
@@ -3213,6 +3374,7 @@ function setupSPANavigation(Coframe, project, config, previewVariantId, isSessio
     observer.observe(document.body, { childList: true, subtree: true });
     let navigationAbortController = null;
     observeUrlChanges(false, async (newPageUrl, _oldPageUrl) => {
+        var _a;
         await new Promise((resolve) => requestAnimationFrame(resolve));
         infiniteLoopProtection = 0;
         if (navigationAbortController)
@@ -3220,27 +3382,33 @@ function setupSPANavigation(Coframe, project, config, previewVariantId, isSessio
         navigationAbortController = new AbortController();
         const { signal } = navigationAbortController;
         let pageProject = project;
+        let pagePersonalizationHeaders = Coframe.personalizationHeaders;
         const cached = getCachedFrames(newPageUrl);
         if (cached) {
             pageProject = cached.project;
+            pagePersonalizationHeaders = {
+                ...cached.personalizationHeaders,
+                'x-visit-url': newPageUrl,
+            };
         }
         else {
             try {
                 const preview = resolvePreview(newPageUrl, previewVariantId, isSessionVariant);
-                const result = await fetchProjectFromEdge(Coframe.projectId, newPageUrl, signal, config.userContext, preview.previewVariantId || undefined);
+                const result = await fetchProject(config.projectUrl, Coframe.projectId, newPageUrl, signal, config.userContext, preview.previewVariantId || undefined, undefined, (_a = config.referrer) !== null && _a !== void 0 ? _a : getBrowserReferrer());
                 if (signal.aborted)
                     return;
                 if (result) {
                     pageProject = result.project;
+                    pagePersonalizationHeaders = result.personalizationHeaders;
                     cacheFrames(newPageUrl, result);
                 }
             }
-            catch (_a) {
+            catch (_b) {
             }
         }
         if (signal.aborted)
             return;
-        await applyVariants(newPageUrl, pageProject);
+        await applyVariants(newPageUrl, pageProject, pagePersonalizationHeaders);
     });
 }
 function readLaneClaims() {
@@ -3271,13 +3439,14 @@ function persistLaneClaims(claims, logger) {
         setCookie(LANE_COOKIE_KEY, encodeURIComponent(serialized), logger);
     }
 }
-function createApplyVariants(Coframe, config, previewVariantId, isSessionVariant, executionStartTime, analytics, personalizationHeaders, laneStore) {
+function createApplyVariants(Coframe, config, previewVariantId, isSessionVariant, executionStartTime, analytics, laneStore) {
     let isFirstApply = true;
-    return async (pageUrl, pageProject) => {
+    return async (pageUrl, pageProject, personalizationHeaders) => {
         const sessionId = isFirstApply ? Coframe.sessionId : generateUUID();
         const sessionContext = buildSessionContext(isFirstApply);
         isFirstApply = false;
         Coframe.sessionId = sessionId;
+        Coframe.personalizationHeaders = personalizationHeaders;
         const preview = resolvePreview(pageUrl, previewVariantId, isSessionVariant);
         setIsPreviewVariant(!!preview.previewVariantId);
         const { variantsAndElements, experimentsInfo, hasActivatedFrames, laneClaims, } = await getVariantsAndElements(personalizationHeaders, pageProject, preview.previewVariantId, Coframe.userToken, pageUrl, getBrowserLanguages(), getBrowserPlatform(), Coframe.logger, config.nonce, laneStore.claims, preview.isSessionVariant);
@@ -3314,8 +3483,8 @@ async function modifyPage(Coframe, configResult, projectResult, analytics) {
     if (!(await ensureBody(Coframe, cdnProject, timeoutMs, config.nonce)))
         return;
     const laneStore = { claims: readLaneClaims() };
-    const applyVariants = createApplyVariants(Coframe, config, previewVariantId, isSessionVariant, executionStartTime, analytics, personalizationHeaders, laneStore);
-    await applyVariants(getCurrentPageUrl(), cdnProject);
+    const applyVariants = createApplyVariants(Coframe, config, previewVariantId, isSessionVariant, executionStartTime, analytics, laneStore);
+    await applyVariants(getCurrentPageUrl(), cdnProject, personalizationHeaders);
     if (!Coframe.variantsAndElements ||
         Coframe.variantsAndElements.length === 0) {
         revealPage();
@@ -3323,7 +3492,7 @@ async function modifyPage(Coframe, configResult, projectResult, analytics) {
     }
     reportInitTiming(Coframe, cdnProject, integrationStartTime, executionStartTime);
     setupSPANavigation(Coframe, cdnProject, config, previewVariantId, isSessionVariant, applyVariants);
-    setupFlushInterval(Coframe.projectId);
+    setupFlushInterval(Coframe);
 }
 
 const TIMEOUT_MAX_MS = 5000;
@@ -3359,6 +3528,7 @@ async function resolveConfig(Coframe, revealPage) {
         : null;
     const executionStartTime = new Date();
     Coframe.batchSize = config.batchSize || 32;
+    configureIngestUrl(config.ingestUrl);
     const gracefulExit = (msg) => {
         console.warn(`[Coframe] ${msg}`);
         revealPage();
@@ -3480,13 +3650,13 @@ async function resolveIdentity(config, Coframe, timeoutMs, gracefulExit) {
 }
 
 async function resolveProject(Coframe, previewVariantId, isSessionVariant, config) {
-    var _a;
+    var _a, _b;
     const logger = Coframe.logger;
     const projectData = (_a = findLastCmd((c) => !!c.projectData)) === null || _a === void 0 ? void 0 : _a.projectData;
     let personalizationHeaders = (projectData === null || projectData === void 0 ? void 0 : projectData.personalizationHeaders) || null;
     let project = isSessionVariant ? undefined : projectData === null || projectData === void 0 ? void 0 : projectData.project;
     if (!project) {
-        const edgeResult = await fetchProjectFromEdge(Coframe.projectId, config.currentUrl || getCurrentPageUrl(), undefined, config.userContext, previewVariantId || undefined);
+        const edgeResult = await fetchProject(config.projectUrl, Coframe.projectId, config.currentUrl || getCurrentPageUrl(), undefined, config.userContext, previewVariantId || undefined, undefined, (_b = config.referrer) !== null && _b !== void 0 ? _b : getBrowserReferrer());
         personalizationHeaders = (edgeResult === null || edgeResult === void 0 ? void 0 : edgeResult.personalizationHeaders) || null;
         project = (edgeResult === null || edgeResult === void 0 ? void 0 : edgeResult.project) || undefined;
     }