@drip-apex/sdk 0.1.0 → 0.3.0

package/src/init-redirects.test.ts

@@ -0,0 +1,2156 @@
+import { describe, expect, it, vi } from "vitest";
+import type { Mutation } from "./types";
+import {
+  RECENT_MONDAY_NOON, documentListeners, windowListeners, appendedAntiFlickerStyle, configPayloadHash, flushDynamicImports, installCookieJar, installMutationObserverStub, makeClassList, makeStorage, readCookieValue, readDecodedDripContext, registerInitTestLifecycle, verifiedHandoverResponse,
+} from "./init-test-helpers";
+
+describe("init redirects", () => {
+  registerInitTestLifecycle();
+
+
+  it("exposes only the redirect assignment before navigation", async () => {
+    const replace = vi.fn();
+    (globalThis as any).location.replace = replace;
+    const onExperimentViewed = vi.fn();
+    const { init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      shopId: "shop_123",
+      trackingStart: "immediate",
+      userId: "visitor_redirect",
+      experiments: [
+        {
+          id: "exp_redirect",
+          experimentType: "redirect",
+          status: "running",
+          targeting: { url: [{ type: "simple", pattern: "/", include: true }] },
+          trafficAllocation: 1,
+          variations: [{ id: "redirect_treatment", weight: 1, mutations: [], redirectUrl: "https://landing.test/sale" }],
+        },
+        {
+          id: "exp_mutation",
+          status: "running",
+          trafficAllocation: 1,
+          // The non-redirect arm must stay unapplied; keep the payload key the
+          // runtime ignores (`value`, not `text`) instead of making it apply.
+          variations: [{ id: "mutation_treatment", weight: 1, mutations: [{ selector: "body", action: "text", value: "changed" } as unknown as Mutation] }],
+        },
+      ],
+      onExperimentViewed,
+    });
+
+    expect(replace).toHaveBeenCalledTimes(1);
+    expect(onExperimentViewed.mock.calls.map(([viewed]) => viewed.experimentId)).toEqual(["exp_redirect"]);
+  });
+
+
+  it("does not navigate a holdout visitor into a redirect treatment", async () => {
+    const replace = vi.fn();
+    (globalThis as any).location.replace = replace;
+    const { getAssignments, init } = await import("./index");
+    const { isHoldoutVisitor } = await import("./hash");
+    const userId = Array.from({ length: 1000 }, (_, index) => `redirect-holdout-${index}`).find((id) =>
+      isHoldoutVisitor({ holdout_v1_enabled: true, holdout_pct: 10 }, id),
+    );
+    expect(userId).toBeTruthy();
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      shopId: "shop_123",
+      trackingStart: "immediate",
+      userId: userId!,
+      holdout_v1_enabled: true,
+      holdout_pct: 10,
+      experiments: [{
+        id: "exp_redirect",
+        experimentType: "redirect",
+        status: "running",
+        targeting: { url: [{ type: "simple", pattern: "/", include: true }] },
+        trafficAllocation: 1,
+        variations: [{
+          id: "redirect_treatment",
+          weight: 1,
+          mutations: [],
+          redirectUrl: "https://landing.test/sale",
+        }],
+      }],
+    });
+
+    expect(getAssignments()).toEqual([]);
+    expect(replace).not.toHaveBeenCalled();
+  });
+
+
+  it("flushes a network redirect exposure before navigation when cached visual hydration is pending", async () => {
+    installMutationObserverStub();
+    const replace = vi.fn();
+    Object.assign((globalThis as any).location, {
+      href: "https://plain.test/products/source",
+      pathname: "/products/source",
+      replace,
+    });
+    (globalThis as any).window.location = (globalThis as any).location;
+    localStorage.setItem("drip_cfg:shop_123:production", JSON.stringify({
+      fetchedAt: Date.now(),
+      hash: "cached-visual-before-network-redirect",
+      experiments: [{
+        id: "exp_cached_visual_before_redirect",
+        status: "running",
+        trafficAllocation: 1,
+        variations: [{
+          id: "var_cached_visual_before_redirect",
+          weight: 1,
+          mutations: [{
+            selector: "#product-title",
+            action: "text",
+            text: "Cached treatment",
+          }],
+        }],
+      }],
+      runtime: {
+        spa: {
+          applyTiming: "after_hydration",
+          hydrationTimeoutMs: 5_000,
+        },
+      },
+    }));
+    globalThis.fetch = vi.fn(async (input: RequestInfo | URL) => (
+      String(input).includes("/config")
+        ? Response.json({
+            experiments: [{
+              id: "exp_network_redirect",
+              experimentType: "redirect",
+              status: "running",
+              targeting: {
+                url: [{
+                  type: "simple",
+                  pattern: "/products/*",
+                  include: true,
+                }],
+              },
+              trafficAllocation: 1,
+              variations: [{
+                id: "var_network_redirect",
+                weight: 1,
+                mutations: [],
+                redirectUrl: "https://landing.test/sale",
+              }],
+            }],
+          })
+        : new Response("ok", { status: 202 })
+    )) as any;
+    const { flush, getDiagnostics, init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      lateConfigPolicy: "apply",
+      shopId: "shop_123",
+      trackingStart: "immediate",
+      userId: "visitor_network_redirect",
+    });
+    for (
+      let attempt = 0;
+      attempt < 20 && getDiagnostics().configSource !== "network";
+      attempt += 1
+    ) {
+      await Promise.resolve();
+    }
+    await flush();
+
+    expect(getDiagnostics().configSource).toBe("network");
+    expect(replace).toHaveBeenCalledWith("https://landing.test/sale");
+    const fetchMock = vi.mocked(globalThis.fetch);
+    const eventsCallIndex = fetchMock.mock.calls.findIndex(
+      (call) => call[0] === "https://events.test/v1/events",
+    );
+    expect(eventsCallIndex).toBeGreaterThanOrEqual(0);
+    expect(fetchMock.mock.invocationCallOrder[eventsCallIndex]).toBeLessThan(
+      replace.mock.invocationCallOrder[0],
+    );
+    const events = JSON.parse(
+      String(fetchMock.mock.calls[eventsCallIndex]?.[1]?.body),
+    ).events;
+    expect(events).toEqual(expect.arrayContaining([
+      expect.objectContaining({
+        type: "experiment_viewed",
+        experimentId: "exp_network_redirect",
+        variationId: "var_network_redirect",
+      }),
+    ]));
+    expect(events).not.toEqual(expect.arrayContaining([
+      expect.objectContaining({
+        type: "experiment_viewed",
+        experimentId: "exp_cached_visual_before_redirect",
+      }),
+    ]));
+  });
+
+
+  it("does not navigate a cached redirect when the refresh stops the experiment", async () => {
+    const replace = vi.fn();
+    Object.assign((globalThis as any).location, {
+      href: "https://plain.test/products/source",
+      pathname: "/products/source",
+      replace,
+    });
+    (globalThis as any).window.location = (globalThis as any).location;
+    const cachedRedirect = {
+      id: "exp_cached_redirect_stopped",
+      experimentType: "redirect" as const,
+      status: "running",
+      targeting: {
+        url: [{ type: "simple" as const, pattern: "/products/*", include: true }],
+      },
+      trafficAllocation: 1,
+      variations: [{
+        id: "var_cached_redirect_stopped",
+        weight: 1,
+        mutations: [],
+        redirectUrl: "https://landing.test/old-sale",
+      }],
+    };
+    localStorage.setItem("drip_cfg:shop_123:production", JSON.stringify({
+      fetchedAt: Date.now(),
+      hash: configPayloadHash([cachedRedirect]),
+      experiments: [cachedRedirect],
+    }));
+    let resolveConfig!: (response: Response) => void;
+    globalThis.fetch = vi.fn((input: RequestInfo | URL) => (
+      String(input).includes("/config")
+        ? new Promise<Response>((resolve) => {
+            resolveConfig = resolve;
+          })
+        : Promise.resolve(new Response("ok", { status: 202 }))
+    )) as any;
+    const { getDiagnostics, init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      shopId: "shop_123",
+      trackingStart: "immediate",
+      userId: "visitor_cached_redirect_stopped",
+    });
+    await Promise.resolve();
+
+    expect(replace).not.toHaveBeenCalled();
+    expect(appendedAntiFlickerStyle()).toBeDefined();
+    await vi.advanceTimersByTimeAsync(1_300);
+    expect(appendedAntiFlickerStyle()).toBeDefined();
+
+    resolveConfig(Response.json({
+      experiments: [{ ...cachedRedirect, status: "paused" }],
+    }));
+    for (
+      let attempt = 0;
+      attempt < 20 && getDiagnostics().configSource !== "network";
+      attempt += 1
+    ) {
+      await Promise.resolve();
+    }
+    expect(getDiagnostics().configSource).toBe("network");
+    expect(replace).not.toHaveBeenCalled();
+  });
+
+
+  it("navigates a cached redirect once after an unchanged refresh confirms it", async () => {
+    const replace = vi.fn();
+    Object.assign((globalThis as any).location, {
+      href: "https://plain.test/products/source",
+      pathname: "/products/source",
+      replace,
+    });
+    (globalThis as any).window.location = (globalThis as any).location;
+    const cachedRedirect = {
+      id: "exp_cached_redirect_confirmed",
+      experimentType: "redirect" as const,
+      status: "running",
+      targeting: {
+        url: [{ type: "simple" as const, pattern: "/products/*", include: true }],
+      },
+      trafficAllocation: 1,
+      variations: [{
+        id: "var_cached_redirect_confirmed",
+        weight: 1,
+        mutations: [],
+        redirectUrl: "https://landing.test/confirmed-sale",
+      }],
+    };
+    localStorage.setItem("drip_cfg:shop_123:production", JSON.stringify({
+      fetchedAt: Date.now(),
+      hash: configPayloadHash([cachedRedirect]),
+      experiments: [cachedRedirect],
+    }));
+    let resolveConfig!: (response: Response) => void;
+    globalThis.fetch = vi.fn((input: RequestInfo | URL) => (
+      String(input).includes("/config")
+        ? new Promise<Response>((resolve) => {
+            resolveConfig = resolve;
+          })
+        : Promise.resolve(new Response("ok", { status: 202 }))
+    )) as any;
+    const { getDiagnostics, init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      shopId: "shop_123",
+      trackingStart: "immediate",
+      userId: "visitor_cached_redirect_confirmed",
+    });
+    await Promise.resolve();
+
+    expect(replace).not.toHaveBeenCalled();
+    expect(appendedAntiFlickerStyle()).toBeDefined();
+    await vi.advanceTimersByTimeAsync(1_300);
+    expect(appendedAntiFlickerStyle()).toBeDefined();
+
+    resolveConfig(Response.json({ experiments: [cachedRedirect] }));
+    for (
+      let attempt = 0;
+      attempt < 20 && getDiagnostics().load.configFetchStatus !== "ok";
+      attempt += 1
+    ) {
+      await Promise.resolve();
+    }
+    expect(getDiagnostics().load.configFetchStatus).toBe("ok");
+    expect(getDiagnostics().configSource).toBe("cache");
+    expect(replace).toHaveBeenCalledTimes(1);
+    expect(replace).toHaveBeenCalledWith(
+      "https://landing.test/confirmed-sale",
+    );
+    expect(appendedAntiFlickerStyle()).toBeDefined();
+  });
+
+
+  it("falls back to the cached redirect after the bounded refresh timeout", async () => {
+    const replace = vi.fn();
+    Object.assign((globalThis as any).location, {
+      href: "https://plain.test/products/source",
+      pathname: "/products/source",
+      replace,
+    });
+    (globalThis as any).window.location = (globalThis as any).location;
+    const cachedRedirect = {
+      id: "exp_cached_redirect_timeout",
+      experimentType: "redirect" as const,
+      status: "running",
+      targeting: {
+        url: [{ type: "simple" as const, pattern: "/products/*", include: true }],
+      },
+      trafficAllocation: 1,
+      variations: [{
+        id: "var_cached_redirect_timeout",
+        weight: 1,
+        mutations: [],
+        redirectUrl: "https://landing.test/fallback-sale",
+      }],
+    };
+    localStorage.setItem("drip_cfg:shop_123:production", JSON.stringify({
+      fetchedAt: Date.now(),
+      hash: configPayloadHash([cachedRedirect]),
+      experiments: [cachedRedirect],
+    }));
+    globalThis.fetch = vi.fn((
+      input: RequestInfo | URL,
+      requestInit?: RequestInit,
+    ) => {
+      if (!String(input).includes("/config")) {
+        return Promise.resolve(new Response("ok", { status: 202 }));
+      }
+      return new Promise<Response>((_resolve, reject) => {
+        requestInit?.signal?.addEventListener("abort", () => {
+          reject(new DOMException("The operation was aborted.", "AbortError"));
+        });
+      });
+    }) as any;
+    vi.spyOn(console, "error").mockImplementation(() => {});
+    const { getDiagnostics, init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      shopId: "shop_123",
+      trackingStart: "immediate",
+      userId: "visitor_cached_redirect_timeout",
+    });
+    await Promise.resolve();
+
+    expect(replace).not.toHaveBeenCalled();
+    expect(appendedAntiFlickerStyle()).toBeDefined();
+    await vi.advanceTimersByTimeAsync(14_999);
+    expect(appendedAntiFlickerStyle()).toBeDefined();
+    expect(replace).not.toHaveBeenCalled();
+    await vi.advanceTimersByTimeAsync(1);
+    expect(getDiagnostics().load.configFetchStatus).toBe("timeout");
+    expect(replace).toHaveBeenCalledTimes(1);
+    expect(replace).toHaveBeenCalledWith(
+      "https://landing.test/fallback-sale",
+    );
+    expect(appendedAntiFlickerStyle()).toBeDefined();
+  });
+
+
+  it("persists redirect bucketing without unsigned carry when the tracking prerequisite is closed", async () => {
+    const replace = vi.fn();
+    Object.assign((globalThis as any).location, {
+      href: "https://plain.test/products/source",
+      pathname: "/products/source",
+      replace,
+    });
+    (globalThis as any).window.location = (globalThis as any).location;
+    const onExperimentViewed = vi.fn();
+    const { getDiagnostics, init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [{
+        id: "exp_redirect_tracking_closed",
+        assignmentEpoch: 4,
+        experimentType: "redirect",
+        status: "running",
+        targeting: {
+          url: [{ type: "simple", pattern: "/products/*", include: true }],
+        },
+        trafficAllocation: 1,
+        variations: [{
+          id: "var_redirect_tracking_closed",
+          weight: 1,
+          mutations: [],
+          redirectUrl: "https://landing.test/tracking-closed",
+        }],
+      }],
+      onExperimentViewed,
+      projectPrerequisites: {
+        startTrackingRule: "return false;",
+      },
+      shopId: "shop_123",
+      trackingStart: "immediate",
+      userId: "visitor_redirect_tracking_closed",
+    });
+
+    expect(getDiagnostics().trackerStarted).toBe(false);
+    expect(onExperimentViewed).not.toHaveBeenCalled();
+    expect(replace).toHaveBeenCalledTimes(1);
+    const destination = new URL(String(replace.mock.calls[0]?.[0]));
+    expect(destination.searchParams.has("_apex_assignment")).toBe(false);
+    expect(
+      JSON.parse(localStorage.getItem("drip_assignments_v1") ?? "{}"),
+    ).toHaveProperty(
+      "exp_redirect_tracking_closed",
+      expect.arrayContaining(["var_redirect_tracking_closed", 4]),
+    );
+  });
+
+
+  it("drops an exclusion-only redirect assignment before application or exposure", async () => {
+    const replace = vi.fn();
+    (globalThis as any).location.replace = replace;
+    (globalThis as any).window.location = (globalThis as any).location;
+    const onExperimentViewed = vi.fn();
+    const { getAssignments, init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      shopId: "shop_123",
+      trackingStart: "immediate",
+      userId: "visitor_exclusion_only_redirect",
+      experiments: [
+        {
+          id: "exp_exclusion_only_redirect",
+          experimentType: "redirect",
+          status: "running",
+          targeting: {
+            url: [
+              {
+                type: "simple",
+                pattern: "/checkout/*",
+                include: false,
+              },
+            ],
+          },
+          trafficAllocation: 1,
+          variations: [
+            {
+              id: "redirect_treatment",
+              weight: 1,
+              mutations: [],
+              redirectUrl: "https://landing.test/sale",
+            },
+          ],
+        },
+      ],
+      onExperimentViewed,
+    });
+
+    expect(getAssignments()).toEqual([]);
+    expect(replace).not.toHaveBeenCalled();
+    expect(onExperimentViewed).not.toHaveBeenCalled();
+  });
+
+
+  it("drops a redirect assignment whose destination matches its source rules", async () => {
+    const replace = vi.fn();
+    Object.assign((globalThis as any).location, {
+      href: "https://plain.test/products/source",
+      pathname: "/products/source",
+      replace,
+    });
+    (globalThis as any).window.location = (globalThis as any).location;
+    const onExperimentViewed = vi.fn();
+    const { getAssignments, init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      shopId: "shop_123",
+      trackingStart: "immediate",
+      userId: "visitor_matching_destination",
+      experiments: [
+        {
+          id: "exp_matching_destination",
+          experimentType: "redirect",
+          status: "running",
+          targeting: {
+            url: [
+              {
+                type: "simple",
+                pattern: "/products/*",
+                include: true,
+              },
+            ],
+          },
+          trafficAllocation: 1,
+          variations: [
+            {
+              id: "redirect_treatment",
+              weight: 1,
+              mutations: [],
+              redirectUrl: "https://plain.test/products/destination",
+            },
+          ],
+        },
+      ],
+      onExperimentViewed,
+    });
+
+    expect(getAssignments()).toEqual([]);
+    expect(replace).not.toHaveBeenCalled();
+    expect(onExperimentViewed).not.toHaveBeenCalled();
+  });
+
+
+  it("does not enroll or expose a direct destination visitor when a host-agnostic source rule shares its path", async () => {
+    const replace = vi.fn();
+    Object.assign((globalThis as any).location, {
+      hostname: "landing.test",
+      href: "https://landing.test/products/destination",
+      origin: "https://landing.test",
+      pathname: "/products/destination",
+      replace,
+    });
+    (globalThis as any).window.location = (globalThis as any).location;
+    const onExperimentViewed = vi.fn();
+    const { getAssignments, init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      shopId: "shop_123",
+      storeOrigin: "https://plain.test",
+      trackingStart: "immediate",
+      userId: "visitor_direct_destination",
+      experiments: [
+        {
+          id: "exp_origin_scoped_redirect",
+          experimentType: "redirect",
+          status: "running",
+          targeting: {
+            url: [
+              {
+                type: "simple",
+                pattern: "/products/*",
+                include: true,
+              },
+            ],
+          },
+          trafficAllocation: 1,
+          variations: [
+            {
+              id: "redirect_treatment",
+              weight: 1,
+              mutations: [],
+              redirectUrl: "https://landing.test/products/destination",
+            },
+          ],
+        },
+      ],
+      onExperimentViewed,
+    });
+
+    expect(getAssignments()).toEqual([]);
+    expect(replace).not.toHaveBeenCalled();
+    expect(onExperimentViewed).not.toHaveBeenCalled();
+  });
+
+
+  it("fires a path-only redirect on a registered public storefront without requiring the backend origin", async () => {
+    const replace = vi.fn();
+    Object.assign((globalThis as any).location, {
+      hostname: "de.storefront.test",
+      href: "https://de.storefront.test/products/source",
+      origin: "https://de.storefront.test",
+      pathname: "/products/source",
+      replace,
+    });
+    (globalThis as any).window.location = (globalThis as any).location;
+    const onExperimentViewed = vi.fn();
+    const { getAssignments, init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      shopId: "shop_123",
+      storeOrigin: "https://backend-app.test",
+      storeOrigins: [
+        "https://storefront.test",
+        "https://de.storefront.test",
+      ],
+      trackingStart: "immediate",
+      userId: "visitor_source_origin",
+      experiments: [
+        {
+          id: "exp_origin_scoped_redirect",
+          experimentType: "redirect",
+          status: "running",
+          targeting: {
+            url: [
+              {
+                type: "simple",
+                pattern: "/products/*",
+                include: true,
+              },
+            ],
+          },
+          trafficAllocation: 1,
+          variations: [
+            {
+              id: "redirect_treatment",
+              weight: 1,
+              mutations: [],
+              redirectUrl: "https://landing.test/products/destination",
+            },
+          ],
+        },
+      ],
+      onExperimentViewed,
+    });
+
+    expect(getAssignments()).toEqual([
+      expect.objectContaining({
+        experimentId: "exp_origin_scoped_redirect",
+        variationId: "redirect_treatment",
+      }),
+    ]);
+    expect(onExperimentViewed).toHaveBeenCalledTimes(1);
+    expect(replace).toHaveBeenCalledTimes(1);
+    expect(new URL(String(replace.mock.calls[0]?.[0])).origin).toBe(
+      "https://landing.test",
+    );
+  });
+
+
+  it("records one exposure when DOM activation discovers a redirect after analytics started", async () => {
+    const replace = vi.fn();
+    (globalThis as any).location.replace = replace;
+    (globalThis as any).window.location = (globalThis as any).location;
+    const onExperimentViewed = vi.fn();
+    const { flush, init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      shopId: "shop_123",
+      trackingStart: "immediate",
+      userId: "visitor_dom_redirect",
+      experiments: [
+        {
+          id: "exp_dom_redirect",
+          experimentType: "redirect",
+          status: "running",
+          targeting: {
+            url: [{ type: "simple", pattern: "/", include: true }],
+            pageRules: [
+              {
+                id: "page_dom_redirect",
+                includeRules: [
+                  { type: "simple", pattern: "/", include: true },
+                ],
+                trigger: {
+                  mode: "manual-callback",
+                  signal: "page.trigger.dom_redirect",
+                  triggerJs: "window.__activateDomRedirect = activate;",
+                },
+              },
+            ],
+          },
+          trafficAllocation: 1,
+          variations: [
+            {
+              id: "redirect_treatment",
+              weight: 1,
+              mutations: [],
+              redirectUrl: "https://landing.test/sale",
+            },
+          ],
+        },
+      ],
+      onExperimentViewed,
+    });
+
+    expect(onExperimentViewed).not.toHaveBeenCalled();
+    (globalThis as any).window.__activateDomRedirect();
+    await flush();
+
+    const eventsCall = vi.mocked(globalThis.fetch).mock.calls.find(
+      (call) => call[0] === "https://events.test/v1/events",
+    );
+    const events = JSON.parse(String(eventsCall?.[1]?.body)).events;
+    expect(
+      events.filter(
+        (event: { type: string }) => event.type === "experiment_viewed",
+      ),
+    ).toHaveLength(1);
+    expect(onExperimentViewed).toHaveBeenCalledTimes(1);
+    expect(replace).toHaveBeenCalledTimes(1);
+  });
+
+
+  it("still applies redirect artifacts on the source page before late navigation", async () => {
+    const replace = vi.fn();
+    (globalThis as any).location.replace = replace;
+    (globalThis as any).window.location = (globalThis as any).location;
+    const sourceTitle = { textContent: "Original source headline" };
+    const sourceStyles: Array<Record<string, any>> = [];
+    (globalThis as any).document.createElement = vi.fn((tag: string) => ({
+      id: "",
+      className: "",
+      remove: vi.fn(),
+      tagName: tag.toUpperCase(),
+      textContent: "",
+    }));
+    (globalThis as any).document.querySelectorAll = vi.fn((selector: string) => (
+      selector === "#redirect-source-title" ? [sourceTitle] : []
+    ));
+    (globalThis as any).document.getElementById = vi.fn((id: string) => (
+      sourceStyles.find((element) => element.id === id) ?? null
+    ));
+    (globalThis as any).document.head.appendChild = vi.fn((element: Record<string, any>) => {
+      sourceStyles.push(element);
+      return element;
+    });
+    const { init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      shopId: "shop_123",
+      trackingStart: "immediate",
+      userId: "visitor_source_artifacts",
+      experiments: [{
+        id: "exp_redirect_source_artifacts",
+        experimentType: "redirect",
+        status: "running",
+        targeting: {
+          url: [{ type: "simple", pattern: "/", include: true }],
+          pageRules: [{
+            id: "page_redirect_source_artifacts",
+            includeRules: [{ type: "simple", pattern: "/", include: true }],
+            trigger: {
+              mode: "manual-callback",
+              signal: "page.trigger.redirect_source_artifacts",
+              triggerJs: "window.__activateRedirectSourceArtifacts = activate;",
+            },
+          }],
+        },
+        trafficAllocation: 1,
+        variations: [{
+          id: "redirect_source_artifacts_treatment",
+          weight: 1,
+          mutations: [{
+            selector: "#redirect-source-title",
+            action: "text",
+            text: "Source treatment headline",
+          }],
+          css: "#redirect-source-title{color:red}",
+          js: "window.__redirectSourceJs=true;",
+          redirectUrl: "https://landing.test/sale",
+        }],
+      }],
+      spa: { activationMode: "manual" },
+    });
+
+    (globalThis as any).window.__activateRedirectSourceArtifacts();
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(sourceTitle.textContent).toBe("Source treatment headline");
+    expect((globalThis as any).window.__redirectSourceJs).toBe(true);
+    expect(sourceStyles.find(
+      (style) =>
+        style.id ===
+        "drip-css-exp_redirect_source_artifacts-redirect_source_artifacts_treatment",
+    )?.textContent).toBe("#redirect-source-title{color:red}");
+    expect(replace).toHaveBeenCalledTimes(1);
+  });
+
+
+  it("plans and exposes a redirect after SPA navigation enters its source route", async () => {
+    const replace = vi.fn();
+    (globalThis as any).location.replace = replace;
+    const onExperimentViewed = vi.fn();
+    const { init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      shopId: "shop_123",
+      trackingStart: "immediate",
+      userId: "visitor_spa_redirect",
+      experiments: [
+        {
+          id: "exp_redirect_spa",
+          experimentType: "redirect",
+          status: "running",
+          targeting: {
+            url: [
+              {
+                type: "simple",
+                pattern: "/products/source",
+                include: true,
+              },
+            ],
+          },
+          trafficAllocation: 1,
+          variations: [
+            {
+              id: "redirect_spa_treatment",
+              weight: 1,
+              mutations: [],
+              redirectUrl: "https://landing.test/sale",
+            },
+          ],
+        },
+        {
+          id: "exp_mutation_spa_peer",
+          status: "running",
+          trafficAllocation: 1,
+          variations: [
+            {
+              id: "mutation_spa_peer",
+              weight: 1,
+              mutations: [],
+            },
+          ],
+        },
+      ],
+      onExperimentViewed,
+    });
+
+    expect(replace).not.toHaveBeenCalled();
+    expect(onExperimentViewed.mock.calls.map(([viewed]) => viewed.experimentId)).toEqual([
+      "exp_mutation_spa_peer",
+    ]);
+
+    Object.assign((globalThis as any).location, {
+      href: "https://plain.test/products/source",
+      pathname: "/products/source",
+    });
+    (globalThis as any).history.pushState({}, "", "/products/source");
+
+    expect(replace).toHaveBeenCalledTimes(1);
+    const redirectDestination = new URL(String(replace.mock.calls[0]?.[0]));
+    expect(redirectDestination.origin + redirectDestination.pathname).toBe(
+      "https://landing.test/sale",
+    );
+    expect(redirectDestination.searchParams.has("_apex_assignment")).toBe(
+      false,
+    );
+    expect(onExperimentViewed.mock.calls.map(([viewed]) => viewed.experimentId)).toEqual([
+      "exp_mutation_spa_peer",
+      "exp_redirect_spa",
+    ]);
+  });
+
+
+  it.each([
+    {
+      label: "missing ingest signature",
+      ingestSignature: undefined,
+      externalTracking: undefined,
+    },
+    {
+      label: "signed handover disabled",
+      ingestSignature: "worker-issued-ingest-signature",
+      externalTracking: { signed: false },
+    },
+  ])(
+    "omits cross-origin redirect carry when signing is unavailable: $label",
+    async ({ ingestSignature, externalTracking }) => {
+      const replace = vi.fn();
+      Object.assign((globalThis as any).location, {
+        hostname: "plain.test",
+        href: "https://plain.test/products/source",
+        origin: "https://plain.test",
+        pathname: "/products/source",
+        search: "",
+        replace,
+      });
+      const { init } = await import("./index");
+      const { parseRedirectAssignmentCarry } = await import("./redirect");
+
+      init({
+        antiFlickerMode: "off",
+        endpoint: "https://events.test",
+        experiments: [{
+          id: "exp_redirect_unsigned",
+          assignmentEpoch: 1,
+          experimentType: "redirect",
+          status: "running",
+          targeting: {
+            url: [{ type: "simple", pattern: "/products/*", include: true }],
+          },
+          trafficAllocation: 1,
+          variations: [{
+            id: "redirect_consent_treatment",
+            weight: 1,
+            mutations: [],
+            redirectUrl: "https://landing.test/sale",
+          }],
+        }],
+        externalTracking,
+        ingestSignature,
+        shopId: "shop_123",
+        trackingStart: "immediate",
+      });
+
+      expect(replace).toHaveBeenCalledTimes(1);
+      const destination = String(replace.mock.calls[0]?.[0]);
+      expect(new URL(destination).searchParams.has("_apex_assignment")).toBe(false);
+      expect(parseRedirectAssignmentCarry(destination)).toBeNull();
+      expect(
+        vi.mocked(globalThis.fetch).mock.calls.some(
+          (call) => String(call[0]).endsWith("/v1/handover/mint"),
+        ),
+      ).toBe(false);
+    },
+  );
+
+
+  it("mints a signed handover before navigating with a cross-origin redirect carry", async () => {
+    const replace = vi.fn();
+    Object.assign((globalThis as any).location, {
+      hostname: "plain.test",
+      href: "https://plain.test/products/source",
+      origin: "https://plain.test",
+      pathname: "/products/source",
+      search: "",
+      replace,
+    });
+    const { createBucketingHandoverPayload } = await import("./handover");
+    globalThis.fetch = vi.fn(async (
+      input: RequestInfo | URL,
+      requestInit?: RequestInit,
+    ) => {
+      if (String(input).endsWith("/v1/handover/mint")) {
+        const body = JSON.parse(String(requestInit?.body)) as {
+          assignments: Array<{ experimentId: string; variationId: string }>;
+          visitorId: string;
+        };
+        const payload = createBucketingHandoverPayload(
+          body.visitorId,
+          body.assignments,
+        );
+        return new Response(JSON.stringify({ token: `${payload}.worker-signature` }), {
+          status: 200,
+        });
+      }
+      return new Response("ok", { status: 202 });
+    }) as any;
+    const { init } = await import("./index");
+    const { parseRedirectAssignmentCarry } = await import("./redirect");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [{
+        id: "exp_redirect_signed_carry",
+        assignmentEpoch: 1,
+        experimentType: "redirect",
+        status: "running",
+        targeting: {
+          url: [{ type: "simple", pattern: "/products/*", include: true }],
+        },
+        trafficAllocation: 1,
+        variations: [{
+          id: "redirect_signed_carry_treatment",
+          weight: 1,
+          mutations: [],
+          redirectUrl: "https://landing.test/sale",
+        }],
+      }],
+      ingestSignature: "worker-issued-ingest-signature",
+      shopId: "shop_123",
+      trackingStart: "immediate",
+      userId: "visitor_signed_redirect",
+    });
+    for (let attempt = 0; attempt < 20 && replace.mock.calls.length === 0; attempt += 1) {
+      await Promise.resolve();
+    }
+
+    expect(replace).toHaveBeenCalledTimes(1);
+    expect(
+      parseRedirectAssignmentCarry(String(replace.mock.calls[0]?.[0]))
+        ?.handoverToken,
+    ).toMatch(/\.worker-signature$/);
+  });
+
+
+  it("reads and cleans a fresh redirect carry from the browser URL when config.url is canonical", async () => {
+    const { buildRedirectDestination } = await import("./redirect");
+    const assignment = {
+      experimentId: "exp_redirect_carry",
+      variationId: "redirect_treatment",
+      assignmentEpoch: 1,
+      index: 0,
+      mutations: [],
+      isControl: false,
+      hashValue: "source",
+    };
+    const destination = buildRedirectDestination(
+      "https://plain.test/products/a",
+      "https://landing.test/sale",
+      assignment,
+      "visitor_source",
+      undefined,
+      true,
+      true,
+    )!;
+    Object.assign((globalThis as any).location, {
+      hostname: "landing.test",
+      href: destination.href,
+      origin: "https://landing.test",
+      pathname: "/sale",
+      search: destination.search,
+      replace: vi.fn(),
+    });
+    const replaceState = globalThis.history.replaceState;
+    const onExperimentViewed = vi.fn();
+    globalThis.fetch = vi.fn(async (
+      input: RequestInfo | URL,
+      requestInit?: RequestInit,
+    ) => verifiedHandoverResponse(input, requestInit)
+      ?? new Response("ok", { status: 202 })) as any;
+    const { getAssignments, init } = await import("./index");
+    const { getUserId } = await import("./hash");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      url: "https://landing.test/sale",
+      shopId: "shop_123",
+      trackingStart: "immediate",
+      experiments: [{
+        id: "exp_redirect_carry",
+        assignmentEpoch: 1,
+        experimentType: "redirect",
+        status: "running",
+        targeting: { url: [{ type: "simple", pattern: "/products/*", include: true }] },
+        trafficAllocation: 1,
+        variations: [{ id: "redirect_treatment", weight: 1, mutations: [], redirectUrl: "https://landing.test/sale" }],
+      }],
+      onExperimentViewed,
+    });
+    for (let attempt = 0; attempt < 20 && getUserId() !== "visitor_source"; attempt += 1) {
+      await Promise.resolve();
+    }
+
+    expect(getUserId()).toBe("visitor_source");
+    expect(getAssignments()).toEqual([expect.objectContaining({
+      experimentId: "exp_redirect_carry",
+      variationId: "redirect_treatment",
+    })]);
+    expect(onExperimentViewed).not.toHaveBeenCalled();
+    expect(replaceState).toHaveBeenCalledWith(
+      undefined,
+      "",
+      "https://landing.test/sale",
+    );
+  });
+
+
+  it("cleans and retains a tampered redirect carry without adopting its forged identity", async () => {
+    const {
+      buildRedirectDestination,
+      REDIRECT_ASSIGNMENT_PARAM,
+      REDIRECT_ASSIGNMENT_PENDING_KEY,
+    } = await import("./redirect");
+    const destination = buildRedirectDestination(
+      "https://plain.test/products/a",
+      "https://landing.test/sale",
+      {
+        experimentId: "exp_redirect_tampered",
+        variationId: "redirect_tampered_treatment",
+        assignmentEpoch: 1,
+      },
+      "attacker_chosen_visitor",
+    )!;
+    const rawCarry = JSON.parse(
+      destination.searchParams.get(REDIRECT_ASSIGNMENT_PARAM)!,
+    ) as { handover: string };
+    rawCarry.handover = `${rawCarry.handover}.tampered-signature`;
+    destination.searchParams.set(
+      REDIRECT_ASSIGNMENT_PARAM,
+      JSON.stringify(rawCarry),
+    );
+    Object.assign((globalThis as any).location, {
+      hostname: "landing.test",
+      href: destination.href,
+      origin: destination.origin,
+      pathname: destination.pathname,
+      search: destination.search,
+      replace: vi.fn(),
+    });
+    const replaceState = globalThis.history.replaceState;
+    globalThis.fetch = vi.fn(async (input: RequestInfo | URL) => (
+      String(input).endsWith("/v1/handover/verify")
+        ? new Response("Invalid handover token", { status: 401 })
+        : new Response("ok", { status: 202 })
+    )) as any;
+    const { init } = await import("./index");
+    const { getUserId } = await import("./hash");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [{
+        id: "exp_redirect_tampered",
+        assignmentEpoch: 1,
+        experimentType: "redirect",
+        status: "running",
+        targeting: {
+          url: [{ type: "simple", pattern: "/products/*", include: true }],
+        },
+        trafficAllocation: 1,
+        variations: [{
+          id: "redirect_tampered_treatment",
+          weight: 1,
+          mutations: [],
+          redirectUrl: "https://landing.test/sale",
+        }],
+      }],
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+    for (let attempt = 0; attempt < 20 && vi.mocked(globalThis.fetch).mock.calls.length === 0; attempt += 1) {
+      await Promise.resolve();
+    }
+
+    expect(getUserId()).not.toBe("attacker_chosen_visitor");
+    expect(replaceState).toHaveBeenCalledWith(
+      undefined,
+      "",
+      "https://landing.test/sale",
+    );
+    expect(sessionStorage.getItem(REDIRECT_ASSIGNMENT_PENDING_KEY)).not.toBeNull();
+  });
+
+
+  it("keeps a persisted cross-origin redirect assignment active at its destination across reloads", async () => {
+    const redirectExperiment = {
+      id: "exp_redirect_destination_reload",
+      assignmentEpoch: 1,
+      experimentType: "redirect" as const,
+      status: "running" as const,
+      targeting: {
+        url: [{
+          type: "simple" as const,
+          pattern: "/products/*",
+          include: true,
+        }],
+      },
+      trafficAllocation: 1,
+      variations: [{
+        id: "redirect_destination_reload_treatment",
+        weight: 1,
+        mutations: [{
+          selector: "#source-only-title",
+          action: "text" as const,
+          text: "Source treatment",
+        }],
+        css: "#source-only-title{color:red}",
+        js: "window.__sourceOnlyRedirectJs=(window.__sourceOnlyRedirectJs||0)+1;",
+        redirectUrl: "https://landing.test/products/destination",
+      }],
+    };
+    const sourceReplace = vi.fn();
+    Object.assign((globalThis as any).location, {
+      hostname: "plain.test",
+      href: "https://plain.test/products/source",
+      origin: "https://plain.test",
+      pathname: "/products/source",
+      search: "",
+      replace: sourceReplace,
+    });
+    const { createBucketingHandoverPayload } = await import("./handover");
+    globalThis.fetch = vi.fn(async (
+      input: RequestInfo | URL,
+      requestInit?: RequestInit,
+    ) => {
+      if (String(input).endsWith("/v1/handover/mint")) {
+        const body = JSON.parse(String(requestInit?.body)) as {
+          assignments: Array<{ experimentId: string; variationId: string }>;
+          visitorId: string;
+        };
+        const payload = createBucketingHandoverPayload(
+          body.visitorId,
+          body.assignments,
+        );
+        return Response.json({ token: `${payload}.worker-signature` });
+      }
+      return new Response("ok", { status: 202 });
+    }) as any;
+    const sourceRuntime = await import("./index");
+
+    sourceRuntime.init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [redirectExperiment],
+      ingestSignature: "worker-issued-ingest-signature",
+      shopId: "shop_123",
+      storeOrigin: "https://plain.test",
+      trackingStart: "immediate",
+      userId: "visitor_destination_reload",
+    });
+    for (
+      let attempt = 0;
+      attempt < 20 && sourceReplace.mock.calls.length === 0;
+      attempt += 1
+    ) {
+      await Promise.resolve();
+    }
+
+    expect(sourceReplace).toHaveBeenCalledTimes(1);
+    const destination = new URL(String(sourceReplace.mock.calls[0]?.[0]));
+    expect(destination.searchParams.has("_apex_assignment")).toBe(true);
+    const { parseRedirectAssignmentCarry } = await import("./redirect");
+    expect(parseRedirectAssignmentCarry(destination.href)).toMatchObject({
+      exposureSent: true,
+    });
+
+    // Browser storage is origin-scoped. The destination starts empty and
+    // receives its first assignment only through the redirect carry.
+    (globalThis as any).localStorage = makeStorage();
+    (globalThis as any).sessionStorage = makeStorage();
+    vi.clearAllTimers();
+    vi.resetModules();
+    delete (globalThis as any).__drip;
+    const firstDestinationReplace = vi.fn();
+    const firstDestinationExposure = vi.fn();
+    const destinationTitle = { textContent: "Destination headline" };
+    const destinationStyles: Array<Record<string, any>> = [];
+    (globalThis as any).document.createElement = vi.fn((tag: string) => ({
+      id: "",
+      className: "",
+      remove: vi.fn(),
+      tagName: tag.toUpperCase(),
+      textContent: "",
+    }));
+    (globalThis as any).document.querySelectorAll = vi.fn((selector: string) => (
+      selector === "#source-only-title" ? [destinationTitle] : []
+    ));
+    (globalThis as any).document.getElementById = vi.fn((id: string) => (
+      destinationStyles.find((element) => element.id === id) ?? null
+    ));
+    (globalThis as any).document.head.appendChild = vi.fn((element: Record<string, any>) => {
+      destinationStyles.push(element);
+      return element;
+    });
+    Object.assign((globalThis as any).location, {
+      hostname: "landing.test",
+      href: destination.href,
+      origin: destination.origin,
+      pathname: destination.pathname,
+      search: destination.search,
+      replace: firstDestinationReplace,
+    });
+    globalThis.fetch = vi.fn(async (
+      input: RequestInfo | URL,
+      requestInit?: RequestInit,
+    ) => verifiedHandoverResponse(input, requestInit)
+      ?? new Response("ok", { status: 202 })) as any;
+    const firstDestinationRuntime = await import("./index");
+
+    firstDestinationRuntime.init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [redirectExperiment],
+      onExperimentViewed: firstDestinationExposure,
+      shopId: "shop_123",
+      storeOrigin: "https://plain.test",
+      trackingStart: "immediate",
+    });
+    for (
+      let attempt = 0;
+      attempt < 20 && firstDestinationRuntime.getAssignments().length === 0;
+      attempt += 1
+    ) {
+      await Promise.resolve();
+    }
+
+    expect(firstDestinationRuntime.getAssignments()).toEqual([
+      expect.objectContaining({
+        experimentId: redirectExperiment.id,
+        variationId: "redirect_destination_reload_treatment",
+      }),
+    ]);
+    expect(firstDestinationReplace).not.toHaveBeenCalled();
+    expect(firstDestinationExposure).not.toHaveBeenCalled();
+    expect(destinationTitle.textContent).toBe("Destination headline");
+    expect((globalThis as any).window.__sourceOnlyRedirectJs).toBeUndefined();
+    expect(destinationStyles).toHaveLength(0);
+
+    vi.clearAllTimers();
+    vi.resetModules();
+    delete (globalThis as any).__drip;
+    const reloadReplace = vi.fn();
+    const reloadExposure = vi.fn();
+    Object.assign((globalThis as any).location, {
+      hostname: "landing.test",
+      href: "https://landing.test/products/destination",
+      origin: "https://landing.test",
+      pathname: "/products/destination",
+      search: "",
+      replace: reloadReplace,
+    });
+    const reloadRuntime = await import("./index");
+
+    reloadRuntime.init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [redirectExperiment],
+      onExperimentViewed: reloadExposure,
+      shopId: "shop_123",
+      storeOrigin: "https://plain.test",
+      trackingStart: "immediate",
+    });
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(reloadRuntime.getAssignments()).toEqual([
+      expect.objectContaining({
+        experimentId: redirectExperiment.id,
+        variationId: "redirect_destination_reload_treatment",
+      }),
+    ]);
+    expect(reloadReplace).not.toHaveBeenCalled();
+    expect(reloadExposure).not.toHaveBeenCalled();
+    expect(
+      reloadRuntime.getDiagnostics().activation.experiments[0]?.reason,
+    ).toBe("persisted_assignment_off_target");
+    expect(destinationTitle.textContent).toBe("Destination headline");
+    expect((globalThis as any).window.__sourceOnlyRedirectJs).toBeUndefined();
+    expect(destinationStyles).toHaveLength(0);
+  });
+
+
+  it("emits the first redirect exposure on the destination when the source tracking rule rejects", async () => {
+    const redirectExperiment = {
+      id: "exp_redirect_tracking_handover",
+      assignmentEpoch: 1,
+      experimentType: "redirect" as const,
+      status: "running" as const,
+      targeting: {
+        url: [{
+          type: "simple" as const,
+          pattern: "https://plain.test/products/*",
+          include: true,
+        }],
+      },
+      trafficAllocation: 1,
+      variations: [{
+        id: "redirect_tracking_handover_treatment",
+        weight: 1,
+        mutations: [],
+        redirectUrl: "https://landing.test/sale",
+      }],
+    };
+    const sourceReplace = vi.fn();
+    const sourceExposure = vi.fn();
+    Object.assign((globalThis as any).location, {
+      hostname: "plain.test",
+      href: "https://plain.test/products/source",
+      origin: "https://plain.test",
+      pathname: "/products/source",
+      search: "",
+      replace: sourceReplace,
+    });
+    const { createBucketingHandoverPayload } = await import("./handover");
+    globalThis.fetch = vi.fn(async (
+      input: RequestInfo | URL,
+      requestInit?: RequestInit,
+    ) => {
+      if (String(input).endsWith("/v1/handover/mint")) {
+        const body = JSON.parse(String(requestInit?.body)) as {
+          assignments: Array<{ experimentId: string; variationId: string }>;
+          visitorId: string;
+        };
+        const payload = createBucketingHandoverPayload(
+          body.visitorId,
+          body.assignments,
+        );
+        return Response.json({ token: `${payload}.worker-signature` });
+      }
+      return new Response("ok", { status: 202 });
+    }) as any;
+    const sourceRuntime = await import("./index");
+
+    sourceRuntime.init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [redirectExperiment],
+      ingestSignature: "worker-issued-ingest-signature",
+      onExperimentViewed: sourceExposure,
+      projectPrerequisites: {
+        startTrackingRule: "return context.url.startsWith('https://landing.test/');",
+      },
+      shopId: "shop_123",
+      trackingStart: "immediate",
+      userId: "visitor_tracking_handover",
+    });
+    for (
+      let attempt = 0;
+      attempt < 20 && sourceReplace.mock.calls.length === 0;
+      attempt += 1
+    ) {
+      await Promise.resolve();
+    }
+
+    expect(sourceReplace).toHaveBeenCalledTimes(1);
+    expect(sourceExposure).not.toHaveBeenCalled();
+    const destination = new URL(String(sourceReplace.mock.calls[0]?.[0]));
+    const { parseRedirectAssignmentCarry } = await import("./redirect");
+    expect(parseRedirectAssignmentCarry(destination.href)).toMatchObject({
+      exposureSent: false,
+      handoverToken: expect.any(String),
+    });
+
+    // Browser storage is origin-scoped. Only the carry links this destination
+    // to the source assignment and its not-yet-exposed state.
+    (globalThis as any).localStorage = makeStorage();
+    (globalThis as any).sessionStorage = makeStorage();
+    vi.clearAllTimers();
+    vi.resetModules();
+    delete (globalThis as any).__drip;
+    const destinationReplace = vi.fn();
+    const destinationExposure = vi.fn();
+    Object.assign((globalThis as any).location, {
+      hostname: "landing.test",
+      href: destination.href,
+      origin: destination.origin,
+      pathname: destination.pathname,
+      search: destination.search,
+      replace: destinationReplace,
+    });
+    globalThis.fetch = vi.fn(async (
+      input: RequestInfo | URL,
+      requestInit?: RequestInit,
+    ) => verifiedHandoverResponse(input, requestInit)
+      ?? new Response("ok", { status: 202 })) as any;
+    const destinationRuntime = await import("./index");
+
+    destinationRuntime.init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [redirectExperiment],
+      onExperimentViewed: destinationExposure,
+      projectPrerequisites: {
+        startTrackingRule: "return context.url.startsWith('https://landing.test/');",
+      },
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+    for (
+      let attempt = 0;
+      attempt < 20 && destinationExposure.mock.calls.length === 0;
+      attempt += 1
+    ) {
+      await Promise.resolve();
+    }
+    await destinationRuntime.flush();
+
+    expect(destinationReplace).not.toHaveBeenCalled();
+    expect(destinationExposure).toHaveBeenCalledTimes(1);
+    const exposureEvents = vi.mocked(globalThis.fetch).mock.calls.flatMap((call) => {
+      if (call[0] !== "https://events.test/v1/events") return [];
+      return JSON.parse(String(call[1]?.body)).events.filter(
+        (event: { type: string; experimentId?: string }) =>
+          event.type === "experiment_viewed" &&
+          event.experimentId === redirectExperiment.id,
+      );
+    });
+    expect(exposureEvents).toHaveLength(1);
+  });
+
+
+  it("retains a redirect carry from cached init until the fresh network config can import it", async () => {
+    const { buildRedirectDestination } = await import("./redirect");
+    const redirectExperiment = {
+      id: "exp_redirect_refresh",
+      assignmentEpoch: 2,
+      experimentType: "redirect" as const,
+      status: "running" as const,
+      targeting: { url: [{ type: "simple" as const, pattern: "/products/*", include: true }] },
+      trafficAllocation: 1,
+      variations: [{
+        id: "redirect_refresh_treatment",
+        weight: 1,
+        mutations: [],
+        redirectUrl: "https://landing.test/sale",
+      }],
+    };
+    const destination = buildRedirectDestination(
+      "https://plain.test/products/a",
+      "https://landing.test/sale",
+      {
+        experimentId: redirectExperiment.id,
+        variationId: "redirect_refresh_treatment",
+        assignmentEpoch: 2,
+      },
+      "visitor_from_source",
+    )!;
+    Object.assign((globalThis as any).location, {
+      hostname: "landing.test",
+      href: destination.href,
+      origin: "https://landing.test",
+      pathname: "/sale",
+      search: destination.search,
+      replace: vi.fn(),
+    });
+    localStorage.setItem("drip_cfg:shop_123:production", JSON.stringify({
+      fetchedAt: Date.now(),
+      hash: "cached-before-redirect",
+      experiments: [],
+    }));
+    globalThis.fetch = vi.fn(async (
+      input: RequestInfo | URL,
+      requestInit?: RequestInit,
+    ) => verifiedHandoverResponse(input, requestInit)
+      ?? (String(input).includes("/config")
+        ? new Response(JSON.stringify({ experiments: [redirectExperiment] }), { status: 200 })
+        : new Response("ok", { status: 202 }))) as any;
+    const replaceState = globalThis.history.replaceState;
+    const { getAssignments, getDiagnostics, init } = await import("./index");
+    const { getUserId } = await import("./hash");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      lateConfigPolicy: "apply",
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+
+    expect(replaceState).toHaveBeenCalledWith(
+      undefined,
+      "",
+      "https://landing.test/sale",
+    );
+    for (let attempt = 0; attempt < 20 && getDiagnostics().configSource !== "network"; attempt += 1) {
+      await Promise.resolve();
+    }
+    expect(getDiagnostics().configSource).toBe("network");
+    expect(getUserId()).toBe("visitor_from_source");
+    expect(getAssignments()).toEqual([expect.objectContaining({
+      experimentId: "exp_redirect_refresh",
+      variationId: "redirect_refresh_treatment",
+    })]);
+  });
+
+
+  it("recovers a pending redirect carry after config retries are exhausted", async () => {
+    vi.setSystemTime(new Date("2026-07-27T10:00:00Z"));
+    const {
+      buildRedirectDestination,
+      REDIRECT_ASSIGNMENT_PENDING_KEY,
+    } = await import("./redirect");
+    const redirectExperiment = {
+      id: "exp_redirect_retry_recovery",
+      assignmentEpoch: 1,
+      experimentType: "redirect" as const,
+      status: "running" as const,
+      targeting: {
+        url: [{
+          type: "simple" as const,
+          pattern: "/products/*",
+          include: true,
+        }],
+      },
+      trafficAllocation: 1,
+      variations: [{
+        id: "redirect_retry_recovery_treatment",
+        weight: 1,
+        mutations: [],
+        redirectUrl: "https://landing.test/sale",
+      }],
+    };
+    const destination = buildRedirectDestination(
+      "https://plain.test/products/source",
+      "https://landing.test/sale",
+      {
+        experimentId: redirectExperiment.id,
+        variationId: "redirect_retry_recovery_treatment",
+        assignmentEpoch: 1,
+      },
+      "visitor_retry_recovery",
+    )!;
+    Object.assign((globalThis as any).location, {
+      hostname: "landing.test",
+      href: destination.href,
+      origin: "https://landing.test",
+      pathname: "/sale",
+      search: destination.search,
+      replace: vi.fn(),
+    });
+    const configFailure = new Error("config unavailable");
+    globalThis.fetch = vi.fn((input: RequestInfo | URL) => (
+      String(input).includes("/config")
+        ? Promise.reject(configFailure)
+        : Promise.resolve(new Response("ok", { status: 202 }))
+    )) as any;
+    vi.spyOn(console, "error").mockImplementation(() => {});
+    const failedRuntime = await import("./index");
+
+    failedRuntime.init({
+      antiFlickerMode: "off",
+      configCache: false,
+      endpoint: "https://events.test",
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+    await vi.advanceTimersByTimeAsync(1_600);
+
+    expect(vi.mocked(globalThis.fetch).mock.calls.filter(
+      ([input]) => String(input).includes("/config"),
+    )).toHaveLength(3);
+    expect(sessionStorage.getItem(REDIRECT_ASSIGNMENT_PENDING_KEY)).not.toBeNull();
+    const pendingRecord = JSON.parse(
+      sessionStorage.getItem(REDIRECT_ASSIGNMENT_PENDING_KEY)!,
+    ) as { expiresAt: number };
+    expect(pendingRecord).toEqual(
+      expect.objectContaining({
+        assignmentEpoch: 1,
+        experimentId: redirectExperiment.id,
+        expiresAt: expect.any(Number),
+        handoverToken: expect.any(String),
+        variationId: "redirect_retry_recovery_treatment",
+      }),
+    );
+
+    vi.clearAllTimers();
+    vi.setSystemTime(new Date("2026-07-27T10:00:01.600Z"));
+    vi.resetModules();
+    delete (globalThis as any).__drip;
+    Object.assign((globalThis as any).location, {
+      href: "https://landing.test/sale",
+      search: "",
+      replace: vi.fn(),
+    });
+    globalThis.fetch = vi.fn(async (
+      input: RequestInfo | URL,
+      requestInit?: RequestInit,
+    ) => verifiedHandoverResponse(input, requestInit)
+      ?? (String(input).includes("/config")
+        ? new Response(
+            JSON.stringify({ experiments: [redirectExperiment] }),
+            { status: 200 },
+          )
+        : new Response("ok", { status: 202 }))) as any;
+    expect(Date.now()).toBeLessThan(pendingRecord.expiresAt);
+    expect(pendingRecord.expiresAt - Date.now()).toBeLessThanOrEqual(10 * 60 * 1000);
+    expect(sessionStorage.getItem(REDIRECT_ASSIGNMENT_PENDING_KEY)).not.toBeNull();
+    const pendingCarryRuntime = await import("./redirect");
+    expect(pendingCarryRuntime.readPendingRedirectAssignmentCarry()).toEqual(
+      expect.objectContaining({
+        experimentId: redirectExperiment.id,
+        handoverToken: expect.any(String),
+      }),
+    );
+    const recoveredRuntime = await import("./index");
+    const { getUserId } = await import("./hash");
+
+    recoveredRuntime.init({
+      antiFlickerMode: "off",
+      configCache: false,
+      endpoint: "https://events.test",
+      lateConfigPolicy: "apply",
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+    for (
+      let attempt = 0;
+      attempt < 20 && recoveredRuntime.getDiagnostics().configSource !== "network";
+      attempt += 1
+    ) {
+      await Promise.resolve();
+    }
+
+    expect(recoveredRuntime.getDiagnostics().configSource).toBe("network");
+    expect(getUserId()).toBe("visitor_retry_recovery");
+    expect(recoveredRuntime.getAssignments()).toEqual([
+      expect.objectContaining({
+        experimentId: redirectExperiment.id,
+        variationId: "redirect_retry_recovery_treatment",
+      }),
+    ]);
+    expect(sessionStorage.getItem(REDIRECT_ASSIGNMENT_PENDING_KEY)).toBeNull();
+  });
+
+
+  it("expires a pending redirect carry after its bounded handover TTL", async () => {
+    vi.setSystemTime(new Date("2026-07-27T10:00:00Z"));
+    const {
+      buildRedirectDestination,
+      REDIRECT_ASSIGNMENT_PENDING_KEY,
+    } = await import("./redirect");
+    const redirectExperiment = {
+      id: "exp_redirect_pending_expiry",
+      assignmentEpoch: 1,
+      experimentType: "redirect" as const,
+      status: "running" as const,
+      targeting: {
+        url: [{
+          type: "simple" as const,
+          pattern: "/products/*",
+          include: true,
+        }],
+      },
+      trafficAllocation: 1,
+      variations: [{
+        id: "redirect_pending_expiry_treatment",
+        weight: 1,
+        mutations: [],
+        redirectUrl: "https://landing.test/sale",
+      }],
+    };
+    const destination = buildRedirectDestination(
+      "https://plain.test/products/source",
+      "https://landing.test/sale",
+      {
+        experimentId: redirectExperiment.id,
+        variationId: "redirect_pending_expiry_treatment",
+        assignmentEpoch: 1,
+      },
+      "visitor_pending_expiry",
+      { handoverTtlSeconds: 120 },
+    )!;
+    Object.assign((globalThis as any).location, {
+      hostname: "landing.test",
+      href: destination.href,
+      origin: "https://landing.test",
+      pathname: "/sale",
+      search: destination.search,
+      replace: vi.fn(),
+    });
+    globalThis.fetch = vi.fn((input: RequestInfo | URL) => (
+      String(input).includes("/config")
+        ? Promise.reject(new Error("config unavailable"))
+        : Promise.resolve(new Response("ok", { status: 202 }))
+    )) as any;
+    vi.spyOn(console, "error").mockImplementation(() => {});
+    const failedRuntime = await import("./index");
+
+    failedRuntime.init({
+      antiFlickerMode: "off",
+      configCache: false,
+      endpoint: "https://events.test",
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+    await vi.advanceTimersByTimeAsync(1_600);
+    expect(sessionStorage.getItem(REDIRECT_ASSIGNMENT_PENDING_KEY)).not.toBeNull();
+
+    vi.clearAllTimers();
+    vi.setSystemTime(new Date("2026-07-27T10:02:01Z"));
+    vi.resetModules();
+    delete (globalThis as any).__drip;
+    Object.assign((globalThis as any).location, {
+      href: "https://landing.test/sale",
+      search: "",
+      replace: vi.fn(),
+    });
+    globalThis.fetch = vi.fn(async (input: RequestInfo | URL) => (
+      String(input).includes("/config")
+        ? new Response(
+            JSON.stringify({ experiments: [redirectExperiment] }),
+            { status: 200 },
+          )
+        : new Response("ok", { status: 202 })
+    )) as any;
+    const reloadedRuntime = await import("./index");
+    const { getUserId } = await import("./hash");
+
+    reloadedRuntime.init({
+      antiFlickerMode: "off",
+      configCache: false,
+      endpoint: "https://events.test",
+      lateConfigPolicy: "apply",
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+    for (
+      let attempt = 0;
+      attempt < 20 && reloadedRuntime.getDiagnostics().configSource !== "network";
+      attempt += 1
+    ) {
+      await Promise.resolve();
+    }
+
+    expect(reloadedRuntime.getDiagnostics().configSource).toBe("network");
+    expect(getUserId()).not.toBe("visitor_pending_expiry");
+    expect(reloadedRuntime.getAssignments()).toEqual([]);
+    expect(sessionStorage.getItem(REDIRECT_ASSIGNMENT_PENDING_KEY)).toBeNull();
+  });
+
+
+  it("discards an epoch-stale redirect carry after the fresh config has its chance", async () => {
+    const { buildRedirectDestination } = await import("./redirect");
+    const destination = buildRedirectDestination(
+      "https://plain.test/products/a",
+      "https://landing.test/sale",
+      {
+        experimentId: "exp_redirect_stale_refresh",
+        variationId: "redirect_stale_treatment",
+        assignmentEpoch: 1,
+      },
+      "visitor_from_source",
+    )!;
+    Object.assign((globalThis as any).location, {
+      hostname: "landing.test",
+      href: destination.href,
+      origin: "https://landing.test",
+      pathname: "/sale",
+      search: destination.search,
+      replace: vi.fn(),
+    });
+    localStorage.setItem("drip_cfg:shop_123:production", JSON.stringify({
+      fetchedAt: Date.now(),
+      hash: "cached-before-redirect-epoch",
+      experiments: [],
+    }));
+    globalThis.fetch = vi.fn(async (
+      input: RequestInfo | URL,
+      requestInit?: RequestInit,
+    ) => verifiedHandoverResponse(input, requestInit)
+      ?? (String(input).includes("/config")
+        ? new Response(JSON.stringify({
+            experiments: [{
+              id: "exp_redirect_stale_refresh",
+              assignmentEpoch: 2,
+              experimentType: "redirect",
+              status: "running",
+              targeting: { url: [{ type: "simple", pattern: "/products/*", include: true }] },
+              trafficAllocation: 1,
+              variations: [{
+                id: "redirect_stale_treatment",
+                weight: 1,
+                mutations: [],
+                redirectUrl: "https://landing.test/sale",
+              }],
+            }],
+          }), { status: 200 })
+        : new Response("ok", { status: 202 }))) as any;
+    const replaceState = globalThis.history.replaceState;
+    const { getAssignments, getDiagnostics, init } = await import("./index");
+    const { getUserId } = await import("./hash");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      lateConfigPolicy: "apply",
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+
+    expect(replaceState).toHaveBeenCalledWith(
+      undefined,
+      "",
+      "https://landing.test/sale",
+    );
+    for (let attempt = 0; attempt < 20 && getDiagnostics().configSource !== "network"; attempt += 1) {
+      await Promise.resolve();
+    }
+    expect(getDiagnostics().configSource).toBe("network");
+    expect(getUserId()).not.toBe("visitor_from_source");
+    expect(getAssignments()).toEqual([]);
+  });
+
+
+  it("honors a same-origin sticky redirect assignment when only its source URL gate fails", async () => {
+    const redirectExperiment = {
+      id: "exp_redirect_same_origin_url_only",
+      assignmentEpoch: 1,
+      experimentType: "redirect" as const,
+      status: "running" as const,
+      targeting: {
+        url: [{
+          type: "simple" as const,
+          pattern: "/products/source",
+          include: true,
+        }],
+      },
+      trafficAllocation: 1,
+      variations: [{
+        id: "redirect_same_origin_url_only_treatment",
+        weight: 1,
+        mutations: [],
+        redirectUrl: "https://plain.test/sale",
+      }],
+    };
+    const sourceReplace = vi.fn();
+    Object.assign((globalThis as any).location, {
+      hostname: "plain.test",
+      href: "https://plain.test/products/source",
+      origin: "https://plain.test",
+      pathname: "/products/source",
+      search: "",
+      replace: sourceReplace,
+    });
+    const sourceRuntime = await import("./index");
+
+    sourceRuntime.init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [redirectExperiment],
+      shopId: "shop_123",
+      trackingStart: "immediate",
+      userId: "visitor_same_origin_url_only",
+    });
+
+    expect(sourceReplace).toHaveBeenCalledTimes(1);
+    const destination = new URL(String(sourceReplace.mock.calls[0]?.[0]));
+    expect(destination.href).toBe("https://plain.test/sale");
+    expect(destination.searchParams.has("_apex_assignment")).toBe(false);
+    expect(
+      JSON.parse(localStorage.getItem("drip_assignments_v1") ?? "{}"),
+    ).toHaveProperty(
+      redirectExperiment.id,
+      expect.arrayContaining(["redirect_same_origin_url_only_treatment"]),
+    );
+
+    vi.clearAllTimers();
+    vi.resetModules();
+    delete (globalThis as any).__drip;
+    const destinationReplace = vi.fn();
+    Object.assign((globalThis as any).location, {
+      hostname: "plain.test",
+      href: destination.href,
+      origin: destination.origin,
+      pathname: destination.pathname,
+      search: destination.search,
+      replace: destinationReplace,
+    });
+    const destinationRuntime = await import("./index");
+
+    destinationRuntime.init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [redirectExperiment],
+      shopId: "shop_123",
+      trackingStart: "immediate",
+      userId: "visitor_same_origin_url_only",
+    });
+
+    expect(destinationRuntime.getAssignments()).toEqual([
+      expect.objectContaining({
+        experimentId: redirectExperiment.id,
+        variationId: "redirect_same_origin_url_only_treatment",
+      }),
+    ]);
+    expect(destinationReplace).not.toHaveBeenCalled();
+  });
+
+
+  it("does not honor a sticky redirect assignment when its segment gate fails", async () => {
+    const redirectExperiment = {
+      id: "exp_redirect_same_origin_segment",
+      assignmentEpoch: 1,
+      experimentType: "redirect" as const,
+      status: "running" as const,
+      targeting: {
+        url: [{
+          type: "simple" as const,
+          pattern: "/products/source",
+          include: true,
+        }],
+        segmentRules: [{
+          id: "vip-segment",
+          rules: {
+            version: 1 as const,
+            operator: "and" as const,
+            conditions: [{
+              signal: "customer.tier",
+              operator: "equals" as const,
+              value: "vip",
+            }],
+          },
+        }],
+      },
+      trafficAllocation: 1,
+      variations: [{
+        id: "redirect_same_origin_segment_treatment",
+        weight: 1,
+        mutations: [],
+        redirectUrl: "https://plain.test/sale",
+      }],
+    };
+    localStorage.setItem(
+      "drip_assignments_v1",
+      JSON.stringify({
+        [redirectExperiment.id]: [
+          "redirect_same_origin_segment_treatment",
+          1,
+          Date.now(),
+        ],
+      }),
+    );
+    Object.assign((globalThis as any).location, {
+      hostname: "plain.test",
+      href: "https://plain.test/products/source",
+      origin: "https://plain.test",
+      pathname: "/products/source",
+      search: "",
+      replace: vi.fn(),
+    });
+    const removeHideStyle = vi.fn();
+    vi.mocked(document.getElementById).mockImplementation((id: string) => (
+      id === "drip-hide" ? { remove: removeHideStyle } as any : null
+    ));
+    const { getAssignments, getDiagnostics, init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      attributes: { "customer.tier": "standard" },
+      endpoint: "https://events.test",
+      experiments: [redirectExperiment],
+      shopId: "shop_123",
+      trackingStart: "immediate",
+      userId: "visitor_same_origin_segment",
+    });
+
+    expect(getAssignments()).toEqual([]);
+    expect(getDiagnostics().activation.experiments[0]).toMatchObject({
+      experimentId: redirectExperiment.id,
+      status: "failed",
+      reason: "segment_mismatch",
+    });
+    expect(removeHideStyle).toHaveBeenCalledTimes(1);
+  });
+
+
+  it("honors a verified carry-imported redirect assignment without destination audience rechecks", async () => {
+    const { buildRedirectDestination } = await import("./redirect");
+    const redirectExperiment = {
+      id: "exp_redirect_source_signal",
+      assignmentEpoch: 1,
+      experimentType: "redirect" as const,
+      status: "running" as const,
+      targeting: {
+        url: [{ type: "simple" as const, pattern: "/products/*", include: true }],
+        attributes: [{
+          attribute: "customer.tier",
+          operator: "equals" as const,
+          value: "vip",
+        }],
+        segmentRules: [{
+          id: "source-host-audience",
+          rules: {
+            version: 1 as const,
+            operator: "and" as const,
+            conditions: [{
+              signal: "url.full",
+              operator: "contains" as const,
+              value: "plain.test",
+            }],
+          },
+        }],
+      },
+      trafficAllocation: 1,
+      variations: [{
+        id: "redirect_source_signal_treatment",
+        weight: 1,
+        mutations: [],
+        redirectUrl: "https://landing.test/sale",
+      }],
+    };
+    const destination = buildRedirectDestination(
+      "https://plain.test/products/a",
+      "https://landing.test/sale",
+      {
+        experimentId: redirectExperiment.id,
+        variationId: "redirect_source_signal_treatment",
+        assignmentEpoch: 1,
+      },
+      "visitor_source_signal",
+    )!;
+    Object.assign((globalThis as any).location, {
+      hostname: "landing.test",
+      href: destination.href,
+      origin: "https://landing.test",
+      pathname: "/sale",
+      search: destination.search,
+      replace: vi.fn(),
+    });
+    globalThis.fetch = vi.fn(async (
+      input: RequestInfo | URL,
+      requestInit?: RequestInit,
+    ) => verifiedHandoverResponse(input, requestInit)
+      ?? new Response("ok", { status: 202 })) as any;
+    const { getAssignments, getDiagnostics, init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      attributes: { "customer.tier": "standard" },
+      endpoint: "https://events.test",
+      experiments: [redirectExperiment],
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+    for (let attempt = 0; attempt < 20 && getAssignments().length === 0; attempt += 1) {
+      await Promise.resolve();
+    }
+
+    expect(getAssignments()).toEqual([
+      expect.objectContaining({
+        experimentId: redirectExperiment.id,
+        variationId: "redirect_source_signal_treatment",
+      }),
+    ]);
+    expect(getDiagnostics().activation.experiments[0]).toMatchObject({
+      experimentId: redirectExperiment.id,
+      status: "passed",
+      reason: "persisted_assignment_off_target",
+    });
+    expect(
+      getDiagnostics().activation.experiments[0].gates.some(
+        (gate) => gate.id === "page" || gate.id === "audience",
+      ),
+    ).toBe(false);
+  });
+});