@drip-apex/sdk 0.1.0 → 0.2.0

package/src/init-integrations.test.ts

@@ -0,0 +1,846 @@
+import { describe, expect, it, vi } from "vitest";
+import {
+  RECENT_MONDAY_NOON, documentListeners, windowListeners, appendedAntiFlickerStyle, configPayloadHash, flushDynamicImports, installCookieJar, installMutationObserverStub, makeClassList, makeStorage, readCookieValue, readDecodedDripContext, registerInitTestLifecycle, verifiedHandoverResponse,
+} from "./init-test-helpers";
+
+describe("init integrations", () => {
+  registerInitTestLifecycle();
+
+
+  it("emits exposure destinations for dataLayer, Hotjar, and generic queues", async () => {
+    const hj = vi.fn();
+    (globalThis as any).window.hj = hj;
+    (globalThis as any).window.dataLayer = [];
+    (globalThis as any).window.adbq = [];
+    (globalThis as any).hj = hj;
+    (globalThis as any).adbq = (globalThis as any).window.adbq;
+
+    const { getDiagnostics, init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [
+        {
+          id: "exp_exposure",
+          status: "running",
+          trafficAllocation: 1,
+          variations: [{ id: "var_exposure", weight: 1, mutations: [] }],
+        },
+      ],
+      exposureDestinations: {
+        dataLayer: { enabled: true, eventName: "apex_test_viewed" },
+        hotjar: { enabled: true, mode: "event", eventName: "apex_test_viewed" },
+        queues: [{ enabled: true, globalName: "adbq", eventName: "Viewed an experiment" }],
+      },
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+
+    expect((globalThis as any).window.dataLayer).toEqual(expect.arrayContaining([
+      expect.objectContaining({ event: "apex_test_viewed", experiment_id: "exp_exposure", variation_id: "var_exposure" }),
+    ]));
+    expect(hj).toHaveBeenCalledWith("event", "apex_test_viewed");
+    expect((globalThis as any).window.adbq).toEqual(expect.arrayContaining([
+      expect.objectContaining({ event: "Viewed an experiment", experiment_id: "exp_exposure", variation_id: "var_exposure" }),
+    ]));
+    expect(getDiagnostics().integrations.exposureDestinations.map((item) => item.status)).toContain("sent");
+  });
+
+
+  it("sets Clarity experiment tags for variants and controls", async () => {
+    const clarity = vi.fn();
+    (globalThis as any).window.clarity = clarity;
+
+    const { init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [
+        {
+          id: "exp_clarity_variant",
+          name: "Homepage hero",
+          status: "running",
+          trafficAllocation: 1,
+          variations: [
+            { id: "var_clarity_control", weight: 0, mutations: [], isControl: true },
+            { id: "var_clarity_treatment", weight: 1, mutations: [] },
+          ],
+        },
+        {
+          id: "exp_clarity_control",
+          name: "Product detail",
+          status: "running",
+          trafficAllocation: 1,
+          variations: [
+            { id: "var_clarity_only_control", weight: 1, mutations: [], isControl: true },
+          ],
+        },
+      ],
+      exposureDestinations: {
+        clarity: { enabled: true, mode: "set" },
+      },
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+
+    expect(clarity).toHaveBeenCalledWith("set", "apex Homepage hero", "variant-1");
+    expect(clarity).toHaveBeenCalledWith("set", "apex Product detail", "control");
+  });
+
+
+  it("records a Clarity diagnostic without throwing when Clarity is absent", async () => {
+    const { getDiagnostics, init } = await import("./index");
+
+    expect(() => init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [
+        {
+          id: "exp_clarity_absent",
+          status: "running",
+          trafficAllocation: 1,
+          variations: [{ id: "var_clarity_absent", weight: 1, mutations: [] }],
+        },
+      ],
+      exposureDestinations: {
+        clarity: { enabled: true },
+      },
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    })).not.toThrow();
+
+    expect(getDiagnostics().integrations.exposureDestinations).toEqual(expect.arrayContaining([
+      expect.objectContaining({ type: "clarity", status: "failed", reason: "clarity_missing" }),
+    ]));
+  });
+
+
+  it("fires Clarity set and event calls while upgrading only once per page", async () => {
+    const clarity = vi.fn();
+    (globalThis as any).window.clarity = clarity;
+
+    const { init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [
+        {
+          id: "exp_clarity_one",
+          name: "First test",
+          status: "running",
+          trafficAllocation: 1,
+          variations: [{ id: "var_clarity_one", weight: 1, mutations: [] }],
+        },
+        {
+          id: "exp_clarity_two",
+          name: "Second test",
+          status: "running",
+          trafficAllocation: 1,
+          variations: [{ id: "var_clarity_two", weight: 1, mutations: [] }],
+        },
+      ],
+      exposureDestinations: {
+        clarity: {
+          enabled: true,
+          mode: "both",
+          eventName: "apex_exposure",
+          upgrade: true,
+        },
+      },
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+
+    expect(clarity.mock.calls.filter(([command]) => command === "set")).toHaveLength(2);
+    expect(clarity.mock.calls.filter(([command]) => command === "event")).toEqual([
+      ["event", "apex_exposure"],
+      ["event", "apex_exposure"],
+    ]);
+    expect(clarity.mock.calls.filter(([command]) => command === "upgrade")).toEqual([
+      ["upgrade", "apex_experiment"],
+    ]);
+  });
+
+
+  it("sanitizes and truncates Clarity custom tag keys", async () => {
+    const clarity = vi.fn();
+    (globalThis as any).window.clarity = clarity;
+    const longName = `Checkout 🚀 100% ${"A".repeat(100)}`;
+
+    const { init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [
+        {
+          id: "exp_clarity_sanitize",
+          name: longName,
+          status: "running",
+          trafficAllocation: 1,
+          variations: [{ id: "var_clarity_sanitize", weight: 1, mutations: [] }],
+        },
+      ],
+      exposureDestinations: {
+        clarity: { enabled: true },
+      },
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+
+    const setCall = clarity.mock.calls.find(([command]) => command === "set");
+    expect(setCall).toBeDefined();
+    expect(setCall?.[1]).toHaveLength(80);
+    expect(setCall?.[1]).toMatch(/^apex Checkout 100 A+$/);
+    expect(setCall?.[2]).toBe("variant-0");
+  });
+
+
+  it("creates the Contentsquare queue and pushes a dynamic variable", async () => {
+    const { init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [
+        {
+          id: "exp_contentsquare",
+          name: "Collection banner",
+          status: "running",
+          trafficAllocation: 1,
+          variations: [{ id: "var_contentsquare", weight: 1, mutations: [] }],
+        },
+      ],
+      exposureDestinations: {
+        contentsquare: { enabled: true },
+      },
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+
+    expect((globalThis as any).window._uxa).toEqual([
+      ["trackDynamicVariable", { key: "apex Collection banner", value: "variant-0" }],
+    ]);
+  });
+
+
+  it("respects an existing Contentsquare queue", async () => {
+    const existingEntry = ["trackPageEvent", "loaded"];
+    const uxa = [existingEntry];
+    (globalThis as any).window._uxa = uxa;
+
+    const { init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [
+        {
+          id: "exp_contentsquare_existing",
+          status: "running",
+          trafficAllocation: 1,
+          variations: [{ id: "var_contentsquare_existing", weight: 1, mutations: [], isControl: true }],
+        },
+      ],
+      exposureDestinations: {
+        contentsquare: { enabled: true, keyPrefix: "apex cs " },
+      },
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+
+    expect((globalThis as any).window._uxa).toBe(uxa);
+    expect(uxa).toEqual([
+      existingEntry,
+      ["trackDynamicVariable", { key: "apex cs exp_contentsquare_existing", value: "control" }],
+    ]);
+  });
+
+
+  it("captures PostHog exposure events with the default event name and payload", async () => {
+    const capture = vi.fn();
+    const register = vi.fn();
+    (globalThis as any).window.posthog = { capture, register };
+
+    const { getDiagnostics, init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [
+        {
+          id: "exp_posthog",
+          status: "running",
+          trafficAllocation: 1,
+          variations: [{ id: "var_posthog", weight: 1, mutations: [] }],
+        },
+      ],
+      exposureDestinations: {
+        posthog: { enabled: true },
+      },
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+
+    expect(capture).toHaveBeenCalledWith("apex_experiment_viewed", expect.objectContaining({
+      project_id: "shop_123",
+      experiment_id: "exp_posthog",
+      variation_id: "var_posthog",
+      experiment_name: "exp_posthog",
+      variation_index: 0,
+      variation_name: "var_posthog",
+      is_control: false,
+    }));
+    expect(getDiagnostics().integrations.exposureDestinations).toEqual(expect.arrayContaining([
+      expect.objectContaining({ type: "posthog", status: "sent" }),
+    ]));
+  });
+
+
+  it("registers PostHog variant super properties by experiment", async () => {
+    const capture = vi.fn();
+    const register = vi.fn();
+    (globalThis as any).window.posthog = { capture, register };
+
+    const { init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [
+        {
+          id: "exp_posthog_register",
+          status: "running",
+          trafficAllocation: 1,
+          variations: [{ id: "var_posthog_register", weight: 1, mutations: [] }],
+        },
+      ],
+      exposureDestinations: {
+        posthog: { enabled: true },
+      },
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+
+    expect(register).toHaveBeenCalledWith({ apex_exp_exp_posthog_register: "var_posthog_register" });
+  });
+
+
+  it("does not register PostHog super properties in capture mode", async () => {
+    const capture = vi.fn();
+    const register = vi.fn();
+    (globalThis as any).window.posthog = { capture, register };
+
+    const { init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [
+        {
+          id: "exp_posthog_capture",
+          status: "running",
+          trafficAllocation: 1,
+          variations: [{ id: "var_posthog_capture", weight: 1, mutations: [] }],
+        },
+      ],
+      exposureDestinations: {
+        posthog: { enabled: true, mode: "capture" },
+      },
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+
+    expect(capture).toHaveBeenCalledOnce();
+    expect(register).not.toHaveBeenCalled();
+  });
+
+
+  it("records a PostHog diagnostic without throwing when PostHog is absent", async () => {
+    const { getDiagnostics, init } = await import("./index");
+
+    expect(() => init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [
+        {
+          id: "exp_posthog_absent",
+          status: "running",
+          trafficAllocation: 1,
+          variations: [{ id: "var_posthog_absent", weight: 1, mutations: [] }],
+        },
+      ],
+      exposureDestinations: {
+        posthog: { enabled: true },
+      },
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    })).not.toThrow();
+
+    expect(getDiagnostics().integrations.exposureDestinations).toEqual(expect.arrayContaining([
+      expect.objectContaining({ type: "posthog", status: "failed", reason: "posthog_missing" }),
+    ]));
+  });
+
+
+  it("emits PostHog exposure calls into stub queue objects", async () => {
+    const calls: Array<[string, ...unknown[]]> = [];
+    (globalThis as any).window.posthog = {
+      capture: (...args: unknown[]) => calls.push(["capture", ...args]),
+      register: (properties: Record<string, unknown>) => calls.push(["register", properties]),
+    };
+
+    const { init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [
+        {
+          id: "exp_posthog_queue",
+          status: "running",
+          trafficAllocation: 1,
+          variations: [{ id: "var_posthog_queue", weight: 1, mutations: [] }],
+        },
+      ],
+      exposureDestinations: {
+        posthog: { enabled: true },
+      },
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+
+    expect(calls).toEqual(expect.arrayContaining([
+      ["capture", "apex_experiment_viewed", expect.objectContaining({
+        experiment_id: "exp_posthog_queue",
+        variation_id: "var_posthog_queue",
+      })],
+      ["register", { apex_exp_exp_posthog_queue: "var_posthog_queue" }],
+    ]));
+  });
+
+
+  it("stores exposed assignments and uses them for order identity beacons on non-targeted confirmation pages", async () => {
+    (globalThis as any).location = {
+      hash: "",
+      hostname: "plain.test",
+      href: "https://plain.test/products/a",
+      origin: "https://plain.test",
+      pathname: "/products/a",
+      search: "",
+    };
+    const { init, getRuntimeValue } = await import("./index");
+    const experiment = {
+      id: "exp_product",
+      status: "running" as const,
+      targeting: { url: [{ type: "simple" as const, pattern: "/products/*" }] },
+      trafficAllocation: 1,
+      variations: [{ id: "var_product", weight: 1, mutations: [] }],
+    };
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [experiment],
+      ingestSignature: "sig",
+      shopId: "11111111-1111-4111-8111-111111111111",
+      trackingStart: "immediate",
+    });
+
+    const stored = JSON.parse(String((globalThis as any).localStorage.getItem("drip_exposures")));
+    expect(stored).toEqual([
+      expect.objectContaining({ e: "exp_product", v: "var_product", t: expect.any(Number) }),
+    ]);
+    expect(getRuntimeValue("orderAttribution")).toMatchObject({
+      assignments: [{ experimentId: "exp_product", variationId: "var_product" }],
+    });
+
+    vi.mocked(globalThis.fetch).mockClear();
+    (globalThis as any).window.__apexOrderIdentity = {
+      platform: "centra",
+      orderId: "order-1",
+      orderNumber: "1001",
+    };
+    (globalThis as any).location = {
+      hash: "",
+      hostname: "plain.test",
+      href: "https://plain.test/checkout/thank-you?orderId=order-1",
+      origin: "https://plain.test",
+      pathname: "/checkout/thank-you",
+      search: "?orderId=order-1",
+    };
+    vi.mocked((globalThis as any).document.querySelector).mockImplementation((selector: string) => {
+      if (selector === "[data-apex-order-id]") {
+        return { dataset: { apexOrderId: "order-1" } };
+      }
+      return null;
+    });
+    Object.defineProperty(globalThis, "navigator", {
+      configurable: true,
+      value: { userAgent: "Mozilla/5.0", doNotTrack: "0", sendBeacon: undefined },
+    });
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [experiment],
+      ingestSignature: "sig",
+      shopId: "11111111-1111-4111-8111-111111111111",
+      trackingStart: "immediate",
+    });
+    await vi.runOnlyPendingTimersAsync();
+
+    const orderIdentityCall = vi.mocked(globalThis.fetch).mock.calls.find((call) =>
+      String(call[0]) === "https://events.test/v1/order-identity",
+    );
+    expect(orderIdentityCall).toBeTruthy();
+    const payload = JSON.parse(String(orderIdentityCall?.[1]?.body));
+    expect(payload).toMatchObject({
+      platform: "centra",
+      environmentKey: "production",
+      platformOrderId: "order-1",
+      orderNumber: "1001",
+      assignments: [{ experimentId: "exp_product", variationId: "var_product" }],
+    });
+  });
+
+
+  it("re-probes a cached null order identity when reInit runs on the same URL", async () => {
+    (globalThis as any).location = {
+      hash: "",
+      hostname: "plain.test",
+      href: "https://plain.test/checkout/thank-you",
+      origin: "https://plain.test",
+      pathname: "/checkout/thank-you",
+      search: "",
+    };
+    const { init, reInit } = await import("./index");
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [{
+        id: "exp_confirmation",
+        status: "running",
+        trafficAllocation: 1,
+        variations: [{ id: "var_confirmation", weight: 1, mutations: [] }],
+      }],
+      ingestSignature: "sig",
+      shopId: "11111111-1111-4111-8111-111111111111",
+      trackingStart: "immediate",
+    });
+    await vi.runOnlyPendingTimersAsync();
+    vi.mocked(globalThis.fetch).mockClear();
+
+    (globalThis as any).window.__apexOrderIdentity = {
+      platform: "centra",
+      orderId: "order-reinit",
+      orderNumber: "2002",
+    };
+    reInit();
+    await vi.runOnlyPendingTimersAsync();
+
+    const call = vi.mocked(globalThis.fetch).mock.calls.find((candidate) =>
+      String(candidate[0]) === "https://events.test/v1/order-identity",
+    );
+    expect(call).toBeTruthy();
+    expect(JSON.parse(String(call?.[1]?.body))).toMatchObject({
+      platform: "centra",
+      platformOrderId: "order-reinit",
+      orderNumber: "2002",
+    });
+  });
+
+
+  it("does not detect order identity from URL params without a confirmation signal", async () => {
+    (globalThis as any).location = {
+      hash: "",
+      hostname: "plain.test",
+      href: "https://plain.test/account/order?orderId=order-1",
+      origin: "https://plain.test",
+      pathname: "/account/order",
+      search: "?orderId=order-1",
+    };
+    const { init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [
+        {
+          id: "exp_any",
+          status: "running",
+          trafficAllocation: 1,
+          variations: [{ id: "var_any", weight: 1, mutations: [] }],
+        },
+      ],
+      ingestSignature: "sig",
+      shopId: "11111111-1111-4111-8111-111111111111",
+      trackingStart: "immediate",
+    });
+    await vi.runOnlyPendingTimersAsync();
+
+    expect(vi.mocked(globalThis.fetch).mock.calls.some((call) =>
+      String(call[0]) === "https://events.test/v1/order-identity",
+    )).toBe(false);
+  });
+
+
+  it("only writes order identity dedupe after successful fetch delivery", async () => {
+    (globalThis as any).localStorage.setItem(
+      "drip_exposures",
+      JSON.stringify([{ e: "exp_prior", v: "var_prior", t: Date.now() }]),
+    );
+    (globalThis as any).location = {
+      hash: "",
+      hostname: "plain.test",
+      href: "https://plain.test/checkout/thank-you",
+      origin: "https://plain.test",
+      pathname: "/checkout/thank-you",
+      search: "",
+    };
+    vi.mocked((globalThis as any).document.querySelector).mockImplementation((selector: string) => {
+      if (selector === "[data-apex-order-id]") {
+        return { dataset: { apexOrderId: "order-1" } };
+      }
+      return null;
+    });
+    let orderIdentityShouldFail = true;
+    const orderIdentityStatuses: number[] = [];
+    vi.mocked(globalThis.fetch).mockImplementation(async (input: RequestInfo | URL) => {
+      if (String(input) === "https://events.test/v1/order-identity") {
+        const status = orderIdentityShouldFail ? 500 : 202;
+        orderIdentityStatuses.push(status);
+        return { status } as Response;
+      }
+      return new Response("ok", { status: 202 });
+    });
+
+    const { init } = await import("./index");
+    const config = {
+      antiFlickerMode: "off" as const,
+      endpoint: "https://events.test",
+      experiments: [],
+      ingestSignature: "sig",
+      shopId: "11111111-1111-4111-8111-111111111111",
+      trackingStart: "immediate" as const,
+    };
+
+    init(config);
+    await vi.runOnlyPendingTimersAsync();
+    await Promise.resolve();
+    const orderIdentityKeyAfterFailure = Array.from({ length: (globalThis as any).sessionStorage.length }, (_, index) =>
+      (globalThis as any).sessionStorage.key(index),
+    ).find((key) => String(key).startsWith("drip:order_identity"));
+    expect(orderIdentityKeyAfterFailure ? (globalThis as any).sessionStorage.getItem(orderIdentityKeyAfterFailure) : null)
+      .not.toBe("1");
+
+    orderIdentityShouldFail = false;
+    init(config);
+    await vi.runOnlyPendingTimersAsync();
+    await Promise.resolve();
+    expect(vi.mocked(globalThis.fetch).mock.calls.filter((call) =>
+      String(call[0]) === "https://events.test/v1/order-identity",
+    )).toHaveLength(2);
+    expect(vi.mocked(globalThis.fetch).mock.calls.filter((call) =>
+      String(call[0]) === "https://events.test/v1/order-identity",
+    ).length).toBeGreaterThanOrEqual(2);
+  });
+
+
+  it("does not resend order identity after a successful fetch delivery", async () => {
+    (globalThis as any).localStorage.setItem(
+      "drip_exposures",
+      JSON.stringify([{ e: "exp_prior", v: "var_prior", t: Date.now() }]),
+    );
+    (globalThis as any).location = {
+      hash: "",
+      hostname: "plain.test",
+      href: "https://plain.test/checkout/thank-you",
+      origin: "https://plain.test",
+      pathname: "/checkout/thank-you",
+      search: "",
+    };
+    vi.mocked((globalThis as any).document.querySelector).mockImplementation((selector: string) => {
+      if (selector === "[data-apex-order-id]") {
+        return { dataset: { apexOrderId: "order-1" } };
+      }
+      return null;
+    });
+    vi.mocked(globalThis.fetch).mockImplementation(async (input: RequestInfo | URL) =>
+      String(input) === "https://events.test/v1/order-identity"
+        ? ({ status: 202 } as Response)
+        : new Response("ok", { status: 202 }),
+    );
+
+    const { init } = await import("./index");
+    const config = {
+      antiFlickerMode: "off" as const,
+      endpoint: "https://events.test",
+      experiments: [],
+      ingestSignature: "sig",
+      shopId: "11111111-1111-4111-8111-111111111111",
+      trackingStart: "immediate" as const,
+    };
+
+    init(config);
+    await vi.runOnlyPendingTimersAsync();
+    await Promise.resolve();
+    init(config);
+    await vi.runOnlyPendingTimersAsync();
+
+    expect(vi.mocked(globalThis.fetch).mock.calls.filter((call) =>
+      String(call[0]) === "https://events.test/v1/order-identity",
+    )).toHaveLength(1);
+  });
+
+
+  it("tracks revenue from configured dataLayer purchase events", async () => {
+    (globalThis as any).window.dataLayer = [];
+
+    const { flush, init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      dataLayerTriggers: [
+        {
+          eventName: "purchase",
+          reEvaluate: false,
+          trackRevenue: {
+            enabled: true,
+            costFrom: "cost",
+            profitFrom: "profit",
+            properties: [
+              { from: "liveRunId", to: "liveRunId" },
+              { from: "mappedRevenue", to: "revenue", valueType: "number" },
+              { from: "mappedSource", to: "source" },
+            ],
+          },
+        },
+      ],
+      endpoint: "https://events.test",
+      experiments: [
+        {
+          id: "exp_revenue_data_layer",
+          status: "running",
+          trafficAllocation: 1,
+          variations: [{ id: "var_revenue_data_layer", weight: 1, mutations: [] }],
+        },
+      ],
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+
+    (globalThis as any).window.dataLayer.push({
+      0: "event",
+      1: "purchase",
+      2: {
+        value: "36",
+        transaction_id: "order_123",
+        currency: "EUR",
+        cost: "10",
+        profit: "26",
+        liveRunId: "run_123",
+        mappedRevenue: "999",
+        mappedSource: "untrusted_source",
+      },
+    });
+    await flush();
+
+    const fetchMock = vi.mocked(globalThis.fetch);
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    const body = JSON.parse(String(fetchMock.mock.calls[0]?.[1]?.body));
+    expect(body.events).toEqual(expect.arrayContaining([
+      expect.objectContaining({
+        type: "goal",
+        experimentId: "exp_revenue_data_layer",
+        variationId: "var_revenue_data_layer",
+        data: expect.objectContaining({
+          goalId: "__revenue__",
+          revenue: 36,
+          orderId: "order_123",
+          currency: "EUR",
+          cost: 10,
+          profit: 26,
+          liveRunId: "run_123",
+          source: "data_layer",
+          dataLayerEvent: "purchase",
+        }),
+      }),
+    ]));
+  });
+
+
+  it("does not let replayed dataLayer events start analytics before first assignments", async () => {
+    const hj = vi.fn();
+    (globalThis as any).window.hj = hj;
+    (globalThis as any).window.dataLayer = [{ event: "virtPageView", page_type: "pdp" }];
+    (globalThis as any).window.adbq = [];
+    (globalThis as any).hj = hj;
+    (globalThis as any).adbq = (globalThis as any).window.adbq;
+
+    const { getAssignments, getDiagnostics, getSignals, init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      dataLayerTriggers: [
+        {
+          eventName: "virtPageView",
+          mappings: [{ from: "page_type", to: "page.type", valueType: "string" }],
+          trackPageview: true,
+        },
+      ],
+      endpoint: "https://events.test",
+      experiments: [
+        {
+          id: "exp_initial_data_layer",
+          status: "running",
+          targeting: {
+            segmentRules: [
+              {
+                id: "segment_pdp",
+                rules: {
+                  version: 1,
+                  operator: "and",
+                  conditions: [{ signal: "page.type", operator: "equals", value: "pdp" }],
+                },
+              },
+            ],
+          },
+          trafficAllocation: 1,
+          variations: [{ id: "var_initial_data_layer", weight: 1, mutations: [] }],
+        },
+      ],
+      exposureDestinations: {
+        dataLayer: { enabled: true, eventName: "apex_test_viewed" },
+        hotjar: { enabled: true, mode: "event", eventName: "apex_test_viewed" },
+        queues: [{ enabled: true, globalName: "adbq", eventName: "Viewed an experiment" }],
+      },
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+
+    expect(getSignals()["page.type"]).toBe("pdp");
+    expect(getAssignments()).toEqual([
+      expect.objectContaining({ experimentId: "exp_initial_data_layer", variationId: "var_initial_data_layer" }),
+    ]);
+    expect((globalThis as any).window.dataLayer).toEqual(expect.arrayContaining([
+      expect.objectContaining({
+        event: "apex_test_viewed",
+        experiment_id: "exp_initial_data_layer",
+        variation_id: "var_initial_data_layer",
+      }),
+    ]));
+    expect(hj).toHaveBeenCalledWith("event", "apex_test_viewed");
+    expect((globalThis as any).window.adbq).toEqual(expect.arrayContaining([
+      expect.objectContaining({
+        event: "Viewed an experiment",
+        experiment_id: "exp_initial_data_layer",
+        variation_id: "var_initial_data_layer",
+      }),
+    ]));
+    expect(getDiagnostics().integrations.exposureDestinations.map((item) => item.status)).toContain("sent");
+  });
+});