(function () { if (typeof window === "undefined") return; var EXPERIMENT_ACTIVE = false; var STORAGE_KEY = "kassel_swic_ab_variant"; var NEW_DOMAIN = "starwarsintrocreator.kassellabs.io"; var OLD_DOMAIN = "old.starwarsintrocreator.kassellabs.io"; var EXPERIMENT_ID = "swic-vs-new-2026-q2"; // Only the production canonical drives the A/B. Vercel preview URLs, // localhost, and the legacy domain itself never auto-redirect. The // canonical guard means a 50/50 coin-flip can't bounce QA traffic away // from a preview deployment, while still letting test query params // (?ab_variant=, ?ab_reset=) work via the helpers exposed below. var isCanonical = location.hostname === NEW_DOMAIN; if (location.hostname === OLD_DOMAIN) return; // Nobody enters the A/B when the experiment is OFF (consolidated to "new", // 2026-06-17) or for crawlers. In both cases the variant is always "new" on // the clean canonical URL: no coin-flip, no redirect to old.*, no // localStorage writes, no utm_* rewrite that would dirty the indexed URL. // // Crawler exclusion fixed the 2026-06-02 deindex: a coin-flipped bot render // was JS-redirected to the noindexed old.* and Google attributed that // noindex to THIS canonical URL. The experiment-off path is the // consolidation that ends the test for everyone. (See // kassellabs-os/planning/swic-vs-new-ab-test.md.) var ua = (typeof navigator !== "undefined" && navigator.userAgent) || ""; var isBot = /bot|crawl|spider|slurp|bingpreview|google-inspectiontool|headless|lighthouse|gtmetrix|pingdom|facebookexternalhit|twitterbot|embedly|quora link preview|outbrain|vkshare|w3c_validator|whatsapp|telegrambot/i.test(ua); if (!EXPERIMENT_ACTIVE || isBot) { window.__KASSEL_AB__ = { experimentId: EXPERIMENT_ID, variant: "new", active: EXPERIMENT_ACTIVE, bot: isBot, inspect: function () { return { experimentId: EXPERIMENT_ID, variant: "new", active: EXPERIMENT_ACTIVE, bot: isBot, url: location.href }; } }; return; } function read() { try { return localStorage.getItem(STORAGE_KEY); } catch (e) { return null; } } function write(v) { try { localStorage.setItem(STORAGE_KEY, v); } catch (e) { /* noop */ } } function clear() { try { localStorage.removeItem(STORAGE_KEY); } catch (e) { /* noop */ } } function valid(v) { return v === "new" || v === "legacy"; } var params = new URLSearchParams(location.search); // 0. Reset switch (?ab_reset=1) — wipe assignment so the next step // either re-coin-flips or uses the explicit ?ab_variant=. if (params.get("ab_reset") === "1") clear(); // 1. URL handshake (?ab_variant=new|legacy) — pin the variant. var fromUrl = params.get("ab_variant"); if (valid(fromUrl)) { write(fromUrl); } // 2. Resolve final variant from storage, or coin-flip. // Coin-flip only persists on the canonical — on preview/localhost we // just compute a transient variant for debugging without polluting // localStorage with a "legacy" that would force-redirect later. var variant = read(); if (!valid(variant)) { variant = Math.random() < 0.5 ? "new" : "legacy"; if (isCanonical) write(variant); } // 3. Test helper: ?ab_no_redirect=1 disables the legacy redirect for // this load so you can inspect the new app even when assigned legacy. // Outside the canonical we always skip the redirect. var skipRedirect = !isCanonical || params.get("ab_no_redirect") === "1"; // 4. Persist the experiment UTMs to localStorage.saved-utm-params (same // key the legacy StarWarsIntroCreator app reads). Without this, the // "new" variant never tags its payments — captureUtmParams() in // TrackingInit only writes when the current URL has utm_*. We merge // so real marketing UTMs (utm_source/medium, gclid, etc.) survive a // revisit; the experiment fields are authoritative for the // experiment window and overwrite any prior value. if (location.hostname !== OLD_DOMAIN) { try { var existingRaw = localStorage.getItem("saved-utm-params"); var bag = {}; if (existingRaw) { try { bag = JSON.parse(existingRaw) || {}; } catch (e) { bag = {}; } } bag.utm_campaign = EXPERIMENT_ID; bag.utm_content = "ab_" + EXPERIMENT_ID + "_" + variant; localStorage.setItem("saved-utm-params", JSON.stringify(bag)); } catch (e) { /* localStorage disabled — best effort */ } } // Expose a debug handle for the JS console (e.g. window.__KASSEL_AB__.reset()). window.__KASSEL_AB__ = { experimentId: EXPERIMENT_ID, variant: variant, setVariant: function (v) { if (!valid(v)) { console.warn("invalid variant", v); return; } write(v); location.reload(); }, reset: function () { clear(); location.reload(); }, inspect: function () { return { experimentId: EXPERIMENT_ID, variant: variant, storage: read(), url: location.href, }; } }; // 5. Stay path (variant "new", or "legacy" with redirect suppressed): // surface the experiment UTMs to GA4 by rewriting the current URL. // GA4 (via the shared GTM container) reads campaign/source from the page // URL when its page_view fires — and that fires AFTER this synchronous // script (GTM loads in TrackingInit's effect). The "new" variant // otherwise sits on a clean URL with no utm_*, so GA4 stamps the session // as (not set)/organic and the experiments dashboard — which filters on // sessionCampaignName == EXPERIMENT_ID — never sees the "new" cohort. // The "legacy" redirect doesn't need this: its target (below) already // carries the UTMs. Only the experiment-owned utm_campaign/utm_content // are set; utm_source/utm_medium/utm_term + gclid are left untouched. var willStay = variant !== "legacy" || skipRedirect; if (willStay) { if (isCanonical && params.get("utm_campaign") !== EXPERIMENT_ID) { try { var stayUrl = new URL(location.href); stayUrl.searchParams.set("utm_campaign", EXPERIMENT_ID); stayUrl.searchParams.set("utm_content", "ab_" + EXPERIMENT_ID + "_" + variant); history.replaceState(history.state, "", stayUrl.toString()); } catch (e) { /* older browsers / file:// — skip */ } } return; } // Path translation: new clean URL → old hashbang. // / → / // / → /#!/ // // → /#!// // //download/pay → /#!//download/donate // //download/paid → /#!//download/donated function translate(pathname) { var segs = pathname.split("/").filter(Boolean); if (segs.length === 0) return "/"; var aliases = { pay: "donate", paid: "donated" }; var out = "#!/" + segs.map(function (s, i) { return (i === segs.length - 1 && aliases[s]) ? aliases[s] : s; }).join("/"); return "/" + out; } // A legacy hashbang link (#!//...) can land on this canonical domain // directly — its key + subpage live in the hash, not the pathname. Reuse the // hash as-is so the redirect to old.* keeps them. Campaign links sometimes // glue a trailing route segment after an embedded hash query, e.g. // #!/?utm_campaign=…/download // so strip the query and rescue the trailing /segments back onto the route // (kept in sync with routePathFromHashContent in LegacyHashRedirect.tsx). function legacyHashRoute(hash) { hash = hash || ""; if (hash.indexOf("#%21/") === 0) hash = "#!/" + hash.slice(5); if (hash.indexOf("#!/") !== 0) return null; var content = hash.slice(3); var q = content.indexOf("?"); if (q !== -1) { var before = content.slice(0, q); var after = content.slice(q + 1); var s = after.indexOf("/"); var tail = s === -1 ? "" : after.slice(s + 1); content = tail ? before + "/" + tail : before; } var segs = content.split("/").filter(Boolean); if (segs.length === 0) return null; return "/#!/" + segs.join("/"); } var search = location.search; // Strip our own test-helper params from the forwarded URL. if (search) { var sp = new URLSearchParams(search); sp.delete("ab_variant"); sp.delete("ab_reset"); sp.delete("ab_no_redirect"); search = sp.toString(); search = search ? "?" + search : ""; } // Pass utm_campaign + utm_content for GA4 + payment attribution. var utm = "utm_campaign=" + encodeURIComponent(EXPERIMENT_ID) + "&utm_content=" + encodeURIComponent("ab_" + EXPERIMENT_ID + "_legacy"); search = search ? (search + "&" + utm) : ("?" + utm); // Prefer an incoming legacy hash (carries the key + subpage); otherwise // translate the clean new-app pathname. var route = legacyHashRoute(location.hash) || translate(location.pathname); var target = "https://" + OLD_DOMAIN + route + search; // Hide body to avoid a flash of the React shell during the redirect. try { document.documentElement.style.visibility = "hidden"; } catch (e) {} location.replace(target); })();