@drip-apex/sdk 0.1.0 → 0.3.0

package/src/init-analytics.test.ts

@@ -0,0 +1,1694 @@
+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 analytics", () => {
+  registerInitTestLifecycle();
+
+
+  it.each([
+    "https://events.test/base/events",
+    "https://events.test/base/v1/events",
+    "https://events.test/base/v1/events/",
+  ])("preserves endpoint path segments while canonicalizing %s", async (endpoint) => {
+    const { flush, init } = await import("./index");
+    init({
+      antiFlickerMode: "off",
+      endpoint,
+      experiments: [],
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+    await flush();
+    expect(vi.mocked(globalThis.fetch).mock.calls[0]?.[0]).toBe(
+      "https://events.test/base/v1/events",
+    );
+  });
+
+
+  it("emits one install conflict without duplicating pageview or sdk perf events", async () => {
+    const { flush, init } = await import("./index");
+    const baseConfig = {
+      antiFlickerMode: "off" as const,
+      endpoint: "https://events.test",
+      experiments: [],
+      pageTrigger: { defaultMode: "manual" as const },
+      runtimeProfile: "full",
+      sdkDeliveryMode: "canary",
+      sdkDeliverySource: "external",
+      sdkPolicyRevision: "sdk_test1234",
+      shopId: "shop_123",
+      trackingStart: "immediate" as const,
+    };
+
+    init({ ...baseConfig, installSurface: "direct_script", sdkVersion: "0.1.0+first" });
+    init({ ...baseConfig, installSurface: "shopify_app_embed", sdkVersion: "0.1.0+second" });
+    init({ ...baseConfig, installSurface: "legacy_shopify_redirect", sdkVersion: "0.1.0+third" });
+    await flush();
+    await vi.waitFor(() => expect(globalThis.fetch).toHaveBeenCalledTimes(2));
+
+    const fetchMock = vi.mocked(globalThis.fetch);
+    const events = fetchMock.mock.calls.flatMap((call) => {
+      const body = JSON.parse(String(call[1]?.body));
+      return body.events as Array<{ type: string; data: Record<string, unknown> }>;
+    });
+    expect(events.filter((event) => event.type === "sdk_perf")).toHaveLength(1);
+    expect(events.find((event) => event.type === "sdk_perf")?.data.perf_event_kind).toBe("init");
+    expect(events.filter((event) => event.type === "pageview")).toHaveLength(1);
+    expect(events.filter((event) => event.type === "sdk_install_conflict")).toEqual([
+      expect.objectContaining({
+        data: expect.objectContaining({
+          first_install_surface: "direct_script",
+          attempted_install_surface: "shopify_app_embed",
+          sdk_version: "0.1.0+second",
+          runtime_profile: "full",
+        }),
+      }),
+    ]);
+  });
+
+
+  it("uses hydrated proxy delivery for a fresh runtime-event tracker and retries direct once", async () => {
+    const fetchMock = vi.mocked(globalThis.fetch);
+    fetchMock
+      .mockResolvedValueOnce(new Response(null, { status: 502 }))
+      .mockResolvedValueOnce(new Response(null, { status: 202 }));
+    const { __test, init } = await import("./index");
+    const capturedBeforeHydration = {
+      antiFlickerMode: "off" as const,
+      endpoint: "https://events.test",
+      experiments: [],
+      projectPrerequisites: { startTrackingRule: "return false;" },
+      shopId: "shop_123",
+      trackingStart: "immediate" as const,
+    };
+    init({ ...capturedBeforeHydration, proxyEventDelivery: { enabled: true } });
+    fetchMock.mockClear();
+    fetchMock
+      .mockResolvedValueOnce(new Response(null, { status: 502 }))
+      .mockResolvedValueOnce(new Response(null, { status: 202 }));
+
+    __test!.sendRuntimeEventNow(capturedBeforeHydration, "collection_viewed", { collection_id: "c1" }, "visitor-1");
+    await vi.waitFor(() => expect(fetchMock).toHaveBeenCalledTimes(2));
+
+    expect(fetchMock.mock.calls[0]?.[0]).toBe("https://plain.test/apps/apex/events");
+    expect(fetchMock.mock.calls[1]?.[0]).toBe("https://events.test/v1/events");
+    expect(String(fetchMock.mock.calls[1]?.[1]?.body)).toContain('"delivery_downgrade":"proxy_failed"');
+    expect(String(fetchMock.mock.calls[1]?.[1]?.body)).toContain('"type":"collection_viewed"');
+  });
+
+
+  it("tracks virtual funnel steps once per session by default", async () => {
+    const { flush, init, trackStep } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [],
+      pageTrigger: { defaultMode: "manual" },
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+    trackStep("postcode_entered", { field: "zip" });
+    trackStep("postcode_entered", { field: "zip" });
+    trackStep("delivery_method_seen", { oncePerSession: false, method: "express" });
+    trackStep("delivery_method_seen", { oncePerSession: false, method: "standard" });
+    await flush();
+
+    const fetchMock = vi.mocked(globalThis.fetch);
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    const body = JSON.parse(String(fetchMock.mock.calls[0]?.[1]?.body));
+    const steps = body.events.filter((event: { type: string }) => event.type === "funnel_step");
+    expect(steps).toHaveLength(3);
+    expect(steps.map((event: { data: { step_name: string } }) => event.data.step_name)).toEqual([
+      "postcode_entered",
+      "delivery_method_seen",
+      "delivery_method_seen",
+    ]);
+    expect(steps[0].data).toMatchObject({
+      source: "virtual_step",
+      step_name: "postcode_entered",
+      path: "/",
+      field: "zip",
+    });
+    expect(steps[1].data).not.toHaveProperty("oncePerSession");
+  });
+
+
+  it("does not write funnel-step dedupe storage before consent allows tracking", async () => {
+    const { flush, init, setConsent, trackStep } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      consentMode: { enabled: true },
+      endpoint: "https://events.test",
+      experiments: [],
+      hasConsent: false,
+      pageTrigger: { defaultMode: "manual" },
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+    trackStep("postcode_entered", { field: "zip" });
+    await flush();
+
+    expect(globalThis.fetch).not.toHaveBeenCalled();
+    expect((globalThis as any).sessionStorage.length).toBe(0);
+
+    setConsent(true);
+    trackStep("postcode_entered", { field: "zip" });
+    await flush();
+
+    const fetchMock = vi.mocked(globalThis.fetch);
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    const body = JSON.parse(String(fetchMock.mock.calls[0]?.[1]?.body));
+    const steps = body.events.filter((event: { type: string }) => event.type === "funnel_step");
+    expect(steps).toHaveLength(1);
+    expect(steps[0].data).toMatchObject({
+      source: "virtual_step",
+      step_name: "postcode_entered",
+      field: "zip",
+    });
+    expect((globalThis as any).sessionStorage.length).toBeGreaterThan(0);
+  });
+
+
+  it("uses a hard timeout when idle analytics has not fired yet", async () => {
+    const requestIdleCallback = vi.fn(() => 42);
+    const cancelIdleCallback = vi.fn();
+    (globalThis as any).requestIdleCallback = requestIdleCallback;
+    (globalThis as any).cancelIdleCallback = cancelIdleCallback;
+
+    const { flush, init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [],
+      pageTrigger: { defaultMode: "manual" },
+      shopId: "shop_123",
+      trackingIdleTimeoutMs: 2000,
+      trackingStart: "idle",
+    });
+
+    expect(requestIdleCallback).toHaveBeenCalledTimes(1);
+    expect(globalThis.fetch).not.toHaveBeenCalled();
+
+    await vi.advanceTimersByTimeAsync(2000);
+    await flush();
+
+    const fetchMock = vi.mocked(globalThis.fetch);
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    expect(cancelIdleCallback).toHaveBeenCalledWith(42);
+    const body = JSON.parse(String(fetchMock.mock.calls[0]?.[1]?.body));
+    expect(body.events.map((event: { type: string }) => event.type)).toEqual([
+      "sdk_perf",
+      "pageview",
+    ]);
+  });
+
+
+  it("attributes public track events to the active assignment by default", async () => {
+    const { flush, init, track } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [
+        {
+          id: "exp_123",
+          status: "running",
+          trafficAllocation: 1,
+          variations: [
+            {
+              id: "var_123",
+              weight: 1,
+              mutations: [],
+            },
+          ],
+        },
+      ],
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+    track("plain_site_primary_click", { source: "onboarding_probe" });
+    await flush();
+
+    const fetchMock = vi.mocked(globalThis.fetch);
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    const body = JSON.parse(String(fetchMock.mock.calls[0]?.[1]?.body));
+    const customEvent = body.events.find((event: { type: string }) => event.type === "plain_site_primary_click");
+    expect(customEvent).toMatchObject({
+      experimentId: "exp_123",
+      variationId: "var_123",
+      url: "https://plain.test/",
+    });
+  });
+
+
+  it("strips redirect assignment carry before the opt-out guard returns", async () => {
+    const carriedUrl = new URL("https://plain.test/products/destination?keep=1");
+    carriedUrl.searchParams.set(
+      "_apex_assignment",
+      JSON.stringify({
+        e: "exp_redirect",
+        v: "landing",
+        epoch: 1,
+        handover: "visitor_source",
+      }),
+    );
+    (globalThis as any).location.href = carriedUrl.href;
+    (globalThis as any).location.search = carriedUrl.search;
+    (globalThis as any).localStorage.setItem("drip_optout", "1");
+
+    const { init } = await import("./index");
+    expect(
+      init({
+        antiFlickerMode: "off",
+        endpoint: "https://events.test",
+        experiments: [],
+        shopId: "shop_123",
+        trackingStart: "immediate",
+      }),
+    ).toEqual([]);
+
+    const cleanedHref = vi.mocked(globalThis.history.replaceState).mock
+      .calls[0]?.[2];
+    expect(cleanedHref).toBeDefined();
+    const cleanedUrl = new URL(String(cleanedHref));
+    expect(cleanedUrl.searchParams.has("_apex_assignment")).toBe(false);
+    expect(cleanedUrl.searchParams.get("keep")).toBe("1");
+    expect(
+      (globalThis as any).localStorage.getItem("drip_assignments_v1"),
+    ).toBeNull();
+    expect(
+      (globalThis as any).sessionStorage.getItem(
+        "drip_redirect_assignment_pending_v1",
+      ),
+    ).toBeNull();
+  });
+
+
+  it("normalizes valid trackRevenue currency and flags invalid currency", async () => {
+    const { flush, init, trackRevenue } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [
+        {
+          id: "exp_revenue",
+          status: "running",
+          trafficAllocation: 1,
+          variations: [{ id: "var_revenue", weight: 1, mutations: [] }],
+        },
+      ],
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+    trackRevenue(10, { currency: " eur ", orderId: "order-1" });
+    trackRevenue(11, { currency: "euro", orderId: "order-2" });
+    await flush();
+
+    const fetchMock = vi.mocked(globalThis.fetch);
+    const body = JSON.parse(String(fetchMock.mock.calls[0]?.[1]?.body));
+    const revenueEvents = body.events.filter((event: { data?: { goalId?: string } }) =>
+      event.data?.goalId === "__revenue__"
+    );
+    expect(revenueEvents).toHaveLength(2);
+    expect(revenueEvents[0].data).toMatchObject({
+      revenue: 10,
+      currency: "EUR",
+      orderId: "order-1",
+    });
+    expect(revenueEvents[1].data).toMatchObject({
+      revenue: 11,
+      orderId: "order-2",
+      currency_raw: "euro",
+      money_error: "invalid_currency",
+    });
+    expect(revenueEvents[1].data).not.toHaveProperty("currency");
+  });
+
+
+  it("shares one event ID across each trackRevenue assignment fanout", async () => {
+    const { flush, init, trackRevenue } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [
+        {
+          id: "exp_revenue_fanout_a",
+          status: "running",
+          trafficAllocation: 1,
+          variations: [{ id: "var_revenue_fanout_a", weight: 1, mutations: [] }],
+        },
+        {
+          id: "exp_revenue_fanout_b",
+          status: "running",
+          trafficAllocation: 1,
+          variations: [{ id: "var_revenue_fanout_b", weight: 1, mutations: [] }],
+        },
+      ],
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+
+    trackRevenue(12);
+    trackRevenue(13);
+    await flush();
+
+    const body = JSON.parse(
+      String(vi.mocked(globalThis.fetch).mock.calls[0]?.[1]?.body),
+    );
+    const revenueEvents = body.events.filter(
+      (event: { data?: { goalId?: string } }) =>
+        event.data?.goalId === "__revenue__",
+    ) as Array<{ event_id: string; data: { revenue: number } }>;
+    const firstCallIds = revenueEvents
+      .filter((event) => event.data.revenue === 12)
+      .map((event) => event.event_id);
+    const secondCallIds = revenueEvents
+      .filter((event) => event.data.revenue === 13)
+      .map((event) => event.event_id);
+
+    expect(firstCallIds).toHaveLength(2);
+    expect(secondCallIds).toHaveLength(2);
+    expect(firstCallIds[0]).toEqual(expect.any(String));
+    expect(secondCallIds[0]).toEqual(expect.any(String));
+    expect(new Set(firstCallIds)).toHaveLength(1);
+    expect(new Set(secondCallIds)).toHaveLength(1);
+    expect(secondCallIds[0]).not.toBe(firstCallIds[0]);
+  });
+
+
+  it("emits one unattributed cohort-tagged revenue event for a holdout visitor", async () => {
+    const { isHoldoutVisitor } = await import("./hash");
+    const userId = Array.from({ length: 1000 }, (_, index) => `revenue-holdout-${index}`)
+      .find((candidate) =>
+        isHoldoutVisitor({ holdout_v1_enabled: true, holdout_pct: 10 }, candidate)
+      )!;
+    const { flush, getAssignments, init, trackRevenue } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [{
+        id: "exp_revenue_holdout",
+        status: "running",
+        trafficAllocation: 1,
+        variations: [{ id: "var_revenue_holdout", weight: 1, mutations: [] }],
+      }],
+      holdout_v1_enabled: true,
+      holdout_pct: 10,
+      shopId: "shop_123",
+      trackingStart: "immediate",
+      userId,
+    });
+    expect(getAssignments()).toEqual([]);
+
+    trackRevenue(35, { currency: "EUR", orderId: "holdout-order" });
+    await flush();
+
+    const body = JSON.parse(String(vi.mocked(globalThis.fetch).mock.calls[0]?.[1]?.body));
+    const revenueEvents = body.events.filter((event: { data?: { goalId?: string } }) =>
+      event.data?.goalId === "__revenue__"
+    );
+    expect(revenueEvents).toHaveLength(1);
+    expect(revenueEvents[0]).toMatchObject({
+      type: "goal",
+      data: {
+        cohort: "holdout",
+        currency: "EUR",
+        goalId: "__revenue__",
+        orderId: "holdout-order",
+        revenue: 35,
+      },
+    });
+    expect(revenueEvents[0]).not.toHaveProperty("experimentId");
+    expect(revenueEvents[0]).not.toHaveProperty("variationId");
+  });
+
+
+  it("keeps per-assignment cohort-tagged revenue for an active visitor", async () => {
+    const { isHoldoutVisitor } = await import("./hash");
+    const userId = Array.from({ length: 1000 }, (_, index) => `revenue-active-${index}`)
+      .find((candidate) =>
+        !isHoldoutVisitor({ holdout_v1_enabled: true, holdout_pct: 10 }, candidate)
+      )!;
+    const { flush, init, trackRevenue } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [{
+        id: "exp_revenue_active",
+        status: "running",
+        trafficAllocation: 1,
+        variations: [{ id: "var_revenue_active", weight: 1, mutations: [] }],
+      }],
+      holdout_v1_enabled: true,
+      holdout_pct: 10,
+      shopId: "shop_123",
+      trackingStart: "immediate",
+      userId,
+    });
+    trackRevenue(42, { orderId: "active-order" });
+    await flush();
+
+    const body = JSON.parse(String(vi.mocked(globalThis.fetch).mock.calls[0]?.[1]?.body));
+    const revenueEvents = body.events.filter((event: { data?: { goalId?: string } }) =>
+      event.data?.goalId === "__revenue__"
+    );
+    expect(revenueEvents).toHaveLength(1);
+    expect(revenueEvents[0]).toMatchObject({
+      type: "goal",
+      experimentId: "exp_revenue_active",
+      variationId: "var_revenue_active",
+      data: {
+        cohort: "active",
+        goalId: "__revenue__",
+        orderId: "active-order",
+        revenue: 42,
+      },
+    });
+  });
+
+
+  it("emits one unattributed cohort-tagged revenue event for an active visitor without an assignment", async () => {
+    const { isHoldoutVisitor } = await import("./hash");
+    const userId = Array.from({ length: 1000 }, (_, index) => `revenue-unassigned-active-${index}`)
+      .find((candidate) =>
+        !isHoldoutVisitor({ holdout_v1_enabled: true, holdout_pct: 10 }, candidate)
+      )!;
+    const { flush, getAssignments, init, trackRevenue } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [{
+        id: "exp_revenue_unassigned_active",
+        status: "running",
+        trafficAllocation: 0,
+        variations: [{ id: "var_revenue_unassigned_active", weight: 1, mutations: [] }],
+      }],
+      holdout_v1_enabled: true,
+      holdout_pct: 10,
+      shopId: "shop_123",
+      trackingStart: "immediate",
+      userId,
+    });
+    expect(getAssignments()).toEqual([]);
+
+    trackRevenue(43, { currency: "EUR", orderId: "active-unassigned-order" });
+    await flush();
+
+    const body = JSON.parse(String(vi.mocked(globalThis.fetch).mock.calls[0]?.[1]?.body));
+    const revenueEvents = body.events.filter((event: { data?: { goalId?: string } }) =>
+      event.data?.goalId === "__revenue__"
+    );
+    expect(revenueEvents).toHaveLength(1);
+    expect(revenueEvents[0]).toMatchObject({
+      type: "goal",
+      data: {
+        cohort: "active",
+        currency: "EUR",
+        goalId: "__revenue__",
+        orderId: "active-unassigned-order",
+        revenue: 43,
+      },
+    });
+    expect(revenueEvents[0]).not.toHaveProperty("experimentId");
+    expect(revenueEvents[0]).not.toHaveProperty("variationId");
+  });
+
+
+  it("replays revenue and funnel steps while initial hydration defers tracker creation", async () => {
+    const { flush, hydrated, init, trackRevenue, trackStep } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [
+        {
+          id: "exp_hydration_revenue",
+          status: "running",
+          trafficAllocation: 1,
+          variations: [
+            {
+              id: "var_hydration_revenue",
+              weight: 1,
+              mutations: [],
+              js: "window.__hydrationRevenueApplied=true;",
+            },
+          ],
+        },
+      ],
+      shopId: "shop_123",
+      spa: { applyTiming: "after_hydration", hydrationTimeoutMs: 3_000 },
+      trackingStart: "immediate",
+    });
+
+    trackRevenue(49.99, { currency: "EUR", orderId: "held-order" });
+    trackStep("checkout_confirmation", { oncePerSession: false, source: "held-data-layer" });
+    expect(vi.mocked(globalThis.fetch)).not.toHaveBeenCalled();
+
+    let flushResolved = false;
+    const pendingFlush = flush().then(() => { flushResolved = true; });
+    // Markerless quiet detector (#2213): the gate auto-resolves on this
+    // settled (mocked) DOM well before the 3,000ms hydrationTimeoutMs, with
+    // NO explicit hydrated() call. Pre-#2213 the detector never armed
+    // without a framework marker, so the gate held the full 3s — advancing
+    // only 300ms discriminates the two behaviors. The quiet-vs-mutating
+    // hold contract itself lives in hydration.test.ts (real DOM).
+    await Promise.resolve();
+    expect(flushResolved).toBe(false);
+
+    await vi.advanceTimersByTimeAsync(300);
+    await pendingFlush;
+    expect(flushResolved).toBe(true);
+    void hydrated; // explicit signal deliberately not used
+
+    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).toEqual(expect.arrayContaining([
+      expect.objectContaining({
+        experimentId: "exp_hydration_revenue",
+        variationId: "var_hydration_revenue",
+        data: expect.objectContaining({
+          goalId: "__revenue__",
+          revenue: 49.99,
+          currency: "EUR",
+          orderId: "held-order",
+        }),
+      }),
+      expect.objectContaining({
+        type: "funnel_step",
+        experimentId: "exp_hydration_revenue",
+        variationId: "var_hydration_revenue",
+        data: expect.objectContaining({
+          source: "virtual_step",
+          step_name: "checkout_confirmation",
+        }),
+      }),
+    ]));
+  });
+
+
+  it("rejects invalid direct revenue while preserving zero and the positional amount", async () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const { flush, init, trackRevenue } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [
+        {
+          id: "exp_revenue_validation",
+          status: "running",
+          trafficAllocation: 1,
+          variations: [{ id: "var_revenue_validation", weight: 1, mutations: [] }],
+        },
+      ],
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+    trackRevenue(Number.NaN);
+    trackRevenue(Number.POSITIVE_INFINITY);
+    trackRevenue(Number.NEGATIVE_INFINITY);
+    trackRevenue(-1);
+    trackRevenue("12" as unknown as number);
+    trackRevenue(0, { orderId: "zero-order" });
+    trackRevenue(25, { revenue: 999, orderId: "positive-order" });
+    await flush();
+
+    const fetchMock = vi.mocked(globalThis.fetch);
+    const body = JSON.parse(String(fetchMock.mock.calls[0]?.[1]?.body));
+    const revenueEvents = body.events.filter((event: { data?: { goalId?: string } }) =>
+      event.data?.goalId === "__revenue__"
+    );
+    expect(revenueEvents).toHaveLength(2);
+    expect(revenueEvents.map((event: { data: { revenue: number } }) => event.data.revenue)).toEqual([
+      0,
+      25,
+    ]);
+    expect(revenueEvents[1].data).toMatchObject({
+      revenue: 25,
+      orderId: "positive-order",
+    });
+    expect(warn).toHaveBeenCalledTimes(5);
+    expect(warn).toHaveBeenCalledWith(
+      "[drip] trackRevenue ignored invalid revenue; expected a finite, non-negative number",
+    );
+    warn.mockRestore();
+  });
+
+
+  it("normalizes invalid custom event names while preserving raw-name goal matching", async () => {
+    const { flush, init, track } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [
+        {
+          id: "exp_custom_goal",
+          status: "running",
+          trafficAllocation: 1,
+          variations: [{ id: "var_custom_goal", weight: 1, mutations: [] }],
+          goals: [
+            {
+              id: "goal_signup",
+              type: "custom",
+              eventName: "click_to_ atc",
+            },
+          ],
+        },
+      ],
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+    track("click_to_ atc", { plan: "pro" });
+    await flush();
+
+    const fetchMock = vi.mocked(globalThis.fetch);
+    const body = JSON.parse(String(fetchMock.mock.calls[0]?.[1]?.body));
+    expect(body.events).toEqual(expect.arrayContaining([
+      expect.objectContaining({
+        type: "click_to__atc",
+        experimentId: "exp_custom_goal",
+        variationId: "var_custom_goal",
+      }),
+      expect.objectContaining({
+        type: "goal",
+        experimentId: "exp_custom_goal",
+        variationId: "var_custom_goal",
+        data: expect.objectContaining({
+          goalId: "goal_signup",
+          plan: "pro",
+        }),
+      }),
+    ]));
+  });
+
+
+  it("emits experiment-scoped pageview behavior events for every active assignment", async () => {
+    const { flush, init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [
+        {
+          id: "exp_123",
+          status: "running",
+          trafficAllocation: 1,
+          variations: [{ id: "var_123", weight: 1, mutations: [] }],
+        },
+        {
+          id: "exp_456",
+          status: "running",
+          trafficAllocation: 1,
+          variations: [{ id: "var_456", weight: 1, mutations: [] }],
+        },
+      ],
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+    await flush();
+
+    const fetchMock = vi.mocked(globalThis.fetch);
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    const body = JSON.parse(String(fetchMock.mock.calls[0]?.[1]?.body));
+    const behaviorPageviews = body.events.filter(
+      (event: { type: string }) => event.type === "experiment_pageview",
+    );
+    const pageviews = body.events.filter((event: { type: string }) => event.type === "pageview");
+    expect(pageviews).toHaveLength(1);
+    expect(pageviews[0]).toMatchObject({
+      experimentId: "exp_123",
+      variationId: "var_123",
+    });
+    expect(behaviorPageviews).toHaveLength(2);
+    expect(behaviorPageviews.map((event: { experimentId: string; variationId: string }) => [
+      event.experimentId,
+      event.variationId,
+    ])).toEqual([
+      ["exp_123", "var_123"],
+      ["exp_456", "var_456"],
+    ]);
+  });
+
+
+  it("emits global and per-assignment page exit once across unload events", async () => {
+    Object.defineProperty(globalThis, "navigator", {
+      configurable: true,
+      value: { userAgent: "Mozilla/5.0", doNotTrack: "0", sendBeacon: undefined },
+    });
+    const { flush, init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [
+        {
+          id: "exp_123",
+          status: "running",
+          trafficAllocation: 1,
+          variations: [{ id: "var_123", weight: 1, mutations: [] }],
+        },
+        {
+          id: "exp_456",
+          status: "running",
+          trafficAllocation: 1,
+          variations: [{ id: "var_456", weight: 1, mutations: [] }],
+        },
+      ],
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+
+    await vi.advanceTimersByTimeAsync(1250);
+    windowListeners.pagehide?.forEach((handler) => handler());
+    windowListeners.beforeunload?.forEach((handler) => handler());
+    await flush();
+
+    const fetchMock = vi.mocked(globalThis.fetch);
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    const body = JSON.parse(String(fetchMock.mock.calls[0]?.[1]?.body));
+    const pageExitEvents = body.events.filter((event: { type: string }) => event.type === "page_exit");
+    const behaviorExits = body.events.filter(
+      (event: { type: string }) => event.type === "experiment_page_exit",
+    );
+    expect(pageExitEvents).toHaveLength(1);
+    expect(behaviorExits).toHaveLength(2);
+    expect(behaviorExits.every((event: { data?: { duration?: number } }) => event.data?.duration === 1)).toBe(true);
+  });
+
+
+  it("emits a shop-level page exit without identity for a contaminated-only assignment", async () => {
+    Object.defineProperty(globalThis, "navigator", {
+      configurable: true,
+      value: { userAgent: "Mozilla/5.0", doNotTrack: "0", sendBeacon: undefined },
+    });
+    const title = { textContent: "Control title" };
+    (globalThis as any).document.querySelectorAll = vi.fn((selector: string) => (
+      selector === "#product-title" ? [title] : []
+    ));
+    const { flush, init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [{
+        id: "exp_contaminated_exit",
+        status: "running",
+        trafficAllocation: 1,
+        variations: [{
+          id: "var_contaminated_exit",
+          weight: 1,
+          mutations: [
+            { selector: "#product-title", action: "text", text: "Treatment title" },
+            { selector: "#missing-cta", action: "text", text: "Missing CTA" },
+          ],
+        }],
+      }],
+      shopId: "shop_123",
+      spa: { activationMode: "manual" },
+      trackingStart: "immediate",
+    });
+
+    await vi.advanceTimersByTimeAsync(1_250);
+    windowListeners.pagehide?.forEach((handler) => handler());
+    await flush();
+
+    const events = vi.mocked(globalThis.fetch).mock.calls
+      .filter((call) => call[0] === "https://events.test/v1/events")
+      .flatMap((call) => JSON.parse(String(call[1]?.body)).events);
+    const pageExits = events.filter((event: { type: string }) => event.type === "page_exit");
+    expect(pageExits).toHaveLength(1);
+    expect(pageExits[0]).not.toHaveProperty("experimentId");
+    expect(pageExits[0]).not.toHaveProperty("variationId");
+    expect(events.filter((event: { type: string }) => event.type === "experiment_page_exit")).toEqual([]);
+  });
+
+
+  it("renders assignments without persistent storage or tracking before consent", async () => {
+    const { flush, getAssignments, init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      consentMode: { enabled: true },
+      endpoint: "https://events.test",
+      experiments: [
+        {
+          id: "exp_123",
+          status: "running",
+          trafficAllocation: 1,
+          variations: [{ id: "var_123", weight: 1, mutations: [] }],
+        },
+      ],
+      hasConsent: false,
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+
+    await flush();
+
+    expect(getAssignments()).toHaveLength(1);
+    expect(globalThis.fetch).not.toHaveBeenCalled();
+    expect((globalThis as any).localStorage.length).toBe(0);
+    expect((globalThis as any).localStorage.getItem("drip_exposures")).toBeNull();
+    expect((globalThis as any).sessionStorage.length).toBe(0);
+    expect((globalThis as any).document.cookie || "").not.toMatch(/drip_uid=[^;]/);
+    expect(readCookieValue("drip_ctx")).toBeNull();
+  });
+
+
+  it("persists the anonymous assignment identity and starts tracking after consent", async () => {
+    const { flush, getAssignments, init, setConsent } = await import("./index");
+    const shopifyPublish = vi.fn();
+    (globalThis as any).window.Shopify = { analytics: { publish: shopifyPublish } };
+
+    init({
+      antiFlickerMode: "off",
+      consentMode: { enabled: true },
+      endpoint: "https://events.test",
+      experiments: [
+        {
+          id: "exp_123",
+          status: "running",
+          trafficAllocation: 1,
+          variations: [{ id: "var_123", weight: 1, mutations: [] }],
+        },
+      ],
+      hasConsent: false,
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+    const beforeConsentHash = getAssignments()[0]?.hashValue;
+    expect(shopifyPublish).not.toHaveBeenCalled();
+
+    setConsent(true);
+    await flush();
+
+    const fetchMock = vi.mocked(globalThis.fetch);
+    expect(getAssignments()[0]?.hashValue).toBe(beforeConsentHash);
+    const eventsCall = fetchMock.mock.calls.find((call) => call[0] === "https://events.test/v1/events");
+    expect(eventsCall).toBeDefined();
+    const body = JSON.parse(String(eventsCall?.[1]?.body));
+    const visitorIds = new Set(body.events.map((event: { visitorId: string }) => event.visitorId));
+    expect(visitorIds.size).toBe(1);
+    expect((globalThis as any).localStorage.getItem("drip_uid")).toBe(Array.from(visitorIds)[0]);
+    expect(readDecodedDripContext()).toContain(`1|${Array.from(visitorIds)[0]}|`);
+    expect(body.events.map((event: { type: string }) => event.type)).toContain("experiment_viewed");
+    expect(body.events.map((event: { type: string }) => event.type)).toContain("pageview");
+    expect(body.events.map((event: { type: string }) => event.type)).not.toContain("sdk_perf");
+    expect(shopifyPublish).toHaveBeenCalledWith("drip_assignment_sync", expect.any(Object));
+  });
+
+
+  it("attaches signal context to experiment and personalization exposure events", async () => {
+    const { flush, init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      attributes: {
+        "traffic.source": "paid",
+        "visitor.returning": true,
+        "cart.item_count": 2,
+        "quiz.answer": "Sensitive",
+        "cookie.value": "secret",
+        "url.path": "/products/secret",
+      },
+      endpoint: "https://events.test",
+      experiments: [
+        {
+          id: "exp_signals",
+          status: "running",
+          trafficAllocation: 1,
+          variations: [{ id: "var_signals", weight: 1, mutations: [] }],
+        },
+        {
+          id: "personalization:homepage-banner:rule_signals",
+          kind: "personalization",
+          status: "running",
+          trafficAllocation: 1,
+          personalization: {
+            id: "personalization_signals",
+            key: "homepage-banner",
+            ruleId: "rule_signals",
+            experienceId: "experience_signals",
+            surface: "home",
+            templateKey: "hero",
+          },
+          variations: [{ id: "experience_signals", weight: 1, mutations: [] }],
+        },
+      ],
+      shopId: "shop_123",
+      signals: [
+        { key: "quiz.answer", valueType: "string" },
+        { key: "cookie.value", valueType: "string" },
+        { key: "url.path", valueType: "string" },
+      ],
+      trackingStart: "immediate",
+      userId: "visitor_signals",
+    });
+    await flush();
+
+    const eventsCall = vi.mocked(globalThis.fetch).mock.calls.find((call) => call[0] === "https://events.test/v1/events");
+    const body = JSON.parse(String(eventsCall?.[1]?.body));
+    const experimentViewed = body.events.find((event: { type: string }) => event.type === "experiment_viewed");
+    const personalizationRendered = body.events.find((event: { type: string }) => event.type === "personalization_rendered");
+
+    expect(experimentViewed?.data.signals).toEqual({
+      cart_item_count: 2,
+      quiz_answer: "Sensitive",
+      traffic_source: "paid",
+      visitor_returning: true,
+    });
+    expect(personalizationRendered?.data.signals).toEqual(experimentViewed?.data.signals);
+  });
+
+
+  it.each([
+    ["QA", "?drip_qa=1", undefined],
+    ["non-production", "", { activeKey: "staging" }],
+  ])("suppresses storefront vitals for %s sessions", async (_label, search, environments) => {
+    vi.mocked(Math.random).mockReturnValue(0);
+    (globalThis as any).location.search = search;
+    (globalThis as any).location.href = `https://plain.test/${search}`;
+    // Typed params only: the beacon assertion below destructures mock.calls.
+    const sendBeacon = vi.fn((_url: string, _body?: BodyInit | null) => true);
+    Object.defineProperty(globalThis, "navigator", {
+      configurable: true,
+      value: { userAgent: "Mozilla/5.0", doNotTrack: "0", sendBeacon },
+    });
+    const { init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      environments,
+      experiments: [],
+      shopId: "shop_123",
+      storefrontVitalsSampleRate: 1,
+      trackingStart: "immediate",
+    });
+    for (const listener of windowListeners.pagehide ?? []) listener();
+
+    expect(sendBeacon.mock.calls.some(([url]) => String(url).endsWith("/storefront-vitals"))).toBe(false);
+  });
+
+
+  it("suppresses storefront vitals while the start-tracking prerequisite is closed", async () => {
+    vi.mocked(Math.random).mockReturnValue(0);
+    const sendBeacon = vi.fn(() => true);
+    Object.defineProperty(globalThis, "navigator", {
+      configurable: true,
+      value: { userAgent: "Mozilla/5.0", doNotTrack: "0", sendBeacon },
+    });
+    const { init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [],
+      projectPrerequisites: { startTrackingRule: "return false;" },
+      shopId: "shop_123",
+      storefrontVitalsSampleRate: 1,
+      trackingStart: "immediate",
+    });
+    for (const listener of windowListeners.pagehide ?? []) listener();
+
+    expect(sendBeacon).not.toHaveBeenCalled();
+  });
+
+
+  it("starts storefront vitals after late consent and stops them on revocation", async () => {
+    vi.mocked(Math.random).mockReturnValue(0);
+    const sendBeacon = vi.fn(() => true);
+    Object.defineProperty(globalThis, "navigator", {
+      configurable: true,
+      value: { userAgent: "Mozilla/5.0", doNotTrack: "0", sendBeacon },
+    });
+    const { init, setConsent } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      consentMode: { enabled: true },
+      endpoint: "https://events.test",
+      experiments: [],
+      hasConsent: false,
+      shopId: "shop_123",
+      storefrontVitalsSampleRate: 1,
+      trackingStart: "immediate",
+    });
+    setConsent(true);
+    for (const listener of windowListeners.pagehide ?? []) listener();
+    expect(sendBeacon).toHaveBeenCalledWith(
+      "https://events.test/storefront-vitals",
+      expect.any(Blob),
+    );
+
+    sendBeacon.mockClear();
+    setConsent(false);
+    for (const listener of windowListeners.pagehide ?? []) listener();
+    expect(sendBeacon).not.toHaveBeenCalled();
+  });
+
+
+  it("keeps storefront vitals observers running across an open-gate SPA route change", async () => {
+    vi.mocked(Math.random).mockReturnValue(0);
+    const observerRegistrations: Array<{
+      disconnect: ReturnType<typeof vi.fn>;
+      type: string;
+    }> = [];
+    vi.stubGlobal("PerformanceObserver", class PerformanceObserver {
+      disconnect = vi.fn();
+      observe = vi.fn((options: PerformanceObserverInit) => {
+        observerRegistrations.push({
+          disconnect: this.disconnect,
+          type: options.type ?? options.entryTypes?.[0] ?? "",
+        });
+      });
+      takeRecords = vi.fn(() => []);
+      constructor(_callback: PerformanceObserverCallback) {}
+    });
+    const { init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [],
+      shopId: "shop_123",
+      spa: { routerMode: "history" },
+      storefrontVitalsSampleRate: 1,
+      trackingStart: "immediate",
+    });
+    const eventObserver = observerRegistrations.find(({ type }) => type === "event");
+    expect(eventObserver).toBeDefined();
+
+    (globalThis as any).location.href = "https://plain.test/next";
+    (globalThis as any).location.pathname = "/next";
+    (globalThis as any).history.pushState({}, "", "/next");
+
+    expect(observerRegistrations.filter(({ type }) => type === "event")).toHaveLength(1);
+    expect(eventObserver!.disconnect).not.toHaveBeenCalled();
+  });
+
+
+  it("labels flag and personalization assignments in diagnostics", async () => {
+    const { getDiagnostics, init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [
+        {
+          id: "diagnostics-flag",
+          kind: "feature_flag",
+          status: "running",
+          trafficAllocation: 1,
+          featureFlag: {
+            id: "flag_db_id",
+            key: "diagnostics-flag",
+          },
+          variations: [
+            {
+              id: "off",
+              weight: 0,
+              mutations: [],
+              value: false,
+              isControl: true,
+            },
+            {
+              id: "on",
+              weight: 1,
+              mutations: [],
+              value: "enabled",
+            },
+          ],
+        },
+        {
+          id: "diagnostics-personalization",
+          kind: "personalization",
+          status: "running",
+          trafficAllocation: 1,
+          personalization: {
+            id: "personalization_db_id",
+            key: "vip-homepage",
+            ruleId: "rule_123",
+            experienceId: "experience_123",
+            surface: "homepage",
+            templateKey: "hero",
+          },
+          variations: [
+            {
+              id: "vip",
+              weight: 1,
+              mutations: [],
+              value: "vip",
+            },
+          ],
+        },
+      ],
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+
+    expect(getDiagnostics().assignments).toEqual(expect.arrayContaining([
+      expect.objectContaining({
+        experimentId: "diagnostics-flag",
+        featureFlagKey: "diagnostics-flag",
+        kind: "feature_flag",
+        value: "enabled",
+      }),
+      expect.objectContaining({
+        experimentId: "diagnostics-personalization",
+        kind: "personalization",
+        personalizationExperienceId: "experience_123",
+        personalizationKey: "vip-homepage",
+        personalizationRuleId: "rule_123",
+        personalizationSurface: "homepage",
+        personalizationTemplateKey: "hero",
+        value: "vip",
+      }),
+    ]));
+  });
+
+
+  it("captures configured URL parameter signals before assignment evaluation", async () => {
+    (globalThis as any).location.href = "https://plain.test/?utm_content=creator_a";
+    (globalThis as any).location.search = "?utm_content=creator_a";
+
+    const { getAssignments, getSignals, init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [
+        {
+          id: "exp_signal",
+          status: "running",
+          trafficAllocation: 1,
+          targeting: {
+            segmentRules: [
+              {
+                id: "segment_signal",
+                rules: {
+                  version: 1,
+                  operator: "and",
+                  conditions: [
+                    { signal: "utm.content", operator: "equals", value: "creator_a" },
+                  ],
+                },
+              },
+            ],
+          },
+          variations: [{ id: "var_signal", weight: 1, mutations: [] }],
+        },
+      ],
+      shopId: "shop_123",
+      signals: [
+        {
+          key: "utm.content",
+          valueType: "string",
+          ttlDays: 30,
+          capture: { mode: "url_parameter", parameter: "utm_content" },
+        },
+      ],
+      trackingStart: "immediate",
+    });
+
+    expect(getSignals()["utm.content"]).toBe("creator_a");
+    expect(getAssignments()).toHaveLength(1);
+  });
+
+
+  it("refreshes non-persistent URL parameter signals during SPA re-evaluation", async () => {
+    (globalThis as any).location.href = "https://plain.test/";
+    (globalThis as any).location.search = "";
+
+    const { getAssignments, getSignals, init, reInit } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [
+        {
+          id: "exp_query_signal",
+          status: "running",
+          trafficAllocation: 1,
+          targeting: {
+            segmentRules: [
+              {
+                id: "segment_query_signal",
+                rules: {
+                  version: 1,
+                  operator: "and",
+                  conditions: [
+                    { signal: "search.query", operator: "equals", value: "recovery" },
+                  ],
+                },
+              },
+            ],
+          },
+          variations: [{ id: "var_query_signal", weight: 1, mutations: [] }],
+        },
+      ],
+      shopId: "shop_123",
+      signals: [
+        {
+          key: "search.query",
+          valueType: "string",
+          capture: { mode: "url_parameter", parameter: "q", persist: false },
+        },
+      ],
+      trackingStart: "immediate",
+    });
+
+    expect(getAssignments()).toHaveLength(0);
+    expect(getSignals()["search.query"]).toBeUndefined();
+
+    (globalThis as any).location.href = "https://plain.test/search?q=recovery";
+    (globalThis as any).location.search = "?q=recovery";
+    reInit();
+
+    expect(getSignals()["search.query"]).toBe("recovery");
+    expect(getAssignments()).toEqual([
+      expect.objectContaining({ experimentId: "exp_query_signal" }),
+    ]);
+
+    (globalThis as any).location.href = "https://plain.test/";
+    (globalThis as any).location.search = "";
+    reInit();
+
+    expect(getSignals()["search.query"]).toBeUndefined();
+    expect(getAssignments()).toHaveLength(0);
+  });
+
+
+  it("captures configured event property signals from track calls", async () => {
+    const { getAssignments, getSignals, init, reInit, track } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [
+        {
+          id: "exp_event_property_signal",
+          status: "running",
+          trafficAllocation: 1,
+          targeting: {
+            segmentRules: [
+              {
+                id: "event-property",
+                rules: {
+                  version: 1,
+                  operator: "and",
+                  conditions: [{ signal: "product.brand", operator: "equals", value: "Apex Goods" }],
+                },
+              },
+            ],
+          },
+          variations: [{ id: "var_event_property_signal", weight: 1, mutations: [] }],
+        },
+      ],
+      shopId: "shop_123",
+      signals: [
+        {
+          key: "product.brand",
+          valueType: "string",
+          ttlDays: 30,
+          capture: {
+            mode: "event_property",
+            eventName: "product_viewed",
+            property: "brand",
+          },
+        },
+      ],
+      trackingStart: "immediate",
+    });
+
+    expect(getAssignments()).toHaveLength(0);
+    track("product_viewed", { brand: "Apex Goods" });
+    reInit();
+
+    expect(getSignals()["product.brand"]).toBe("Apex Goods");
+    expect(getAssignments()).toEqual([
+      expect.objectContaining({ experimentId: "exp_event_property_signal" }),
+    ]);
+  });
+
+
+  it("captures configured click selector signals and supports manual re-evaluation", async () => {
+    const clickHandlers: Array<(event: { target: unknown }) => void> = [];
+    (globalThis as any).document.addEventListener = vi.fn((type: string, handler: (event: { target: unknown }) => void) => {
+      if (type === "click") clickHandlers.push(handler);
+    });
+
+    const { getAssignments, getSignals, init, reInit } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [
+        {
+          id: "exp_click_selector_signal",
+          status: "running",
+          trafficAllocation: 1,
+          targeting: {
+            segmentRules: [
+              {
+                id: "click-selector",
+                rules: {
+                  version: 1,
+                  operator: "and",
+                  conditions: [{ signal: "interaction.intent", operator: "contains", value: "add" }],
+                },
+              },
+            ],
+          },
+          variations: [{ id: "var_click_selector_signal", weight: 1, mutations: [] }],
+        },
+      ],
+      shopId: "shop_123",
+      signals: [
+        {
+          key: "interaction.intent",
+          valueType: "string",
+          capture: {
+            mode: "click_selector",
+            selector: "[data-action='add-cart']",
+            source: "constant",
+            value: "add_cart",
+          },
+        },
+      ],
+      trackingStart: "immediate",
+    });
+
+    expect(getAssignments()).toHaveLength(0);
+    clickHandlers.forEach((handler) => handler({
+      target: {
+        closest: (selector: string) => selector === "[data-action='add-cart']" ? {} : null,
+      },
+    }));
+    reInit();
+
+    expect(getSignals()["interaction.intent"]).toBe("add_cart");
+    expect(getAssignments()).toEqual([
+      expect.objectContaining({ experimentId: "exp_click_selector_signal" }),
+    ]);
+  });
+
+
+  it("captures dataLayer trigger signals and re-evaluates SPA targeting", async () => {
+    const { getAssignments, getDiagnostics, getSignals, init } = await import("./index");
+
+    (globalThis as any).window.dataLayer = [];
+    init({
+      antiFlickerMode: "off",
+      dataLayerTriggers: [
+        {
+          eventName: "virtPageView",
+          mappings: [{ from: "page_type", to: "page.type", valueType: "string" }],
+          trackPageview: true,
+        },
+      ],
+      endpoint: "https://events.test",
+      experiments: [
+        {
+          id: "exp_pdp",
+          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_pdp", weight: 1, mutations: [] }],
+        },
+      ],
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+
+    expect(getAssignments()).toHaveLength(0);
+    (globalThis as any).window.dataLayer.push({ event: "virtPageView", page_type: "home" });
+    expect(getSignals()["page.type"]).toBe("home");
+    expect(getAssignments()).toHaveLength(0);
+    (globalThis as any).window.dataLayer.push({ event: "virtPageView", page_type: "pdp" });
+    expect(getSignals()["page.type"]).toBe("pdp");
+    expect(getAssignments()).toHaveLength(1);
+    (globalThis as any).window.dataLayer.push({ event: "virtPageView", page_type: "home" });
+    expect(getSignals()["page.type"]).toBe("home");
+    expect(getAssignments()).toHaveLength(0);
+    expect(getDiagnostics()).toMatchObject({
+      spa: {
+        lastDataLayerTrigger: {
+          eventName: "virtPageView",
+          dataLayerName: "dataLayer",
+          mappedSignals: ["page.type"],
+        },
+      },
+      signals: {
+        sources: {
+          "page.type": "data_layer",
+        },
+      },
+    });
+  });
+
+
+  it("contains dataLayer observer failures and processes subsequent pushes", async () => {
+    const { getDiagnostics, getSignals, init } = await import("./index");
+    (globalThis as any).window.dataLayer = [];
+    init({
+      antiFlickerMode: "off",
+      dataLayerTriggers: [{
+        eventName: "virtPageView",
+        mappings: [{ from: "page_type", to: "page.type", valueType: "string" }],
+      }],
+      endpoint: "https://events.test",
+      experiments: [],
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+
+    const broken = { event: "virtPageView" } as Record<string, unknown>;
+    Object.defineProperty(broken, "page_type", { get: () => { throw new Error("bad page signal"); } });
+    expect(() => (globalThis as any).window.dataLayer.push(broken)).not.toThrow();
+    expect(() => (globalThis as any).window.dataLayer.push({ event: "virtPageView", page_type: "home" })).not.toThrow();
+
+    expect(getSignals()["page.type"]).toBe("home");
+    expect(getDiagnostics().spa.observerErrors).toMatchObject({
+      count: 1,
+      last: { source: "data_layer", message: "bad page signal" },
+    });
+  });
+
+
+  it("re-evaluates once after route observers return so post-pushState signals are current", async () => {
+    vi.useFakeTimers();
+    const onExperimentViewed = vi.fn();
+    const { flush, getAssignments, init } = await import("./index");
+    (globalThis as any).window.dataLayer = [];
+    init({
+      antiFlickerMode: "off",
+      dataLayerTriggers: [{
+        eventName: "virtPageView",
+        mappings: [{ from: "page_type", to: "page.type", valueType: "string" }],
+        reEvaluate: false,
+      }],
+      endpoint: "https://events.test",
+      experiments: [{
+        id: "exp_home_after_route",
+        status: "running",
+        targeting: { segmentRules: [{
+          id: "home",
+          rules: { version: 1, operator: "and", conditions: [{ signal: "page.type", operator: "equals", value: "home" }] },
+        }] },
+        trafficAllocation: 1,
+        variations: [{ id: "var_home", weight: 1, mutations: [] }],
+      }],
+      onExperimentViewed,
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+
+    (globalThis as any).location.href = "https://plain.test/home";
+    (globalThis as any).location.pathname = "/home";
+    (globalThis as any).history.pushState({}, "", "/home");
+    (globalThis as any).window.dataLayer.push({ event: "virtPageView", page_type: "home" });
+    expect(getAssignments()).toHaveLength(0);
+    expect(onExperimentViewed).not.toHaveBeenCalled();
+    await vi.advanceTimersByTimeAsync(0);
+    expect(getAssignments()).toEqual([expect.objectContaining({ experimentId: "exp_home_after_route" })]);
+    expect(onExperimentViewed).toHaveBeenCalledTimes(1);
+    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")).toEqual([
+      expect.objectContaining({
+        experimentId: "exp_home_after_route",
+        variationId: "var_home",
+      }),
+    ]);
+  });
+
+
+  it("normalizes real and numeric-key gtag event records without mutating them", async () => {
+    const { getDiagnostics, getSignals, init } = await import("./index");
+    (globalThis as any).window.dataLayer = [];
+    init({
+      antiFlickerMode: "off",
+      dataLayerTriggers: [{
+        eventName: "add_to_cart",
+        mappings: [
+          { from: "currency", to: "cart.currency" },
+          { from: "value", to: "cart.value", valueType: "number" },
+        ],
+        reEvaluate: false,
+      }],
+      endpoint: "https://events.test",
+      experiments: [],
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+
+    (function (..._args: unknown[]) {
+      (globalThis as any).window.dataLayer.push(arguments);
+    })("event", "add_to_cart", { currency: "EUR", value: 495 });
+    expect(getSignals()).toMatchObject({ "cart.currency": "EUR", "cart.value": 495 });
+
+    const observedRecord = {
+      0: "event",
+      1: "add_to_cart",
+      2: { currency: "USD", event: "wrong", value: 725 },
+    };
+    const originalKeys = Object.keys(observedRecord);
+    (globalThis as any).window.dataLayer.push(observedRecord);
+
+    expect(getSignals()).toMatchObject({ "cart.currency": "USD", "cart.value": 725 });
+    expect(Object.keys(observedRecord)).toEqual(originalKeys);
+    expect(observedRecord).not.toHaveProperty("event");
+    expect(getDiagnostics().spa.lastDataLayerTrigger).toMatchObject({
+      eventName: "add_to_cart",
+      gtagNormalized: true,
+    });
+  });
+
+
+  it("ignores non-event gtag commands", async () => {
+    const { getDiagnostics, init } = await import("./index");
+    (globalThis as any).window.dataLayer = [];
+    init({
+      antiFlickerMode: "off",
+      dataLayerTriggers: [{ eventName: "add_to_cart", reEvaluate: false }],
+      endpoint: "https://events.test",
+      experiments: [],
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+
+    for (const command of ["consent", "config", "set", "js", "get"]) {
+      (globalThis as any).window.dataLayer.push({
+        0: command,
+        1: "add_to_cart",
+        2: { event: "add_to_cart" },
+      });
+    }
+
+    expect(getDiagnostics().spa.lastDataLayerTrigger).toBeUndefined();
+  });
+
+
+  it("normalizes gtag records replayed from the last 50 pre-init entries", async () => {
+    (globalThis as any).window.dataLayer = [
+      { 0: "event", 1: "add_to_cart", 2: { currency: "EUR" } },
+    ];
+    const { getDiagnostics, getSignals, init } = await import("./index");
+    init({
+      antiFlickerMode: "off",
+      dataLayerTriggers: [{
+        eventName: "add_to_cart",
+        mappings: [{ from: "currency", to: "cart.currency" }],
+        reEvaluate: false,
+      }],
+      endpoint: "https://events.test",
+      experiments: [],
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+
+    expect(getSignals()["cart.currency"]).toBe("EUR");
+    expect(getDiagnostics().spa.lastDataLayerTrigger).toMatchObject({ gtagNormalized: true });
+  });
+
+
+  it.each([
+    {
+      name: "trackEventName only",
+      trigger: { trackEventName: "add_to_cart" },
+      expectedTypes: ["add_to_cart"],
+    },
+    {
+      name: "trackPageview only",
+      trigger: { trackPageview: true },
+      expectedTypes: ["pageview"],
+    },
+    {
+      name: "neither tracking option",
+      trigger: {},
+      expectedTypes: [],
+    },
+    {
+      name: "trackEventName and trackPageview",
+      trigger: { trackEventName: "add_to_cart", trackPageview: true },
+      expectedTypes: ["add_to_cart"],
+    },
+  ])("emits the configured dataLayer event with $name", async ({ trigger, expectedTypes }) => {
+    const { flush, init } = await import("./index");
+
+    (globalThis as any).window.dataLayer = [];
+    init({
+      antiFlickerMode: "off",
+      dataLayerTriggers: [
+        {
+          eventName: "add_to_cart",
+          reEvaluate: false,
+          ...trigger,
+        },
+      ],
+      endpoint: "https://events.test",
+      experiments: [],
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+    await flush();
+    vi.mocked(globalThis.fetch).mockClear();
+
+    (globalThis as any).window.dataLayer.push({ event: "add_to_cart", sku: "sku_123" });
+    await flush();
+
+    const events = 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 as Array<{ type: string }>;
+    });
+    expect(events.map((event) => event.type)).toEqual(expectedTypes);
+  });
+});