@drip-apex/sdk 0.1.0

package/src/commerce-analytics-lifecycle.test.ts

@@ -0,0 +1,1416 @@
+// @vitest-environment jsdom
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import {
+  commerceAssignmentResponseFixture,
+  commercePriceFixture as commerce,
+  installCommerceProductPage,
+  priceExperimentsFixture as experiments,
+} from "./test-fixtures/commerce";
+
+describe("commerce analytics lifecycle", () => {
+  const originalFetch = globalThis.fetch;
+  let fetchMock: ReturnType<typeof vi.fn>;
+
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.resetModules();
+    delete (globalThis as any).__drip;
+    delete (globalThis as any).drip;
+    delete (globalThis as any).Apex;
+    localStorage.clear();
+    sessionStorage.clear();
+    installCommerceProductPage();
+    fetchMock = vi.fn(async (input: RequestInfo | URL) =>
+      String(input).endsWith("/cart.js")
+        ? Response.json({ token: "cart-runtime?key=runtime-secret" })
+        : String(input).includes("/v1/assign")
+        ? new Response(JSON.stringify(commerceAssignmentResponseFixture), { status: 200 })
+        : new Response("ok", { status: 202 }));
+    globalThis.fetch = fetchMock as typeof fetch;
+  });
+
+  afterEach(() => {
+    vi.clearAllTimers();
+    vi.useRealTimers();
+    vi.restoreAllMocks();
+    globalThis.fetch = originalFetch;
+    delete (globalThis as any).__drip;
+    delete (globalThis as any).drip;
+    delete (globalThis as any).Apex;
+    delete (window as Window & { Shopify?: unknown }).Shopify;
+    delete (window as Window & { ShopifyAnalytics?: unknown }).ShopifyAnalytics;
+    document.head.innerHTML = "";
+    document.body.innerHTML = "";
+  });
+
+  it("adopts a null cart pin without retaining treatment state or exposure", async () => {
+    const nullPinToken = JSON.stringify({
+      v: 2,
+      p: {
+        price: {
+          v: 1,
+          r: 3,
+          c: "b".repeat(64),
+          x: "2026-07-20",
+          cartHash: "c".repeat(64),
+          a: [],
+          s: "d".repeat(64),
+        },
+      },
+    });
+    fetchMock = vi.fn(async (input: RequestInfo | URL) =>
+      String(input).endsWith("/cart.js")
+        ? Response.json({ token: "cart-runtime?key=runtime-secret" })
+        : String(input).includes("/v1/assign")
+        ? Response.json({ assignments: [], commerce_authorization: nullPinToken })
+        : new Response("ok", { status: 202 }));
+    globalThis.fetch = fetchMock as typeof fetch;
+    const onExperimentViewed = vi.fn();
+    const { getDiagnostics, init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      commerce,
+      endpoint: "https://events.test",
+      experiments,
+      ingestSignature: "ingest-token",
+      onExperimentViewed,
+      shopId: "shop_123",
+      trackingStart: "immediate",
+      userId: "visitor_123",
+    });
+
+    await vi.waitFor(() => {
+      expect(getDiagnostics().assignments).toEqual([]);
+      expect(document.querySelector(".price")?.textContent).toBe("€1.299,00");
+      expect(fetchMock.mock.calls.some(([url]) => url === "/cart/update.js")).toBe(true);
+    });
+    const cartUpdate = fetchMock.mock.calls.find(([url]) => url === "/cart/update.js");
+    const attributes = JSON.parse(String(cartUpdate?.[1]?.body)).attributes;
+    expect(attributes).toMatchObject({
+      apex_assignments: "[]",
+      apex_assignment_authorization: nullPinToken,
+      apex_experiment_id: "",
+      apex_variation_id: "",
+      apex_assignment_epoch: "",
+    });
+    expect(JSON.parse(localStorage.getItem("drip_assignments_v1") ?? "{}")).not.toHaveProperty(
+      "exp_price",
+    );
+    expect(localStorage.getItem("drip_exposures")).toBeNull();
+    expect(onExperimentViewed).not.toHaveBeenCalled();
+  });
+
+  it.each([
+    ["withholds exposure for rejected compare-at framing", "1299.00", false],
+    ["emits exposure for rendered compare-at framing", "1499.00", true],
+  ] as const)("%s", async (_label, amount, shouldExpose) => {
+    const onExperimentViewed = vi.fn();
+    const { init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      commerce: {
+        price: {
+          revision: 1,
+          checksum: "sum",
+          experiments: [
+            {
+              experiment_id: "exp_compare",
+              assignment_epoch: 1,
+              currency: "EUR",
+              variants: {
+                treatment: [
+                  {
+                    variant_gid: "gid://shopify/ProductVariant/123",
+                    compareAt: { mode: "set", amount },
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      },
+      endpoint: "https://events.test",
+      experiments: [
+        {
+          id: "exp_compare",
+          assignmentEpoch: 1,
+          status: "running",
+          trafficAllocation: 1,
+          variations: [
+            { id: "treatment", weight: 1, isControl: false, mutations: [] },
+          ],
+        },
+      ],
+      onExperimentViewed,
+      shopId: "shop_123",
+      trackingStart: "immediate",
+      userId: "visitor_compare",
+    });
+
+    await vi.waitFor(() => {
+      expect(Boolean(document.querySelector("[data-apex-compare-at]"))).toBe(
+        shouldExpose,
+      );
+      expect(onExperimentViewed).toHaveBeenCalledTimes(shouldExpose ? 1 : 0);
+    });
+  });
+
+  it("keeps an off-target resurrected pin in the price plane only", async () => {
+    delete (window as Window & { ShopifyAnalytics?: unknown }).ShopifyAnalytics;
+    document.body.insertAdjacentHTML(
+      "beforeend",
+      '<div class="companion">Control companion</div>',
+    );
+    const targetedExperiments = [{
+      ...experiments[0],
+      targeting: {
+        url: [{ type: "simple" as const, pattern: "*/products/other", include: true }],
+      },
+      variations: [{
+        ...experiments[0]!.variations[0],
+        mutations: [{
+          selector: ".companion",
+          action: "text" as const,
+          text: "Treatment companion",
+        }],
+      }],
+      goals: [{
+        id: "goal_companion",
+        type: "click" as const,
+        selector: ".companion",
+      }],
+    }];
+    const pinnedToken = JSON.stringify({
+      v: 1,
+      cartHash: "c".repeat(64),
+      a: [{ e: "exp_price", v: "treatment", ep: 1 }],
+    });
+    fetchMock = vi.fn(async (input: RequestInfo | URL) =>
+      String(input).endsWith("/cart.js")
+        ? Response.json({ token: "cart-runtime?key=runtime-secret" })
+        : String(input).includes("/v1/assign")
+        ? Response.json({
+            assignments: [{
+              experiment_id: "exp_price",
+              variation_id: "treatment",
+              assignment_epoch: 1,
+              commerce_price_only: true,
+            }],
+            commerce_authorization: pinnedToken,
+          })
+        : new Response("ok", { status: 202 }));
+    globalThis.fetch = fetchMock as typeof fetch;
+    const onExperimentViewed = vi.fn();
+    const { flush, getAssignments, init, trackRevenue } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      commerce,
+      endpoint: "https://events.test",
+      experiments: targetedExperiments,
+      ingestSignature: "ingest-token",
+      onExperimentViewed,
+      shopId: "shop_123",
+      trackingStart: "immediate",
+      userId: "visitor_123",
+    });
+
+    await vi.waitFor(() => {
+      expect(fetchMock.mock.calls.some(([url]) => url === "/cart/update.js")).toBe(true);
+    });
+    expect(document.querySelector(".price")?.textContent).toBe("€1.299,00");
+    expect(document.querySelector(".companion")?.textContent).toBe("Control companion");
+    expect(getAssignments()).toEqual([]);
+    expect(onExperimentViewed).not.toHaveBeenCalled();
+    expect(localStorage.getItem("drip_exposures")).toBeNull();
+
+    trackRevenue(19.99, { orderId: "off-target-order" });
+    await flush();
+    const trackedEvents = fetchMock.mock.calls
+      .filter(([url]) => String(url) === "https://events.test/events")
+      .flatMap(([, options]) => JSON.parse(String(options?.body)).events);
+    expect(trackedEvents.some((event: { type: string }) =>
+      event.type === "experiment_viewed" || event.type === "goal"
+    )).toBe(false);
+    const cartUpdate = fetchMock.mock.calls.find(([url]) => url === "/cart/update.js");
+    expect(JSON.parse(String(cartUpdate?.[1]?.body)).attributes).toMatchObject({
+      apex_assignments: JSON.stringify([{ e: "exp_price", v: "treatment", ep: 1 }]),
+      apex_assignment_authorization: pinnedToken,
+    });
+
+  });
+
+  it("keeps off-target offer pins charge-only while applying targeted offers", async () => {
+    document.body.insertAdjacentHTML(
+      "beforeend",
+      '<div class="off-target-offer">Off-target control</div><div class="targeted-offer">Targeted control</div>',
+    );
+    const offerExperiments = [
+      {
+        id: "exp_offer_off_target",
+        assignmentEpoch: 1,
+        status: "running" as const,
+        trafficAllocation: 1,
+        targeting: {
+          url: [{ type: "simple" as const, pattern: "*/products/other", include: true }],
+        },
+        variations: [{
+          id: "off_target_treatment",
+          weight: 1,
+          isControl: false,
+          mutations: [{
+            selector: ".off-target-offer",
+            action: "text" as const,
+            text: "Off-target treatment",
+          }],
+        }],
+      },
+      {
+        id: "exp_offer_targeted",
+        assignmentEpoch: 1,
+        status: "running" as const,
+        trafficAllocation: 1,
+        variations: [{
+          id: "targeted_treatment",
+          weight: 1,
+          isControl: false,
+          mutations: [{
+            selector: ".targeted-offer",
+            action: "text" as const,
+            text: "Targeted treatment",
+          }],
+        }],
+      },
+    ];
+    const authorization = JSON.stringify({
+      v: 2,
+      p: {
+        offers: {
+          v: 1,
+          a: [
+            { e: "exp_offer_off_target", v: "off_target_treatment", ep: 1 },
+            { e: "exp_offer_targeted", v: "targeted_treatment", ep: 1 },
+          ],
+        },
+      },
+    });
+    fetchMock = vi.fn(async (input: RequestInfo | URL) =>
+      String(input).endsWith("/cart.js")
+        ? Response.json({ token: "cart-runtime?key=runtime-secret" })
+        : String(input).includes("/v1/assign")
+        ? Response.json({
+            assignments: [
+              {
+                experiment_id: "exp_offer_off_target",
+                variation_id: "off_target_treatment",
+                assignment_epoch: 1,
+                commerce_price_only: true,
+              },
+              {
+                experiment_id: "exp_offer_targeted",
+                variation_id: "targeted_treatment",
+                assignment_epoch: 1,
+              },
+            ],
+            commerce_authorization: authorization,
+          })
+        : new Response("ok", { status: 202 }));
+    globalThis.fetch = fetchMock as typeof fetch;
+    const onExperimentViewed = vi.fn();
+    const { getAssignments, init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      commerce: {
+        offers: {
+          authorization: {
+            version: 1,
+            revision: 1,
+            checksum: "a".repeat(64),
+            experimentIds: ["exp_offer_off_target", "exp_offer_targeted"],
+          },
+          experiments: [],
+        },
+      },
+      endpoint: "https://events.test",
+      experiments: offerExperiments,
+      ingestSignature: "ingest-token",
+      onExperimentViewed,
+      shopId: "shop_123",
+      trackingStart: "immediate",
+      userId: "visitor_123",
+    });
+
+    await vi.waitFor(() => {
+      expect(fetchMock.mock.calls.some(([url]) => url === "/cart/update.js")).toBe(true);
+    });
+    expect(document.querySelector(".off-target-offer")?.textContent)
+      .toBe("Off-target control");
+    expect(document.querySelector(".targeted-offer")?.textContent)
+      .toBe("Targeted treatment");
+    expect(getAssignments()).toEqual([
+      expect.objectContaining({ experimentId: "exp_offer_targeted" }),
+    ]);
+    expect(onExperimentViewed).toHaveBeenCalledTimes(1);
+    expect(onExperimentViewed).toHaveBeenCalledWith(
+      expect.objectContaining({ experimentId: "exp_offer_targeted" }),
+    );
+    expect(JSON.parse(localStorage.getItem("drip_assignments_v1") ?? "{}"))
+      .not.toHaveProperty("exp_offer_off_target");
+    expect(JSON.parse(localStorage.getItem("drip_assignments_v1") ?? "{}"))
+      .toHaveProperty("exp_offer_targeted");
+    const cartUpdate = fetchMock.mock.calls.find(([url]) => url === "/cart/update.js");
+    expect(JSON.parse(JSON.parse(String(cartUpdate?.[1]?.body)).attributes.apex_assignments))
+      .toEqual(expect.arrayContaining([
+        { e: "exp_offer_off_target", v: "off_target_treatment", ep: 1 },
+        { e: "exp_offer_targeted", v: "targeted_treatment", ep: 1 },
+      ]));
+    await expect(window.fetch("/cart/add.js", { method: "POST" }))
+      .resolves.toMatchObject({ status: 202 });
+  });
+
+  it("keeps browser-only companion mutations but withholds price display and exposure", async () => {
+    document.body.insertAdjacentHTML(
+      "beforeend",
+      '<div class="browser-copy">Browser control</div>',
+    );
+    const browserOnlyExperiment = {
+      id: "exp_browser_only",
+      assignmentEpoch: 1,
+      status: "running" as const,
+      trafficAllocation: 1,
+      variations: [{
+        id: "browser_treatment",
+        weight: 1,
+        isControl: false,
+        mutations: [{
+          selector: ".browser-copy",
+          action: "text" as const,
+          text: "Browser treatment",
+        }],
+      }],
+    };
+    const mixedCommerce = {
+      price: {
+        ...commerce.price!,
+        authorization: {
+          ...commerce.price!.authorization!,
+          experimentIds: ["exp_price", "exp_browser_only"],
+        },
+        experiments: [
+          ...commerce.price!.experiments,
+          {
+            experiment_id: "exp_browser_only",
+            assignment_epoch: 1,
+            currency: "EUR",
+            variants: {
+              browser_treatment: [{
+                variant_gid: "gid://shopify/ProductVariant/123",
+                fixedPricePerUnit: "1099.95",
+              }],
+            },
+          },
+        ],
+      },
+    };
+    const nullPinToken = JSON.stringify({
+      v: 2,
+      e: ["exp_price"],
+      p: {
+        price: {
+          v: 1,
+          r: 3,
+          c: "b".repeat(64),
+          x: "2026-07-20",
+          cartHash: "c".repeat(64),
+          a: [],
+          s: "d".repeat(64),
+        },
+      },
+    });
+    fetchMock = vi.fn(async (input: RequestInfo | URL) =>
+      String(input).endsWith("/cart.js")
+        ? Response.json({ token: "cart-runtime?key=runtime-secret" })
+        : String(input).includes("/v1/assign")
+        ? Response.json({ assignments: [], commerce_authorization: nullPinToken })
+        : new Response("ok", { status: 202 }));
+    globalThis.fetch = fetchMock as typeof fetch;
+    const onExperimentViewed = vi.fn();
+    const { getDiagnostics, init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      commerce: mixedCommerce,
+      endpoint: "https://events.test",
+      experiments: [...experiments, browserOnlyExperiment],
+      ingestSignature: "ingest-token",
+      onExperimentViewed,
+      shopId: "shop_123",
+      trackingStart: "immediate",
+      userId: "visitor_123",
+    });
+
+    await vi.waitFor(() => {
+      expect(getDiagnostics().assignments).toEqual([
+        expect.objectContaining({
+          experimentId: "exp_browser_only",
+          variationId: "browser_treatment",
+        }),
+      ]);
+      expect(document.querySelector(".browser-copy")?.textContent)
+        .toBe("Browser treatment");
+      expect(document.querySelector(".price")?.textContent).toBe("€1.299,00");
+      expect(fetchMock.mock.calls.some(([url]) => url === "/cart/update.js")).toBe(true);
+    });
+    expect(onExperimentViewed).not.toHaveBeenCalled();
+    expect(localStorage.getItem("drip_exposures")).toBeNull();
+    const cartUpdate = fetchMock.mock.calls.find(([url]) => url === "/cart/update.js");
+    const attributes = JSON.parse(String(cartUpdate?.[1]?.body)).attributes;
+    expect(JSON.parse(attributes.apex_assignments)).toEqual([{
+      e: "exp_browser_only",
+      v: "browser_treatment",
+      ep: 1,
+    }]);
+    expect(attributes.apex_assignment_authorization).toBe(nullPinToken);
+  });
+
+  it("keeps headless display published until a successful cart write is acknowledged", async () => {
+    fetchMock = vi.fn(async (input: RequestInfo | URL) =>
+      String(input).endsWith("/cart.js")
+        ? new Response("unavailable", { status: 503 })
+        : String(input).includes("/v1/assign")
+        ? Response.json(commerceAssignmentResponseFixture)
+        : new Response("ok", { status: 202 }));
+    globalThis.fetch = fetchMock as typeof fetch;
+    const onExperimentViewed = vi.fn();
+    const {
+      confirmCartAttributesWritten,
+      getDiagnostics,
+      getSignedCartAttributes,
+      init,
+    } = await import("./index");
+    expect((globalThis as any).drip.confirmCartAttributesWritten)
+      .toBe(confirmCartAttributesWritten);
+    expect((globalThis as any).Apex.confirmCartAttributesWritten)
+      .toBe(confirmCartAttributesWritten);
+
+    init({
+      antiFlickerMode: "off",
+      commerce,
+      endpoint: "https://events.test",
+      experiments,
+      ingestSignature: "ingest-token",
+      onExperimentViewed,
+      shopId: "shop_123",
+      trackingStart: "immediate",
+      userId: "visitor_123",
+    });
+    await vi.waitFor(() => {
+      expect(fetchMock.mock.calls.some(([url]) => String(url).endsWith("/cart.js")))
+        .toBe(true);
+    });
+
+    expect(document.querySelector(".price")?.textContent).toBe("€1.299,00");
+    expect(onExperimentViewed).not.toHaveBeenCalled();
+
+    const entries = await getSignedCartAttributes(
+      "gid://shopify/Cart/headless?key=headless-secret",
+    );
+
+    expect(Object.fromEntries(entries.map((entry) => [entry.key, entry.value])))
+      .toMatchObject({
+        apex_assignment_authorization: commerceAssignmentResponseFixture.commerce_authorization,
+      });
+    expect(document.querySelector(".price")?.textContent).toBe("€1.299,00");
+    expect(onExperimentViewed).not.toHaveBeenCalled();
+    expect(localStorage.getItem("drip_exposures")).toBeNull();
+    expect(getDiagnostics().spa.lastShopifyCartSync?.status).toBe("pending");
+
+    expect(confirmCartAttributesWritten(
+      "gid://shopify/Cart/wrong?key=wrong-secret",
+    )).toBe(false);
+    expect(document.querySelector(".price")?.textContent).toBe("€1.299,00");
+    expect(onExperimentViewed).not.toHaveBeenCalled();
+
+    expect(confirmCartAttributesWritten(
+      "gid://shopify/Cart/headless?key=headless-secret",
+    )).toBe(true);
+    await vi.waitFor(() => {
+      expect(document.querySelector(".price")?.textContent).toBe("€1.149,95");
+      expect(onExperimentViewed).toHaveBeenCalledWith(
+        expect.objectContaining({
+          experimentId: "exp_price",
+          variationId: "treatment",
+        }),
+      );
+    });
+    expect(getDiagnostics().spa.lastShopifyCartSync?.status).toBe("sent");
+    expect(confirmCartAttributesWritten(
+      "gid://shopify/Cart/headless?key=headless-secret",
+    )).toBe(false);
+    expect(fetchMock.mock.calls.some(([url]) => url === "/cart/update.js")).toBe(false);
+
+    const replacementEntries = await getSignedCartAttributes(
+      "gid://shopify/Cart/replacement?key=replacement-secret",
+    );
+    expect(Object.fromEntries(replacementEntries.map((entry) => [entry.key, entry.value])))
+      .toMatchObject({
+        apex_assignment_authorization: commerceAssignmentResponseFixture.commerce_authorization,
+      });
+    expect(document.querySelector(".price")?.textContent).toBe("€1.299,00");
+    expect(getDiagnostics().spa.lastShopifyCartSync?.status).toBe("pending");
+
+    expect(confirmCartAttributesWritten(
+      "gid://shopify/Cart/replacement?key=replacement-secret",
+    )).toBe(true);
+    expect(document.querySelector(".price")?.textContent).toBe("€1.149,95");
+
+    fetchMock.mockImplementation(async (input: RequestInfo | URL) =>
+      String(input).includes("/v1/assign")
+        ? new Response("unavailable", { status: 503 })
+        : new Response("ok", { status: 202 }));
+    const cartWritesBeforeFailure = fetchMock.mock.calls.filter(
+      ([url]) => url === "/cart/update.js",
+    ).length;
+
+    await expect(getSignedCartAttributes(
+      "gid://shopify/Cart/failed-replacement?key=failed-secret",
+    )).resolves.toEqual([]);
+    await vi.waitFor(() => {
+      expect(document.querySelector(".price")?.textContent).toBe("€1.299,00");
+    });
+    expect(fetchMock.mock.calls.filter(([url]) => url === "/cart/update.js"))
+      .toHaveLength(cartWritesBeforeFailure);
+  });
+
+  it("rejects a stale headless acknowledgement for the same cart generation", async () => {
+    fetchMock = vi.fn(async (input: RequestInfo | URL) =>
+      String(input).endsWith("/cart.js")
+        ? new Response("unavailable", { status: 503 })
+        : String(input).includes("/v1/assign")
+        ? Response.json(commerceAssignmentResponseFixture)
+        : new Response("ok", { status: 202 }));
+    globalThis.fetch = fetchMock as typeof fetch;
+    const {
+      confirmCartAttributesWritten,
+      getSignedCartAttributes,
+      init,
+    } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      commerce,
+      endpoint: "https://events.test",
+      experiments,
+      ingestSignature: "ingest-token",
+      shopId: "shop_123",
+      trackingStart: "immediate",
+      userId: "visitor_123",
+    });
+    await vi.waitFor(() => {
+      expect(fetchMock.mock.calls.some(([url]) => String(url).endsWith("/cart.js")))
+        .toBe(true);
+    });
+
+    const cartToken = "gid://shopify/Cart/headless?key=headless-secret";
+    await expect(getSignedCartAttributes(cartToken)).resolves.not.toEqual([]);
+
+    let resolveLatest!: (response: Response) => void;
+    fetchMock.mockImplementation(async (input: RequestInfo | URL) => {
+      if (!String(input).includes("/v1/assign")) return new Response("ok", { status: 202 });
+      return new Promise<Response>((resolve) => { resolveLatest = resolve; });
+    });
+    const latest = getSignedCartAttributes(cartToken);
+    await vi.waitFor(() => expect(resolveLatest).toEqual(expect.any(Function)));
+
+    expect(confirmCartAttributesWritten(cartToken)).toBe(false);
+    expect(document.querySelector(".price")?.textContent).toBe("€1.299,00");
+
+    resolveLatest(Response.json(commerceAssignmentResponseFixture));
+    await expect(latest).resolves.not.toEqual([]);
+    expect(confirmCartAttributesWritten(cartToken)).toBe(true);
+    expect(document.querySelector(".price")?.textContent).toBe("€1.149,95");
+  });
+
+  it("does not let a stale failed headless call revoke the newer cart", async () => {
+    fetchMock = vi.fn(async (input: RequestInfo | URL) =>
+      String(input).endsWith("/cart.js")
+        ? new Response("unavailable", { status: 503 })
+        : String(input).includes("/v1/assign")
+        ? Response.json(commerceAssignmentResponseFixture)
+        : new Response("ok", { status: 202 }));
+    globalThis.fetch = fetchMock as typeof fetch;
+    const {
+      confirmCartAttributesWritten,
+      getDiagnostics,
+      getSignedCartAttributes,
+      init,
+    } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      commerce,
+      endpoint: "https://events.test",
+      experiments,
+      ingestSignature: "ingest-token",
+      shopId: "shop_123",
+      trackingStart: "immediate",
+      userId: "visitor_123",
+    });
+    await vi.waitFor(() => {
+      expect(fetchMock.mock.calls.some(([url]) => String(url).endsWith("/cart.js")))
+        .toBe(true);
+    });
+    const initialCartToken = "gid://shopify/Cart/initial?key=initial-secret";
+    await expect(getSignedCartAttributes(initialCartToken)).resolves.not.toEqual([]);
+    expect(confirmCartAttributesWritten(initialCartToken)).toBe(true);
+    expect(document.querySelector(".price")?.textContent).toBe("€1.149,95");
+
+    let resolveOlder!: (response: Response) => void;
+    let resolveNewer!: (response: Response) => void;
+    let headlessAuthorizationCalls = 0;
+    fetchMock.mockImplementation(async (input: RequestInfo | URL) => {
+      if (!String(input).includes("/v1/assign")) return new Response("ok", { status: 202 });
+      headlessAuthorizationCalls += 1;
+      return new Promise<Response>((resolve) => {
+        if (headlessAuthorizationCalls === 1) resolveOlder = resolve;
+        else resolveNewer = resolve;
+      });
+    });
+
+    const older = getSignedCartAttributes(
+      "gid://shopify/Cart/older?key=older-secret",
+    );
+    const newer = getSignedCartAttributes(
+      "gid://shopify/Cart/newer?key=newer-secret",
+    );
+    await vi.waitFor(() => expect(headlessAuthorizationCalls).toBe(2));
+
+    resolveNewer(Response.json(commerceAssignmentResponseFixture));
+    await expect(newer).resolves.not.toEqual([]);
+    expect(getDiagnostics().spa.lastShopifyCartSync?.status).toBe("pending");
+
+    resolveOlder(new Response("unavailable", { status: 503 }));
+    await expect(older).resolves.toEqual([]);
+    expect(confirmCartAttributesWritten(
+      "gid://shopify/Cart/older?key=older-secret",
+    )).toBe(false);
+    expect(confirmCartAttributesWritten(
+      "gid://shopify/Cart/newer?key=newer-secret",
+    )).toBe(true);
+    expect(getDiagnostics().spa.lastShopifyCartSync?.status).toBe("sent");
+    expect(document.querySelector(".price")?.textContent).toBe("€1.149,95");
+  });
+
+  it("withholds shipping display and exposure when only the price plane is signed", async () => {
+    const shippingExperiment = {
+      id: "exp_shipping",
+      assignmentEpoch: 1,
+      status: "running" as const,
+      trafficAllocation: 1,
+      variations: [{
+        id: "shipping_treatment",
+        weight: 1,
+        isControl: false,
+        mutations: [],
+      }],
+    };
+    const mixedCommerce = {
+      ...commerce,
+      shipping: {
+        authorization: {
+          version: 1 as const,
+          revision: 7,
+          checksum: "b".repeat(64),
+          experimentIds: ["exp_shipping"],
+        },
+        experiments: [{
+          experiment_id: "exp_shipping",
+          assignment_epoch: 1,
+          currency: "EUR",
+          variants: {
+            shipping_treatment: {
+              threshold: "50.00",
+              treatment: "banner" as const,
+              progressCopy: "Only {remaining} until free shipping",
+              reachedCopy: "Free shipping reached",
+            },
+          },
+        }],
+      },
+    };
+    const priceOnlyToken = JSON.stringify({
+      v: 2,
+      p: {
+        price: {
+          v: 1,
+          cartHash: "c".repeat(64),
+          a: [{ e: "exp_price", v: "treatment", ep: 1 }],
+        },
+      },
+    });
+    fetchMock = vi.fn(async (input: RequestInfo | URL) => {
+      const url = String(input);
+      if (url.endsWith("/cart.js")) {
+        return Response.json({
+          token: "cart-runtime?key=runtime-secret",
+          currency: "EUR",
+          items_subtotal_price: 2500,
+        });
+      }
+      if (url.includes("/v1/assign")) {
+        return Response.json({
+          assignments: [
+            { experiment_id: "exp_price", variation_id: "treatment", assignment_epoch: 1 },
+            {
+              experiment_id: "exp_shipping",
+              variation_id: "shipping_treatment",
+              assignment_epoch: 1,
+            },
+          ],
+          commerce_authorization: priceOnlyToken,
+        });
+      }
+      return new Response("ok", { status: 202 });
+    });
+    globalThis.fetch = fetchMock as typeof fetch;
+    const onExperimentViewed = vi.fn();
+    const { init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      commerce: mixedCommerce,
+      endpoint: "https://events.test",
+      experiments: [...experiments, shippingExperiment],
+      ingestSignature: "ingest-token",
+      onExperimentViewed,
+      shopId: "shop_123",
+      trackingStart: "immediate",
+      userId: "visitor_123",
+    });
+
+    await vi.waitFor(() => {
+      expect(fetchMock.mock.calls.some(([url]) => url === "/cart/update.js")).toBe(true);
+      expect(document.querySelector(".price")?.textContent).toBe("€1.149,95");
+    });
+    expect(document.querySelector("[data-apex-shipping]")).toBeNull();
+    expect(onExperimentViewed).toHaveBeenCalledWith(
+      expect.objectContaining({ experimentId: "exp_price" }),
+    );
+    expect(onExperimentViewed).not.toHaveBeenCalledWith(
+      expect.objectContaining({ experimentId: "exp_shipping" }),
+    );
+    const cartUpdate = fetchMock.mock.calls.find(([url]) => url === "/cart/update.js");
+    const attributes = JSON.parse(String(cartUpdate?.[1]?.body)).attributes;
+    expect(JSON.parse(attributes.apex_assignments)).toEqual([
+      { e: "exp_price", v: "treatment", ep: 1 },
+    ]);
+  });
+
+  it("waits for a matching cart before exposing a scoped display-only shipping arm", async () => {
+    const shippingExperiment = {
+      id: "exp_shipping_display_only",
+      assignmentEpoch: 1,
+      status: "running" as const,
+      trafficAllocation: 1,
+      variations: [{
+        id: "shipping_banner",
+        weight: 1,
+        isControl: false,
+        mutations: [],
+      }],
+    };
+    const displayOnlyCommerce = {
+      shipping: {
+        experiments: [{
+          experiment_id: "exp_shipping_display_only",
+          assignment_epoch: 1,
+          currency: "EUR",
+          variants: {
+            shipping_banner: {
+              threshold: null,
+              treatment: "banner" as const,
+              progressCopy: "",
+              reachedCopy: "",
+              bannerCopy: "Shipping update",
+              flatRate: null,
+              percentOff: null,
+              target: {
+                productGids: ["gid://shopify/Product/42"],
+                variantGids: [],
+              },
+            },
+          },
+        }],
+      },
+    };
+    let cartReads = 0;
+    fetchMock = vi.fn(async (input: RequestInfo | URL) => {
+      const url = String(input);
+      if (url.endsWith("/cart.js")) {
+        cartReads += 1;
+        return Response.json({
+          token: "cart-runtime?key=runtime-secret",
+          currency: "EUR",
+          items_subtotal_price: 2500,
+          items: cartReads === 1 ? [] : [{ product_id: 42, variant_id: 7 }],
+        });
+      }
+      return new Response("ok", { status: 202 });
+    });
+    globalThis.fetch = fetchMock as typeof fetch;
+    const onExperimentViewed = vi.fn();
+    const { init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      commerce: displayOnlyCommerce,
+      endpoint: "https://events.test",
+      experiments: [shippingExperiment],
+      ingestSignature: "ingest-token",
+      onExperimentViewed,
+      shopId: "shop_123",
+      trackingStart: "immediate",
+      userId: "visitor_123",
+    });
+
+    await vi.waitFor(() => expect(cartReads).toBe(1));
+    expect(onExperimentViewed).not.toHaveBeenCalled();
+
+    await window.fetch("/cart/update.js", { method: "POST" });
+    await vi.waitFor(() => {
+      expect(onExperimentViewed).toHaveBeenCalledWith(
+        expect.objectContaining({ experimentId: "exp_shipping_display_only" }),
+      );
+    });
+    expect(onExperimentViewed).toHaveBeenCalledTimes(1);
+  });
+
+  it("uses the assigned treatment arm target instead of a sibling arm target", async () => {
+    const experiment = {
+      id: "exp_shipping_per_arm",
+      assignmentEpoch: 1,
+      status: "running" as const,
+      trafficAllocation: 1,
+      variations: [
+        { id: "arm_a", weight: 1, isControl: false, mutations: [] },
+        { id: "arm_b", weight: 0, isControl: false, mutations: [] },
+      ],
+    };
+    const target = (product: number) => ({
+      productGids: [`gid://shopify/Product/${product}`],
+      variantGids: [] as string[],
+    });
+    const variant = (product: number) => ({
+      threshold: null,
+      treatment: "banner" as const,
+      progressCopy: "",
+      reachedCopy: "",
+      bannerCopy: "Shipping update",
+      flatRate: null,
+      percentOff: null,
+      target: target(product),
+    });
+    let product = 43;
+    fetchMock = vi.fn(async (input: RequestInfo | URL) =>
+      String(input).endsWith("/cart.js")
+        ? Response.json({ currency: "EUR", items_subtotal_price: 2500, items: [{ product_id: product }] })
+        : new Response("ok", { status: 202 }));
+    globalThis.fetch = fetchMock as typeof fetch;
+    const onExperimentViewed = vi.fn();
+    const { init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      commerce: { shipping: { experiments: [{
+        experiment_id: experiment.id,
+        assignment_epoch: 1,
+        currency: "EUR",
+        variants: { arm_a: variant(42), arm_b: variant(43) },
+      }] } },
+      endpoint: "https://events.test",
+      experiments: [experiment],
+      ingestSignature: "ingest-token",
+      onExperimentViewed,
+      shopId: "shop_123",
+      trackingStart: "immediate",
+      userId: "visitor_123",
+    });
+
+    await vi.waitFor(() => expect(fetchMock.mock.calls.some(([url]) => String(url).endsWith("/cart.js"))).toBe(true));
+    expect(onExperimentViewed).not.toHaveBeenCalled();
+    product = 42;
+    await window.fetch("/cart/update.js", { method: "POST" });
+    await vi.waitFor(() => expect(onExperimentViewed).toHaveBeenCalledTimes(1));
+  });
+
+  it("withholds a scoped shipping control assignment until the experiment target matches", async () => {
+    const experiment = {
+      id: "exp_shipping_scoped_control",
+      assignmentEpoch: 1,
+      status: "running" as const,
+      trafficAllocation: 1,
+      variations: [{ id: "control", weight: 1, isControl: true, mutations: [] }],
+    };
+    const emptyTarget = { productGids: [] as string[], variantGids: [] as string[] };
+    const commerceConfig = {
+      shipping: {
+        experiments: [{
+          experiment_id: experiment.id,
+          assignment_epoch: 1,
+          currency: "EUR",
+          variants: {
+            control: {
+              threshold: null,
+              treatment: "none" as const,
+              progressCopy: "",
+              reachedCopy: "",
+              bannerCopy: "",
+              flatRate: null,
+              percentOff: null,
+              target: emptyTarget,
+            },
+            treatment: {
+              threshold: null,
+              treatment: "banner" as const,
+              progressCopy: "",
+              reachedCopy: "",
+              bannerCopy: "Shipping update",
+              flatRate: null,
+              percentOff: null,
+              target: {
+                productGids: ["gid://shopify/Product/42"],
+                variantGids: [],
+              },
+            },
+          },
+        }],
+      },
+    };
+    let cartReads = 0;
+    fetchMock = vi.fn(async (input: RequestInfo | URL) => {
+      const url = String(input);
+      if (url.endsWith("/cart.js")) {
+        cartReads += 1;
+        return Response.json({
+          currency: "EUR",
+          items_subtotal_price: 2500,
+          items: cartReads === 1 ? [] : [{ product_id: 42, variant_id: 7 }],
+        });
+      }
+      return new Response("ok", { status: 202 });
+    });
+    globalThis.fetch = fetchMock as typeof fetch;
+    const onExperimentViewed = vi.fn();
+    const { init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      commerce: commerceConfig,
+      endpoint: "https://events.test",
+      experiments: [experiment],
+      ingestSignature: "ingest-token",
+      onExperimentViewed,
+      shopId: "shop_123",
+      trackingStart: "immediate",
+      userId: "visitor_123",
+    });
+
+    await vi.waitFor(() => expect(cartReads).toBe(1));
+    expect(onExperimentViewed).not.toHaveBeenCalled();
+    await window.fetch("/cart/update.js", { method: "POST" });
+    await vi.waitFor(() => expect(onExperimentViewed).toHaveBeenCalledTimes(1));
+    expect(document.querySelector("[data-apex-shipping]")).toBeNull();
+  });
+
+  it.each([
+    {
+      name: "withholds a cross-currency currency-bound arm",
+      treatment: "free_shipping" as const,
+      threshold: "50.00",
+      expectedExposures: 0,
+      expectedCartReads: 0,
+    },
+    {
+      name: "exposes a cross-currency thresholdless percent arm",
+      treatment: "percent_off" as const,
+      threshold: null,
+      expectedExposures: 1,
+      expectedCartReads: 1,
+    },
+  ])("$name", async ({ treatment, threshold, expectedExposures, expectedCartReads }) => {
+    const experiment = {
+      id: "exp_shipping_currency",
+      assignmentEpoch: 1,
+      status: "running" as const,
+      trafficAllocation: 1,
+      variations: [{ id: "treatment", weight: 1, isControl: false, mutations: [] }],
+    };
+    fetchMock = vi.fn(async (input: RequestInfo | URL) =>
+      String(input).endsWith("/cart.js")
+        ? Response.json({ currency: "EUR", items_subtotal_price: 2500, items: [] })
+        : new Response("ok", { status: 202 }));
+    globalThis.fetch = fetchMock as typeof fetch;
+    const onExperimentViewed = vi.fn();
+    const { init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      commerce: {
+        shipping: {
+          experiments: [{
+            experiment_id: experiment.id,
+            assignment_epoch: 1,
+            currency: "USD",
+            variants: {
+              treatment: {
+                threshold,
+                treatment,
+                progressCopy: "Only {remaining}",
+                reachedCopy: "Reached",
+                bannerCopy: "Shipping update",
+                flatRate: null,
+                percentOff: treatment === "percent_off" ? 10 : null,
+                target: { productGids: [], variantGids: [] },
+              },
+            },
+          }],
+        },
+      },
+      endpoint: "https://events.test",
+      experiments: [experiment],
+      ingestSignature: "ingest-token",
+      onExperimentViewed,
+      shopId: "shop_123",
+      trackingStart: "immediate",
+      userId: "visitor_123",
+    });
+
+    if (expectedCartReads > 0) {
+      await vi.waitFor(() => expect(onExperimentViewed).toHaveBeenCalledTimes(expectedExposures));
+    } else {
+      await vi.waitFor(() => expect(fetchMock).toHaveBeenCalled());
+    }
+    expect(fetchMock.mock.calls.filter(([url]) => String(url).endsWith("/cart.js"))).toHaveLength(
+      expectedCartReads,
+    );
+    expect(onExperimentViewed).toHaveBeenCalledTimes(expectedExposures);
+  });
+
+  it("exposes a cross-currency control for a thresholdless percent treatment", async () => {
+    fetchMock = vi.fn(async (input: RequestInfo | URL) =>
+      String(input).endsWith("/cart.js")
+        ? Response.json({ currency: "EUR", items_subtotal_price: 2500, items: [] })
+        : new Response("ok", { status: 202 }));
+    globalThis.fetch = fetchMock as typeof fetch;
+    const onExperimentViewed = vi.fn();
+    const { init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      commerce: { shipping: { experiments: [{
+        experiment_id: "exp_shipping_percent_control",
+        assignment_epoch: 1,
+        currency: "USD",
+        variants: {
+          control: { threshold: null, treatment: "none", progressCopy: "", reachedCopy: "", bannerCopy: "", flatRate: null, percentOff: null, target: { productGids: [], variantGids: [] } },
+          treatment: { threshold: null, treatment: "percent_off", progressCopy: "", reachedCopy: "", bannerCopy: "Shipping update", flatRate: null, percentOff: 10, target: { productGids: [], variantGids: [] } },
+        },
+      }] } },
+      endpoint: "https://events.test",
+      experiments: [{
+        id: "exp_shipping_percent_control",
+        assignmentEpoch: 1,
+        status: "running",
+        trafficAllocation: 1,
+        variations: [
+          { id: "control", weight: 1, isControl: true, mutations: [] },
+          { id: "treatment", weight: 0, isControl: false, mutations: [] },
+        ],
+      }],
+      ingestSignature: "ingest-token",
+      onExperimentViewed,
+      shopId: "shop_123",
+      trackingStart: "immediate",
+      userId: "visitor_123",
+    });
+
+    await vi.waitFor(() => expect(onExperimentViewed).toHaveBeenCalledTimes(1));
+  });
+
+  it("exposes an untargeted threshold control once the cart currency matches", async () => {
+    const controlCommerce = {
+      shipping: {
+        experiments: [{
+          experiment_id: "exp_shipping_control",
+          assignment_epoch: 1,
+          currency: "EUR",
+          variants: {
+            control_arm: {
+              threshold: null,
+              treatment: "none" as const,
+              progressCopy: "",
+              reachedCopy: "",
+              bannerCopy: "",
+              flatRate: null,
+              percentOff: null,
+              target: { productGids: [], variantGids: [] },
+            },
+            banner_arm: {
+              threshold: "5000",
+              treatment: "banner" as const,
+              progressCopy: "",
+              reachedCopy: "",
+              bannerCopy: "Free shipping at {threshold}",
+              flatRate: null,
+              percentOff: null,
+              target: { productGids: [], variantGids: [] },
+            },
+          },
+        }],
+      },
+    };
+    fetchMock = vi.fn(async (input: RequestInfo | URL) => {
+      const url = String(input);
+      if (url.endsWith("/cart.js")) {
+        return Response.json({
+          token: "cart-1",
+          currency: "EUR",
+          items_subtotal_price: 2500,
+          items: [],
+        });
+      }
+      return new Response("ok", { status: 202 });
+    });
+    globalThis.fetch = fetchMock as typeof fetch;
+    const onExperimentViewed = vi.fn();
+    const { init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      commerce: controlCommerce,
+      endpoint: "https://events.test",
+      experiments: [{
+        id: "exp_shipping_control",
+        assignmentEpoch: 1,
+        status: "running" as const,
+        trafficAllocation: 1,
+        variations: [
+          { id: "control_arm", weight: 1, isControl: true, mutations: [] },
+          { id: "banner_arm", weight: 0, isControl: false, mutations: [] },
+        ],
+      }],
+      ingestSignature: "ingest-token",
+      onExperimentViewed,
+      shopId: "shop_123",
+      trackingStart: "immediate",
+      userId: "visitor_123",
+    });
+
+    await vi.waitFor(() => {
+      expect(onExperimentViewed).toHaveBeenCalledWith(
+        expect.objectContaining({ experimentId: "exp_shipping_control" }),
+      );
+    });
+  });
+
+  it("keeps plane-inactive price display and exposure behavior unchanged", async () => {
+    const planeInactiveCommerce = {
+      price: {
+        ...commerce.price!,
+        authorization: undefined,
+      },
+    };
+    const onExperimentViewed = vi.fn();
+    const { init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      commerce: planeInactiveCommerce,
+      endpoint: "https://events.test",
+      experiments,
+      ingestSignature: "ingest-token",
+      onExperimentViewed,
+      shopId: "shop_123",
+      trackingStart: "immediate",
+      userId: "visitor_123",
+    });
+
+    await vi.waitFor(() => {
+      expect(document.querySelector(".price")?.textContent).toBe("€1.149,95");
+      expect(onExperimentViewed).toHaveBeenCalledWith(
+        expect.objectContaining({
+          experimentId: "exp_price",
+          variationId: "treatment",
+        }),
+      );
+    });
+  });
+
+  it("does not remove an active price swap when analytics stops", async () => {
+    const { init, setConsent } = await import("./index");
+    init({
+      antiFlickerMode: "off",
+      commerce,
+      consentMode: { enabled: true },
+      debug: { enabled: true, restrictMode: "always" },
+      endpoint: "https://events.test",
+      experiments,
+      hasConsent: true,
+      ingestSignature: "ingest-token",
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+    await vi.waitFor(() => {
+      expect(document.querySelector(".price")?.textContent).toBe("€1.149,95");
+    });
+
+    setConsent(false);
+
+    expect(document.querySelector(".price")?.textContent).toBe("€1.149,95");
+  });
+
+  it("stamps a commerce cohort despite blocked tracking without starting analytics", async () => {
+    const publish = vi.fn();
+    (window as any).Shopify.analytics = { publish };
+    const { getDiagnostics, init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      commerce,
+      consentMode: { enabled: true },
+      debug: { enabled: true, restrictMode: "always" },
+      endpoint: "https://events.test",
+      exclusionGroups: [{
+        id: "group_commerce",
+        epoch: 3,
+        members: [{ experimentId: "exp_price", share: 1 }],
+      }],
+      experiments,
+      hasConsent: false,
+      ingestSignature: "ingest-token",
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+
+    await vi.waitFor(() => {
+      expect(fetchMock.mock.calls.some(([url]) => url === "/cart/update.js"))
+        .toBe(true);
+    });
+    expect(getDiagnostics().trackingBlocked).toBe(true);
+    expect(getDiagnostics().analyticsStarted).toBe(false);
+    expect(publish).not.toHaveBeenCalled();
+    expect(fetchMock.mock.calls.some(([url]) =>
+      new URL(String(url), location.href).pathname === "/events"))
+      .toBe(false);
+    const assignRequest = fetchMock.mock.calls.find(([url]) =>
+      String(url).includes("/v1/assign")
+    );
+    expect(JSON.parse(String(assignRequest?.[1]?.body))).toMatchObject({
+      exclusion_group_selections: [{
+        group_id: "group_commerce",
+        experiment_id: "exp_price",
+        epoch: 3,
+      }],
+    });
+  });
+
+  it("keeps blocked non-commerce assignments unchanged and performs no sync", async () => {
+    const publish = vi.fn();
+    (window as any).Shopify.analytics = { publish };
+    const { getDiagnostics, init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      consentMode: { enabled: true },
+      debug: { enabled: true, restrictMode: "always" },
+      endpoint: "https://events.test",
+      experiments,
+      hasConsent: false,
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+    await Promise.resolve();
+
+    expect(getDiagnostics().trackingBlocked).toBe(true);
+    expect(fetchMock).not.toHaveBeenCalled();
+    expect(publish).not.toHaveBeenCalled();
+  });
+
+  it("force re-stamps the cohort after a successful cart add", async () => {
+    const { getDiagnostics, init } = await import("./index");
+    init({
+      antiFlickerMode: "off",
+      commerce,
+      endpoint: "https://events.test",
+      experiments,
+      ingestSignature: "ingest-token",
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+    const cartWrites = () => fetchMock.mock.calls
+      .filter(([url]) => url === "/cart/update.js");
+    await vi.waitFor(() => expect(cartWrites().length).toBeGreaterThan(0));
+    const writesBeforeAdd = cartWrites().length;
+
+    await window.fetch("/cart/add.js", { method: "POST" });
+    await vi.waitFor(() => expect(cartWrites()).toHaveLength(writesBeforeAdd + 1));
+
+    const completedWrites = cartWrites();
+    const body = JSON.parse(String(completedWrites[completedWrites.length - 1]?.[1]?.body));
+    expect(JSON.parse(body.attributes.apex_assignments)).toEqual([
+      expect.objectContaining({ e: "exp_price", v: "treatment" }),
+    ]);
+    expect(getDiagnostics().spa.lastShopifyCartSync?.status).toBe("sent");
+    expect(document.querySelector(".price")?.textContent).toBe("€1.149,95");
+  });
+
+  it("adopts a mismatching cart pin into runtime and displayed price state", async () => {
+    const controlFirstExperiments = [{
+      ...experiments[0],
+      variations: [
+        { id: "control", weight: 1, isControl: true, mutations: [] },
+        { ...experiments[0].variations[0], weight: 0 },
+      ],
+    }];
+    const { getDiagnostics, init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      commerce,
+      endpoint: "https://events.test",
+      experiments: controlFirstExperiments,
+      ingestSignature: "ingest-token",
+      shopId: "shop_123",
+      trackingStart: "immediate",
+      userId: "visitor_123",
+    });
+
+    await vi.waitFor(() => {
+      expect(getDiagnostics().assignments).toEqual([
+        expect.objectContaining({
+          experimentId: "exp_price",
+          variationId: "treatment",
+          isControl: false,
+        }),
+      ]);
+      expect(document.querySelector(".price")?.textContent).toBe("€1.149,95");
+    });
+    await vi.waitFor(() => {
+      expect(fetchMock.mock.calls.some(([url]) => url === "/cart/update.js")).toBe(true);
+    });
+    const cartUpdate = fetchMock.mock.calls.find(([url]) => url === "/cart/update.js");
+    const attributes = JSON.parse(String(cartUpdate?.[1]?.body)).attributes;
+    expect(JSON.parse(attributes.apex_assignments)).toEqual([{
+      e: "exp_price",
+      v: "treatment",
+      ep: 1,
+    }]);
+    expect(JSON.parse(localStorage.getItem("drip_assignments_v1") ?? "{}")).toMatchObject({
+      exp_price: ["treatment", 1, expect.any(Number)],
+    });
+  });
+
+});